Add files using upload-large-folder tool

parse/train/3Wp8HM2CNdR/3Wp8HM2CNdR.md

@@ -0,0 +1,308 @@
+# WHITENING FOR SELF-SUPERVISED REPRESENTATION LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Most of the self-supervised representation learning methods are based on the contrastive loss and the instance-discrimination task, where augmented versions of the same image instance (“positives”) are contrasted with instances extracted from other images (“negatives”). For the learning to be effective, a lot of negatives should be compared with a positive pair, which is computationally demanding. In this paper, we propose a different direction and a new loss function for selfsupervised representation learning which is based on the whitening of the latentspace features. The whitening operation has a “scattering” effect on the batch samples, which compensates the use of negatives, avoiding degenerate solutions where all the sample representations collapse to a single point. Our Whitening MSE (W-MSE) loss does not require special heuristics (e.g. additional networks) and it is conceptually simple. Since negatives are not needed, we can extract multiple positive pairs from the same image instance. We empirically show that WMSE is competitive with respect to popular, more complex self-supervised methods. The source code of the method and all the experiments is included in the Supplementary Material.
+
+# 1 INTRODUCTION
+
+One of the current main bottlenecks in deep network training is the dependence on large annotated training datasets, and this motivates the recent surge of interest in unsupervised methods. Specifically, in self-supervised representation learning, a network is (pre-)trained without any form of manual annotation, thus providing a means to extract information from unlabeled-data sources (e.g., text corpora, videos, images from the Internet, etc.). In self-supervision, label information is replaced by a prediction problem using some form of context or using a pretext task. Pioneering work in this direction was done in Natural Language Processing (NLP), in which the co-occurrence of words in a sentence is used to learn a language model (Mikolov et al., 2013a;b; Devlin et al., 2019). In Computer Vision, typical contexts or pretext tasks are based on: (1) the temporal consistency in videos (Wang & Gupta, 2015; Misra et al., 2016; Dwibedi et al., 2019), (2) the spatial order of patches in still images (Noroozi & Favaro, 2016; Misra & van der Maaten, 2019; Henaff et al., 2019) ´ or (3) simple image transformation techniques (Ji et al., 2019; He et al., 2019; Wu et al., 2018). The intuitive idea behind most of these methods is to collect pairs of positive and negative samples: two positive samples should share the same semantics, while negatives should be perceptually different. A triplet loss (Sohn, 2016; Schroff et al., 2015; Hermans et al., 2017; Wang & Gupta, 2015; Misra et al., 2016) can then be used to learn a metric space which should represent the human perceptual similarity. However, most of the recent studies use a contrastive loss (Hadsell et al., 2006) or one of its variants (Gutmann & Hyvarinen, 2010; van den Oord et al., 2018; Hjelm et al., 2019), while ¨ Tschannen et al. (2019) show the relation between the triplet loss and the contrastive loss.
+
+It is worth noticing that the success of both kinds of losses is strongly affected by the number and the quality of the negative samples. For instance, in the case of the triplet loss, a common practice is to select hard/semi-hard negatives (Schroff et al., 2015; Hermans et al., 2017). On the other hand, Hjelm et al. (2019) have shown that the contrastive loss needs a large number of negatives to be competitive. This implies using batches with a large size, which is computationally demanding, especially with high-resolution images. In order to alleviate this problem, Wu et al. (2018) use a memory bank of negatives, which is composed of feature-vector representations of all the training samples. He et al. (2019) conjecture that the use of large and fixed-representation vocabularies is one of the keys to the success of self-supervision in NLP. The solution proposed by He et al. (2019) extends Wu et al. (2018) using a memory-efficient queue of the last visited negatives, together with a momentum encoder which preserves the intra-queue representation consistency. Chen et al. (2020) have performed large-scale experiments confirming that a large number of negatives (and therefore a large batch size) is required for the contrastive loss to be efficient. Concurrently with our work, Grill et al. (2020) have suggested that it is not necessary to rely on the contrastive scheme, introducing a high-performing alternative based on bootstrapping.
+
+In this paper we propose a new self-supervised loss function which first scatters all the sample representations in a spherical distribution1 and then penalizes the positive pairs which are far from each other. In more detail, given a set of samples $V = \{ \mathbf { v } _ { i } \}$ , corresponding to the current minibatch of images $B = \{ x _ { i } \}$ , we first project the elements of $V$ onto a spherical distribution using a whitening transform (Siarohin et al., 2019). The whitened representations $\left\{ \mathbf { z } _ { i } \right\}$ , corresponding to $V$ , are normalized and then used to compute a Mean Squared Error (MSE) loss which accumulates the error taking into account only positive pairs $( \mathbf { z } _ { i } , \mathbf { z } _ { j } )$ . We do not need to contrast positives against negatives as in the contrastive loss or in the triplet loss because the optimization process leads to shrinking the distance between positive pairs and, indirectly, scatters the other samples to satisfy the overall spherical-distribution constraint.
+
+In summary, our contributions are the following:
+
+• We propose a new loss function, Whitening MSE (W-MSE), for self-supervised training. W-MSE constrains the batch samples to lie in a spherical distribution and it is an alternative to positive-negative instance contrasting methods.   
+Our loss does not rely on negatives, thus including more positive samples in the batch can be beneficial; we indeed demonstrate that multiple positive pairs extracted from one image improve the performance.   
+• We empirically show that our W-MSE loss outperforms the commonly adopted contrastive loss when measured using different standard classification protocols. We show that W-MSE is competitive with respect to state-of-the-art self-supervised methods.
+
+# 2 BACKGROUND AND RELATED WORK
+
+A typical self-supervised method is composed of two main components: a pretext task, which exploits some a-priori knowledge about the domain to automatically extract supervision from data, and a loss function. In this section we briefly review both aspects, and we additionally analyse the recent literature concerning feature whitening.
+
+Pretext Tasks. The temporal consistency in a video provides an intuitive form of self-supervision: temporally-close frames usually contain a similar semantic content (Wang & Gupta, 2015; van den Oord et al., 2018). Misra et al. (2016) extended this idea using the relative temporal order of 3 frames, while Dwibedi et al. (2019) used a temporal cycle consistency for self-supervision, which is based on comparing two videos sharing the same semantics and computing inter-video frame-toframe nearest neighbour assignments.
+
+When dealing with still images, the most common pretext task is instance discrimination (Wu et al. (2018)): from a training image $x$ , a composition of data-augmentation techniques are used to extract two different views of $x$ $\cdot \boldsymbol { x } _ { i }$ and $x _ { j }$ ). Commonly adopted transformations are: image cropping, rotation, color jittering, Sobel filtering, etc.. The learner is then required to discriminate $( x _ { i } , x _ { j } )$ from other views extracted from other samples (Wu et al., 2018; Ji et al., 2019; He et al., 2019; Chen et al., 2020).
+
+Denoising auto-encoders (Vincent et al., 2008) add random noise to the input image and try to recover the original image. More sophisticated pretext tasks consist in predicting the spatial order of image patches (Noroozi & Favaro, 2016; Misra & van der Maaten, 2019) or in reconstructing large masked regions of the image (Pathak et al., 2016). Hjelm et al. (2019); Bachman et al. (2019) compare the holistic representation of an input image with a patch of the same image. Henaff et al. ´ (2019) use a similar idea, where the comparison depends on the patch order: the appearance of a given patch should be predicted given the appearance of the patches which lie above it in the image.
+
+In this paper we use standard data augmentation techniques on still images to obtain positive pairs, which is a simple method to get self-supervision (Chen et al., 2020) and does not require a pretexttask specific network architecture (Hjelm et al., 2019; Bachman et al., 2019; Henaff et al., 2019). ´
+
+Loss functions. Denoising auto-encoders use a reconstruction loss which compares the generated image with the input image before adding noise. Other generative methods use an adversarial loss in which a discriminator provides supervisory information to the generator (Donahue et al., 2017; Donahue & Simonyan, 2019).
+
+Early self-supervised (deep) discriminative methods used a triplet loss (Wang & Gupta, 2015; Misra et al., 2016): given two positive images $x _ { i } , x _ { j }$ and a negative $x _ { k }$ (Sec. 1), together with their corresponding latent-space representations $\mathbf { z } _ { i } , \mathbf { z } _ { j } , \mathbf { z } _ { k }$ , this loss penalizes those cases in which $\mathbf { z } _ { i }$ and $\mathbf { z } _ { k }$ are closer to each other than $\mathbf { z } _ { i }$ and $\mathbf { z } _ { j }$ plus a margin $m$ :
+
+$$
+L _ { T r i p l e t } = - \operatorname* { m a x } ( \mathbf { z } _ { i } ^ { T } \mathbf { z } _ { k } - \mathbf { z } _ { i } ^ { T } \mathbf { z } _ { j } + m , 0 ) .
+$$
+
+Most of the recent self-supervised discriminative methods are based on some contrastive loss (Hadsell et al., 2006) variant, in which $\mathbf { z } _ { i }$ and $\mathbf { z } _ { j }$ are contrasted against a set of negative pairs. Following the common formulation proposed by van den Oord et al. (2018):
+
+$$
+L _ { C o n t r a s t i v e } = - \log \frac { \exp { ( \mathbf { z } _ { i } ^ { T } \mathbf { z } _ { j } / \tau ) } } { \sum _ { k = 1 , k \neq i } ^ { K } \exp { ( \mathbf { z } _ { i } ^ { T } \mathbf { z } _ { k } / \tau ) } } ,
+$$
+
+where $\tau$ is a temperature hyperparameter which should be manually set and the sum in the denominator is over a set of $K - 1$ negative samples. Usually $K$ is the size of the current batch, i.e., $K = 2 N$ , being $N$ the number of the positive pairs. However, as shown by Hjelm et al. (2019), the contrastive loss (2) requires a large number of negative samples to be competitive. Wu et al. (2018); He et al. (2019) use a set of negatives much larger than the current batch, by pre-computing latent-space representations of old samples. SimCLR (Chen et al. (2020)) uses a simpler, but computationally very demanding, solution based on large batches.
+
+While recent works (van den Oord et al., 2018; Henaff et al., 2019; Hjelm et al., 2019; Bachman ´ et al., 2019; Ravanelli & Bengio, 2018) draw a relation between the contrastive loss and an estimate of the mutual information between the latent-space image representations, Tschannen et al. (2019) showed that the success of this loss is likely related to learning a metric space, similarly to what happens with a triplet loss. On the other hand, Wang & Isola (2020) showed that the $L _ { 2 }$ normalized contrastive loss asymptotically converges to the minimization of two desirable characteristics of the latent-space representations on the surface of the unit hypersphere: uniformity and semantic alignment. In the same paper, the authors propose two new losses ( ${ \mathcal L } _ { \mathrm { u n i f o r m } }$ and $\mathcal { L } _ { \mathrm { a l i g n } , }$ ) which explicitly deal with these characteristics.
+
+Concurrently with our work, BYOL (Grill et al. (2020)) proposes a “bootstrapping” scheme which is alternative to the positive-negative contrastive learning. In BYOL, an “online” network is optimised to predict the output of a “target” network, whose parameters are a running average of the online network. The predictions of the two networks are compared using an additional prediction network and an MSE loss. However, very recently, Fetterman & Albrecht (2020) and Tian et al. (2020) have empirically shown that BYOL can avoid a collapsed solution through the use of the Batch Norm (BN) (Ioffe & Szegedy, 2015) which avoids constant representations. Our work can be seen as a generalization of this finding with a much simpler network architecture (more details in Sec. 3.1).
+
+In this paper we propose a different loss which is competitive with respect to other alternatives. Our loss formulation is simpler because it does not require a proper setting of the $\tau$ hyperparameter in equation 2, $m$ in equation 1, or additional networks with a specific weight update schemes as in BYOL.
+
+Feature Whitening. We adopt the efficient and stable Cholesky decomposition (Dereniowski & Marek, 2004) based whitening transform proposed by Siarohin et al. (2019) to project our latentspace vectors into a spherical distribution (more details in Sec. 3). Note that Huang et al. (2018);
+
+![](images/d1a34f8c28ebe7ade64be93a372c8c1761ea3e488a8ecaa0f60e91f994505bfc.jpg)  
+Figure 1: A schematic representation of the W-MSE based optimization process. Positive pairs are indicated with the same shapes and colors. (1) A representation of the feature batch $V$ when training starts. (2, 3) The distribution of the elements after whitening and $L _ { 2 }$ normalization. (4) The MSE computed over the normalized $\mathbf { z }$ features encourages the network to move the positive pair representations closer to each other. (5) The subsequent iterations move closer and closer the positive pairs, while the relative layout of the other samples is forced to lie in a spherical distribution.
+
+Siarohin et al. (2019) use whitening transforms in the intermediate layers of the network for a completely different task: extending BN to a multivariate batch normalization.
+
+# 3 THE WHITENING MSE LOSS
+
+Given an image $x$ , we extract an embedding $\mathrm { ~ \bf ~ z ~ } = \mathrm { ~ \bf ~ \it ~ f ~ } ( x ; \theta )$ using an encoder network $f ( \cdot ; \theta )$ parametrized with $\theta$ (more details below). We require that: (1) the image embeddings are drawn from a non-degenerate distribution (the latter being a distribution where, e.g., all the representations collapse to a single point), and (2) positive image pairs $( x _ { i } , x _ { j } )$ , which share a similar semantics, should be clustered close to each other. We formulate this problem as follows:
+
+$$
+\begin{array} { c } { m i n _ { \theta } \operatorname { \mathbb { E } } d i s t ( \mathbf { z } _ { i } , \mathbf { z } _ { j } ) , } \\ { s . t . c o v ( \mathbf { z } _ { i } , \mathbf { z } _ { i } ) = c o v ( \mathbf { z } _ { j } , \mathbf { z } _ { j } ) = I , } \end{array}
+$$
+
+where $d i s t ( \cdot )$ is a distance between vectors, $I$ is the identity matrix and $( \mathbf { z } _ { i } , \mathbf { z } _ { j } )$ corresponds to a positive pair of images $( x _ { i } , x _ { j } )$ . With equation 4, we constrain the distribution of the $\mathbf { z }$ values to be non-degenerate, hence avoiding that all the probability mass is concentrated in a single point. Moreover, equation 4 makes all the components of $\mathbf { z }$ to be linearly independent from each other, which encourages the different dimensions of $\mathbf { z }$ to represent different semantic content. We define the distance with the cosine similarity, implemented with MSE between normalized vectors:
+
+$$
+d i s t ( \mathbf { z } _ { i } , \mathbf { z } _ { j } ) = \left\| { \frac { \mathbf { z } _ { i } } { \left\| \mathbf { z } _ { i } \right\| _ { 2 } } } - { \frac { \mathbf { z } _ { j } } { \left\| \mathbf { z } _ { j } \right\| _ { 2 } } } \right\| _ { 2 } ^ { 2 } = 2 - 2 { \frac { \langle \mathbf { z } _ { i } , \mathbf { z } _ { j } \rangle } { \left\| \mathbf { z } _ { i } \right\| _ { 2 } \cdot \left\| \mathbf { z } _ { j } \right\| _ { 2 } } }
+$$
+
+In Appendix C we also include other experiments in which the cosine similarity is replaced by the Euclidean distance. We provide below the details on how positive image samples are collected, how they are encoded and how the above optimization is implemented.
+
+First, similarly to Chen et al. (2020), we obtain positive samples sharing the same semantics from a single image $x$ and using standard image transformation techniques. Specifically, we use a composition of image cropping, grayscaling and color jittering transformations $T ( \cdot ; \mathbf { p } )$ . The parameters $\mathbf { \tau } ( \mathbf { p } )$ are selected uniformly at random and independently for each positive sample extracted from the same image: $x _ { i } = T ( x ; { \mathbf p } _ { i } )$ . We concisely indicate with $p o s ( i , j )$ the fact that $x _ { i }$ and $x _ { j } ( x _ { i } , x _ { j } \in B$ , $B$ the current batch) have been extracted from the same image.
+
+![](images/30fed903347f9275f5f14cd0634d881a6b9fc03086e82bb722a8a53a8a41ffdd.jpg)  
+Figure 2: A scheme of our training procedure. First, $d$ $Q = 4$ in this case) positive samples are generated using augmentations. These images are transformed into vectors with the encoder $E ( \cdot )$ . Next, they are projected onto a lower dimensional space with a projection head $g ( \cdot )$ . Then, Whitening projects these vectors onto a spherical distribution, followed by an optional $L _ { 2 }$ normalization. Finally, the dashed curves show all the $d ( d - 1 ) / 2 = 6$ comparisons used in our W-MSE loss.
+
+The number of positive samples per image $d$ may vary, trading off diversity in the batch and the amount of the training signal. Favoring more negatives, most of the methods use one positive pair $\left[ d = 2 \right.$ ). However, Ji et al. (2019) have demonstrated improved performance with 5 samples, while Caron et al. (2020) use 8 samples. In our MSE-based loss (see below), we use all the possible $d ( d - 1 ) / 2$ combinations of positive samples. We include experiments for $d = 2$ (1 positive pair) and $d = 4$ (6 positive pairs).
+
+For representation learning, we use a backbone encoder network $E ( \cdot ) . E ( \cdot )$ , trained without human supervision, will be used in Sec. 4 for evaluation using standard protocols. We use a standard ResNet-18 (He et al., 2016) as the encoder, and $\mathbf { h } = E ( x )$ is the output of the average-pooling layer. This choice has the advantage to be simple and easily reproducible, in contrast to other methods which use encoder architectures specific for a given pretext task (see Sec. 2). Since $\mathbf { h } \in \mathbb { R } ^ { 5 1 2 }$ is a high-dimensional vector, following Chen et al. (2020) we use a nonlinear projection head $g ( \cdot )$ to project h in a lower dimensional space: $\mathbf { v } = g ( \mathbf { h } )$ , where $g ( \cdot )$ is implemented with a MLP with one hidden layer and a BN layer. The whole network $f ( \cdot )$ is given by the composition of $g ( \cdot )$ with $E ( \cdot )$ (see Fig. 2).
+
+Given $N$ original images and a batch of samples $B = \{ x _ { 1 } , . . . x _ { K } \}$ , where $K \ : = \ : N d$ , let $V =$ $\left\{ \mathbf { v } _ { 1 } , \ldots \mathbf { v } _ { K } \right\}$ , be the corresponding batch of features obtained as described above. In the proposed W-MSE loss we compute the MSE over all $N d ( d { - } 1 ) / 2$ positive pairs, where constraint 4 is satisfied using the reparameterization of the $\mathbf { v }$ variables with the whitened variables $\mathbf { z }$ :
+
+$$
+L _ { W - M S E } ( V ) = \frac { 2 } { N d ( d - 1 ) } \sum _ { ( { \bf v } _ { i } , { \bf v } _ { j } ) \in V , p o s ( i , j ) } d i s t ( { \bf z } _ { i } , { \bf z } _ { j } ) ,
+$$
+
+where $\mathbf { z } = W h i t e n i n g ( \mathbf { v } )$ , and:
+
+$$
+W h i t e n i n g ( \mathbf { v } ) = W _ { V } ( \mathbf { v } - { \pmb \mu } _ { V } ) .
+$$
+
+In equation 7, $\pmb { \mu } _ { V }$ is the mean of the elements in $V$ : $\begin{array} { r } { \pmb { \mu } _ { V } = \frac { 1 } { K } \sum _ { k } \mathbf { v } _ { k } } \end{array}$ , while the matrix $W _ { V }$ is such that: $W _ { V } ^ { \top } W _ { V } = \Sigma _ { V } ^ { - 1 }$ , being $\Sigma _ { V }$ the covariance matrix of $V$ :
+
+$$
+\boldsymbol { \Sigma } _ { V } = \frac { 1 } { K - 1 } \sum _ { k } ( { \bf v } _ { k } - { \pmb \mu } _ { V } ) ( { \bf v } _ { k } - { \pmb \mu } _ { V } ) ^ { T } .
+$$
+
+For more details on how $W _ { V }$ is computed, we refer to Appendix B. Equation 7 performs the full whitening of each $\mathbf { v } _ { i } \in V$ and the resulting set of vectors $Z = \{ { \bf z } _ { 1 } , . . . , { \bf z } _ { K } \}$ lies in a zero-centered distribution with a covariance matrix equal to the identity matrix (Fig. 1).
+
+![](images/670f016219ae719cc7b4ed09e98be2e40ee9566bbaefc881897287654761deab.jpg)  
+Figure 3: Batch slicing. $V$ is first partitioned in $d$ parts $\left( d = 2 \right.$ in this example). We randomly permute the first part and we apply the same permutation to the other $d - 1$ parts. Then, we further split all the partitions and we create sub-batches $( V _ { i } )$ . Each $V _ { i }$ is independently used to compute the sub-batch specific whitening matrix $W _ { V } ^ { i }$ and centroid $\mu _ { V } ^ { i }$ .
+
+The intuition behind the proposed loss is that equation 6 penalizes positives which are far apart from each other, thus leading $\overset { \cdot } { g } ( \bar { E } ( \cdot ) )$ to shrink the inter-positive distances. On the other hand, since $Z$ must lie in a spherical distribution, the other samples should be “moved” and rearranged in order to satisfy constraint 4 (see Fig. 1).
+
+Batch Slicing. The estimation of the Mean Square Error in equation 6 depends on the whitening matrix $W _ { V }$ , which may have a high variance over consecutive iteration batches $V _ { t } , V _ { t + 1 } , \dots$ For this reason, inspired by the resampling methods (Efron, 1982), given a batch $V$ , we slice $V$ in different non-overlapping sub-batches and we compute a whitening matrix independently for each sub-batch. In more details, we first partition the batch in $d$ parts, being $d$ the number of positives extracted from one image. In this way, each partition contains elements extracted from different original images (i.e., no pair of positives is included in a single partition, see Fig. 3). Then, we randomly permute the elements of the each partition with the same permutation. Next, each partition is further split in sub-batches, using the heuristic that the size of each sub-batch $( V _ { i } )$ should be equal to the size of embedding (v) times 2 (this prevents instability issues when computing the covariance matrices). Next, for each $V _ { i }$ , we use only its elements to compute a corresponding whitening matrix $W _ { V } ^ { i }$ , which is used to whiten the elements of $V _ { i }$ only (Fig. 3). In the loss computation (equation 6), all the elements of all the sub-batches are used, thus implicitly alleviating the differences among the different whitening matrices. Finally, it is possible to repeat the whole operation several times and to average the result to get a more robust estimate of equation 6.
+
+# 3.1 DISCUSSION
+
+In a common instance-discrimination task (Sec. 2), e.g., solved using equation 2, the similarity of a positive pair $( \mathbf { z } _ { i } ^ { T } \mathbf { z } _ { j } )$ is contrasted with the similarity computed with respect to all the other samples $( { \bf z } _ { k } )$ in the batch $\mathbf { \langle z } _ { i } ^ { T } \mathbf { z } _ { k } , 1 \leq k \leq K , k \neq i )$ . However, $\mathbf { z } _ { k }$ and $\mathbf { z } _ { i }$ , extracted from different image instances, can occasionally share the same semantics (e.g., $x _ { i }$ and $x _ { k }$ are two different image instances of the unknown “cat” class). Conversely, the proposed W-MSE loss does not force all the instance samples to lie far from each other, but it only imposes a soft constraint (equation 4), which avoids degenerate distributions.
+
+Note that previous work (He et al., 2019; Henaff et al., 2019; Chen et al., 2020) highlighted that ´ BN may be harmful for learning semantically meaningful representations because the network can “cheat” and exploit the batch statistics in order to find a trivial solution to equation 2. However, our whitening transform (equation 7) is applied only to the very last layer of the network $f ( \cdot )$ (see Fig. 2) and it is not used in the intermediate layers, which is instead the case of BN. Hence, our $f ( \cdot )$ cannot learn to exploit subtle inter-sample dependencies introduced by batch-statistics because of the lack of other learnable layers on top of the $\mathbf { z }$ features.
+
+Similarly to equation 6, in BYOL (Grill et al., 2020) an MSE loss is used to compare the latent representations of two positives computed by slightly different networks without contrasting positives with negatives (Sec. 2). However, the MSE loss alone is inclined to collapse the representations of all the images to a constant value, which would make the MSE computation equal to zero. In BYOL, both the projection and the prediction sub-networks have BN layers, and, very recently, (Fetterman & Albrecht, 2020; Tian et al., 2020) have empirically shown that BYOL, without these BN layers, generates collapsed latent-space representations with a close-to-chance level classification accuracy. The reason of this behaviour seems to depend on the fact that the feature standardization in BN scatters the $\mathbf { z }$ values in a batch and avoids constant representations. Our W-MSE can be seen as a generalization of this implicit property of BYOL, in which the $\mathbf { z }$ values of the current batch are full-whitened, so preventing possible collapsing effects of the MSE loss. Importantly, we reach this result without the need of a target network or sophisticated training protocols.
+
+Finally, note that using BN alone without whitening, as in W-MSE, and without additional networks, as in BYOL, is not sufficient. Indeed, if we just minimize an MSE after feature standardization, the network can easily find a solution where all the dimensions of the embedding represent the same feature. We have empirically verified this behaviour in preliminary experiments based on standardization, in which the network converges to a zero loss value after a few epochs but with a low classification accuracy.
+
+# 4 EXPERIMENTS
+
+We test our loss and its competitors on the following datasets.
+
+• CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009), two small-scale datasets composed of $3 2 \times 3 2$ images with 10 and 100 classes, respectively.   
+• Tiny ImageNet (Le & Yang, 2015), a reduced version of ImageNet, composed of 200 classes with images scaled down to $6 4 \times 6 4$ . The total number of images is: 100K (training) and 10K (testing). STL-10 (Coates et al., 2011), also derived from ImageNet, with $9 6 \times 9 6$ resolution images. While CIFAR-10, CIFAR-100 and Tiny ImageNet are fully-labeled, STL-10 is composed of 5K labeled training samples (500 per class) and 100K unlabeled training examples from a similar but broader distribution of images. There are additional 8K labeled testing images.   
+• ImageNet-100, a random 100-class subset of ImageNet (the list of the 100 classes is published in (Wang & Isola, 2020)), consisting of unaltered ImageNet images.
+
+Setting. The goal of our experiments is to compare W-MSE with state-of-the-art losses, isolating the effects of other settings, such as the architectural choices. For this reason, we use the same encoder $E ( \cdot )$ ResNet-18 for all the experiments. We independently select the best hyperparameter values for every method and every dataset. Each method uses $L _ { 2 }$ feature normalization unless otherwise stated. Contrastive refers to our implementation of the contrastive loss (equation 2) following the details in (Chen et al., 2020), with temperature $\tau = 0 . 5$ . BYOL is our reproduction of (Grill et al., 2020), introduced concurrently with our work. For this method we use the exponential moving average with cosine increasing, starting from 0.99. W-MSE 2 and W-MSE 4 correspond to our method with $d = 2$ and $d = 4$ positives extracted per image, respectively. For CIFAR-10 and CIFAR-100, the slicing sub-batch size is 128, for Tiny ImageNet and STL-10, it is 256. For experiments W-MSE 2 for Tiny ImageNet and STL-10 we use 4 iterations of batch slicing, for all other experiments we use 1 iteration.
+
+In all the experiments, we use the Adam optimizer (Kingma & Ba, 2014). For all the tested methods (including ours), we use the same number of epochs and the same learning rate schedule. Specifically, for CIFAR-10 and CIFAR-100, we use 1,000 epochs with learning rate $3 \times 1 0 ^ { - 3 }$ ; for Tiny ImageNet, 1,000 epochs with learning rate $2 \times 1 0 ^ { - 3 }$ ; for STL-10, 2,000 epochs with learning rate $2 \times \mathrm { 1 0 ^ { - 3 } }$ . We use learning rate warm-up for the first 500 iterations of the optimizer, and a 0.2 learning rate drop 50 and 25 epochs before the end. We use a mini-batch size of $K = 1 0 2 4$ samples. The dimension of the hidden layer of the projection head $g ( \cdot )$ is 1024. The weight decay is $1 \bar { 0 } ^ { - 6 }$ . Finally, we use an embedding size of 64 for CIFAR-10 and CIFAR-100, and an embedding of size of 128 for STL-10 and Tiny ImageNet. For ImageNet-100 we use a configuration similar to the Tiny ImageNet experiments, and 240 epochs of training.
+
+As a common practice when using ResNet-like architectures for small-size image resolutions, in all the experiments, except ImageNet-100, we have a first convolutional layer with kernel size 3, stride 1 and padding 1. Additionally, in case of CIFAR-10 and CIFAR-100, we remove the first max pooling layer.
+
+Table 1: Classification accuracy (top 1) of a linear classifier and a 5-nearest neighbors classifier for different loss functions and datasets with a ResNet-18 encoder.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">CIFAR-10</td><td rowspan="2">CIFAR-100</td><td colspan="2">STL-10</td><td rowspan="2"></td><td colspan="2"> Tiny ImageNet</td></tr><tr><td>linear</td><td>5-nn</td><td>linear 5-nn</td><td>linear</td><td>5-nn linear</td><td>5-nn</td></tr><tr><td>Contrastive</td><td>91.80</td><td>88.42</td><td>66.83</td><td>56.56</td><td>90.51</td><td>85.68</td><td>48.84</td><td>32.86</td></tr><tr><td>BYOL</td><td>91.73</td><td>89.45</td><td>66.60</td><td>56.82</td><td>91.99</td><td>88.64</td><td>51.00</td><td>36.24</td></tr><tr><td>W-MSE 2</td><td>91.55</td><td>89.69</td><td>66.10</td><td>56.69</td><td>90.36</td><td>87.10</td><td>48.20</td><td>34.16</td></tr><tr><td>W-MSE 4</td><td>91.99</td><td>89.87</td><td>67.64</td><td>56.45</td><td>91.75</td><td>88.59</td><td>49.22</td><td>35.44</td></tr></table>
+
+Table 2: Classification accuracy on ImageNet-100. W-MSE (2 and 4) are based on a ResNet-18 encoder. † indicates that the results are based on a ResNet-50 encoder and the values are reported from (Wang & Isola, 2020).   
+
+<table><tr><td>Method</td><td>linear (top 1)</td><td>linear (top 5)</td><td>5-nn</td></tr><tr><td>MoCot</td><td>72.80</td><td>91.64</td><td>1</td></tr><tr><td>Lalign and Luniform +</td><td>74.60</td><td>92.74</td><td>1</td></tr><tr><td>W-MSE 2</td><td>76.00</td><td>93.14</td><td>67.04</td></tr><tr><td>W-MSE 4</td><td>79.02</td><td>94.46</td><td>71.32</td></tr></table>
+
+Image Transformation Details. We extract crops with a random size from 0.2 to 1.0 of the original area and a random aspect ratio from $3 / 4$ to $4 / 3$ of the original aspect ratio, which is a commonly used data-augmentation technique. We also apply horizontal mirroring with probability 0.5. Finally, we apply color jittering with configuration $( 0 . 4 , 0 . 4 , 0 . 4 , 0 . 1 )$ with probability 0.8 and grayscaling with probability 0.1. For ImageNet-100 we follow details in (Chen et al., 2020): crop size from 0.08 to 1.0, stronger jittering (0.8, 0.8, 0.8, 0.2), grayscaling probability 0.2, and Gaussian blurring with 0.5 probability.
+
+Evaluation Protocol. The most common evaluation protocol for unsupervised feature learning is based on freezing the network encoder $( E ( \cdot )$ , in our case) after unsupervised pre-training, and then train a supervised linear classifier on top of it. Specifically, the linear classifier is a fully-connected layer followed by softmax, which is placed on top of $E ( \cdot )$ after removing the projection head $g ( \cdot )$ . In all the experiments we train the linear classifier for 500 epochs using the Adam optimizer and the labeled training set of each specific dataset, without data augmentation. The learning rate is exponentially decayed from $1 0 ^ { - 2 }$ to $1 0 ^ { - 6 }$ . The weight decay is $5 \times 1 0 ^ { - 6 }$ .
+
+In our experiments, we also include the accuracy of a $\mathbf { k }$ -nearest neighbors classifier (k-nn, $k = 5$ ). The advantage of using this classifier is that it does not require additional parameters and training, and it is deterministic.
+
+# 4.1 COMPARISON WITH THE STATE OF THE ART
+
+Tab. 1 shows the results of the experiments on small and medium size datasets. For W-MSE, 4 samples are generally better than 2. The contrastive loss performs the worst in most cases. The W-MSE 4 accuracy is the best on CIFAR-10 and CIFAR-100, while BYOL leads on STL-10 and Tiny ImageNet, although the gap between the two methods is minor. In Appendix A, we plot the linear classification accuracy during training for the STL-10 dataset. The plot shows that W-MSE 4 and BYOL have a similar performance during most of the training. However, in the first 120 epochs, BYOL significantly underperforms W-MSE 4 (e.g., the accuracy after 20 epochs: W-MSE 4, $7 9 . 9 8 \%$ ; BYOL, $7 3 . 2 4 \%$ ), indicating that BYOL requires a “warmup” period. On the other hand, W-MSE performs well from the beginning. This property is useful in those domains which require a rapid adaptation of the encoder, e.g., due to the change of the data distribution in continual learning or in reinforcement learning.
+
+Tab. 2 shows the results on a larger dataset (ImageNet-100). In that table, MoCo is the contrastiveloss based method proposed in (He et al., 2019), where a momentum encoder and a large queue of negatives are used to improve the contrast of the positive pairs with respect to the other samples (see Sec. 2). $\mathcal { L } _ { \mathrm { a l i g n } }$ and ${ \mathcal { L } } _ { \mathrm { u n i f o r m } }$ are the two losses proposed in (Wang & Isola, 2020) (Sec. 2). Note that, while W-MSE (2 and 4) in Tab. 2 refer to our method with a ResNet-18 encoder, the other results are reported from (Wang & Isola, 2020), where a much larger-capacity network (i.e., a ResNet-50) is used as the encoder. Despite this large difference in the encoder capacity, both versions of W-MSE significantly outperform the other two compared methods in this dataset.
+
+# 4.2 TRAINING TIME COMPLEXITY
+
+Following (Siarohin et al., 2019), the complexity of the whitening transform is $O ( k ^ { 3 } + M k ^ { 2 } )$ , where $k$ is the embedding dimension and $M$ is the size of the sub-batch used in the batch slicing process. Since $k < M$ (see Sec. 3), the whitening transform is $O ( M k ^ { 2 } )$ , which is basically equivalent to the forward pass of $M$ activations in a fully-connected layer connecting two layers of $k$ neurons each. In fact, the training time is dominated by other architectural choices which are usually more computationally demanding than the loss computation. For instance, BYOL (Grill et al., 2020) needs 4 forward passes through 2 networks for each pair of positives. Hence, to evaluate the wallclock time, we measure the time spent for one mini-batch iteration by all the methods compared in Tab. 1. We use the STL-10 dataset, a ResNet-18 encoder and a server with one Nvidia Titan $\mathrm { X p }$ GPU. Time of one iteration: Contrastive - 459ms, BYOL - 602ms, W-MSE 2 - 478ms, W-MSE 4 - $4 9 3 \mathrm { m s }$ . The $1 9 \mathrm { m s }$ difference between Contrastive and W-MSE 2 is due to the whitening transform. Since the factual time is mostly related to the sample forward and backward passes, the $d ( d - 1 )$ positive comparisons in equation 6 do not significantly increase the wall-clock time of W-MSE 4 with respect to W-MSE 2.
+
+# 4.3 CONTRASTIVE LOSS WITH WHITENING
+
+Table 3: Accuracy of the whitened contrastive loss on CIFAR-10 trained for 200 epochs.   
+
+<table><tr><td>Method</td><td>linear</td><td>5-nn</td></tr><tr><td>Contrastive</td><td>89.66</td><td>86.55</td></tr><tr><td>Contrastive with Whitening</td><td colspan="2">diverged</td></tr><tr><td>Contrastive,unnormalized features</td><td>79.48</td><td>76.60</td></tr><tr><td>Contrastive with Whitening,unnormalized features</td><td>77.39</td><td>74.14</td></tr></table>
+
+In this section, we analyse the effect of the whitening transform in combination with the contrastive loss. Tab. 3 shows the results. The first row refers to the standard contrastive loss. Note that the difference with respect to Tab.1 is due to the use of only 200 training epochs. The second row refers to equation 2, where the features $\mathbf { \rho } ( \mathbf { z } )$ are computed using equation 7 and then $L _ { 2 }$ normalized, while in the last two rows, $\mathbf { z }$ is not normalized. If the features are whitened and then normalized, we observed an unstable training, with divergence after a few epochs. The unnormalized version with whitening converged, but its accuracy is worse than the standard contrastive loss (both normalized and unnormalized). This experiments show that whitening itself does not improve the performance, but it only allows to satisfy the constraint 4.
+
+# 5 CONCLUSION
+
+In this paper, we have proposed a new self-supervised representation learning loss, W-MSE, which is alternative to common loss functions used in the field. Differently from the triplet loss and the contrastive loss, both of which are based on comparing an instance-level similarity against other samples, W-MSE computes only the intra-positive distances, while using a whitening transform to avoid degenerate solutions. Despite W-MSE is very simple, its classification accuracy is comparable with state-of-the-art methods, achieving results significantly higher than MoCo, which requires an additional momentum encoder and a large queue of past samples. W-MSE is also comparable with BYOL, which needs an additional target network and a specific training protocol. We believe that the use of whitening to avoid collapsing effects can inspire other self-supervised methods.
+
+# REFERENCES
+
+Philip Bachman, R. Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In NeurIPS, 2019.
+
+Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments, 2020.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations, 2020.
+
+Adam Coates, Andrew Y. Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In AISTATS, 2011.
+
+Dariusz Dereniowski and Kubale Marek. Cholesky factorization of matrices in parallel and ranking of graphs. In 5th Int. Conference on Parallel Processing and Applied Mathematics, 2004.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL,, 2019.
+
+Jeff Donahue and Karen Simonyan. Large scale adversarial representation learning. In NeurIPS, 2019.
+
+Jeff Donahue, Philipp Krahenb ¨ uhl, and Trevor Darrell. Adversarial feature learning. In ¨ ICLR, 2017.
+
+Debidatta Dwibedi, Yusuf Aytar, Jonathan Tompson, Pierre Sermanet, and Andrew Zisserman. Temporal cycle-consistency learning. In CVPR, 2019.
+
+Bradley Efron. The jackknife, the bootstrap, and other resampling plans, volume 38. Siam, 1982.
+
+Abe Fetterman and Josh Albrecht. Understanding self-supervised and contrastive learning with bootstrap your own latent (BYOL). https://untitled-ai.github.io/understanding-self-supervisedcontrastive-learning.html, 2020.
+
+Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H. Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, Bilal Piot, Koray Kavukcuoglu, Remi Munos, and Michal Valko. Bootstrap your own ´ latent: A new approach to self-supervised learning, 2020.
+
+Michael Gutmann and Aapo Hyvarinen. Noise-contrastive estimation: A new estimation principle ¨ for unnormalized statistical models. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, 2010.
+
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In CVPR, 2006.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv:1911.05722, 2019.
+
+Olivier J. Henaff, Ali Razavi, Carl Doersch, S. M. Ali Eslami, and A ´ aron van den Oord. Data- ¨ efficient image recognition with contrastive predictive coding. arXiv:1905.09272, 2019.
+
+Alexander Hermans, Lucas Beyer, and Bastian Leibe. In defense of the triplet loss for person reidentification. arXiv:1703.07737, 2017.
+
+R. Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Philip Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019.
+
+Lei Huang, Dawei Yang, Bo Lang, and Jia Deng. Decorrelated batch normalization. In CVPR, 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+Xu Ji, Joao F. Henriques, and Andrea Vedaldi. Invariant information clustering for unsupervised ˜ image classification and segmentation. In ICCV, 2019.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical Report, 2009.
+
+Ya Le and Xuan Yang. Tiny imagenet visual recognition challenge. 2015.
+
+Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv:1301.3781, 2013a.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Gregory S. Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. In NIPS, 2013b.
+
+Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. arXiv:1912.01991, 2019.
+
+Ishan Misra, C. Lawrence Zitnick, and Martial Hebert. Shuffle and learn: Unsupervised learning using temporal order verification. In ECCV, 2016.
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, 2016.
+
+Deepak Pathak, Philipp Krahenb ¨ uhl, Jeff Donahue, Trevor Darrell, and Alexei A. Efros. Context ¨ encoders: Feature learning by inpainting. CVPR, 2016.
+
+Mirco Ravanelli and Yoshua Bengio. Learning speaker representations with mutual information. arXiv:1812.00271, 2018.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. FaceNet: A unified embedding for face recognition and clustering. In CVPR, 2015.
+
+Aliaksandr Siarohin, Enver Sangineto, and Nicu Sebe. Whitening and coloring transform for GANs. In International Conference on Learning Representations, 2019.
+
+Kihyuk Sohn. Improved deep metric learning with multi-class n-pair loss objective. In NIPS, 2016.
+
+Yuandong Tian, Lantao Yu, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning with dual deep networks. arXiv:2010.00578, 2020.
+
+Michael Tschannen, Josip Djolonga, Paul K. Rubenstein, Sylvain Gelly, and Mario Lucic. On mutual information maximization for representation learning. arXiv:1907.13625, 2019.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predic- ¨ tive coding. arXiv:1807.03748, 2018.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In ICML, 2008.
+
+Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. In International Conference on Machine Learning, 2020.
+
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015.
+
+Zhirong Wu, Yuanjun Xiong, Stella Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance-level discrimination. arXiv:1805.01978, 2018.
+
+# A TRAINING DYNAMICS
+
+Fig. 4 and 5 show the training dynamics for each of the considered losses. Charts are smoothed with a 0.3 moving average for readability (curves before smoothing are shown semi-transparent).
+
+![](images/4da7361dea4e214120a4f83ad835fe56daaf9d4478d45e9de5e947e5f9e43203.jpg)  
+Figure 4: Training dynamics on STL-10 dataset for linear classifier
+
+![](images/56fa92474a274079c986ab314b71342c7622615ad0b973ce49ef164a7fafb890.jpg)  
+Figure 5: Training dynamics on STL-10 dataset for 5-nn classifier
+
+# B CHOLESKY WHITENING AND BACKPROGATION
+
+We compute $W _ { V }$ (equation 8) following (Siarohin et al., 2019) and using the Cholesky decomposition. The Cholesky decomposition is based on the factorisation of the covariance symmetric matrix using two triangular matrices: $\Sigma _ { V } = L L ^ { \top }$ , where $L$ is a lower triangular matrix. Once we get $L$ , we compute the inverse of $L$ , and we get: $W _ { V } = L ^ { - 1 }$ . Note that Cholesky decomposition is fully diferentiable and it is implemented in all of the major frameworks, such as PyTorch and TensorFlow. However, for the sake of completeness, we provide below the gradient computation.
+
+# B.1 GRADIENT COMPUTATION
+
+We provide here the equations for whitening differentiation. Let $Z$ be the whitened version of the batch $V$ , i.e., $Z = W _ { V } ( V - \mu _ { V } )$ (equation 7). The gradient $\textstyle { \frac { \partial L } { \partial V } }$ can be computed by:
+
+$$
+\frac { \partial L } { \partial V } = \frac { 2 } { K - 1 } \frac { \partial L } { \partial \Sigma } V + W _ { V } ^ { T } \frac { \partial L } { \partial Z } .
+$$
+
+where the partial derivative $\frac { \partial L } { \partial Z }$ is backpropogated, while $\frac { \partial L } { \partial \Sigma }$ is computed as follows:
+
+$$
+\frac { \partial L } { \partial \Sigma } = - \frac { 1 } { 2 } W _ { V } ^ { T } \left( P \circ \frac { \partial L } { \partial W _ { V } } W _ { V } ^ { T } + \left( P \circ \frac { \partial L } { \partial W _ { V } } W _ { V } ^ { T } \right) ^ { T } \right) W _ { V }
+$$
+
+In equation $1 0 , \circ$ is Hadamard product, while $\frac { \partial L } { \partial W _ { V } }$ is:
+
+$$
+\frac { \partial \cal { L } } { \partial W _ { V } } = \frac { \partial \cal { L } } { \partial Z } V ^ { T } ,
+$$
+
+and $P$ is:
+
+$$
+P = \left( { \begin{array} { l l l l } { { \frac { 1 } { 2 } } } & { 0 } & { \cdots } & { 0 } \\ { 1 } & { { \frac { 1 } { 2 } } } & { \ddots } & { 0 } \\ { 1 } & { \ddots } & { \ddots } & { 0 } \\ { 1 } & { \cdots } & { 1 } & { { \frac { 1 } { 2 } } } \end{array} } \right) .
+$$
+
+# C EUCLIDEAN DISTANCE
+
+Table 4: Classification accuracy (top 1) using the Euclidean distance (unnormalized embeddings) on STL-10.   
+
+<table><tr><td>Method</td><td> linear</td><td>5-nn</td></tr><tr><td>Contrastive</td><td>78.00</td><td>71.07</td></tr><tr><td>BYOL</td><td>80.83</td><td>74.94</td></tr><tr><td>W-MSE 2</td><td>89.91</td><td>85.56</td></tr><tr><td>W-MSE 4</td><td>90.40</td><td>87.09</td></tr></table>
+
+The cosine similarity is a crucial component in most of the current self-supervised learning approaches. This is usually implemented with an $L _ { 2 }$ normalization of the latent representations, which corresponds to projecting the features on the surface of the unit hypersphere. However, in our WMSE, the whitening transform projects the representation onto a spherical distribution (intuitively, we can say on the whole unit hypersphere). Preserving the module of the features before the $L _ { 2 }$ normalization may be useful in some applications, e.g., clustering the features after the projection head using a Gaussian mixture model. Tab. 4 shows an experiment on the STL-10 dataset where we use unnormalized embeddings for all the methods (and $\tau = 1$ for the contrastive loss). Comparing Tab. 4 with Tab. 1, the accuracy decrease of W-MSE is significantly smaller than the other methods.

parse/train/3Wp8HM2CNdR/3Wp8HM2CNdR_content_list.json

@@ -0,0 +1,1620 @@
+[
+    {
+        "type": "text",
+        "text": "WHITENING FOR SELF-SUPERVISED REPRESENTATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            607,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most of the self-supervised representation learning methods are based on the contrastive loss and the instance-discrimination task, where augmented versions of the same image instance (“positives”) are contrasted with instances extracted from other images (“negatives”). For the learning to be effective, a lot of negatives should be compared with a positive pair, which is computationally demanding. In this paper, we propose a different direction and a new loss function for selfsupervised representation learning which is based on the whitening of the latentspace features. The whitening operation has a “scattering” effect on the batch samples, which compensates the use of negatives, avoiding degenerate solutions where all the sample representations collapse to a single point. Our Whitening MSE (W-MSE) loss does not require special heuristics (e.g. additional networks) and it is conceptually simple. Since negatives are not needed, we can extract multiple positive pairs from the same image instance. We empirically show that WMSE is competitive with respect to popular, more complex self-supervised methods. The source code of the method and all the experiments is included in the Supplementary Material. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the current main bottlenecks in deep network training is the dependence on large annotated training datasets, and this motivates the recent surge of interest in unsupervised methods. Specifically, in self-supervised representation learning, a network is (pre-)trained without any form of manual annotation, thus providing a means to extract information from unlabeled-data sources (e.g., text corpora, videos, images from the Internet, etc.). In self-supervision, label information is replaced by a prediction problem using some form of context or using a pretext task. Pioneering work in this direction was done in Natural Language Processing (NLP), in which the co-occurrence of words in a sentence is used to learn a language model (Mikolov et al., 2013a;b; Devlin et al., 2019). In Computer Vision, typical contexts or pretext tasks are based on: (1) the temporal consistency in videos (Wang & Gupta, 2015; Misra et al., 2016; Dwibedi et al., 2019), (2) the spatial order of patches in still images (Noroozi & Favaro, 2016; Misra & van der Maaten, 2019; Henaff et al., 2019) ´ or (3) simple image transformation techniques (Ji et al., 2019; He et al., 2019; Wu et al., 2018). The intuitive idea behind most of these methods is to collect pairs of positive and negative samples: two positive samples should share the same semantics, while negatives should be perceptually different. A triplet loss (Sohn, 2016; Schroff et al., 2015; Hermans et al., 2017; Wang & Gupta, 2015; Misra et al., 2016) can then be used to learn a metric space which should represent the human perceptual similarity. However, most of the recent studies use a contrastive loss (Hadsell et al., 2006) or one of its variants (Gutmann & Hyvarinen, 2010; van den Oord et al., 2018; Hjelm et al., 2019), while ¨ Tschannen et al. (2019) show the relation between the triplet loss and the contrastive loss. ",
+        "bbox": [
+            173,
+            541,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is worth noticing that the success of both kinds of losses is strongly affected by the number and the quality of the negative samples. For instance, in the case of the triplet loss, a common practice is to select hard/semi-hard negatives (Schroff et al., 2015; Hermans et al., 2017). On the other hand, Hjelm et al. (2019) have shown that the contrastive loss needs a large number of negatives to be competitive. This implies using batches with a large size, which is computationally demanding, especially with high-resolution images. In order to alleviate this problem, Wu et al. (2018) use a memory bank of negatives, which is composed of feature-vector representations of all the training samples. He et al. (2019) conjecture that the use of large and fixed-representation vocabularies is one of the keys to the success of self-supervision in NLP. The solution proposed by He et al. (2019) extends Wu et al. (2018) using a memory-efficient queue of the last visited negatives, together with a momentum encoder which preserves the intra-queue representation consistency. Chen et al. (2020) have performed large-scale experiments confirming that a large number of negatives (and therefore a large batch size) is required for the contrastive loss to be efficient. Concurrently with our work, Grill et al. (2020) have suggested that it is not necessary to rely on the contrastive scheme, introducing a high-performing alternative based on bootstrapping. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose a new self-supervised loss function which first scatters all the sample representations in a spherical distribution1 and then penalizes the positive pairs which are far from each other. In more detail, given a set of samples $V = \\{ \\mathbf { v } _ { i } \\}$ , corresponding to the current minibatch of images $B = \\{ x _ { i } \\}$ , we first project the elements of $V$ onto a spherical distribution using a whitening transform (Siarohin et al., 2019). The whitened representations $\\left\\{ \\mathbf { z } _ { i } \\right\\}$ , corresponding to $V$ , are normalized and then used to compute a Mean Squared Error (MSE) loss which accumulates the error taking into account only positive pairs $( \\mathbf { z } _ { i } , \\mathbf { z } _ { j } )$ . We do not need to contrast positives against negatives as in the contrastive loss or in the triplet loss because the optimization process leads to shrinking the distance between positive pairs and, indirectly, scatters the other samples to satisfy the overall spherical-distribution constraint. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, our contributions are the following: ",
+        "bbox": [
+            173,
+            354,
+            491,
+            368
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose a new loss function, Whitening MSE (W-MSE), for self-supervised training. W-MSE constrains the batch samples to lie in a spherical distribution and it is an alternative to positive-negative instance contrasting methods.   \nOur loss does not rely on negatives, thus including more positive samples in the batch can be beneficial; we indeed demonstrate that multiple positive pairs extracted from one image improve the performance.   \n• We empirically show that our W-MSE loss outperforms the commonly adopted contrastive loss when measured using different standard classification protocols. We show that W-MSE is competitive with respect to state-of-the-art self-supervised methods. ",
+        "bbox": [
+            215,
+            382,
+            825,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            540,
+            513,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A typical self-supervised method is composed of two main components: a pretext task, which exploits some a-priori knowledge about the domain to automatically extract supervision from data, and a loss function. In this section we briefly review both aspects, and we additionally analyse the recent literature concerning feature whitening. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            628
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Pretext Tasks. The temporal consistency in a video provides an intuitive form of self-supervision: temporally-close frames usually contain a similar semantic content (Wang & Gupta, 2015; van den Oord et al., 2018). Misra et al. (2016) extended this idea using the relative temporal order of 3 frames, while Dwibedi et al. (2019) used a temporal cycle consistency for self-supervision, which is based on comparing two videos sharing the same semantics and computing inter-video frame-toframe nearest neighbour assignments. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            718
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When dealing with still images, the most common pretext task is instance discrimination (Wu et al. (2018)): from a training image $x$ , a composition of data-augmentation techniques are used to extract two different views of $x$ $\\cdot \\boldsymbol { x } _ { i }$ and $x _ { j }$ ). Commonly adopted transformations are: image cropping, rotation, color jittering, Sobel filtering, etc.. The learner is then required to discriminate $( x _ { i } , x _ { j } )$ from other views extracted from other samples (Wu et al., 2018; Ji et al., 2019; He et al., 2019; Chen et al., 2020). ",
+        "bbox": [
+            173,
+            726,
+            825,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Denoising auto-encoders (Vincent et al., 2008) add random noise to the input image and try to recover the original image. More sophisticated pretext tasks consist in predicting the spatial order of image patches (Noroozi & Favaro, 2016; Misra & van der Maaten, 2019) or in reconstructing large masked regions of the image (Pathak et al., 2016). Hjelm et al. (2019); Bachman et al. (2019) compare the holistic representation of an input image with a patch of the same image. Henaff et al. ´ (2019) use a similar idea, where the comparison depends on the patch order: the appearance of a given patch should be predicted given the appearance of the patches which lie above it in the image. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper we use standard data augmentation techniques on still images to obtain positive pairs, which is a simple method to get self-supervision (Chen et al., 2020) and does not require a pretexttask specific network architecture (Hjelm et al., 2019; Bachman et al., 2019; Henaff et al., 2019). ´ ",
+        "bbox": [
+            176,
+            138,
+            823,
+            181
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Loss functions. Denoising auto-encoders use a reconstruction loss which compares the generated image with the input image before adding noise. Other generative methods use an adversarial loss in which a discriminator provides supervisory information to the generator (Donahue et al., 2017; Donahue & Simonyan, 2019). ",
+        "bbox": [
+            174,
+            188,
+            825,
+            244
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Early self-supervised (deep) discriminative methods used a triplet loss (Wang & Gupta, 2015; Misra et al., 2016): given two positive images $x _ { i } , x _ { j }$ and a negative $x _ { k }$ (Sec. 1), together with their corresponding latent-space representations $\\mathbf { z } _ { i } , \\mathbf { z } _ { j } , \\mathbf { z } _ { k }$ , this loss penalizes those cases in which $\\mathbf { z } _ { i }$ and $\\mathbf { z } _ { k }$ are closer to each other than $\\mathbf { z } _ { i }$ and $\\mathbf { z } _ { j }$ plus a margin $m$ : ",
+        "bbox": [
+            173,
+            251,
+            823,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44b2b560b0f14c65533db1f708379ccdefbeb3954729f1889df2a26a81d0c111.jpg",
+        "text": "$$\nL _ { T r i p l e t } = - \\operatorname* { m a x } ( \\mathbf { z } _ { i } ^ { T } \\mathbf { z } _ { k } - \\mathbf { z } _ { i } ^ { T } \\mathbf { z } _ { j } + m , 0 ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            324,
+            640,
+            344
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Most of the recent self-supervised discriminative methods are based on some contrastive loss (Hadsell et al., 2006) variant, in which $\\mathbf { z } _ { i }$ and $\\mathbf { z } _ { j }$ are contrasted against a set of negative pairs. Following the common formulation proposed by van den Oord et al. (2018): ",
+        "bbox": [
+            174,
+            354,
+            825,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb22b78d299c708f33722ee37e28f18a059a44e82828af4f9962a697223db1e9.jpg",
+        "text": "$$\nL _ { C o n t r a s t i v e } = - \\log \\frac { \\exp { ( \\mathbf { z } _ { i } ^ { T } \\mathbf { z } _ { j } / \\tau ) } } { \\sum _ { k = 1 , k \\neq i } ^ { K } \\exp { ( \\mathbf { z } _ { i } ^ { T } \\mathbf { z } _ { k } / \\tau ) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            414,
+            656,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau$ is a temperature hyperparameter which should be manually set and the sum in the denominator is over a set of $K - 1$ negative samples. Usually $K$ is the size of the current batch, i.e., $K = 2 N$ , being $N$ the number of the positive pairs. However, as shown by Hjelm et al. (2019), the contrastive loss (2) requires a large number of negative samples to be competitive. Wu et al. (2018); He et al. (2019) use a set of negatives much larger than the current batch, by pre-computing latent-space representations of old samples. SimCLR (Chen et al. (2020)) uses a simpler, but computationally very demanding, solution based on large batches. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While recent works (van den Oord et al., 2018; Henaff et al., 2019; Hjelm et al., 2019; Bachman ´ et al., 2019; Ravanelli & Bengio, 2018) draw a relation between the contrastive loss and an estimate of the mutual information between the latent-space image representations, Tschannen et al. (2019) showed that the success of this loss is likely related to learning a metric space, similarly to what happens with a triplet loss. On the other hand, Wang & Isola (2020) showed that the $L _ { 2 }$ normalized contrastive loss asymptotically converges to the minimization of two desirable characteristics of the latent-space representations on the surface of the unit hypersphere: uniformity and semantic alignment. In the same paper, the authors propose two new losses ( ${ \\mathcal L } _ { \\mathrm { u n i f o r m } }$ and $\\mathcal { L } _ { \\mathrm { a l i g n } , }$ ) which explicitly deal with these characteristics. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concurrently with our work, BYOL (Grill et al. (2020)) proposes a “bootstrapping” scheme which is alternative to the positive-negative contrastive learning. In BYOL, an “online” network is optimised to predict the output of a “target” network, whose parameters are a running average of the online network. The predictions of the two networks are compared using an additional prediction network and an MSE loss. However, very recently, Fetterman & Albrecht (2020) and Tian et al. (2020) have empirically shown that BYOL can avoid a collapsed solution through the use of the Batch Norm (BN) (Ioffe & Szegedy, 2015) which avoids constant representations. Our work can be seen as a generalization of this finding with a much simpler network architecture (more details in Sec. 3.1). ",
+        "bbox": [
+            173,
+            699,
+            825,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose a different loss which is competitive with respect to other alternatives. Our loss formulation is simpler because it does not require a proper setting of the $\\tau$ hyperparameter in equation 2, $m$ in equation 1, or additional networks with a specific weight update schemes as in BYOL. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Feature Whitening. We adopt the efficient and stable Cholesky decomposition (Dereniowski & Marek, 2004) based whitening transform proposed by Siarohin et al. (2019) to project our latentspace vectors into a spherical distribution (more details in Sec. 3). Note that Huang et al. (2018); ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1a34f8c28ebe7ade64be93a372c8c1761ea3e488a8ecaa0f60e91f994505bfc.jpg",
+        "image_caption": [
+            "Figure 1: A schematic representation of the W-MSE based optimization process. Positive pairs are indicated with the same shapes and colors. (1) A representation of the feature batch $V$ when training starts. (2, 3) The distribution of the elements after whitening and $L _ { 2 }$ normalization. (4) The MSE computed over the normalized $\\mathbf { z }$ features encourages the network to move the positive pair representations closer to each other. (5) The subsequent iterations move closer and closer the positive pairs, while the relative layout of the other samples is forced to lie in a spherical distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            99,
+            727,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Siarohin et al. (2019) use whitening transforms in the intermediate layers of the network for a completely different task: extending BN to a multivariate batch normalization. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 THE WHITENING MSE LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            446,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given an image $x$ , we extract an embedding $\\mathrm { ~ \\bf ~ z ~ } = \\mathrm { ~ \\bf ~ \\it ~ f ~ } ( x ; \\theta )$ using an encoder network $f ( \\cdot ; \\theta )$ parametrized with $\\theta$ (more details below). We require that: (1) the image embeddings are drawn from a non-degenerate distribution (the latter being a distribution where, e.g., all the representations collapse to a single point), and (2) positive image pairs $( x _ { i } , x _ { j } )$ , which share a similar semantics, should be clustered close to each other. We formulate this problem as follows: ",
+        "bbox": [
+            173,
+            564,
+            825,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30d72da0e98a5c371d2397190b73c3f5ebc19ca27011f812a7ab29fdc71e7c94.jpg",
+        "text": "$$\n\\begin{array} { c } { m i n _ { \\theta } \\operatorname { \\mathbb { E } } d i s t ( \\mathbf { z } _ { i } , \\mathbf { z } _ { j } ) , } \\\\ { s . t . c o v ( \\mathbf { z } _ { i } , \\mathbf { z } _ { i } ) = c o v ( \\mathbf { z } _ { j } , \\mathbf { z } _ { j } ) = I , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            654,
+            614,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $d i s t ( \\cdot )$ is a distance between vectors, $I$ is the identity matrix and $( \\mathbf { z } _ { i } , \\mathbf { z } _ { j } )$ corresponds to a positive pair of images $( x _ { i } , x _ { j } )$ . With equation 4, we constrain the distribution of the $\\mathbf { z }$ values to be non-degenerate, hence avoiding that all the probability mass is concentrated in a single point. Moreover, equation 4 makes all the components of $\\mathbf { z }$ to be linearly independent from each other, which encourages the different dimensions of $\\mathbf { z }$ to represent different semantic content. We define the distance with the cosine similarity, implemented with MSE between normalized vectors: ",
+        "bbox": [
+            174,
+            695,
+            825,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64a3f2fce66c9fabe7cd11f9eeab3f4b08cf392f4b703cc4a4159a0d5227dfde.jpg",
+        "text": "$$\nd i s t ( \\mathbf { z } _ { i } , \\mathbf { z } _ { j } ) = \\left\\| { \\frac { \\mathbf { z } _ { i } } { \\left\\| \\mathbf { z } _ { i } \\right\\| _ { 2 } } } - { \\frac { \\mathbf { z } _ { j } } { \\left\\| \\mathbf { z } _ { j } \\right\\| _ { 2 } } } \\right\\| _ { 2 } ^ { 2 } = 2 - 2 { \\frac { \\langle \\mathbf { z } _ { i } , \\mathbf { z } _ { j } \\rangle } { \\left\\| \\mathbf { z } _ { i } \\right\\| _ { 2 } \\cdot \\left\\| \\mathbf { z } _ { j } \\right\\| _ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            784,
+            691,
+            823
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Appendix C we also include other experiments in which the cosine similarity is replaced by the Euclidean distance. We provide below the details on how positive image samples are collected, how they are encoded and how the above optimization is implemented. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First, similarly to Chen et al. (2020), we obtain positive samples sharing the same semantics from a single image $x$ and using standard image transformation techniques. Specifically, we use a composition of image cropping, grayscaling and color jittering transformations $T ( \\cdot ; \\mathbf { p } )$ . The parameters $\\mathbf { \\tau } ( \\mathbf { p } )$ are selected uniformly at random and independently for each positive sample extracted from the same image: $x _ { i } = T ( x ; { \\mathbf p } _ { i } )$ . We concisely indicate with $p o s ( i , j )$ the fact that $x _ { i }$ and $x _ { j } ( x _ { i } , x _ { j } \\in B$ , $B$ the current batch) have been extracted from the same image. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/30fed903347f9275f5f14cd0634d881a6b9fc03086e82bb722a8a53a8a41ffdd.jpg",
+        "image_caption": [
+            "Figure 2: A scheme of our training procedure. First, $d$ $Q = 4$ in this case) positive samples are generated using augmentations. These images are transformed into vectors with the encoder $E ( \\cdot )$ . Next, they are projected onto a lower dimensional space with a projection head $g ( \\cdot )$ . Then, Whitening projects these vectors onto a spherical distribution, followed by an optional $L _ { 2 }$ normalization. Finally, the dashed curves show all the $d ( d - 1 ) / 2 = 6$ comparisons used in our W-MSE loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            99,
+            761,
+            219
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            321,
+            825,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The number of positive samples per image $d$ may vary, trading off diversity in the batch and the amount of the training signal. Favoring more negatives, most of the methods use one positive pair $\\left[ d = 2 \\right.$ ). However, Ji et al. (2019) have demonstrated improved performance with 5 samples, while Caron et al. (2020) use 8 samples. In our MSE-based loss (see below), we use all the possible $d ( d - 1 ) / 2$ combinations of positive samples. We include experiments for $d = 2$ (1 positive pair) and $d = 4$ (6 positive pairs). ",
+        "bbox": [
+            173,
+            371,
+            825,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For representation learning, we use a backbone encoder network $E ( \\cdot ) . E ( \\cdot )$ , trained without human supervision, will be used in Sec. 4 for evaluation using standard protocols. We use a standard ResNet-18 (He et al., 2016) as the encoder, and $\\mathbf { h } = E ( x )$ is the output of the average-pooling layer. This choice has the advantage to be simple and easily reproducible, in contrast to other methods which use encoder architectures specific for a given pretext task (see Sec. 2). Since $\\mathbf { h } \\in \\mathbb { R } ^ { 5 1 2 }$ is a high-dimensional vector, following Chen et al. (2020) we use a nonlinear projection head $g ( \\cdot )$ to project h in a lower dimensional space: $\\mathbf { v } = g ( \\mathbf { h } )$ , where $g ( \\cdot )$ is implemented with a MLP with one hidden layer and a BN layer. The whole network $f ( \\cdot )$ is given by the composition of $g ( \\cdot )$ with $E ( \\cdot )$ (see Fig. 2). ",
+        "bbox": [
+            173,
+            460,
+            825,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given $N$ original images and a batch of samples $B = \\{ x _ { 1 } , . . . x _ { K } \\}$ , where $K \\ : = \\ : N d$ , let $V =$ $\\left\\{ \\mathbf { v } _ { 1 } , \\ldots \\mathbf { v } _ { K } \\right\\}$ , be the corresponding batch of features obtained as described above. In the proposed W-MSE loss we compute the MSE over all $N d ( d { - } 1 ) / 2$ positive pairs, where constraint 4 is satisfied using the reparameterization of the $\\mathbf { v }$ variables with the whitened variables $\\mathbf { z }$ : ",
+        "bbox": [
+            173,
+            593,
+            825,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df8c5ace3f4e6908c1d2ecf424eaeca69c163617bcde0a6046166050c6b8b208.jpg",
+        "text": "$$\nL _ { W - M S E } ( V ) = \\frac { 2 } { N d ( d - 1 ) } \\sum _ { ( { \\bf v } _ { i } , { \\bf v } _ { j } ) \\in V , p o s ( i , j ) } d i s t ( { \\bf z } _ { i } , { \\bf z } _ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            666,
+            692,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { z } = W h i t e n i n g ( \\mathbf { v } )$ , and: ",
+        "bbox": [
+            174,
+            719,
+            390,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4a3309d784ff6b3da37bca7dab87d2bd6b0664152c9e722b75ebad52d4b4981.jpg",
+        "text": "$$\nW h i t e n i n g ( \\mathbf { v } ) = W _ { V } ( \\mathbf { v } - { \\pmb \\mu } _ { V } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            755,
+            611,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In equation 7, $\\pmb { \\mu } _ { V }$ is the mean of the elements in $V$ : $\\begin{array} { r } { \\pmb { \\mu } _ { V } = \\frac { 1 } { K } \\sum _ { k } \\mathbf { v } _ { k } } \\end{array}$ , while the matrix $W _ { V }$ is such that: $W _ { V } ^ { \\top } W _ { V } = \\Sigma _ { V } ^ { - 1 }$ , being $\\Sigma _ { V }$ the covariance matrix of $V$ : ",
+        "bbox": [
+            171,
+            782,
+            825,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24f762961275719278600b5e97d497dbbd866c070b26a83fbc5616b98ad4927a.jpg",
+        "text": "$$\n\\boldsymbol { \\Sigma } _ { V } = \\frac { 1 } { K - 1 } \\sum _ { k } ( { \\bf v } _ { k } - { \\pmb \\mu } _ { V } ) ( { \\bf v } _ { k } - { \\pmb \\mu } _ { V } ) ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            832,
+            642,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For more details on how $W _ { V }$ is computed, we refer to Appendix B. Equation 7 performs the full whitening of each $\\mathbf { v } _ { i } \\in V$ and the resulting set of vectors $Z = \\{ { \\bf z } _ { 1 } , . . . , { \\bf z } _ { K } \\}$ lies in a zero-centered distribution with a covariance matrix equal to the identity matrix (Fig. 1). ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/670f016219ae719cc7b4ed09e98be2e40ee9566bbaefc881897287654761deab.jpg",
+        "image_caption": [
+            "Figure 3: Batch slicing. $V$ is first partitioned in $d$ parts $\\left( d = 2 \\right.$ in this example). We randomly permute the first part and we apply the same permutation to the other $d - 1$ parts. Then, we further split all the partitions and we create sub-batches $( V _ { i } )$ . Each $V _ { i }$ is independently used to compute the sub-batch specific whitening matrix $W _ { V } ^ { i }$ and centroid $\\mu _ { V } ^ { i }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            318,
+            102,
+            665,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The intuition behind the proposed loss is that equation 6 penalizes positives which are far apart from each other, thus leading $\\overset { \\cdot } { g } ( \\bar { E } ( \\cdot ) )$ to shrink the inter-positive distances. On the other hand, since $Z$ must lie in a spherical distribution, the other samples should be “moved” and rearranged in order to satisfy constraint 4 (see Fig. 1). ",
+        "bbox": [
+            174,
+            342,
+            825,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Batch Slicing. The estimation of the Mean Square Error in equation 6 depends on the whitening matrix $W _ { V }$ , which may have a high variance over consecutive iteration batches $V _ { t } , V _ { t + 1 } , \\dots$ For this reason, inspired by the resampling methods (Efron, 1982), given a batch $V$ , we slice $V$ in different non-overlapping sub-batches and we compute a whitening matrix independently for each sub-batch. In more details, we first partition the batch in $d$ parts, being $d$ the number of positives extracted from one image. In this way, each partition contains elements extracted from different original images (i.e., no pair of positives is included in a single partition, see Fig. 3). Then, we randomly permute the elements of the each partition with the same permutation. Next, each partition is further split in sub-batches, using the heuristic that the size of each sub-batch $( V _ { i } )$ should be equal to the size of embedding (v) times 2 (this prevents instability issues when computing the covariance matrices). Next, for each $V _ { i }$ , we use only its elements to compute a corresponding whitening matrix $W _ { V } ^ { i }$ , which is used to whiten the elements of $V _ { i }$ only (Fig. 3). In the loss computation (equation 6), all the elements of all the sub-batches are used, thus implicitly alleviating the differences among the different whitening matrices. Finally, it is possible to repeat the whole operation several times and to average the result to get a more robust estimate of equation 6. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            302,
+            645
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In a common instance-discrimination task (Sec. 2), e.g., solved using equation 2, the similarity of a positive pair $( \\mathbf { z } _ { i } ^ { T } \\mathbf { z } _ { j } )$ is contrasted with the similarity computed with respect to all the other samples $( { \\bf z } _ { k } )$ in the batch $\\mathbf { \\langle z } _ { i } ^ { T } \\mathbf { z } _ { k } , 1 \\leq k \\leq K , k \\neq i )$ . However, $\\mathbf { z } _ { k }$ and $\\mathbf { z } _ { i }$ , extracted from different image instances, can occasionally share the same semantics (e.g., $x _ { i }$ and $x _ { k }$ are two different image instances of the unknown “cat” class). Conversely, the proposed W-MSE loss does not force all the instance samples to lie far from each other, but it only imposes a soft constraint (equation 4), which avoids degenerate distributions. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that previous work (He et al., 2019; Henaff et al., 2019; Chen et al., 2020) highlighted that ´ BN may be harmful for learning semantically meaningful representations because the network can “cheat” and exploit the batch statistics in order to find a trivial solution to equation 2. However, our whitening transform (equation 7) is applied only to the very last layer of the network $f ( \\cdot )$ (see Fig. 2) and it is not used in the intermediate layers, which is instead the case of BN. Hence, our $f ( \\cdot )$ cannot learn to exploit subtle inter-sample dependencies introduced by batch-statistics because of the lack of other learnable layers on top of the $\\mathbf { z }$ features. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Similarly to equation 6, in BYOL (Grill et al., 2020) an MSE loss is used to compare the latent representations of two positives computed by slightly different networks without contrasting positives with negatives (Sec. 2). However, the MSE loss alone is inclined to collapse the representations of all the images to a constant value, which would make the MSE computation equal to zero. In BYOL, both the projection and the prediction sub-networks have BN layers, and, very recently, (Fetterman & Albrecht, 2020; Tian et al., 2020) have empirically shown that BYOL, without these BN layers, generates collapsed latent-space representations with a close-to-chance level classification accuracy. The reason of this behaviour seems to depend on the fact that the feature standardization in BN scatters the $\\mathbf { z }$ values in a batch and avoids constant representations. Our W-MSE can be seen as a generalization of this implicit property of BYOL, in which the $\\mathbf { z }$ values of the current batch are full-whitened, so preventing possible collapsing effects of the MSE loss. Importantly, we reach this result without the need of a target network or sophisticated training protocols. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, note that using BN alone without whitening, as in W-MSE, and without additional networks, as in BYOL, is not sufficient. Indeed, if we just minimize an MSE after feature standardization, the network can easily find a solution where all the dimensions of the embedding represent the same feature. We have empirically verified this behaviour in preliminary experiments based on standardization, in which the network converges to a zero loss value after a few epochs but with a low classification accuracy. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            305
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            327,
+            326,
+            343
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We test our loss and its competitors on the following datasets. ",
+        "bbox": [
+            174,
+            359,
+            581,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009), two small-scale datasets composed of $3 2 \\times 3 2$ images with 10 and 100 classes, respectively.   \n• Tiny ImageNet (Le & Yang, 2015), a reduced version of ImageNet, composed of 200 classes with images scaled down to $6 4 \\times 6 4$ . The total number of images is: 100K (training) and 10K (testing). STL-10 (Coates et al., 2011), also derived from ImageNet, with $9 6 \\times 9 6$ resolution images. While CIFAR-10, CIFAR-100 and Tiny ImageNet are fully-labeled, STL-10 is composed of 5K labeled training samples (500 per class) and 100K unlabeled training examples from a similar but broader distribution of images. There are additional 8K labeled testing images.   \n• ImageNet-100, a random 100-class subset of ImageNet (the list of the 100 classes is published in (Wang & Isola, 2020)), consisting of unaltered ImageNet images. ",
+        "bbox": [
+            215,
+            388,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Setting. The goal of our experiments is to compare W-MSE with state-of-the-art losses, isolating the effects of other settings, such as the architectural choices. For this reason, we use the same encoder $E ( \\cdot )$ ResNet-18 for all the experiments. We independently select the best hyperparameter values for every method and every dataset. Each method uses $L _ { 2 }$ feature normalization unless otherwise stated. Contrastive refers to our implementation of the contrastive loss (equation 2) following the details in (Chen et al., 2020), with temperature $\\tau = 0 . 5$ . BYOL is our reproduction of (Grill et al., 2020), introduced concurrently with our work. For this method we use the exponential moving average with cosine increasing, starting from 0.99. W-MSE 2 and W-MSE 4 correspond to our method with $d = 2$ and $d = 4$ positives extracted per image, respectively. For CIFAR-10 and CIFAR-100, the slicing sub-batch size is 128, for Tiny ImageNet and STL-10, it is 256. For experiments W-MSE 2 for Tiny ImageNet and STL-10 we use 4 iterations of batch slicing, for all other experiments we use 1 iteration. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In all the experiments, we use the Adam optimizer (Kingma & Ba, 2014). For all the tested methods (including ours), we use the same number of epochs and the same learning rate schedule. Specifically, for CIFAR-10 and CIFAR-100, we use 1,000 epochs with learning rate $3 \\times 1 0 ^ { - 3 }$ ; for Tiny ImageNet, 1,000 epochs with learning rate $2 \\times 1 0 ^ { - 3 }$ ; for STL-10, 2,000 epochs with learning rate $2 \\times \\mathrm { 1 0 ^ { - 3 } }$ . We use learning rate warm-up for the first 500 iterations of the optimizer, and a 0.2 learning rate drop 50 and 25 epochs before the end. We use a mini-batch size of $K = 1 0 2 4$ samples. The dimension of the hidden layer of the projection head $g ( \\cdot )$ is 1024. The weight decay is $1 \\bar { 0 } ^ { - 6 }$ . Finally, we use an embedding size of 64 for CIFAR-10 and CIFAR-100, and an embedding of size of 128 for STL-10 and Tiny ImageNet. For ImageNet-100 we use a configuration similar to the Tiny ImageNet experiments, and 240 epochs of training. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As a common practice when using ResNet-like architectures for small-size image resolutions, in all the experiments, except ImageNet-100, we have a first convolutional layer with kernel size 3, stride 1 and padding 1. Additionally, in case of CIFAR-10 and CIFAR-100, we remove the first max pooling layer. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bb45fa6fa8652c6f2c393511f1f90725ffe31605855f3e3d19b82df58bd95096.jpg",
+        "table_caption": [
+            "Table 1: Classification accuracy (top 1) of a linear classifier and a 5-nearest neighbors classifier for different loss functions and datasets with a ResNet-18 encoder. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">CIFAR-10</td><td rowspan=\"2\">CIFAR-100</td><td colspan=\"2\">STL-10</td><td rowspan=\"2\"></td><td colspan=\"2\"> Tiny ImageNet</td></tr><tr><td>linear</td><td>5-nn</td><td>linear 5-nn</td><td>linear</td><td>5-nn linear</td><td>5-nn</td></tr><tr><td>Contrastive</td><td>91.80</td><td>88.42</td><td>66.83</td><td>56.56</td><td>90.51</td><td>85.68</td><td>48.84</td><td>32.86</td></tr><tr><td>BYOL</td><td>91.73</td><td>89.45</td><td>66.60</td><td>56.82</td><td>91.99</td><td>88.64</td><td>51.00</td><td>36.24</td></tr><tr><td>W-MSE 2</td><td>91.55</td><td>89.69</td><td>66.10</td><td>56.69</td><td>90.36</td><td>87.10</td><td>48.20</td><td>34.16</td></tr><tr><td>W-MSE 4</td><td>91.99</td><td>89.87</td><td>67.64</td><td>56.45</td><td>91.75</td><td>88.59</td><td>49.22</td><td>35.44</td></tr></table>",
+        "bbox": [
+            222,
+            133,
+            776,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3b212b9e82f350eb8213f1000f5d267fa44359e5362bc3fed3290b943b75fbc8.jpg",
+        "table_caption": [
+            "Table 2: Classification accuracy on ImageNet-100. W-MSE (2 and 4) are based on a ResNet-18 encoder. † indicates that the results are based on a ResNet-50 encoder and the values are reported from (Wang & Isola, 2020). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>linear (top 1)</td><td>linear (top 5)</td><td>5-nn</td></tr><tr><td>MoCot</td><td>72.80</td><td>91.64</td><td>1</td></tr><tr><td>Lalign and Luniform +</td><td>74.60</td><td>92.74</td><td>1</td></tr><tr><td>W-MSE 2</td><td>76.00</td><td>93.14</td><td>67.04</td></tr><tr><td>W-MSE 4</td><td>79.02</td><td>94.46</td><td>71.32</td></tr></table>",
+        "bbox": [
+            289,
+            314,
+            707,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            441,
+            823,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Image Transformation Details. We extract crops with a random size from 0.2 to 1.0 of the original area and a random aspect ratio from $3 / 4$ to $4 / 3$ of the original aspect ratio, which is a commonly used data-augmentation technique. We also apply horizontal mirroring with probability 0.5. Finally, we apply color jittering with configuration $( 0 . 4 , 0 . 4 , 0 . 4 , 0 . 1 )$ with probability 0.8 and grayscaling with probability 0.1. For ImageNet-100 we follow details in (Chen et al., 2020): crop size from 0.08 to 1.0, stronger jittering (0.8, 0.8, 0.8, 0.2), grayscaling probability 0.2, and Gaussian blurring with 0.5 probability. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Protocol. The most common evaluation protocol for unsupervised feature learning is based on freezing the network encoder $( E ( \\cdot )$ , in our case) after unsupervised pre-training, and then train a supervised linear classifier on top of it. Specifically, the linear classifier is a fully-connected layer followed by softmax, which is placed on top of $E ( \\cdot )$ after removing the projection head $g ( \\cdot )$ . In all the experiments we train the linear classifier for 500 epochs using the Adam optimizer and the labeled training set of each specific dataset, without data augmentation. The learning rate is exponentially decayed from $1 0 ^ { - 2 }$ to $1 0 ^ { - 6 }$ . The weight decay is $5 \\times 1 0 ^ { - 6 }$ . ",
+        "bbox": [
+            173,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we also include the accuracy of a $\\mathbf { k }$ -nearest neighbors classifier (k-nn, $k = 5$ ). The advantage of using this classifier is that it does not require additional parameters and training, and it is deterministic. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMPARISON WITH THE STATE OF THE ART ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            516,
+            758
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tab. 1 shows the results of the experiments on small and medium size datasets. For W-MSE, 4 samples are generally better than 2. The contrastive loss performs the worst in most cases. The W-MSE 4 accuracy is the best on CIFAR-10 and CIFAR-100, while BYOL leads on STL-10 and Tiny ImageNet, although the gap between the two methods is minor. In Appendix A, we plot the linear classification accuracy during training for the STL-10 dataset. The plot shows that W-MSE 4 and BYOL have a similar performance during most of the training. However, in the first 120 epochs, BYOL significantly underperforms W-MSE 4 (e.g., the accuracy after 20 epochs: W-MSE 4, $7 9 . 9 8 \\%$ ; BYOL, $7 3 . 2 4 \\%$ ), indicating that BYOL requires a “warmup” period. On the other hand, W-MSE performs well from the beginning. This property is useful in those domains which require a rapid adaptation of the encoder, e.g., due to the change of the data distribution in continual learning or in reinforcement learning. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tab. 2 shows the results on a larger dataset (ImageNet-100). In that table, MoCo is the contrastiveloss based method proposed in (He et al., 2019), where a momentum encoder and a large queue of negatives are used to improve the contrast of the positive pairs with respect to the other samples (see Sec. 2). $\\mathcal { L } _ { \\mathrm { a l i g n } }$ and ${ \\mathcal { L } } _ { \\mathrm { u n i f o r m } }$ are the two losses proposed in (Wang & Isola, 2020) (Sec. 2). Note that, while W-MSE (2 and 4) in Tab. 2 refer to our method with a ResNet-18 encoder, the other results are reported from (Wang & Isola, 2020), where a much larger-capacity network (i.e., a ResNet-50) is used as the encoder. Despite this large difference in the encoder capacity, both versions of W-MSE significantly outperform the other two compared methods in this dataset. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 TRAINING TIME COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            232,
+            419,
+            246
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Following (Siarohin et al., 2019), the complexity of the whitening transform is $O ( k ^ { 3 } + M k ^ { 2 } )$ , where $k$ is the embedding dimension and $M$ is the size of the sub-batch used in the batch slicing process. Since $k < M$ (see Sec. 3), the whitening transform is $O ( M k ^ { 2 } )$ , which is basically equivalent to the forward pass of $M$ activations in a fully-connected layer connecting two layers of $k$ neurons each. In fact, the training time is dominated by other architectural choices which are usually more computationally demanding than the loss computation. For instance, BYOL (Grill et al., 2020) needs 4 forward passes through 2 networks for each pair of positives. Hence, to evaluate the wallclock time, we measure the time spent for one mini-batch iteration by all the methods compared in Tab. 1. We use the STL-10 dataset, a ResNet-18 encoder and a server with one Nvidia Titan $\\mathrm { X p }$ GPU. Time of one iteration: Contrastive - 459ms, BYOL - 602ms, W-MSE 2 - 478ms, W-MSE 4 - $4 9 3 \\mathrm { m s }$ . The $1 9 \\mathrm { m s }$ difference between Contrastive and W-MSE 2 is due to the whitening transform. Since the factual time is mostly related to the sample forward and backward passes, the $d ( d - 1 )$ positive comparisons in equation 6 do not significantly increase the wall-clock time of W-MSE 4 with respect to W-MSE 2. ",
+        "bbox": [
+            173,
+            258,
+            825,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 CONTRASTIVE LOSS WITH WHITENING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            482,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/24450ef1a580db46f30fd514a144d0633fe1025690c2dcc174a01f7f67b8453b.jpg",
+        "table_caption": [
+            "Table 3: Accuracy of the whitened contrastive loss on CIFAR-10 trained for 200 epochs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>linear</td><td>5-nn</td></tr><tr><td>Contrastive</td><td>89.66</td><td>86.55</td></tr><tr><td>Contrastive with Whitening</td><td colspan=\"2\">diverged</td></tr><tr><td>Contrastive,unnormalized features</td><td>79.48</td><td>76.60</td></tr><tr><td>Contrastive with Whitening,unnormalized features</td><td>77.39</td><td>74.14</td></tr></table>",
+        "bbox": [
+            263,
+            518,
+            735,
+            598
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyse the effect of the whitening transform in combination with the contrastive loss. Tab. 3 shows the results. The first row refers to the standard contrastive loss. Note that the difference with respect to Tab.1 is due to the use of only 200 training epochs. The second row refers to equation 2, where the features $\\mathbf { \\rho } ( \\mathbf { z } )$ are computed using equation 7 and then $L _ { 2 }$ normalized, while in the last two rows, $\\mathbf { z }$ is not normalized. If the features are whitened and then normalized, we observed an unstable training, with divergence after a few epochs. The unnormalized version with whitening converged, but its accuracy is worse than the standard contrastive loss (both normalized and unnormalized). This experiments show that whitening itself does not improve the performance, but it only allows to satisfy the constraint 4. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            767,
+            318,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have proposed a new self-supervised representation learning loss, W-MSE, which is alternative to common loss functions used in the field. Differently from the triplet loss and the contrastive loss, both of which are based on comparing an instance-level similarity against other samples, W-MSE computes only the intra-positive distances, while using a whitening transform to avoid degenerate solutions. Despite W-MSE is very simple, its classification accuracy is comparable with state-of-the-art methods, achieving results significantly higher than MoCo, which requires an additional momentum encoder and a large queue of past samples. W-MSE is also comparable with BYOL, which needs an additional target network and a specific training protocol. We believe that the use of whitening to avoid collapsing effects can inspire other self-supervised methods. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Philip Bachman, R. Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In NeurIPS, 2019. ",
+        "bbox": [
+            176,
+            126,
+            821,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments, 2020. ",
+        "bbox": [
+            176,
+            161,
+            821,
+            191
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations, 2020. ",
+        "bbox": [
+            174,
+            199,
+            821,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Coates, Andrew Y. Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In AISTATS, 2011. ",
+        "bbox": [
+            174,
+            236,
+            821,
+            266
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dariusz Dereniowski and Kubale Marek. Cholesky factorization of matrices in parallel and ranking of graphs. In 5th Int. Conference on Parallel Processing and Applied Mathematics, 2004. ",
+        "bbox": [
+            176,
+            273,
+            823,
+            304
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL,, 2019. ",
+        "bbox": [
+            176,
+            310,
+            823,
+            340
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue and Karen Simonyan. Large scale adversarial representation learning. In NeurIPS, 2019. ",
+        "bbox": [
+            176,
+            347,
+            823,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue, Philipp Krahenb ¨ uhl, and Trevor Darrell. Adversarial feature learning. In ¨ ICLR, 2017. ",
+        "bbox": [
+            173,
+            385,
+            821,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Debidatta Dwibedi, Yusuf Aytar, Jonathan Tompson, Pierre Sermanet, and Andrew Zisserman. Temporal cycle-consistency learning. In CVPR, 2019. ",
+        "bbox": [
+            174,
+            409,
+            820,
+            438
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bradley Efron. The jackknife, the bootstrap, and other resampling plans, volume 38. Siam, 1982. ",
+        "bbox": [
+            171,
+            445,
+            810,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abe Fetterman and Josh Albrecht. Understanding self-supervised and contrastive learning with bootstrap your own latent (BYOL). https://untitled-ai.github.io/understanding-self-supervisedcontrastive-learning.html, 2020. ",
+        "bbox": [
+            176,
+            468,
+            820,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H. Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, Bilal Piot, Koray Kavukcuoglu, Remi Munos, and Michal Valko. Bootstrap your own ´ latent: A new approach to self-supervised learning, 2020. ",
+        "bbox": [
+            173,
+            518,
+            823,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Gutmann and Aapo Hyvarinen. Noise-contrastive estimation: A new estimation principle ¨ for unnormalized statistical models. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, 2010. ",
+        "bbox": [
+            174,
+            584,
+            823,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In CVPR, 2006. ",
+        "bbox": [
+            173,
+            635,
+            823,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            671,
+            821,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv:1911.05722, 2019. ",
+        "bbox": [
+            174,
+            709,
+            823,
+            738
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olivier J. Henaff, Ali Razavi, Carl Doersch, S. M. Ali Eslami, and A ´ aron van den Oord. Data- ¨ efficient image recognition with contrastive predictive coding. arXiv:1905.09272, 2019. ",
+        "bbox": [
+            171,
+            746,
+            821,
+            776
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander Hermans, Lucas Beyer, and Bastian Leibe. In defense of the triplet loss for person reidentification. arXiv:1703.07737, 2017. ",
+        "bbox": [
+            173,
+            784,
+            820,
+            814
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "R. Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Philip Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019. ",
+        "bbox": [
+            176,
+            820,
+            821,
+            864
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lei Huang, Dawei Yang, Bo Lang, and Jia Deng. Decorrelated batch normalization. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            872,
+            820,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xu Ji, Joao F. Henriques, and Andrea Vedaldi. Invariant information clustering for unsupervised ˜ image classification and segmentation. In ICCV, 2019. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2014. ",
+        "bbox": [
+            173,
+            140,
+            753,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical Report, 2009. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ya Le and Xuan Yang. Tiny imagenet visual recognition challenge. 2015. ",
+        "bbox": [
+            174,
+            202,
+            658,
+            218
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv:1301.3781, 2013a. ",
+        "bbox": [
+            173,
+            226,
+            823,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Gregory S. Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. In NIPS, 2013b. ",
+        "bbox": [
+            171,
+            263,
+            825,
+            294
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. arXiv:1912.01991, 2019. ",
+        "bbox": [
+            171,
+            301,
+            823,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra, C. Lawrence Zitnick, and Martial Hebert. Shuffle and learn: Unsupervised learning using temporal order verification. In ECCV, 2016. ",
+        "bbox": [
+            171,
+            339,
+            823,
+            369
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, 2016. ",
+        "bbox": [
+            171,
+            377,
+            823,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Philipp Krahenb ¨ uhl, Jeff Donahue, Trevor Darrell, and Alexei A. Efros. Context ¨ encoders: Feature learning by inpainting. CVPR, 2016. ",
+        "bbox": [
+            171,
+            415,
+            823,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mirco Ravanelli and Yoshua Bengio. Learning speaker representations with mutual information. arXiv:1812.00271, 2018. ",
+        "bbox": [
+            171,
+            452,
+            823,
+            482
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. FaceNet: A unified embedding for face recognition and clustering. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            489,
+            823,
+            520
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aliaksandr Siarohin, Enver Sangineto, and Nicu Sebe. Whitening and coloring transform for GANs. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            171,
+            527,
+            823,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn. Improved deep metric learning with multi-class n-pair loss objective. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            565,
+            823,
+            582
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuandong Tian, Lantao Yu, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning with dual deep networks. arXiv:2010.00578, 2020. ",
+        "bbox": [
+            173,
+            589,
+            823,
+            619
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Tschannen, Josip Djolonga, Paul K. Rubenstein, Sylvain Gelly, and Mario Lucic. On mutual information maximization for representation learning. arXiv:1907.13625, 2019. ",
+        "bbox": [
+            171,
+            627,
+            825,
+            657
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predic- ¨ tive coding. arXiv:1807.03748, 2018. ",
+        "bbox": [
+            171,
+            665,
+            823,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In ICML, 2008. ",
+        "bbox": [
+            171,
+            703,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. In International Conference on Machine Learning, 2020. ",
+        "bbox": [
+            176,
+            741,
+            823,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            792,
+            821,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhirong Wu, Yuanjun Xiong, Stella Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance-level discrimination. arXiv:1805.01978, 2018. ",
+        "bbox": [
+            173,
+            830,
+            821,
+            859
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A TRAINING DYNAMICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            393,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 and 5 show the training dynamics for each of the considered losses. Charts are smoothed with a 0.3 moving average for readability (curves before smoothing are shown semi-transparent). ",
+        "bbox": [
+            173,
+            132,
+            823,
+            162
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/4da7361dea4e214120a4f83ad835fe56daaf9d4478d45e9de5e947e5f9e43203.jpg",
+        "image_caption": [
+            "Figure 4: Training dynamics on STL-10 dataset for linear classifier "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            172,
+            825,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/56fa92474a274079c986ab314b71342c7622615ad0b973ce49ef164a7fafb890.jpg",
+        "image_caption": [
+            "Figure 5: Training dynamics on STL-10 dataset for 5-nn classifier "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            486,
+            825,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B CHOLESKY WHITENING AND BACKPROGATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            808,
+            602,
+            825
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We compute $W _ { V }$ (equation 8) following (Siarohin et al., 2019) and using the Cholesky decomposition. The Cholesky decomposition is based on the factorisation of the covariance symmetric matrix using two triangular matrices: $\\Sigma _ { V } = L L ^ { \\top }$ , where $L$ is a lower triangular matrix. Once we get $L$ , we compute the inverse of $L$ , and we get: $W _ { V } = L ^ { - 1 }$ . Note that Cholesky decomposition is fully diferentiable and it is implemented in all of the major frameworks, such as PyTorch and TensorFlow. However, for the sake of completeness, we provide below the gradient computation. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 GRADIENT COMPUTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            400,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We provide here the equations for whitening differentiation. Let $Z$ be the whitened version of the batch $V$ , i.e., $Z = W _ { V } ( V - \\mu _ { V } )$ (equation 7). The gradient $\\textstyle { \\frac { \\partial L } { \\partial V } }$ can be computed by: ",
+        "bbox": [
+            173,
+            128,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f8afbf803ce533b2085950e8fc825a17961bb95879b919e2858de7c02590e52.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial V } = \\frac { 2 } { K - 1 } \\frac { \\partial L } { \\partial \\Sigma } V + W _ { V } ^ { T } \\frac { \\partial L } { \\partial Z } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            165,
+            606,
+            198
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where the partial derivative $\\frac { \\partial L } { \\partial Z }$ is backpropogated, while $\\frac { \\partial L } { \\partial \\Sigma }$ is computed as follows: ",
+        "bbox": [
+            176,
+            204,
+            730,
+            223
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/396a3a4f79da4a846dbd53d39f2f92b43e589b26bf62cbd064a76c987d233181.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial \\Sigma } = - \\frac { 1 } { 2 } W _ { V } ^ { T } \\left( P \\circ \\frac { \\partial L } { \\partial W _ { V } } W _ { V } ^ { T } + \\left( P \\circ \\frac { \\partial L } { \\partial W _ { V } } W _ { V } ^ { T } \\right) ^ { T } \\right) W _ { V }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            228,
+            702,
+            271
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In equation $1 0 , \\circ$ is Hadamard product, while $\\frac { \\partial L } { \\partial W _ { V } }$ is: ",
+        "bbox": [
+            171,
+            277,
+            529,
+            295
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2a29065731ec551647dad9f989db50e2a861620b48bdc48639cd097aaab9a52.jpg",
+        "text": "$$\n\\frac { \\partial \\cal { L } } { \\partial W _ { V } } = \\frac { \\partial \\cal { L } } { \\partial Z } V ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            303,
+            558,
+            335
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "and $P$ is: ",
+        "bbox": [
+            173,
+            348,
+            236,
+            363
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c6627970627ab3dadeb9de587b6a9b5acb93e9d0da11acf7afb72420247c5833.jpg",
+        "text": "$$\nP = \\left( { \\begin{array} { l l l l } { { \\frac { 1 } { 2 } } } & { 0 } & { \\cdots } & { 0 } \\\\ { 1 } & { { \\frac { 1 } { 2 } } } & { \\ddots } & { 0 } \\\\ { 1 } & { \\ddots } & { \\ddots } & { 0 } \\\\ { 1 } & { \\cdots } & { 1 } & { { \\frac { 1 } { 2 } } } \\end{array} } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            358,
+            593,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C EUCLIDEAN DISTANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            398,
+            472
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/f9df48ccc18f58650e27cceff16f26e86a16c5551f19c79b3da719364ec4566e.jpg",
+        "table_caption": [
+            "Table 4: Classification accuracy (top 1) using the Euclidean distance (unnormalized embeddings) on STL-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td> linear</td><td>5-nn</td></tr><tr><td>Contrastive</td><td>78.00</td><td>71.07</td></tr><tr><td>BYOL</td><td>80.83</td><td>74.94</td></tr><tr><td>W-MSE 2</td><td>89.91</td><td>85.56</td></tr><tr><td>W-MSE 4</td><td>90.40</td><td>87.09</td></tr></table>",
+        "bbox": [
+            393,
+            523,
+            604,
+            619
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The cosine similarity is a crucial component in most of the current self-supervised learning approaches. This is usually implemented with an $L _ { 2 }$ normalization of the latent representations, which corresponds to projecting the features on the surface of the unit hypersphere. However, in our WMSE, the whitening transform projects the representation onto a spherical distribution (intuitively, we can say on the whole unit hypersphere). Preserving the module of the features before the $L _ { 2 }$ normalization may be useful in some applications, e.g., clustering the features after the projection head using a Gaussian mixture model. Tab. 4 shows an experiment on the STL-10 dataset where we use unnormalized embeddings for all the methods (and $\\tau = 1$ for the contrastive loss). Comparing Tab. 4 with Tab. 1, the accuracy decrease of W-MSE is significantly smaller than the other methods. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            768
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SJeqs6EFvB/SJeqs6EFvB.md

@@ -0,0 +1,353 @@
+# HOPPITY: LEARNING GRAPH TRANSFORMATIONS TO DETECT AND FIX BUGS IN PROGRAMS
+
+Elizabeth Dinella∗ University of Pennsylvania
+
+Hanjun Dai∗ Google Brain
+
+Ziyang Li University of Pennsylvania
+
+Mayur Naik University of Pennsylvania
+
+Le Song Georgia Tech
+
+Ke Wang Visa Research
+
+# ABSTRACT
+
+We present a learning-based approach to detect and fix a broad range of bugs in Javascript programs. We frame the problem in terms of learning a sequence of graph transformations: given a buggy program modeled by a graph structure, our model makes a sequence of predictions including the position of bug nodes and corresponding graph edits to produce a fix. Unlike previous works built upon deep neural networks, our approach targets bugs that are more diverse and complex in nature (i.e. bugs that require adding or deleting statements to fix). We have realized our approach in a tool called HOPPITY. By training on 290,715 Javascript code change commits on Github, HOPPITY correctly detects and fixes bugs in 9,490 out of 36,361 programs in an end-to-end fashion. Given the bug location and type of the fix, HOPPITY also outperforms the baseline approach by a wide margin.
+
+# 1 INTRODUCTION
+
+The sheer size and complexity of modern codebases makes it impossible for them to be bug-free. As a result, a more reasonable and effective strategy has emerged, which aims to prevent bugs in production by applying automated tools to detect and even fix them early in the development process.
+
+This trend has gained increasing popularity in recent years. Examples include Google’s Tricorder (Sadowski et al., 2015), Facebook’s Getafix (Scott et al., 2019) and Zoncolan, and Microsoft’s Visual Studio IntelliCode. The techniques underlying these tools can be classified into broadly two categories: logical, rule-based techniques (Sadowski et al., 2015) and statistical, data-driven techniques (Allamanis et al., 2018; Pradel & Sen, 2018; Vasic et al., 2019). The former uses manually written rules capturing undesirable code patterns and scans the entire codebase for these classes of bugs. The latter learns to detect abnormal code from a large code corpus using deep neural networks. Despite great strides, however, both kinds of tools are limited in generality because they target error patterns in specific codebases or they target specific bug types. For instance, Zoncolan’s rules are designed to be specifically applicable to Facebook’s codebases, and deep learning models target specialized bugs in variable naming (Allamanis et al., 2018) or binary expressions (Pradel & Sen, 2018). Moreover, the patterns are relatively syntactic, allowing them to be specified by human experts using logical rules or learnt from a corpus of programs.
+
+In this paper, we propose a novel learning-based approach for finding and fixing bugs in Javascript programs automatically. Javascript is a scripting language designed for web application development. It has been the most popular programming language on GitHub since 2014 (Github, 2019). Repairing Javascript code presents a unique challenge as bugs manifest in diverse forms due to unusual language features and the lack of tooling support. Therefore, the primary goal of our approach is generality since it must be effective against a board spectrum of programming errors, such as using wrong operators or identifiers, accessing undefined properties, mishandling variable scopes, triggering type incompatibilites, among many others. Another important novel aspect concerns our approach’s ability to deal with bugs that are more complex and semantic in nature, namely, bugs that require adding or removing statements from a program, which are not considered by prior works. Finally, compared to automated program repair techniques (Le Goues et al., 2019; Scott et al., 2019; Hua et al., 2018; Chen et al., 2018) which require knowledge of bug location, this paper presents an end-to-end approach including localizing bugs, predicting the types of fixes, and generating patches.
+
+We design our model architecture in a similar vein as a Neural Turing Machine (NTM) (Graves et al., 2014). It consists of an external memory (a Graph Neural Network) for embedding a buggy program and a central controller (an LSTM) that makes a sequence of primitive actions (e.g., predicting type, generating patch, etc.) to perform a fix. The multi-step decision process is implemented by an autoregressive model. Crucially, our model differs from the standard NTM in how the memory is manipulated: apart from the common read and write operations, the controller can also expand or shrink the memory when adding or deleting nodes in the original graph.
+
+We have realized our approach in a tool called HOPPITY. By training on 290,715 Javascript code change commits collected from Github, HOPPITY correctly detects and fixes bugs in 9,490 out of 36,361 programs using a beam size of three.
+
+# 2 MOTIVATING EXAMPLES
+
+Javascript is quite different compared to traditional object-oriented languages (e.g. $\mathrm { C } { + + }$ , Java, or $\mathbf { C } \#$ ). In addition to the weak, dynamic typing discipline of scripting languages, Javascript supports many peculiar features that do not exist in other languages. For example, it allows a property (i.e., a field) to be added to or removed from an object at runtime. As another example, Javascript did not support block-level scoping until recently, allowing a variable defined in a block structure such as a for loop to be exposed to the entire function in which the loop occurs. While the latest ES6 language standard incorporates block-level scoping, developers have been programming without it for decades, resulting in a large body of legacy code. Finally, Javascript’s eval function, which interprets and executes a string as a code fragment, is widely regarded as a major source of bugs and vulnerabilities. All of these aspects make programming in Javascript a frustrating and error-prone experience.
+
+![](images/5d5db4d59feaf5fb2d4045cba10080cbb7a131b8e8d7ef8e54625067bc4119e3.jpg)  
+(c) copy function should have also been included in (d) parseInt should have been removed because $= = = =$ the highlighted list. implies this.value is an integer.   
+Figure 1: Example programs that illustrate limitations of existing approaches inculding both rulebased static analyzers and neural-based bug predictors.
+
+Static analyzers aim to detect common coding errors in Javascript programs by applying logical rulebased reasoning on source code. TAJS (Jensen et al., 2009) and ESLint (Zakas, 2013) are prominent examples. These tools face important challenges to be effective. We present several examples in Figure 1 to illustrate their limitations. Due to the complex nature of client-side web APIs, TAJS and ESLint choose to ignore analyzing built-in libraries for the sake of scalability. As depicted in Figure 1a, when developers mistakenly capitalize the first letter of innerHTML, a property of class Element in DOM (Document Object Model), both analyzers fail to catch the error. Javascript will then silently allow developers to set the previously non-existent property InnerHTML to the empty string. Later, when developers attempt to access the intended property, innerHTML, the program will crash and potentially cause a security vulnerability or incur a costly debugging experience. Additionally, static analyzers can never deal with functional bugs (i.e., errors that violate the program specification and yet conform to the coding rules). Figure 1b shows one such example. The goal is to split a string using regular expressions. However, the program incorrectly splits the input ' and ' into ['', and ''] instead of $[ { \bf \Phi } ^ { \prime \prime } , { \bf \Phi } ^ { \prime \prime } ]$ , which is what the developer intended. Since the error is simply a mismatch between the developer’s implicit specification and implementation, static analyzers are incapable of catching it.
+
+![](images/debfa503638c9e415a26e59edbafb8dbed10fbd181589d19251d769b600dfc54.jpg)  
+Figure 2: Code repair as graph transformation. Each step the source code graph is edited via one of the operator module until STOP is triggered by controller.
+
+The bugs that static analyzers missed in both cases are in hindsight quite obvious to human programmers. The criteria they use is very simple: any code snippet that seems to deviate from common code patterns is likely to be buggy. This is precisely the observation that our approach seeks to mimic. In particular, if a model observes a property or an unusual way of splitting strings that never appeared in the training data, it is likely to recognize those abnormal code fragments as potential bugs. The main advantage of our approach over existing neural-based bug detectors (Allamanis et al., 2018; Pradel & Sen, 2018; Vasic et al., 2019) is its generality. Unlike prior works that target specific classes of bugs (e.g., variable naming issues or binary expression bugs), we train a single model to deal with a wide range of bug types, encompassing all previously proposed ones. Compared to past approaches that leverage a graph-based neural network model (Allamanis et al., 2018), our model is capable of more sophisticated transformations such as adding or removing nodes, as shown in Figure 1c and 1d. Finally, our model not only locates but also fixes bugs, whereas program repair (Le Goues et al., 2019; Scott et al., 2019; Hua et al., 2018; Chen et al., 2018) or bug localization (Ball et al., 2003; Jose & Majumdar, 2011; Wang et al., 2019) techniques only solve a single task.
+
+# 3 MODEL
+
+We model the problem of detecting and repairing bugs in programs as a structured prediction problem on a graph-based representation of programs. Given a graph $g _ { b u g }$ that represents a buggy program, we wish to predict a graph $g _ { f i x }$ that represents the fixed program. Our model aims to capture the structured prediction by a sequence of up to $T$ steps of graph transformations:
+
+$$
+p ( g _ { f i x } | g _ { b u g } ; \theta ) = p ( g _ { 1 } | g _ { b u g } ; \theta ) p ( g _ { 2 } | g _ { 1 } ; \theta ) \ldots p ( g _ { f i x } | g _ { T - 1 } ; \theta )
+$$
+
+The high-level overview of the graph sequence transformation is shown in Figure 2. Different programs may need a different number of steps $T ( g _ { b u g } )$ which is also determined by the model.
+
+We first introduce our representation module for programs in Sec 3.1. We then elucidate each step of the above transformation in Sec 3.2. Finally, we summarize and present the full model in Sec 3.3.
+
+# 3.1 PROGRAM REPRESENTATION
+
+Programs written in a high-level language have rich structure. Researchers have proposed graph-based representations to capture this structure (Allamanis et al., 2018). We start with this approach of representing programs using graphs with certain modifications for our task.
+
+As shown in the left part of Figure 2, we first parse the program’s source code into an abstract syntax tree (AST) form that captures the program’s syntactic structure. We then connect the leaf nodes with SuccToken edges. Unlike previous approaches, we additionally add value nodes that store the actual content of the leaf nodes, with special ValueLink edges connecting them together. The purpose of introducing this additional set of nodes is to provide a name-independent strategy for code representation and modification, which we elucidate in the next section. Hereafter, we use $g _ { f i x } , g _ { b u g }$ or $g$ in general to represent either the source code or the corresponding graph structure.
+
+After representing the program as a graph, we use a Graph Neural Network (GNN) (Scarselli et al., 2008) to map the graph into a representation in a fixed dimensional vector space. Specifically, given a graph $g = ( V , E )$ with set of nodes $V$ and edges $E$ , we need a function $f ( \boldsymbol { g } ) \mapsto ( \mathbb { R } ^ { d } , \mathbb { R } ^ { | V | \times d } )$ to obtain the $d$ -dimensional representation of graph $g$ (denoted as $\vec { g } )$ , as well as representations of individual nodes $v \in V$ (denoted as $\vec { v }$ ). To parameterize $f ( \cdot )$ , we employ the form in GIN ( $\mathrm { X u }$ et al., 2018), with our adaptation to our multigraph for program representation in the following manner:
+
+![](images/a2cc2ae4322d124cf58d65e62b0b650dc2a5f95c8603f0cf15ae0a1c0490a56b.jpg)  
+Figure 3: Graph edit operators with low-level primitives.
+
+$$
+\begin{array} { r l } & { h _ { v } ^ { ( l + 1 ) , k } = \sigma ( \sum _ { u \in \mathcal { N } ^ { k } ( v ) } \mathbf { W } _ { 1 } ^ { l , k } h _ { u } ^ { ( l ) } ) , \forall k \in \{ 1 , 2 , \ldots , K \} } \\ & { h _ { v } ^ { ( l + 1 ) } = \sigma ( \mathbf { W } _ { 2 } ^ { l } [ h _ { v } ^ { ( l + 1 ) , 1 } , h _ { v } ^ { ( l + 1 ) , 2 } , \ldots , h _ { v } ^ { ( l + 1 ) , K } ] + h _ { v } ^ { ( l ) } ) } \end{array}
+$$
+
+where $\mathbf { W } _ { 1 } ^ { l , k } \in \mathbb { R } ^ { d \times d }$ , $\mathbf { W } _ { 2 } ^ { l } \in \mathbb { R } ^ { d K \times d }$ are model parameters and $\sigma ( \cdot )$ is tanh in this implementation. $K$ is the total number of edge types in this multi-graph representation. In the end, the node embedding is $\vec { v } = h _ { v } ^ { ( L ) }$ , where $L$ is the total number of propagations in the GNN. $\mathcal { N } ^ { k } ( v )$ is the set of neighbors of node $v$ that are connected by edge with type $k$ . Following GIN, the graph representation $\vec { g }$ is the aggregation of $h _ { v } ^ { l } , \forall l \in 0 , 1 , \therefore , \bar { L }$ . We use max pooling to aggregate $\mathsf { \bar { h } } _ { v } ^ { l }$ for each $l$ , and then take the average of these $L + 1$ vectors to obtain $\vec { g }$ .
+
+Initially, we use the node type as one-hot features as a starting value for either obtained from the AST representation, or from the local value ta $h _ { v } ^ { ( 0 ) }$ , where the types areas shown in Figure 2. Note that we don’t use features like variable names or function names in this graph representation, as different programs may follow different naming conventions. Instead, we focus on the syntactic structure of the source code, so as to enable naming-agnostic representation across different programs.
+
+# 3.2 ONE-STEP GRAPH EDIT
+
+There are five types of operators to choose from for a single step graph edit, namely, adding a node (ADD), deleting a node (DEL), replacing a node value (REP_VAL), replacing a node type (REP_TYPE) and stop (NO_OP). When combined with multi-step edits, these operators suffice to capture a rich variety of code modifications. These operators share some common low-level primitives, such as finding the location, predicting value, etc. We first introduce the individual low-level primitives and then present how to assemble these for each type of graph edit operator.
+
+# 3.2.1 LOW-LEVEL PRIMITIVES
+
+Our low-level primitives contain location, type, and value prediction. These primitives can be combined for different operators later on. In this section, we assume the availability of a controller, represented as $\vec { c } \in \mathbb R ^ { d }$ . It keeps track of the global state, including the original source code, as well as the edits made so far. We will elaborate this when we assemble different primitives together.
+
+Location The location primitive locates a specific position in the source code. While it corresponds to region selection in the original text representation, with the graph representation, we can easily treat it as a node selection step. As different programs have different numbers of nodes, we employ a pointer network (Vinyals et al., 2015) into the graph structure. Specifically, after obtaining the node embeddings $\{ \vec { v } \} _ { v \in V }$ , we select the node via $l o \bar { c } ( \bar { \vec { c } } , g ) = \arg \operatorname* { m a x } _ { v \in V } \vec { v } ^ { \top } \bar { \vec { c } }$ for simplicity.
+
+Value The value primitive assigns a value for a leaf node in the AST. Instead of predicting the replacement value using a language generative model (Chen et al., 2018) or GNN score function (Allamanis et al., 2018), we adopt the attention mechanism to let the model to choose from either the values appearing in the current file (local value table), or a collection of global values that are common for the specific language. Let $D _ { v a l }$ be the global dictionary of commonly used leaf-node values in the language, where each item $i _ { v } \in D _ { v a l }$ is associated with a vector representation $\vec { i _ { v } } \in \mathbb R ^ { d }$ . The local value table is denoted as $V _ { v a l }$ which is a subset of the nodes in current graph. Then, the value is predicted via $\begin{array} { r } { v a l ( \vec { c } , g ) = \operatorname * { a r g m a x } _ { t \in D _ { v a l } \cup V _ { v a l } } \vec { t } ^ { \top } \vec { c } . } \end{array}$ . Again we use inner product simply for efficiency, while more expressive score functions can also be used.
+
+Type The type primitive assigns the type for non-terminal nodes in an AST. As the total possible number of types is finite and fixed for a given language, the type prediction is simply a multiclass classification problem. However, we can utilize the AST grammar checker with contextual information to prune the output space. To predict the type of a given non-terminal node, we can obtain its parent node and current children. Then, by looping over the valid production rules at the current location, we can obtain a list of all valid types. The final type is only chosen from this set.
+
+# 3.2.2 GRAPH EDIT OPERATORS
+
+The $t$ -th round of edit starts with the current graph $g _ { t - 1 }$ , the corresponding graph embedding, and the ‘macro-context’ embedding $\overrightarrow { c _ { M } } _ { t - 1 }$ that captures the edit history so far. Every type of edit operation (excluding NO_OP), requires prediction of the buggy location. So, in each round, the location primitive is invoked to determine the node to target. Then the edit type $e$ that is feasible at this location $v$ is predicted out of the five operators. A ‘micro-context’ embedding $\overrightarrow { c _ { m _ { t } } }$ is obtained from the macro embedding updated by two LSTM calls with location node embedding $\vec { v }$ and operator embedding $\vec { e } .$ . To summarize:
+
+$$
+\overrightarrow { c _ { M _ { t } } } ^ { \prime } = \mathrm { L S T M } ( \overrightarrow { g _ { t - 1 } } | \overrightarrow { c _ { M _ { t - 1 } } } ) , \overrightarrow { c _ { m _ { t } } } = \mathrm { L S T M } ( \overrightarrow { e _ { t } } | \mathrm { L S T M } ( \overrightarrow { v _ { t } ^ { \prime } } | \overrightarrow { c _ { M _ { t } } } ) ) ,
+$$
+
+The micro-context embedding is used as the controller throughout the process of each operator. In the following content, we present these operators in detail.
+
+ADD This operation adds a new node to the graph. Unlike in Li et al. (2018) where the node and corresponding edges are added in separate stages, which would introduce extra complexity, we introduce a simple mechanism that can uniquely add a node and corresponding edges. As is shown in Figure 3, this process invokes one location primitive, one value primitive, and one type primitive. The location primitive invoked before the edit (i.e., node $v$ ) determines the parent of the node to be added, while the location primitive called during the edit chooses the left sibling of the node. In a special case where the parent node does not have any children, then such left sibling node is set to the parent node itself. With this information, we can uniquely determine the position to insert into the AST. Finally, the corresponding edges—SuccToken, ValueLink, and AST edges—can automatically be inferred with the location of new node to be added.
+
+As this process is autoregressive, the micro-context embedding is kept updated with all the primitive calls. For this specific operator, the context is updated in the order of: $\overrightarrow { c _ { m 1 } } = \mathrm { L S T M } ( \overrightarrow { v _ { s i b l i n g } } | c _ { m } ^ {  } )$ , $c _ { m 2 } ^ {  } = \mathrm { L S T M } ( \bar { v } a l ( c _ { m 1 } ^ {  } , \bar { g } ) | c _ { m 1 } ^ {  } )$ and $c _ { m 3 } ^ {  } = \mathrm { L S T M } ( t y p e ( c _ { m 2 } ^ {  } , g ) | c _ { m 2 } ^ {  } )$ . In the end, $\vec { c } _ { A D D } = c _ { m 3 } ^ {  }$ summarizes the process.
+
+DEL This operator deletes a node and corresponding edges in the graph. If it is a non-terminal node in the AST, then the corresponding subtree is removed as well. The micro-context embedding is updated by the LSTM via the embedding of the node being deleted.
+
+REP_VAL This operator replaces the value of a leaf (terminal) node in the AST. This procedure requires the prediction the value. The leaf node is linked to the new value node in the internal value table via a ValueLink edge. Also, the micro-context embedding is updated by the LSTM via the embedding of the corresponding node and value.
+
+REP_TYPE This operator changes the type of a non-terminal node, which involves type primitive steps. The micro-context embedding is updated by the LSTM via the embedding of the corresponding node and type.
+
+NO_OP This op does not change the graph. It simply denotes the end of the sequence of graph edits.
+
+# 3.3 GRAPH TRANSFORMATION
+
+Our end-to-end model for graph transformation inference is shown in Alg 1. We denote the buggy graph $g _ { b u g }$ as $g _ { 0 }$ for simplicity. Then, for the $t$ -th graph edit, the following steps are performed:
+
+1. Obtain the graph representation $\overrightarrow { g _ { t - 1 } }$ and node embeddings. Update the macro-context embedding using $\overrightarrow { g _ { t - 1 } }$ ; 2. Choose edit location $v _ { t }$ by performing location primitive and update the context embedding; 3. Pick the graph edit operator $e _ { t }$ that is compatible with $v _ { t }$ ; Use both $v _ { t }$ and $e _ { t }$ to obtain the micro-context embedding. 4. Perform the edit, obtain the corresponding micro-context summary $\overrightarrow { c _ { e _ { t } } }$ and update the macro-context embedding. 5. If the edit is not NO_OP, then go back to step 1; otherwise return the graph.
+
+# Algorithm 1 Transformation inference of $\overline { { p ( g _ { f i x } | g _ { b u g } ) } }$
+
+1: Input $g _ { b u g } \sim \mathcal { D }$ and model parameters $\theta$ .   
+2: Obtain $\vec { g _ { 0 } }$ , $\{ \vec { v } _ { v \in g _ { b u g } } \} = f _ { 0 } ( g _ { b u g } )$ , let $c _ { M _ { 0 } } ^ {  }$ be null.   
+3: for $t = 1$ to $T$ do   
+4: Obtain $\overrightarrow { c _ { M _ { t } } ^ { \prime } } = \mathrm { L S T M } ( \overrightarrow { g _ { t - 1 } } | \overrightarrow { c _ { M _ { t - 1 } } } )$ .   
+5: Choose location $v _ { t }$ , then edit type $e _ { t }$ ;   
+6: if $e _ { t } = \tt N O \_ O P$ then   
+7: set $g _ { T } = g _ { t - 1 }$ and exit the loop.   
+8: end if   
+9: Perform operator $e _ { t }$ with $\overrightarrow { c _ { m _ { t . } } }$ obtained by $\operatorname { E q } 3$ .   
+10: Get new graph $g _ { t }$ , update $\xrightarrow [ { \boldsymbol { c } _ { M _ { t } } } ] { }$ with $\overrightarrow { c _ { e _ { t } } }$ .   
+11: end for   
+12: Return gT
+
+This process repeats until it reaches the maximum steps $T$ or the NO_OP operator is selected. Note that our framework can capture the situation when the input program is bug-free. In this case, the NO_OP operator is supposed to be triggered at the first step. Also, each edit step is not limited to a single node level operation. It can be extended to modify a certain substructure (e.g., replace a tree node with one of its children). This in turn allows program repair to be performed in fewer edit steps.
+
+# 4 LEARNING
+
+Given the dataset $\mathcal { D } = \{ ( g _ { b u g } ^ { ( i ) } , g _ { f i x } ^ { ( i ) } ) \} _ { i = 1 } ^ { | \mathcal { D } | }$ which consists of pairs of buggy code and the fixed code, the learning objective maxθ $\bar { \mathbb { E } } _ { ( g _ { b u g } , g _ { f i x } ) \sim \mathcal { D } } p ( g _ { f i x } | g _ { b u g } ; \theta )$ maximizes the likelihood of fixes.
+
+Since the probability is factorized according to $\operatorname { E q }$ where a sequence of transformations is performed, we parse the source code using the SHIFT AST format, and utilize a JSON diff toolbox to compile the code differences into a sequence of AST edits. This serves as the fine-grained supervision mechanism for our graph transformation formulation. Thus, the MLE objective above is realized with the sum of cross entropy loss at each step of graph edits. During training, we jointly optimize the graph representation module $\{ f _ { t } ( \cdot ) \} _ { t = 1 } ^ { T }$ , each of the operator module and the controller module which is parameterized by LSTM. We use the Adam optimizer with $\beta _ { 1 } = 0 . 9 , \beta _ { 2 } = 0 . 9 9$ and initial learning rate of $1 0 ^ { - 3 }$ . Due to the large size of each sample, we use a small batch size of 10 during training. Furthermore, to stabilize the training, we apply the gradient clip with the maximum norm of 5.
+
+# 5 INFERENCE
+
+The inference procedure involves searching for the maximum in the combinatorial space: arg $\operatorname* { m a x } _ { g _ { f i x } } p ( g _ { f i x } | g _ { b u g } ; \theta )$ . Since the search space is very large, however, we use beam-search to approximately find the fixes with highest probabilities.
+
+Specifically, we maintain a pool of partially fixed programs $\{ \tilde { g } \}$ , which starts with simply the single buggy program $g _ { b u g }$ . The pool size is limited by the beam-search size $B$ . For each $\tilde { g }$ , we propose the top $B$ locations to be modified, top $B$ operators or top $B$ primitives (location, type, value), depending on the current stage of the edit $\tilde { g }$ . Then the total joint one-step graph transformation solutions are ranked together based on the joint log-likelihood, and the top $B$ solutions with the largest likelihood are kept in the pool for the next round of beam search.
+
+Unlike beam search for language models where the vocabulary size is fixed, in our setting, the available choices or even the steps of inference may vary (e.g., the ADD operator has more steps of primitive calls than the DEL operator). Our implementation is based on PyTorch with customized GPU kernels to enable efficient inference on GPUs.
+
+# 6 EXPERIMENTS
+
+Dataset Our model is trained and evaluated on a corpus of nearly half a million data points. We have created a robust system to continuously collect small changes in Javascript programs from Github. Given a commit, we download the Javascript file before and after the change: $( s r c _ { b u g g y } , s r c _ { f i x e d } )$ . Commits can contain many types of changes such as feature additions, refactorings, bug fixes, etc. In an attempt to filter our dataset to only include bug fixes, we use a heuristic based on the number of changes to the AST. Our insight is that a commit with a smaller number of AST differences is more likely to be a bug fix than a commit containing large changes. Thus for the experiments, we use three different datasets: OneDiff with precisely one edit; ZeroOneDiff with zero and one edit and ZeroOneTwoDiff with zero, one or two edits. We additionally filter out data points with ASTs larger than 500 nodes as a parameter in our system. A detailed overview of our corpus crawler is available in Appendix B.
+
+Table 1: Statistic of OneDiff dataset. See appendix for more information of other dataset.   
+
+<table><tr><td></td><td>ADD</td><td>REP_TYPE</td><td>REP_VAL</td><td>DEL</td><td>total</td></tr><tr><td>train</td><td>6,473</td><td>1,864</td><td>251,097</td><td>31,281</td><td>290,715</td></tr><tr><td>validate</td><td>790</td><td>245</td><td>31,357</td><td>3,957</td><td>36,349</td></tr><tr><td>test</td><td>796</td><td>233</td><td>31,387</td><td>3,945</td><td>36,361</td></tr></table>
+
+<table><tr><td rowspan="3"></td><td colspan="2">Total</td><td colspan="2">Location</td><td>Operator</td><td colspan="2">Value</td><td colspan="2">Type</td></tr><tr><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td></tr><tr><td>TOTAL</td><td>26.1</td><td>14.2</td><td>35.5</td><td>20.4</td><td>34.4</td><td>52.3</td><td>29.1</td><td>76.1</td><td>66.7</td></tr><tr><td>ADD</td><td>52.9</td><td>39.2</td><td>69.6</td><td>51.4</td><td>70.6</td><td>65.7</td><td>55.1</td><td>76.8</td><td>68.5</td></tr><tr><td>REP_VAL</td><td>23.4</td><td>11.9</td><td>33.3</td><td>18.5</td><td>31.7</td><td>53.0</td><td>28.8</td><td>-</td><td>1</td></tr><tr><td>REP_TYPE</td><td>71.7</td><td>52.4</td><td>73.0</td><td>52.8</td><td>79.4</td><td>-</td><td>-</td><td>74.7</td><td>61.0</td></tr><tr><td>DEL</td><td>39.6</td><td>24.8</td><td>44.0</td><td>27.5</td><td>45.8</td><td>1</td><td>1</td><td>1</td><td>二</td></tr><tr><td>Random</td><td>.08</td><td>.07</td><td>2.28</td><td>1.4</td><td>27.7</td><td>.01</td><td>.01</td><td>.27</td><td>0</td></tr></table>
+
+Table 2: Evaluation of model on the OneDiff dataset: accuracy $( \% )$
+
+# 6.1 EVALUATION
+
+We train the model for 3 epochs on the training set until the validation loss converges. We tried different configurations of our model with different number of layers and different graph embedding methods besides the generic one in Eq 2. We report on these ablation studies in Appendix C.
+
+Table 2 shows the evaluation results of our model on a held out test set consisting of samples from our OneDiff dataset. Additional experiments on ZeroOneDiff and ZeroOneTwoDiff datasets are available in Appendix A. We also provide experimental results with respect to different configurations.
+
+Accuracy is shown for each graph edit operation type. Accuracy is measured in a complete discrete graph edit operation step. For example consider Figure 1a, in which we edit an object property name with the REP_VAL operation. If the model incorrectly predicts the edit operation to be of type DEL, then it will not go on to predict a value. In this case, the model will be penalized twice in the operation accuracy as well as the value accuracy. A prediction is considered totally correct only if the entire sequence of graph edit primitives is correct. Note that top-1 greedy prediction is not always among top-3 when beam search is used. Additionally, operator prediction is only evaluated on the top prediction as the search space only includes four operators.
+
+To demonstrate the magnitude of the search space, we compare HOPPITY to a model that selects uniformly at random, in each step of the graph edit process. The random model performs well at operation type selection since the search space only has four options (ADD, REP_VAL, REP_TYPE, DEL). However, after the operation type is predicted, the random model’s accuracy drops, as there are up to 500 nodes in the buggy AST. When it predicts value, the accuracy drops even further as our vocabulary contains 5,000 values. Lastly, type prediction has slightly better accuracy than value prediction because the number of the types of AST nodes in total is smaller than our vocabulary.
+
+# 6.2 BASELINES
+
+As existing approaches cannot be applied for comparison in Table 7, we adapt the baselines to some restricted settings in this section. We report the results on the OneDiff dataset as most of the baselines target repair of a single bug. Note that for all comparisons we provide equal amounts of information to HOPPITY and the baseline without retraining our model.
+
+<table><tr><td>Type</td><td>GGNN-Rep</td><td>GGNN-Cls</td><td>HOPPITY</td></tr><tr><td>Top-1</td><td>53.2%</td><td>99.6%</td><td>90.0%</td></tr><tr><td>Top-3</td><td>85.8%</td><td>99.6%</td><td>94.8%</td></tr></table>
+
+Table 5: Overall OneDiff accuracy with location.   
+
+<table><tr><td rowspan="2">HOPPITY</td><td>Top-1</td><td>Top-3</td></tr><tr><td>67.7%</td><td>73.3%</td></tr><tr><td>SequenceR</td><td>64.2%</td><td>68.6%</td></tr></table>
+
+Table 3: REP_TYPE accuracies with location+op.   
+Table 6: Comparison with TAJS.   
+
+<table><tr><td>Bug Type</td><td>Amount</td><td>TAJS</td><td>HOPPITY</td></tr><tr><td>Undefined Property Functional Bug</td><td>7 11</td><td>0 0</td><td>1 3</td></tr><tr><td>Refactoring</td><td>12</td><td>0</td><td>1</td></tr><tr><td>Total</td><td>30</td><td>0</td><td>5</td></tr></table>
+
+<table><tr><td>Value</td><td>GGNN-Rep</td><td>GGNN-RNN</td><td>HOPPITY</td></tr><tr><td>Top-1</td><td>63.8%</td><td>60.3%</td><td>69.1%</td></tr><tr><td>Top-3</td><td>67.6%</td><td>63.6%</td><td>73.4%</td></tr></table>
+
+Table 4: REP_VAL accuracies with location+op.
+
+GGNN: Allamanis et al. (2018), uses Gated Graph Neural Networks (GGNN) for two specific bug repair tasks: VARMISUSE, in which the model learns to select the correct variable that should be used at a given location, and VARNAMING, in which the model predicts a variable name based on its usage. We adapt these tasks to compare with HOPPITY on the REP_TYPE and REP_VAL tasks. Specifically, for REP_TYPE prediction we have
+
+• GGNN-Rep: we adopt VARMISUSE to replace with candidate node type and modify the graph structure correspondingly; we use their proposed max-margin formulation for training. • GGNN-Cls: we perform multi-class classification using the target node and graph embedding.
+
+For REP_VAL prediction, we also made two versions of adaptations:
+
+• GGNN-Rep: similar to above, here the candidate set is from values in the current graphs plus the top-100 frequent values used for repair in the training set. • GGNN-RNN: we adopt VARNAMING approach to predict value directly. Due to the huge vocabulary size, we use char-level language model for predicting the replacement.
+
+Table 3 and 4 show the comparison when buggy node is known. Regarding the type prediction, as the number of types is large, the likelihood formulation with classification objective outperforms the max-margin loss based one (i.e., GGNN-Rep). As in this limited case GGNN-Cls and HOPPITY are quite similar except for graph representation, the performance is expected to be comparable. As HOPPITY is not trained to predict type fix only, it performs slighly worse than GGNN-Cls. Also for the value prediction, our formulation of pointer on graph is more effective. We found when the space of decisions is large, it is hard to apply structured prediction method like GGNN-Rep in this setting. Since real-world programs are noisy, the sentences used in different programs vary greatly, making it difficult for language models to predict the exact accurate value. A possible extension is to combine the language model with the graph pointer, which we will explore in future work.
+
+SequenceR: The model proposed by Chen et al. (2018) is a translation based model that predicts a fixed sequence of tokens when given a buggy line in the source code. We compare with our model by providing location information to both approaches.
+
+Table 5 summarizes the total accuracy for fixing a single bug. In order to provide a fair comparison, we allow SequenceR to predict the same information as our model (i.e., predict op, value etc.in a sequential way), rather than an entire sequence of raw textual tokens. This experiment shows the benefit of formulating code repair with graphs over text tokens.
+
+With the above two baselines, we can see that in the restricted case our model can still yield comparable or even better performances. Given that our model can go for more edits without location information, we believe this tool is more generic and effective for code repair.
+
+TAJS: We also compare the bug detection ability of HOPPITY against TAJS (Jensen et al., 2009) which is a well-known static analysis tool for Javascript programs. Automating the comparison for our entire test set proved to be infeasible. For example, TAJS only accepts JavaScript ES5 programs, while the vast majority of current JavaScript projects use ES6 or other variants like React JSX. Another problem is that TAJS does not analyze code that is not invoked, e.g., a library function that is not called by client code. Moreover, determining the right command-line options of TAJS is non-trivial since it provides many options targeting different JavaScript runtime environments. Due to these issues, we forgo a large-scale comparison, and instead pick 30 random points in our test set to manually analyze using TAJS. Table 6 depicts the results (Appendix D provides further details).
+
+We restrict the chosen test points to satisfy a necessary condition for undefined property bugs since TAJS claims to be proficient in detecting this class of bugs. In the process, we also pick some functional bugs, as well as cases of refactoring modifications. By resolving the numerous issues that prevented us from automating the comparison, we were able to run TAJS manually. TAJS failed to detect any real bugs in the 30 test points. While functional bugs and refactoring modifications are beyond TAJS, however, TAJS also raises many unrelated false alarms due to its failures in locating NodeJS libraries, importing JSON files, or recognizing built-in global variables. These warnings are detrimental because TAJS suspends the analysis as soon as it detects what it preceives to be a bug. To further aid TAJS, we omitted parts of each program that are unrelated to the bug, in the hope of driving TAJS’s analysis as deep as possible. After all these measures, TAJS managed to detect two of the undefined property bugs (Bug IDs 4 and 6 in Appendix D).
+
+In contrast, HOPPITY is able to correctly detect 5 bug locations of the 30 testing points within our top 3 predictions. Moreover, HOPPITY also produces 4 patches that are identical to the developer’s fixes. Our comparison highlights HOPPITY’s two important strengths compared to TAJS. First, HOPPITY relieves developers from the enormous burden of manual configuration. Second, HOPPITY achieves far better performance in detecting as well as fixing the bugs in Javascript programs.
+
+# 7 RELATED WORK
+
+Static analysis for bug detection. Static analyzers such as FindBugs, Error-Prone, and Semmle use syntactic pattern-matching and dataflow analysis to find common bugs. Typically, detecting even a single class of bugs can require dozens or even hundreds of patterns. Coverity (Bessey et al., 2010), SonarQube, and Clang Static Analyzer check for semantic inconsistencies in code based on more sophisticated path analyses. Infer (Calcagno et al., 2015) is built upon sound principles and can prove the absence of certain classes of bugs. TAJS belongs to this category as well. Due to the undecidability of the problem, however, approximations are inevitable which voids the guarantees in practice. Compared to all static analysis tools, HOPPITY offers the following advantages: (1) it targets a board range of programming errors; (2) it not only localizes bugs but also fixes them; and (3) it has significantly higher signal-to-noise ratio (i.e., detects more bugs with less false alarms).
+
+Learning-based bug detection. Allamanis et al. (2018) target variable-misuse errors and present a solution based on a gated graph neural network model to predict the correct variable name given a buggy location. Vasic et al. (2019) present a pointer network on top of a RNN which outperforms Allamanis et al. (2018) on the same task. DeepBugs (Pradel & Sen, 2018) proposes a name-based bug detection scheme. Their model is trained to predict three classes of bugs: swapped function arguments, wrong binary operator, and wrong operand in a binary operation. Compared to these models, our approach is capable of detecting and fixing a wide range of errors in Javascript. SequenceR (Chen et al., 2018) uses sequence-to-sequence model to translate a buggy code segment into correct one; Getafix (Scott et al., 2019) produces human-like bug fixes by learning from past fixes. It employs a hierarchical clustering algorithm that sorts fix patterns according to their generality. While these approaches are general against different types of bugs, they still need the bug location as input.
+
+Graph learning and optimization. Our work is closely related to the literature in graph representation learning and optimization. Our model uses a variant of GNN that is inspired by many representative works (Li et al., 2015; Xu et al., 2018; Si et al., 2018), with the adaptation of local value table and pointer mechanism. Our work is also related to auto-regressive graph modeling Johnson (2016); Li et al. (2018); Brockschmidt et al. (2018); Dai et al. (2018), but with more generic operations such as subtree deletion and attribute modifications. Some other works model the graph modification in latent space (Jin et al., 2018; Yin et al., 2018), but such frameworks lack fine-grained control over the generative process, and thus are not very suitable for performing code repair.
+
+# 8 CONCLUSION
+
+We proposed an end-to-end learning-based approach to detect and fix bugs in Javascript programs. We realized the approach in a tool HOPPITY and demonstrated that it correctly predicts 9,490 out of 36,361 code changes in real programs on Github. In the future, we plan to expand the targeted bugs to include those that are caused by the interdependence among multiple files or that require multiple steps to fix. We will also deploy HOPPITY in an IDE to further evaluate its accuracy and utility. Finally, we plan to extend our learning framework to support other languages. Due to its language-independence, we believe HOPPITY will benefit developers beyond Javascript as well.
+
+# ACKNOWLEDGMENTS
+
+We thank the reviewers for their insightful comments. This research was supported in part by NSF awards #1836936 and #1836822, ONR award #N00014-18-1-2021, and Facebook research awards.
+
+# REFERENCES
+
+Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. International Conference on Learning Representations, 2018.
+
+Thomas Ball, Mayur Naik, and Sriram K. Rajamani. From symptom to cause: Localizing errors in counterexample traces. In Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, 2003.
+
+Al Bessey, Ken Block, Ben Chelf, Andy Chou, Bryan Fulton, Seth Hallem, Charles Henri-Gros, Asya Kamsky, Scott McPeak, and Dawson Engler. A few billion lines of code later: Using static analysis to find bugs in the real world. Communications of the ACM, 53(2), February 2010.
+
+Marc Brockschmidt, Miltiadis Allamanis, Alexander L Gaunt, and Oleksandr Polozov. Generative code modeling with graphs. arXiv preprint arXiv:1805.08490, 2018.
+
+Cristiano Calcagno, Dino Distefano, Jeremy Dubreil, Dominik Gabi, Pieter Hooimeijer, Martino Luca, Peter O’Hearn, Irene Papakonstantinou, Jim Purbrick, and Dulma Rodriguez. Moving fast with software verification. In NASA Formal Method Symposium, 2015.
+
+Zimin Chen, Steve Kommrusch, Michele Tufano, Louis-Noël Pouchet, Denys Poshyvanyk, and Martin Monperrus. Sequencer: Sequence-to-sequence learning for end-to-end program repair. arXiv preprint arXiv:1901.01808, 2018.
+
+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.
+
+Github. State of the Octoverse. https://octoverse.github.com/#top-languages, 2019.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Jinru Hua, Mengshi Zhang, Kaiyuan Wang, and Sarfraz Khurshid. Sketchfix: A tool for automated program repair approach using lazy candidate generation. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, 2018.
+
+Simon Holm Jensen, Anders Møller, and Peter Thiemann. Type analysis for javascript. In Proceedings of the 16th International Symposium on Static Analysis, 2009.
+
+Wengong Jin, Kevin Yang, Regina Barzilay, and Tommi Jaakkola. Learning multimodal graph-tograph translation for molecular optimization. arXiv preprint arXiv:1812.01070, 2018.
+
+Daniel D Johnson. Learning graphical state transitions. 2016.
+
+Manu Jose and Rupak Majumdar. Cause clue clauses: Error localization using maximum satisfiability. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, 2011.
+
+Claire Le Goues, Michael Pradel, and Abhik Roychoudhury. Automated program repair. Commun. ACM, 2019.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Yujia Li, Oriol Vinyals, Chris Dyer, Razvan Pascanu, and Peter Battaglia. Learning deep generative models of graphs. arXiv preprint arXiv:1803.03324, 2018.
+
+Michael Pradel and Koushik Sen. Deepbugs: A learning approach to name-based bug detection. Proc. ACM Program. Lang., 2(OOPSLA), 2018.
+
+Caitlin Sadowski, Jeffrey van Gogh, Ciera Jaspan, Emma Söderberg, and Collin Winter. Tricorder: Building a program analysis ecosystem. In Proceedings of the 37th International Conference on Software Engineering, 2015.
+
+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.
+
+Andrew Scott, Johannes Bader, and Satish Chandra. Getafix: Learning to fix bugs automatically. volume 2, 2019.
+
+Xujie Si, Hanjun Dai, Mukund Raghothaman, Mayur Naik, and Le Song. Learning loop invariants for program verification. In Advances in Neural Information Processing Systems, pp. 7751–7762, 2018.
+
+Marko Vasic, Aditya Kanade, Petros Maniatis, David Bieber, and Rishabh Singh. Neural program repair by jointly learning to localize and repair. International Conference on Learning Representations, 2019.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015.
+
+Yu Wang, Fengjuan Gao, Linzhang Wang, and Ke Wang. Learning a static bug finder from data. arXiv preprint arXiv:1907.05579, 2019.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.
+
+Pengcheng Yin, Graham Neubig, Miltiadis Allamanis, Marc Brockschmidt, and Alexander L Gaunt. Learning to represent edits. arXiv preprint arXiv:1810.13337, 2018.
+
+Nicholas C. Zakas. ESLint. https://eslint.org/, 2013.
+
+A ADDITIONAL EXPERIMENTS   
+
+<table><tr><td rowspan="3"></td><td colspan="2">Total</td><td colspan="2">Location</td><td>Operator</td><td colspan="2">Value</td><td colspan="2">Type</td></tr><tr><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td></tr><tr><td>ZeroOneTwoDiff</td><td>40.8</td><td>29.7</td><td>18.9</td><td>3.9</td><td>30.3</td><td>35.0</td><td>6.5</td><td>38.6</td><td>3.4</td></tr><tr><td>ZeroOneDiff</td><td>51.6</td><td>34.5</td><td>27.1</td><td>5.5</td><td>35.6</td><td>45.4</td><td>10.4</td><td>73.9</td><td>58.9</td></tr><tr><td>OneDiff</td><td>26.1</td><td>14.2</td><td>35.5</td><td>20.4</td><td>34.4</td><td>52.3</td><td>29.1</td><td>76.1</td><td>66.7</td></tr><tr><td>Random</td><td>.08</td><td>.07</td><td>2.28</td><td>1.4</td><td>27.7</td><td>.01</td><td>.01</td><td>.27</td><td>0</td></tr></table>
+
+Table 7: Evaluation of models on each dataset. The Random model is evaluated on the OneDiff dataset and is shown for comparison.
+
+Full experiment results In addition to the evaluation of samples with one edit Table 7, we also evaluate HOPPITY on the following datasets:
+
+• ZeroOneDiff - Includes samples with labels of zero or one edit • ZeroOneTwoDiff - Includes samples with labels of zero, one, or two edits.
+
+We trained models on each dataset for roughly 12 hours on a single GTX 2080Ti GPU. Accuracy on the ZeroOneDiff is the highest as predicting that an AST is not buggy does not consist of any low level primitive predictions. This makes it a much easier prediction for the model than say, an ADD operation which the parent location, left sibling, value, and type must all be predicted correctly in order to be considered accurate.
+
+Table 8: Results on true/false predictions.   
+
+<table><tr><td colspan="3">TRUELABEL</td></tr><tr><td colspan="3"></td></tr><tr><td rowspan="2">ALARM PREDICTED NO ALARM</td><td>BUGGY</td><td>NOTBUGGY</td></tr><tr><td>10,293 26,517</td><td>7,210 20,605</td></tr></table>
+
+False positive/negative study An evaluation of false positives and false negatives is available in Table 8. In this setting, we treat the problem as a classification problem on our ZeroOneDiff dataset and our model attempts to predict if a given AST is BUGGY / NOT BUGGY. If the model predicts ADD, REP_VAL, REP_TYPE, or DEL, we consider this a prediction of "BUGGY." Accordingly, if the model predicts NO_OP, we consider this to be a prediction of "NOT BUGGY."
+
+Accuracy v.s. size of graph To demonstrate the affect of AST size on HOPPITY’s prediction accuracy on the OneDiff dataset, we include Figure 4. As expected, AST size and accuracy are inversely related.
+
+Table 9: Accuracy vs beam sizes.   
+
+<table><tr><td>Beam Size (k)</td><td>Top-k Accuracy (%)</td></tr><tr><td>1</td><td>14.37%</td></tr><tr><td>2</td><td>21.10%</td></tr><tr><td>3</td><td>26.14%</td></tr><tr><td>4</td><td>30.12%</td></tr><tr><td>5</td><td>33.58%</td></tr></table>
+
+Accuracy v.s. beam search size In Table 9 we compare the performance with different beam sizes on the OneDiff dataset. As we can see, the top-3 accuracy with beam size 3 is significantly better than top-1 accuracy with just greedy prediction. This is expected, as in the decision process there are ’bottleneck’ stages with only a few predictions (e.g., the op prediction). Thus from beam-1 to beam-3 there’s huge improvement, but further beyond the performance maxed out.
+
+![](images/2d4d22c9e753089552f3570ecc2cf47b4f93588aa8e3ea9b1d474d5c45c331a9.jpg)  
+Figure 4: End-to-end code repair accuracy v.s. size of AST of source code.
+
+# B DATA COLLECTION
+
+We have built a robust system to automatically collect millions of bug-fixes in Javascript programs from Github. Our system continuously crawls Github for commits containing Javascript files and creates a label consisting of the change to the AST corresponding to each such file.
+
+Our system consists of three entirely automated parallel steps:
+
+1. Collect Commits: Our system uses the GH Archive API to easily access Github event data for a specific hour in time. After obtaining all data for the hour, we filter this using the Github API to only include commits that consist of edits to Javascript files.
+
+2. Download Files: As we are obtaining a list of valid commits from step 1, we begin downloading the pair: $( s r c _ { b u g g y } , s r c _ { f i x e d } )$ where $s r c _ { b u g g y }$ is the file prior to the commit, and $s r c _ { f i x e d }$ is the file following the commit that contains the changes made.
+
+3. Create Label: For each Javascript file downloaded, we parse the source code into a JSON format of the AST. Our system uses the SHIFT AST 1. Abstract Syntax Tree representations are designed to naturally and intuitively represent the structure of the source code. Because of this design goal, small changes in the source code can often lead to very large changes in the AST. We chose the SHIFT AST representation with consideration to our goal of maximizing the number of commits with only one difference between the ASTs. This component produces a pair of ASTs: $( A S T _ { b u g g y } , A S T _ { f i x e d } )$ at which point a JSON differencing algorithm, fast-json-patch 2 is applied to create a label. The label includes the operation type and node edited for each difference between $A S T _ { b u g g y }$ and $A S T _ { f i x e d }$ .
+
+Each step of this process is parallelized in order to grow our corpus as quickly as possible. Our dataset has the advantage that it is continuously growing without human input.
+
+Our system is language independent and highly extensible and modular. For example, it can handle any language so long as it can be parsed into a JSON AST.
+
+For each label, we must download two files $s r c _ { b u g g y }$ and $s r c _ { f i x e d }$ . Additionally, if source files cannot be parsed into a SHIFT AST, a label cannot be created. For our learning corpus, we limit the dataset to only include labels with one AST difference. Additionally, in an attempt to limit graph size, we only include data points in which the $A S T _ { b u g g y }$ and $A S T _ { f i x e d }$ have less than 500 nodes.
+
+Table 10: Data collection statistics.   
+
+<table><tr><td rowspan=1 colspan=1>Total Files Downloaded:</td><td rowspan=1 colspan=1>52,719,402</td></tr><tr><td rowspan=1 colspan=1>Total Labelled Data Points:</td><td rowspan=1 colspan=1>15,225,347</td></tr><tr><td rowspan=1 colspan=1># AST differences:</td><td rowspan=1 colspan=1># data points:</td></tr><tr><td rowspan=1 colspan=1>012-1011-2021-5051-100101+</td><td rowspan=1 colspan=1>3,473,3911,863,1933,247,4372,117,9772,047,998858,981921,754</td></tr></table>
+
+![](images/b0883dab9f4a7fec3bda7f5feb2162d7d71eb6b3b303edf2c63e2002d7a13d51.jpg)  
+Figure 5: Distribution of number of edits in the entire crawled dataset.
+
+Figure 5 plots the distribution of number of edits that are recorded in Table 10. We can see the distribution is long tail, with majority of edits as 1 or 2.
+
+# C ABLATION STUDY
+
+We tried different graph representations with corresponding graph embedding methods. The multi represents the multi-graph defined by different edge types, with the parameterization of message passing function mentioned in Eq 2; the code2inv is the parameterization used in Si et al. (2018); the single instead uses a single graph with edge types as one-hot edge features. We found that more layers does not lead to better generalization in our setting, and it becomes slower in terms of convergence. So we report the results with 4 layers in our main paper.
+
+<table><tr><td>model</td><td>max_lv</td><td>Total</td><td>Operator</td><td>Location</td><td>Value</td><td>Type</td></tr><tr><td>multi</td><td>20</td><td>7.63</td><td>30.0</td><td>13.1</td><td>22.6</td><td>54.5</td></tr><tr><td>multi</td><td>14</td><td>11.05</td><td>48.0</td><td>17.9</td><td>38.6</td><td>61.6</td></tr><tr><td>multi</td><td>4</td><td>13.33</td><td>53.4</td><td>36.2</td><td>38.6</td><td>56.4</td></tr><tr><td>code2inv</td><td>20</td><td>10.3</td><td>18.1</td><td>25.7</td><td>38.8</td><td>57.7</td></tr><tr><td>code2inv</td><td>14</td><td>8.92</td><td>40.0</td><td>18.1</td><td>36.0</td><td>55.9</td></tr><tr><td>code2inv</td><td>4</td><td>13.29</td><td>30.8</td><td>18.9</td><td>28.2</td><td>68.21</td></tr><tr><td>single</td><td>20</td><td>5.00</td><td>20.2</td><td>10.3</td><td>14.2</td><td>44.8</td></tr><tr><td>single</td><td>14</td><td>10.69</td><td>67.7</td><td>18.6</td><td>49.6</td><td>38.7</td></tr><tr><td>single</td><td>4</td><td>12.88</td><td>55.8</td><td>20.8</td><td>43.2</td><td>55.8</td></tr></table>
+
+Table 11: Ablation study with different graph embedding parameterizations and different number of layers. Full end-to-end repair accuracy as well as the accuracies for each primitives are reported. All the numbers are for top-1 prediction.
+
+# D 30 RANDOM TESTING POINTS FOR TAJS BASELINE STUDY
+
+<table><tr><td colspan="1" rowspan="1">868记2</td><td colspan="1" rowspan="1">记记记7亿</td><td colspan="1" rowspan="1">068u9</td><td colspan="1" rowspan="1">g1uuⅡ</td><td colspan="1" rowspan="1">668L9</td><td colspan="1" rowspan="1">S4ε乙</td><td colspan="1" rowspan="1">U</td></tr><tr><td colspan="1" rowspan="1"> org.civicrm.civicaseDiscordWithDatabasecryptiifo_restkootCaseDetailsFileTab.jshelp.jsROT13.jsindex.jsbefore_router_match.js</td><td colspan="1" rowspan="1"> pizza-totally-rocks geekTalks simple-crafting WTF-AdventurezulipForm.jsindex.jsgather.jsmana.js stream_muting.js</td><td colspan="1" rowspan="1"> matic.js graph-jsCraxi j5-ledsflom-reactgetETHFromFaucet.jspoint.jsdisplay.jsblink.jsquestion.js</td><td colspan="1" rowspan="1">iotdb-mongodbOrca pandora-validationAloChat react-native-with-redux-react-navigation-v2-boilerplatecount.js会index.jsContainer.jssplash.js</td><td colspan="1" rowspan="1">hackcincinnati/siteALFACharts musketeer-shop React-QuizComponent rn-mitrais-mbAdvisors.jscrosshairs.jsorder.jsQuizQuestion.jsListAlbums.js</td><td colspan="1" rowspan="1"> js-dom-and-events-acting-on-events-lab-v-000MEANLetsRollroma2hira js-ajax-hiting-apis-lab--000index.jsarticles.server.route.jsrouter.jsconvert.jsindex.js</td><td colspan="1" rowspan="1">Github Link to Diff</td></tr><tr><td colspan="1" rowspan="1">areAvailable()print（）registerSetting()testRecipesoriginisAllowed()printSplit()addSetting() preferenceoriginTrue</td><td colspan="1" rowspan="1">getRecipecheckTalkOwnershipgetBehaviorthis._superadd_messagesgetRecipescheckCommentOwnershipgetMetathis.superadd_old_messages</td><td colspan="1" rowspan="1">ETHFaucetAddressdatagame.draw()blinkDataTypes.STRINGETHFAUCET_ADDRESSdataManagergame.run（)strobeDataTypes.TEXT</td><td colspan="1" rowspan="1">thenerase()addAsyncSetup PropTypes.stringCOLOR.DARKmakeexplode()addSyncSetup PropTypes.objectCOLOR.PANTOME</td><td colspan="1" rowspan="1">color.primaryMath.floorDECIMAL(obj).instruction_textsinfo.typecolor.accentMath.roundINTEGER(obj).instruction_textinfo.album_type</td><td colspan="1" rowspan="1">(elem).InnerHTMLapp.paramsusername(elem).valuelogin(elem）.innerHTMLapp.paramuserName（elem）.innerHTMLname</td><td colspan="1" rowspan="1">Buggy CodeFixed Code</td></tr><tr><td colspan="1" rowspan="1">868□2</td><td colspan="1" rowspan="1">记记记记2</td><td colspan="1" rowspan="1">068u%</td><td colspan="1" rowspan="1">G切uu</td><td colspan="1" rowspan="1">068  9</td><td colspan="1" rowspan="1">C4c乙</td><td colspan="2" rowspan="1">U</td></tr><tr><td colspan="1" rowspan="1">refactoringrefactoringrefactoringrefactoringrefactoring</td><td colspan="1" rowspan="1">refactoringrefactoringrefactoringrefactoringrefactoring</td><td colspan="1" rowspan="1">refactoringrefactoringfunctional bugfunctional bugfunctional bug</td><td colspan="1" rowspan="1">functional bugfunctional bugfunctional bugfunctional bugfunctional bug</td><td colspan="1" rowspan="1">functional bugfunctional bugfunctional bugundefined propertyundefined property</td><td colspan="1" rowspan="1">undefined propertyundefined propertyundefined propertyundefined propertyundefined property</td><td colspan="2" rowspan="1">Bug Type</td></tr><tr><td colspan="1" rowspan="1">Failed importing library</td><td colspan="1" rowspan="1">Failed importing libraryFailed importing library</td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1">Failed importing library event s</td><td colspan="1" rowspan="1">Undefined pr oces s</td><td colspan="1" rowspan="1">Failed doc.getElem () Undefined processFailed importing library ut ilFailed doc.getElem ()</td><td colspan="2" rowspan="1">False AlarmTAJS</td></tr><tr><td colspan="1" rowspan="1">exports.testRecipesI</td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1">this.game.draw()led.strobe(750)</td><td colspan="1" rowspan="1">serviceProvider.addAsyncSetup(...)</td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1">app.params('.</td><td colspan="1" rowspan="1">Prediction</td><td colspan="1" rowspan="4">HOPPITY</td></tr><tr><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1">八</td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td></tr><tr><td colspan="1" rowspan="1">厂</td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1">厂</td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td></tr><tr><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1"></td><td colspan="1" rowspan="1">厂</td><td colspan="1" rowspan="1"></td></tr></table>

parse/train/SJeqs6EFvB/SJeqs6EFvB_content_list.json

@@ -0,0 +1,1891 @@
+[
+    {
+        "type": "text",
+        "text": "HOPPITY: LEARNING GRAPH TRANSFORMATIONS TO DETECT AND FIX BUGS IN PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Elizabeth Dinella∗ University of Pennsylvania ",
+        "bbox": [
+            184,
+            170,
+            362,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hanjun Dai∗ Google Brain ",
+        "bbox": [
+            452,
+            170,
+            544,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ziyang Li University of Pennsylvania ",
+        "bbox": [
+            635,
+            170,
+            813,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mayur Naik University of Pennsylvania ",
+        "bbox": [
+            184,
+            219,
+            362,
+            247
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Le Song Georgia Tech ",
+        "bbox": [
+            455,
+            219,
+            547,
+            247
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ke Wang Visa Research ",
+        "bbox": [
+            640,
+            219,
+            735,
+            247
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            285,
+            544,
+            299
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a learning-based approach to detect and fix a broad range of bugs in Javascript programs. We frame the problem in terms of learning a sequence of graph transformations: given a buggy program modeled by a graph structure, our model makes a sequence of predictions including the position of bug nodes and corresponding graph edits to produce a fix. Unlike previous works built upon deep neural networks, our approach targets bugs that are more diverse and complex in nature (i.e. bugs that require adding or deleting statements to fix). We have realized our approach in a tool called HOPPITY. By training on 290,715 Javascript code change commits on Github, HOPPITY correctly detects and fixes bugs in 9,490 out of 36,361 programs in an end-to-end fashion. Given the bug location and type of the fix, HOPPITY also outperforms the baseline approach by a wide margin. ",
+        "bbox": [
+            233,
+            315,
+            766,
+            468
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            336,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The sheer size and complexity of modern codebases makes it impossible for them to be bug-free. As a result, a more reasonable and effective strategy has emerged, which aims to prevent bugs in production by applying automated tools to detect and even fix them early in the development process. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This trend has gained increasing popularity in recent years. Examples include Google’s Tricorder (Sadowski et al., 2015), Facebook’s Getafix (Scott et al., 2019) and Zoncolan, and Microsoft’s Visual Studio IntelliCode. The techniques underlying these tools can be classified into broadly two categories: logical, rule-based techniques (Sadowski et al., 2015) and statistical, data-driven techniques (Allamanis et al., 2018; Pradel & Sen, 2018; Vasic et al., 2019). The former uses manually written rules capturing undesirable code patterns and scans the entire codebase for these classes of bugs. The latter learns to detect abnormal code from a large code corpus using deep neural networks. Despite great strides, however, both kinds of tools are limited in generality because they target error patterns in specific codebases or they target specific bug types. For instance, Zoncolan’s rules are designed to be specifically applicable to Facebook’s codebases, and deep learning models target specialized bugs in variable naming (Allamanis et al., 2018) or binary expressions (Pradel & Sen, 2018). Moreover, the patterns are relatively syntactic, allowing them to be specified by human experts using logical rules or learnt from a corpus of programs. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a novel learning-based approach for finding and fixing bugs in Javascript programs automatically. Javascript is a scripting language designed for web application development. It has been the most popular programming language on GitHub since 2014 (Github, 2019). Repairing Javascript code presents a unique challenge as bugs manifest in diverse forms due to unusual language features and the lack of tooling support. Therefore, the primary goal of our approach is generality since it must be effective against a board spectrum of programming errors, such as using wrong operators or identifiers, accessing undefined properties, mishandling variable scopes, triggering type incompatibilites, among many others. Another important novel aspect concerns our approach’s ability to deal with bugs that are more complex and semantic in nature, namely, bugs that require adding or removing statements from a program, which are not considered by prior works. Finally, compared to automated program repair techniques (Le Goues et al., 2019; Scott et al., 2019; Hua et al., 2018; Chen et al., 2018) which require knowledge of bug location, this paper presents an end-to-end approach including localizing bugs, predicting the types of fixes, and generating patches. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We design our model architecture in a similar vein as a Neural Turing Machine (NTM) (Graves et al., 2014). It consists of an external memory (a Graph Neural Network) for embedding a buggy program and a central controller (an LSTM) that makes a sequence of primitive actions (e.g., predicting type, generating patch, etc.) to perform a fix. The multi-step decision process is implemented by an autoregressive model. Crucially, our model differs from the standard NTM in how the memory is manipulated: apart from the common read and write operations, the controller can also expand or shrink the memory when adding or deleting nodes in the original graph. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We have realized our approach in a tool called HOPPITY. By training on 290,715 Javascript code change commits collected from Github, HOPPITY correctly detects and fixes bugs in 9,490 out of 36,361 programs using a beam size of three. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MOTIVATING EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            294,
+            411,
+            310
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Javascript is quite different compared to traditional object-oriented languages (e.g. $\\mathrm { C } { + + }$ , Java, or $\\mathbf { C } \\#$ ). In addition to the weak, dynamic typing discipline of scripting languages, Javascript supports many peculiar features that do not exist in other languages. For example, it allows a property (i.e., a field) to be added to or removed from an object at runtime. As another example, Javascript did not support block-level scoping until recently, allowing a variable defined in a block structure such as a for loop to be exposed to the entire function in which the loop occurs. While the latest ES6 language standard incorporates block-level scoping, developers have been programming without it for decades, resulting in a large body of legacy code. Finally, Javascript’s eval function, which interprets and executes a string as a code fragment, is widely regarded as a major source of bugs and vulnerabilities. All of these aspects make programming in Javascript a frustrating and error-prone experience. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d5db4d59feaf5fb2d4045cba10080cbb7a131b8e8d7ef8e54625067bc4119e3.jpg",
+        "image_caption": [
+            "(c) copy function should have also been included in (d) parseInt should have been removed because $= = = =$ the highlighted list. implies this.value is an integer. ",
+            "Figure 1: Example programs that illustrate limitations of existing approaches inculding both rulebased static analyzers and neural-based bug predictors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            168,
+            470,
+            828,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Static analyzers aim to detect common coding errors in Javascript programs by applying logical rulebased reasoning on source code. TAJS (Jensen et al., 2009) and ESLint (Zakas, 2013) are prominent examples. These tools face important challenges to be effective. We present several examples in Figure 1 to illustrate their limitations. Due to the complex nature of client-side web APIs, TAJS and ESLint choose to ignore analyzing built-in libraries for the sake of scalability. As depicted in Figure 1a, when developers mistakenly capitalize the first letter of innerHTML, a property of class Element in DOM (Document Object Model), both analyzers fail to catch the error. Javascript will then silently allow developers to set the previously non-existent property InnerHTML to the empty string. Later, when developers attempt to access the intended property, innerHTML, the program will crash and potentially cause a security vulnerability or incur a costly debugging experience. Additionally, static analyzers can never deal with functional bugs (i.e., errors that violate the program specification and yet conform to the coding rules). Figure 1b shows one such example. The goal is to split a string using regular expressions. However, the program incorrectly splits the input ' and ' into ['', and ''] instead of $[ { \\bf \\Phi } ^ { \\prime \\prime } , { \\bf \\Phi } ^ { \\prime \\prime } ]$ , which is what the developer intended. Since the error is simply a mismatch between the developer’s implicit specification and implementation, static analyzers are incapable of catching it. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/debfa503638c9e415a26e59edbafb8dbed10fbd181589d19251d769b600dfc54.jpg",
+        "image_caption": [
+            "Figure 2: Code repair as graph transformation. Each step the source code graph is edited via one of the operator module until STOP is triggered by controller. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            813,
+            258
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            311,
+            823,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The bugs that static analyzers missed in both cases are in hindsight quite obvious to human programmers. The criteria they use is very simple: any code snippet that seems to deviate from common code patterns is likely to be buggy. This is precisely the observation that our approach seeks to mimic. In particular, if a model observes a property or an unusual way of splitting strings that never appeared in the training data, it is likely to recognize those abnormal code fragments as potential bugs. The main advantage of our approach over existing neural-based bug detectors (Allamanis et al., 2018; Pradel & Sen, 2018; Vasic et al., 2019) is its generality. Unlike prior works that target specific classes of bugs (e.g., variable naming issues or binary expression bugs), we train a single model to deal with a wide range of bug types, encompassing all previously proposed ones. Compared to past approaches that leverage a graph-based neural network model (Allamanis et al., 2018), our model is capable of more sophisticated transformations such as adding or removing nodes, as shown in Figure 1c and 1d. Finally, our model not only locates but also fixes bugs, whereas program repair (Le Goues et al., 2019; Scott et al., 2019; Hua et al., 2018; Chen et al., 2018) or bug localization (Ball et al., 2003; Jose & Majumdar, 2011; Wang et al., 2019) techniques only solve a single task. ",
+        "bbox": [
+            173,
+            347,
+            826,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            550,
+            269,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We model the problem of detecting and repairing bugs in programs as a structured prediction problem on a graph-based representation of programs. Given a graph $g _ { b u g }$ that represents a buggy program, we wish to predict a graph $g _ { f i x }$ that represents the fixed program. Our model aims to capture the structured prediction by a sequence of up to $T$ steps of graph transformations: ",
+        "bbox": [
+            173,
+            574,
+            825,
+            630
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0103504e54b020eebcd2ba17427b2ea4faa5994e7bd64f0da7b5f5151b25031f.jpg",
+        "text": "$$\np ( g _ { f i x } | g _ { b u g } ; \\theta ) = p ( g _ { 1 } | g _ { b u g } ; \\theta ) p ( g _ { 2 } | g _ { 1 } ; \\theta ) \\ldots p ( g _ { f i x } | g _ { T - 1 } ; \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            633,
+            686,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The high-level overview of the graph sequence transformation is shown in Figure 2. Different programs may need a different number of steps $T ( g _ { b u g } )$ which is also determined by the model. ",
+        "bbox": [
+            176,
+            654,
+            820,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first introduce our representation module for programs in Sec 3.1. We then elucidate each step of the above transformation in Sec 3.2. Finally, we summarize and present the full model in Sec 3.3. ",
+        "bbox": [
+            174,
+            689,
+            823,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROGRAM REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            413,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Programs written in a high-level language have rich structure. Researchers have proposed graph-based representations to capture this structure (Allamanis et al., 2018). We start with this approach of representing programs using graphs with certain modifications for our task. ",
+        "bbox": [
+            176,
+            742,
+            823,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As shown in the left part of Figure 2, we first parse the program’s source code into an abstract syntax tree (AST) form that captures the program’s syntactic structure. We then connect the leaf nodes with SuccToken edges. Unlike previous approaches, we additionally add value nodes that store the actual content of the leaf nodes, with special ValueLink edges connecting them together. The purpose of introducing this additional set of nodes is to provide a name-independent strategy for code representation and modification, which we elucidate in the next section. Hereafter, we use $g _ { f i x } , g _ { b u g }$ or $g$ in general to represent either the source code or the corresponding graph structure. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After representing the program as a graph, we use a Graph Neural Network (GNN) (Scarselli et al., 2008) to map the graph into a representation in a fixed dimensional vector space. Specifically, given a graph $g = ( V , E )$ with set of nodes $V$ and edges $E$ , we need a function $f ( \\boldsymbol { g } ) \\mapsto ( \\mathbb { R } ^ { d } , \\mathbb { R } ^ { | V | \\times d } )$ to obtain the $d$ -dimensional representation of graph $g$ (denoted as $\\vec { g } )$ , as well as representations of individual nodes $v \\in V$ (denoted as $\\vec { v }$ ). To parameterize $f ( \\cdot )$ , we employ the form in GIN ( $\\mathrm { X u }$ et al., 2018), with our adaptation to our multigraph for program representation in the following manner: ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a2cc2ae4322d124cf58d65e62b0b650dc2a5f95c8603f0cf15ae0a1c0490a56b.jpg",
+        "image_caption": [
+            "Figure 3: Graph edit operators with low-level primitives. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            84,
+            826,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            347,
+            826,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b7168a9bac585efec6eb75c06a41342cc380a2ca446564ae2a7dff6d7d219027.jpg",
+        "text": "$$\n\\begin{array} { r l } & { h _ { v } ^ { ( l + 1 ) , k } = \\sigma ( \\sum _ { u \\in \\mathcal { N } ^ { k } ( v ) } \\mathbf { W } _ { 1 } ^ { l , k } h _ { u } ^ { ( l ) } ) , \\forall k \\in \\{ 1 , 2 , \\ldots , K \\} } \\\\ & { h _ { v } ^ { ( l + 1 ) } = \\sigma ( \\mathbf { W } _ { 2 } ^ { l } [ h _ { v } ^ { ( l + 1 ) , 1 } , h _ { v } ^ { ( l + 1 ) , 2 } , \\ldots , h _ { v } ^ { ( l + 1 ) , K } ] + h _ { v } ^ { ( l ) } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            406,
+            669,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W } _ { 1 } ^ { l , k } \\in \\mathbb { R } ^ { d \\times d }$ , $\\mathbf { W } _ { 2 } ^ { l } \\in \\mathbb { R } ^ { d K \\times d }$ are model parameters and $\\sigma ( \\cdot )$ is tanh in this implementation. $K$ is the total number of edge types in this multi-graph representation. In the end, the node embedding is $\\vec { v } = h _ { v } ^ { ( L ) }$ , where $L$ is the total number of propagations in the GNN. $\\mathcal { N } ^ { k } ( v )$ is the set of neighbors of node $v$ that are connected by edge with type $k$ . Following GIN, the graph representation $\\vec { g }$ is the aggregation of $h _ { v } ^ { l } , \\forall l \\in 0 , 1 , \\therefore , \\bar { L }$ . We use max pooling to aggregate $\\mathsf { \\bar { h } } _ { v } ^ { l }$ for each $l$ , and then take the average of these $L + 1$ vectors to obtain $\\vec { g }$ . ",
+        "bbox": [
+            173,
+            454,
+            825,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Initially, we use the node type as one-hot features as a starting value for either obtained from the AST representation, or from the local value ta $h _ { v } ^ { ( 0 ) }$ , where the types areas shown in Figure 2. Note that we don’t use features like variable names or function names in this graph representation, as different programs may follow different naming conventions. Instead, we focus on the syntactic structure of the source code, so as to enable naming-agnostic representation across different programs. ",
+        "bbox": [
+            173,
+            550,
+            826,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 ONE-STEP GRAPH EDIT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            628,
+            375,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There are five types of operators to choose from for a single step graph edit, namely, adding a node (ADD), deleting a node (DEL), replacing a node value (REP_VAL), replacing a node type (REP_TYPE) and stop (NO_OP). When combined with multi-step edits, these operators suffice to capture a rich variety of code modifications. These operators share some common low-level primitives, such as finding the location, predicting value, etc. We first introduce the individual low-level primitives and then present how to assemble these for each type of graph edit operator. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 LOW-LEVEL PRIMITIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            736,
+            398,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our low-level primitives contain location, type, and value prediction. These primitives can be combined for different operators later on. In this section, we assume the availability of a controller, represented as $\\vec { c } \\in \\mathbb R ^ { d }$ . It keeps track of the global state, including the original source code, as well as the edits made so far. We will elaborate this when we assemble different primitives together. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Location The location primitive locates a specific position in the source code. While it corresponds to region selection in the original text representation, with the graph representation, we can easily treat it as a node selection step. As different programs have different numbers of nodes, we employ a pointer network (Vinyals et al., 2015) into the graph structure. Specifically, after obtaining the node embeddings $\\{ \\vec { v } \\} _ { v \\in V }$ , we select the node via $l o \\bar { c } ( \\bar { \\vec { c } } , g ) = \\arg \\operatorname* { m a x } _ { v \\in V } \\vec { v } ^ { \\top } \\bar { \\vec { c } }$ for simplicity. ",
+        "bbox": [
+            173,
+            818,
+            825,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Value The value primitive assigns a value for a leaf node in the AST. Instead of predicting the replacement value using a language generative model (Chen et al., 2018) or GNN score function (Allamanis et al., 2018), we adopt the attention mechanism to let the model to choose from either the values appearing in the current file (local value table), or a collection of global values that are common for the specific language. Let $D _ { v a l }$ be the global dictionary of commonly used leaf-node values in the language, where each item $i _ { v } \\in D _ { v a l }$ is associated with a vector representation $\\vec { i _ { v } } \\in \\mathbb R ^ { d }$ . The local value table is denoted as $V _ { v a l }$ which is a subset of the nodes in current graph. Then, the value is predicted via $\\begin{array} { r } { v a l ( \\vec { c } , g ) = \\operatorname * { a r g m a x } _ { t \\in D _ { v a l } \\cup V _ { v a l } } \\vec { t } ^ { \\top } \\vec { c } . } \\end{array}$ . Again we use inner product simply for efficiency, while more expressive score functions can also be used. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Type The type primitive assigns the type for non-terminal nodes in an AST. As the total possible number of types is finite and fixed for a given language, the type prediction is simply a multiclass classification problem. However, we can utilize the AST grammar checker with contextual information to prune the output space. To predict the type of a given non-terminal node, we can obtain its parent node and current children. Then, by looping over the valid production rules at the current location, we can obtain a list of all valid types. The final type is only chosen from this set. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 GRAPH EDIT OPERATORS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            301,
+            401,
+            315
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The $t$ -th round of edit starts with the current graph $g _ { t - 1 }$ , the corresponding graph embedding, and the ‘macro-context’ embedding $\\overrightarrow { c _ { M } } _ { t - 1 }$ that captures the edit history so far. Every type of edit operation (excluding NO_OP), requires prediction of the buggy location. So, in each round, the location primitive is invoked to determine the node to target. Then the edit type $e$ that is feasible at this location $v$ is predicted out of the five operators. A ‘micro-context’ embedding $\\overrightarrow { c _ { m _ { t } } }$ is obtained from the macro embedding updated by two LSTM calls with location node embedding $\\vec { v }$ and operator embedding $\\vec { e } .$ . To summarize: ",
+        "bbox": [
+            173,
+            320,
+            825,
+            419
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/157ffc9373a7c7bfa79aa1d9975e7345563fcd3e5975e20cc94cee2600908f11.jpg",
+        "text": "$$\n\\overrightarrow { c _ { M _ { t } } } ^ { \\prime } = \\mathrm { L S T M } ( \\overrightarrow { g _ { t - 1 } } | \\overrightarrow { c _ { M _ { t - 1 } } } ) , \\overrightarrow { c _ { m _ { t } } } = \\mathrm { L S T M } ( \\overrightarrow { e _ { t } } | \\mathrm { L S T M } ( \\overrightarrow { v _ { t } ^ { \\prime } } | \\overrightarrow { c _ { M _ { t } } } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            426,
+            710,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The micro-context embedding is used as the controller throughout the process of each operator. In the following content, we present these operators in detail. ",
+        "bbox": [
+            173,
+            454,
+            823,
+            482
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ADD This operation adds a new node to the graph. Unlike in Li et al. (2018) where the node and corresponding edges are added in separate stages, which would introduce extra complexity, we introduce a simple mechanism that can uniquely add a node and corresponding edges. As is shown in Figure 3, this process invokes one location primitive, one value primitive, and one type primitive. The location primitive invoked before the edit (i.e., node $v$ ) determines the parent of the node to be added, while the location primitive called during the edit chooses the left sibling of the node. In a special case where the parent node does not have any children, then such left sibling node is set to the parent node itself. With this information, we can uniquely determine the position to insert into the AST. Finally, the corresponding edges—SuccToken, ValueLink, and AST edges—can automatically be inferred with the location of new node to be added. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As this process is autoregressive, the micro-context embedding is kept updated with all the primitive calls. For this specific operator, the context is updated in the order of: $\\overrightarrow { c _ { m 1 } } = \\mathrm { L S T M } ( \\overrightarrow { v _ { s i b l i n g } } | c _ { m } ^ {  } )$ , $c _ { m 2 } ^ {  } = \\mathrm { L S T M } ( \\bar { v } a l ( c _ { m 1 } ^ {  } , \\bar { g } ) | c _ { m 1 } ^ {  } )$ and $c _ { m 3 } ^ {  } = \\mathrm { L S T M } ( t y p e ( c _ { m 2 } ^ {  } , g ) | c _ { m 2 } ^ {  } )$ . In the end, $\\vec { c } _ { A D D } = c _ { m 3 } ^ {  }$ summarizes the process. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "DEL This operator deletes a node and corresponding edges in the graph. If it is a non-terminal node in the AST, then the corresponding subtree is removed as well. The micro-context embedding is updated by the LSTM via the embedding of the node being deleted. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "REP_VAL This operator replaces the value of a leaf (terminal) node in the AST. This procedure requires the prediction the value. The leaf node is linked to the new value node in the internal value table via a ValueLink edge. Also, the micro-context embedding is updated by the LSTM via the embedding of the corresponding node and value. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            803
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "REP_TYPE This operator changes the type of a non-terminal node, which involves type primitive steps. The micro-context embedding is updated by the LSTM via the embedding of the corresponding node and type. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "NO_OP This op does not change the graph. It simply denotes the end of the sequence of graph edits. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            873
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 GRAPH TRANSFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            880,
+            400,
+            893
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our end-to-end model for graph transformation inference is shown in Alg 1. We denote the buggy graph $g _ { b u g }$ as $g _ { 0 }$ for simplicity. Then, for the $t$ -th graph edit, the following steps are performed: ",
+        "bbox": [
+            173,
+            900,
+            825,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. Obtain the graph representation $\\overrightarrow { g _ { t - 1 } }$ and node embeddings. Update the macro-context embedding using $\\overrightarrow { g _ { t - 1 } }$ ; 2. Choose edit location $v _ { t }$ by performing location primitive and update the context embedding; 3. Pick the graph edit operator $e _ { t }$ that is compatible with $v _ { t }$ ; Use both $v _ { t }$ and $e _ { t }$ to obtain the micro-context embedding. 4. Perform the edit, obtain the corresponding micro-context summary $\\overrightarrow { c _ { e _ { t } } }$ and update the macro-context embedding. 5. If the edit is not NO_OP, then go back to step 1; otherwise return the graph. ",
+        "bbox": [
+            173,
+            125,
+            452,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Transformation inference of $\\overline { { p ( g _ { f i x } | g _ { b u g } ) } }$ ",
+        "text_level": 1,
+        "bbox": [
+            465,
+            123,
+            823,
+            138
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Input $g _ { b u g } \\sim \\mathcal { D }$ and model parameters $\\theta$ .   \n2: Obtain $\\vec { g _ { 0 } }$ , $\\{ \\vec { v } _ { v \\in g _ { b u g } } \\} = f _ { 0 } ( g _ { b u g } )$ , let $c _ { M _ { 0 } } ^ {  }$ be null.   \n3: for $t = 1$ to $T$ do   \n4: Obtain $\\overrightarrow { c _ { M _ { t } } ^ { \\prime } } = \\mathrm { L S T M } ( \\overrightarrow { g _ { t - 1 } } | \\overrightarrow { c _ { M _ { t - 1 } } } )$ .   \n5: Choose location $v _ { t }$ , then edit type $e _ { t }$ ;   \n6: if $e _ { t } = \\tt N O \\_ O P$ then   \n7: set $g _ { T } = g _ { t - 1 }$ and exit the loop.   \n8: end if   \n9: Perform operator $e _ { t }$ with $\\overrightarrow { c _ { m _ { t . } } }$ obtained by $\\operatorname { E q } 3$ .   \n10: Get new graph $g _ { t }$ , update $\\xrightarrow [ { \\boldsymbol { c } _ { M _ { t } } } ] { }$ with $\\overrightarrow { c _ { e _ { t } } }$ .   \n11: end for   \n12: Return gT ",
+        "bbox": [
+            470,
+            143,
+            820,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This process repeats until it reaches the maximum steps $T$ or the NO_OP operator is selected. Note that our framework can capture the situation when the input program is bug-free. In this case, the NO_OP operator is supposed to be triggered at the first step. Also, each edit step is not limited to a single node level operation. It can be extended to modify a certain substructure (e.g., replace a tree node with one of its children). This in turn allows program repair to be performed in fewer edit steps. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            405,
+            295,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the dataset $\\mathcal { D } = \\{ ( g _ { b u g } ^ { ( i ) } , g _ { f i x } ^ { ( i ) } ) \\} _ { i = 1 } ^ { | \\mathcal { D } | }$ which consists of pairs of buggy code and the fixed code, the learning objective maxθ $\\bar { \\mathbb { E } } _ { ( g _ { b u g } , g _ { f i x } ) \\sim \\mathcal { D } } p ( g _ { f i x } | g _ { b u g } ; \\theta )$ maximizes the likelihood of fixes. ",
+        "bbox": [
+            174,
+            430,
+            823,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since the probability is factorized according to $\\operatorname { E q }$ where a sequence of transformations is performed, we parse the source code using the SHIFT AST format, and utilize a JSON diff toolbox to compile the code differences into a sequence of AST edits. This serves as the fine-grained supervision mechanism for our graph transformation formulation. Thus, the MLE objective above is realized with the sum of cross entropy loss at each step of graph edits. During training, we jointly optimize the graph representation module $\\{ f _ { t } ( \\cdot ) \\} _ { t = 1 } ^ { T }$ , each of the operator module and the controller module which is parameterized by LSTM. We use the Adam optimizer with $\\beta _ { 1 } = 0 . 9 , \\beta _ { 2 } = 0 . 9 9$ and initial learning rate of $1 0 ^ { - 3 }$ . Due to the large size of each sample, we use a small batch size of 10 during training. Furthermore, to stabilize the training, we apply the gradient clip with the maximum norm of 5. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            606,
+            302,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The inference procedure involves searching for the maximum in the combinatorial space: arg $\\operatorname* { m a x } _ { g _ { f i x } } p ( g _ { f i x } | g _ { b u g } ; \\theta )$ . Since the search space is very large, however, we use beam-search to approximately find the fixes with highest probabilities. ",
+        "bbox": [
+            176,
+            628,
+            823,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we maintain a pool of partially fixed programs $\\{ \\tilde { g } \\}$ , which starts with simply the single buggy program $g _ { b u g }$ . The pool size is limited by the beam-search size $B$ . For each $\\tilde { g }$ , we propose the top $B$ locations to be modified, top $B$ operators or top $B$ primitives (location, type, value), depending on the current stage of the edit $\\tilde { g }$ . Then the total joint one-step graph transformation solutions are ranked together based on the joint log-likelihood, and the top $B$ solutions with the largest likelihood are kept in the pool for the next round of beam search. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Unlike beam search for language models where the vocabulary size is fixed, in our setting, the available choices or even the steps of inference may vary (e.g., the ADD operator has more steps of primitive calls than the DEL operator). Our implementation is based on PyTorch with customized GPU kernels to enable efficient inference on GPUs. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            834,
+            328,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset Our model is trained and evaluated on a corpus of nearly half a million data points. We have created a robust system to continuously collect small changes in Javascript programs from Github. Given a commit, we download the Javascript file before and after the change: $( s r c _ { b u g g y } , s r c _ { f i x e d } )$ . Commits can contain many types of changes such as feature additions, refactorings, bug fixes, etc. In an attempt to filter our dataset to only include bug fixes, we use a heuristic based on the number of changes to the AST. Our insight is that a commit with a smaller number of AST differences is more likely to be a bug fix than a commit containing large changes. Thus for the experiments, we use three different datasets: OneDiff with precisely one edit; ZeroOneDiff with zero and one edit and ZeroOneTwoDiff with zero, one or two edits. We additionally filter out data points with ASTs larger than 500 nodes as a parameter in our system. A detailed overview of our corpus crawler is available in Appendix B. ",
+        "bbox": [
+            174,
+            858,
+            825,
+            914
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/260307005ec8034ecc489793ca6e552c2c8fa7cd80cc7fb9319ed20cd3a63470.jpg",
+        "table_caption": [
+            "Table 1: Statistic of OneDiff dataset. See appendix for more information of other dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ADD</td><td>REP_TYPE</td><td>REP_VAL</td><td>DEL</td><td>total</td></tr><tr><td>train</td><td>6,473</td><td>1,864</td><td>251,097</td><td>31,281</td><td>290,715</td></tr><tr><td>validate</td><td>790</td><td>245</td><td>31,357</td><td>3,957</td><td>36,349</td></tr><tr><td>test</td><td>796</td><td>233</td><td>31,387</td><td>3,945</td><td>36,361</td></tr></table>",
+        "bbox": [
+            272,
+            102,
+            725,
+            171
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6804b2678b6e4d02976053503ce62f38875916e8f457aa9c4a2cc4643a24e5fa.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Evaluation of model on the OneDiff dataset: accuracy $( \\% )$ "
+        ],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"2\">Total</td><td colspan=\"2\">Location</td><td>Operator</td><td colspan=\"2\">Value</td><td colspan=\"2\">Type</td></tr><tr><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td></tr><tr><td>TOTAL</td><td>26.1</td><td>14.2</td><td>35.5</td><td>20.4</td><td>34.4</td><td>52.3</td><td>29.1</td><td>76.1</td><td>66.7</td></tr><tr><td>ADD</td><td>52.9</td><td>39.2</td><td>69.6</td><td>51.4</td><td>70.6</td><td>65.7</td><td>55.1</td><td>76.8</td><td>68.5</td></tr><tr><td>REP_VAL</td><td>23.4</td><td>11.9</td><td>33.3</td><td>18.5</td><td>31.7</td><td>53.0</td><td>28.8</td><td>-</td><td>1</td></tr><tr><td>REP_TYPE</td><td>71.7</td><td>52.4</td><td>73.0</td><td>52.8</td><td>79.4</td><td>-</td><td>-</td><td>74.7</td><td>61.0</td></tr><tr><td>DEL</td><td>39.6</td><td>24.8</td><td>44.0</td><td>27.5</td><td>45.8</td><td>1</td><td>1</td><td>1</td><td>二</td></tr><tr><td>Random</td><td>.08</td><td>.07</td><td>2.28</td><td>1.4</td><td>27.7</td><td>.01</td><td>.01</td><td>.27</td><td>0</td></tr></table>",
+        "bbox": [
+            174,
+            195,
+            821,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            377,
+            825,
+            476
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            305,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We train the model for 3 epochs on the training set until the validation loss converges. We tried different configurations of our model with different number of layers and different graph embedding methods besides the generic one in Eq 2. We report on these ablation studies in Appendix C. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            550
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the evaluation results of our model on a held out test set consisting of samples from our OneDiff dataset. Additional experiments on ZeroOneDiff and ZeroOneTwoDiff datasets are available in Appendix A. We also provide experimental results with respect to different configurations. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            612
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Accuracy is shown for each graph edit operation type. Accuracy is measured in a complete discrete graph edit operation step. For example consider Figure 1a, in which we edit an object property name with the REP_VAL operation. If the model incorrectly predicts the edit operation to be of type DEL, then it will not go on to predict a value. In this case, the model will be penalized twice in the operation accuracy as well as the value accuracy. A prediction is considered totally correct only if the entire sequence of graph edit primitives is correct. Note that top-1 greedy prediction is not always among top-3 when beam search is used. Additionally, operator prediction is only evaluated on the top prediction as the search space only includes four operators. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the magnitude of the search space, we compare HOPPITY to a model that selects uniformly at random, in each step of the graph edit process. The random model performs well at operation type selection since the search space only has four options (ADD, REP_VAL, REP_TYPE, DEL). However, after the operation type is predicted, the random model’s accuracy drops, as there are up to 500 nodes in the buggy AST. When it predicts value, the accuracy drops even further as our vocabulary contains 5,000 values. Lastly, type prediction has slightly better accuracy than value prediction because the number of the types of AST nodes in total is smaller than our vocabulary. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            847,
+            294,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As existing approaches cannot be applied for comparison in Table 7, we adapt the baselines to some restricted settings in this section. We report the results on the OneDiff dataset as most of the baselines target repair of a single bug. Note that for all comparisons we provide equal amounts of information to HOPPITY and the baseline without retraining our model. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3fc7aa85f3f186fed81d7adb9b29d0582b9304f81cfd01db28a4d2d705a0d14.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Type</td><td>GGNN-Rep</td><td>GGNN-Cls</td><td>HOPPITY</td></tr><tr><td>Top-1</td><td>53.2%</td><td>99.6%</td><td>90.0%</td></tr><tr><td>Top-3</td><td>85.8%</td><td>99.6%</td><td>94.8%</td></tr></table>",
+        "bbox": [
+            174,
+            102,
+            496,
+            156
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f572866c7818a8cee4335dbcfda575145c5982e034fdacb29741d784145d9cf0.jpg",
+        "table_caption": [
+            "Table 5: Overall OneDiff accuracy with location. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">HOPPITY</td><td>Top-1</td><td>Top-3</td></tr><tr><td>67.7%</td><td>73.3%</td></tr><tr><td>SequenceR</td><td>64.2%</td><td>68.6%</td></tr></table>",
+        "bbox": [
+            547,
+            102,
+            774,
+            159
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bcc01911703e3743f6813e87717d7a45721e9f31c80f48457a455646fe7fd12f.jpg",
+        "table_caption": [
+            "Table 3: REP_TYPE accuracies with location+op. ",
+            "Table 6: Comparison with TAJS. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Bug Type</td><td>Amount</td><td>TAJS</td><td>HOPPITY</td></tr><tr><td>Undefined Property Functional Bug</td><td>7 11</td><td>0 0</td><td>1 3</td></tr><tr><td>Refactoring</td><td>12</td><td>0</td><td>1</td></tr><tr><td>Total</td><td>30</td><td>0</td><td>5</td></tr></table>",
+        "bbox": [
+            504,
+            179,
+            820,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/59fc82e0435aa6ffd6b6385e7bb4f022ecb72406e90f2e033eecc0769a1c7afa.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: REP_VAL accuracies with location+op. "
+        ],
+        "table_body": "<table><tr><td>Value</td><td>GGNN-Rep</td><td>GGNN-RNN</td><td>HOPPITY</td></tr><tr><td>Top-1</td><td>63.8%</td><td>60.3%</td><td>69.1%</td></tr><tr><td>Top-3</td><td>67.6%</td><td>63.6%</td><td>73.4%</td></tr></table>",
+        "bbox": [
+            173,
+            195,
+            496,
+            250
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "GGNN: Allamanis et al. (2018), uses Gated Graph Neural Networks (GGNN) for two specific bug repair tasks: VARMISUSE, in which the model learns to select the correct variable that should be used at a given location, and VARNAMING, in which the model predicts a variable name based on its usage. We adapt these tasks to compare with HOPPITY on the REP_TYPE and REP_VAL tasks. Specifically, for REP_TYPE prediction we have ",
+        "bbox": [
+            174,
+            281,
+            825,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• GGNN-Rep: we adopt VARMISUSE to replace with candidate node type and modify the graph structure correspondingly; we use their proposed max-margin formulation for training. • GGNN-Cls: we perform multi-class classification using the target node and graph embedding. ",
+        "bbox": [
+            171,
+            358,
+            825,
+            401
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For REP_VAL prediction, we also made two versions of adaptations: ",
+        "bbox": [
+            173,
+            407,
+            624,
+            421
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• GGNN-Rep: similar to above, here the candidate set is from values in the current graphs plus the top-100 frequent values used for repair in the training set. • GGNN-RNN: we adopt VARNAMING approach to predict value directly. Due to the huge vocabulary size, we use char-level language model for predicting the replacement. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            484
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 and 4 show the comparison when buggy node is known. Regarding the type prediction, as the number of types is large, the likelihood formulation with classification objective outperforms the max-margin loss based one (i.e., GGNN-Rep). As in this limited case GGNN-Cls and HOPPITY are quite similar except for graph representation, the performance is expected to be comparable. As HOPPITY is not trained to predict type fix only, it performs slighly worse than GGNN-Cls. Also for the value prediction, our formulation of pointer on graph is more effective. We found when the space of decisions is large, it is hard to apply structured prediction method like GGNN-Rep in this setting. Since real-world programs are noisy, the sentences used in different programs vary greatly, making it difficult for language models to predict the exact accurate value. A possible extension is to combine the language model with the graph pointer, which we will explore in future work. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            631
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "SequenceR: The model proposed by Chen et al. (2018) is a translation based model that predicts a fixed sequence of tokens when given a buggy line in the source code. We compare with our model by providing location information to both approaches. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            680
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5 summarizes the total accuracy for fixing a single bug. In order to provide a fair comparison, we allow SequenceR to predict the same information as our model (i.e., predict op, value etc.in a sequential way), rather than an entire sequence of raw textual tokens. This experiment shows the benefit of formulating code repair with graphs over text tokens. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "With the above two baselines, we can see that in the restricted case our model can still yield comparable or even better performances. Given that our model can go for more edits without location information, we believe this tool is more generic and effective for code repair. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "TAJS: We also compare the bug detection ability of HOPPITY against TAJS (Jensen et al., 2009) which is a well-known static analysis tool for Javascript programs. Automating the comparison for our entire test set proved to be infeasible. For example, TAJS only accepts JavaScript ES5 programs, while the vast majority of current JavaScript projects use ES6 or other variants like React JSX. Another problem is that TAJS does not analyze code that is not invoked, e.g., a library function that is not called by client code. Moreover, determining the right command-line options of TAJS is non-trivial since it provides many options targeting different JavaScript runtime environments. Due to these issues, we forgo a large-scale comparison, and instead pick 30 random points in our test set to manually analyze using TAJS. Table 6 depicts the results (Appendix D provides further details). ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We restrict the chosen test points to satisfy a necessary condition for undefined property bugs since TAJS claims to be proficient in detecting this class of bugs. In the process, we also pick some functional bugs, as well as cases of refactoring modifications. By resolving the numerous issues that prevented us from automating the comparison, we were able to run TAJS manually. TAJS failed to detect any real bugs in the 30 test points. While functional bugs and refactoring modifications are beyond TAJS, however, TAJS also raises many unrelated false alarms due to its failures in locating NodeJS libraries, importing JSON files, or recognizing built-in global variables. These warnings are detrimental because TAJS suspends the analysis as soon as it detects what it preceives to be a bug. To further aid TAJS, we omitted parts of each program that are unrelated to the bug, in the hope of driving TAJS’s analysis as deep as possible. After all these measures, TAJS managed to detect two of the undefined property bugs (Bug IDs 4 and 6 in Appendix D). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In contrast, HOPPITY is able to correctly detect 5 bug locations of the 30 testing points within our top 3 predictions. Moreover, HOPPITY also produces 4 patches that are identical to the developer’s fixes. Our comparison highlights HOPPITY’s two important strengths compared to TAJS. First, HOPPITY relieves developers from the enormous burden of manual configuration. Second, HOPPITY achieves far better performance in detecting as well as fixing the bugs in Javascript programs. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            342,
+            344,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Static analysis for bug detection. Static analyzers such as FindBugs, Error-Prone, and Semmle use syntactic pattern-matching and dataflow analysis to find common bugs. Typically, detecting even a single class of bugs can require dozens or even hundreds of patterns. Coverity (Bessey et al., 2010), SonarQube, and Clang Static Analyzer check for semantic inconsistencies in code based on more sophisticated path analyses. Infer (Calcagno et al., 2015) is built upon sound principles and can prove the absence of certain classes of bugs. TAJS belongs to this category as well. Due to the undecidability of the problem, however, approximations are inevitable which voids the guarantees in practice. Compared to all static analysis tools, HOPPITY offers the following advantages: (1) it targets a board range of programming errors; (2) it not only localizes bugs but also fixes them; and (3) it has significantly higher signal-to-noise ratio (i.e., detects more bugs with less false alarms). ",
+        "bbox": [
+            174,
+            366,
+            825,
+            506
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learning-based bug detection. Allamanis et al. (2018) target variable-misuse errors and present a solution based on a gated graph neural network model to predict the correct variable name given a buggy location. Vasic et al. (2019) present a pointer network on top of a RNN which outperforms Allamanis et al. (2018) on the same task. DeepBugs (Pradel & Sen, 2018) proposes a name-based bug detection scheme. Their model is trained to predict three classes of bugs: swapped function arguments, wrong binary operator, and wrong operand in a binary operation. Compared to these models, our approach is capable of detecting and fixing a wide range of errors in Javascript. SequenceR (Chen et al., 2018) uses sequence-to-sequence model to translate a buggy code segment into correct one; Getafix (Scott et al., 2019) produces human-like bug fixes by learning from past fixes. It employs a hierarchical clustering algorithm that sorts fix patterns according to their generality. While these approaches are general against different types of bugs, they still need the bug location as input. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Graph learning and optimization. Our work is closely related to the literature in graph representation learning and optimization. Our model uses a variant of GNN that is inspired by many representative works (Li et al., 2015; Xu et al., 2018; Si et al., 2018), with the adaptation of local value table and pointer mechanism. Our work is also related to auto-regressive graph modeling Johnson (2016); Li et al. (2018); Brockschmidt et al. (2018); Dai et al. (2018), but with more generic operations such as subtree deletion and attribute modifications. Some other works model the graph modification in latent space (Jin et al., 2018; Yin et al., 2018), but such frameworks lack fine-grained control over the generative process, and thus are not very suitable for performing code repair. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            320,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed an end-to-end learning-based approach to detect and fix bugs in Javascript programs. We realized the approach in a tool HOPPITY and demonstrated that it correctly predicts 9,490 out of 36,361 code changes in real programs on Github. In the future, we plan to expand the targeted bugs to include those that are caused by the interdependence among multiple files or that require multiple steps to fix. We will also deploy HOPPITY in an IDE to further evaluate its accuracy and utility. Finally, we plan to extend our learning framework to support other languages. Due to its language-independence, we believe HOPPITY will benefit developers beyond Javascript as well. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            914
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            357,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank the reviewers for their insightful comments. This research was supported in part by NSF awards #1836936 and #1836822, ONR award #N00014-18-1-2021, and Facebook research awards. ",
+        "bbox": [
+            174,
+            125,
+            825,
+            154
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            287,
+            179
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            185,
+            823,
+            214
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas Ball, Mayur Naik, and Sriram K. Rajamani. From symptom to cause: Localizing errors in counterexample traces. In Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, 2003. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            266
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Al Bessey, Ken Block, Ben Chelf, Andy Chou, Bryan Fulton, Seth Hallem, Charles Henri-Gros, Asya Kamsky, Scott McPeak, and Dawson Engler. A few billion lines of code later: Using static analysis to find bugs in the real world. Communications of the ACM, 53(2), February 2010. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            318
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Brockschmidt, Miltiadis Allamanis, Alexander L Gaunt, and Oleksandr Polozov. Generative code modeling with graphs. arXiv preprint arXiv:1805.08490, 2018. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cristiano Calcagno, Dino Distefano, Jeremy Dubreil, Dominik Gabi, Pieter Hooimeijer, Martino Luca, Peter O’Hearn, Irene Papakonstantinou, Jim Purbrick, and Dulma Rodriguez. Moving fast with software verification. In NASA Formal Method Symposium, 2015. ",
+        "bbox": [
+            176,
+            363,
+            825,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zimin Chen, Steve Kommrusch, Michele Tufano, Louis-Noël Pouchet, Denys Poshyvanyk, and Martin Monperrus. Sequencer: Sequence-to-sequence learning for end-to-end program repair. arXiv preprint arXiv:1901.01808, 2018. ",
+        "bbox": [
+            176,
+            415,
+            825,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            171,
+            465,
+            823,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Github. State of the Octoverse. https://octoverse.github.com/#top-languages, 2019. ",
+        "bbox": [
+            174,
+            503,
+            748,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            173,
+            527,
+            823,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jinru Hua, Mengshi Zhang, Kaiyuan Wang, and Sarfraz Khurshid. Sketchfix: A tool for automated program repair approach using lazy candidate generation. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, 2018. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            622
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Simon Holm Jensen, Anders Møller, and Peter Thiemann. Type analysis for javascript. In Proceedings of the 16th International Symposium on Static Analysis, 2009. ",
+        "bbox": [
+            171,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wengong Jin, Kevin Yang, Regina Barzilay, and Tommi Jaakkola. Learning multimodal graph-tograph translation for molecular optimization. arXiv preprint arXiv:1812.01070, 2018. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            698
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel D Johnson. Learning graphical state transitions. 2016. ",
+        "bbox": [
+            173,
+            707,
+            578,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Manu Jose and Rupak Majumdar. Cause clue clauses: Error localization using maximum satisfiability. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, 2011. ",
+        "bbox": [
+            173,
+            731,
+            826,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Claire Le Goues, Michael Pradel, and Abhik Roychoudhury. Automated program repair. Commun. ACM, 2019. ",
+        "bbox": [
+            173,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            174,
+            819,
+            821,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Oriol Vinyals, Chris Dyer, Razvan Pascanu, and Peter Battaglia. Learning deep generative models of graphs. arXiv preprint arXiv:1803.03324, 2018. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Pradel and Koushik Sen. Deepbugs: A learning approach to name-based bug detection. Proc. ACM Program. Lang., 2(OOPSLA), 2018. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Caitlin Sadowski, Jeffrey van Gogh, Ciera Jaspan, Emma Söderberg, and Collin Winter. Tricorder: Building a program analysis ecosystem. In Proceedings of the 37th International Conference on Software Engineering, 2015. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Scott, Johannes Bader, and Satish Chandra. Getafix: Learning to fix bugs automatically. volume 2, 2019. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xujie Si, Hanjun Dai, Mukund Raghothaman, Mayur Naik, and Le Song. Learning loop invariants for program verification. In Advances in Neural Information Processing Systems, pp. 7751–7762, 2018. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marko Vasic, Aditya Kanade, Petros Maniatis, David Bieber, and Rishabh Singh. Neural program repair by jointly learning to localize and repair. International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yu Wang, Fengjuan Gao, Linzhang Wang, and Ke Wang. Learning a static bug finder from data. arXiv preprint arXiv:1907.05579, 2019. ",
+        "bbox": [
+            174,
+            371,
+            823,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018. ",
+        "bbox": [
+            174,
+            409,
+            823,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pengcheng Yin, Graham Neubig, Miltiadis Allamanis, Marc Brockschmidt, and Alexander L Gaunt. Learning to represent edits. arXiv preprint arXiv:1810.13337, 2018. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas C. Zakas. ESLint. https://eslint.org/, 2013. ",
+        "bbox": [
+            173,
+            484,
+            527,
+            500
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/5cd3304835de83b9702c715caa6ec8b294f0c2583a723eda313e3854115c9a28.jpg",
+        "table_caption": [
+            "A ADDITIONAL EXPERIMENTS "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"2\">Total</td><td colspan=\"2\">Location</td><td>Operator</td><td colspan=\"2\">Value</td><td colspan=\"2\">Type</td></tr><tr><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-1</td><td>Top-3</td><td>Top-1</td><td>Top-3</td><td>Top-1</td></tr><tr><td>ZeroOneTwoDiff</td><td>40.8</td><td>29.7</td><td>18.9</td><td>3.9</td><td>30.3</td><td>35.0</td><td>6.5</td><td>38.6</td><td>3.4</td></tr><tr><td>ZeroOneDiff</td><td>51.6</td><td>34.5</td><td>27.1</td><td>5.5</td><td>35.6</td><td>45.4</td><td>10.4</td><td>73.9</td><td>58.9</td></tr><tr><td>OneDiff</td><td>26.1</td><td>14.2</td><td>35.5</td><td>20.4</td><td>34.4</td><td>52.3</td><td>29.1</td><td>76.1</td><td>66.7</td></tr><tr><td>Random</td><td>.08</td><td>.07</td><td>2.28</td><td>1.4</td><td>27.7</td><td>.01</td><td>.01</td><td>.27</td><td>0</td></tr></table>",
+        "bbox": [
+            173,
+            135,
+            821,
+            238
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Evaluation of models on each dataset. The Random model is evaluated on the OneDiff dataset and is shown for comparison. ",
+        "bbox": [
+            174,
+            247,
+            823,
+            276
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Full experiment results In addition to the evaluation of samples with one edit Table 7, we also evaluate HOPPITY on the following datasets: ",
+        "bbox": [
+            174,
+            297,
+            825,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• ZeroOneDiff - Includes samples with labels of zero or one edit • ZeroOneTwoDiff - Includes samples with labels of zero, one, or two edits. ",
+        "bbox": [
+            217,
+            340,
+            745,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We trained models on each dataset for roughly 12 hours on a single GTX 2080Ti GPU. Accuracy on the ZeroOneDiff is the highest as predicting that an AST is not buggy does not consist of any low level primitive predictions. This makes it a much easier prediction for the model than say, an ADD operation which the parent location, left sibling, value, and type must all be predicted correctly in order to be considered accurate. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            459
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/ca19e165327d0ceb4a33243f97517cf22d73ad22180d79e2a58247c2c663095e.jpg",
+        "table_caption": [
+            "Table 8: Results on true/false predictions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">TRUELABEL</td></tr><tr><td colspan=\"3\"></td></tr><tr><td rowspan=\"2\">ALARM PREDICTED NO ALARM</td><td>BUGGY</td><td>NOTBUGGY</td></tr><tr><td>10,293 26,517</td><td>7,210 20,605</td></tr></table>",
+        "bbox": [
+            284,
+            477,
+            684,
+            537
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "False positive/negative study An evaluation of false positives and false negatives is available in Table 8. In this setting, we treat the problem as a classification problem on our ZeroOneDiff dataset and our model attempts to predict if a given AST is BUGGY / NOT BUGGY. If the model predicts ADD, REP_VAL, REP_TYPE, or DEL, we consider this a prediction of \"BUGGY.\" Accordingly, if the model predicts NO_OP, we consider this to be a prediction of \"NOT BUGGY.\" ",
+        "bbox": [
+            173,
+            579,
+            826,
+            650
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Accuracy v.s. size of graph To demonstrate the affect of AST size on HOPPITY’s prediction accuracy on the OneDiff dataset, we include Figure 4. As expected, AST size and accuracy are inversely related. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            705
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/37c74477b88668f7fba40c34591379be12f674b42467f25c677f49c8341a89d9.jpg",
+        "table_caption": [
+            "Table 9: Accuracy vs beam sizes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Beam Size (k)</td><td>Top-k Accuracy (%)</td></tr><tr><td>1</td><td>14.37%</td></tr><tr><td>2</td><td>21.10%</td></tr><tr><td>3</td><td>26.14%</td></tr><tr><td>4</td><td>30.12%</td></tr><tr><td>5</td><td>33.58%</td></tr></table>",
+        "bbox": [
+            362,
+            724,
+            630,
+            813
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Accuracy v.s. beam search size In Table 9 we compare the performance with different beam sizes on the OneDiff dataset. As we can see, the top-3 accuracy with beam size 3 is significantly better than top-1 accuracy with just greedy prediction. This is expected, as in the decision process there are ’bottleneck’ stages with only a few predictions (e.g., the op prediction). Thus from beam-1 to beam-3 there’s huge improvement, but further beyond the performance maxed out. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d4d22c9e753089552f3570ecc2cf47b4f93588aa8e3ea9b1d474d5c45c331a9.jpg",
+        "image_caption": [
+            "Figure 4: End-to-end code repair accuracy v.s. size of AST of source code. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            109,
+            781,
+            385
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B DATA COLLECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            441,
+            370,
+            458
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We have built a robust system to automatically collect millions of bug-fixes in Javascript programs from Github. Our system continuously crawls Github for commits containing Javascript files and creates a label consisting of the change to the AST corresponding to each such file. ",
+        "bbox": [
+            176,
+            465,
+            823,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our system consists of three entirely automated parallel steps: ",
+        "bbox": [
+            173,
+            515,
+            580,
+            529
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. Collect Commits: Our system uses the GH Archive API to easily access Github event data for a specific hour in time. After obtaining all data for the hour, we filter this using the Github API to only include commits that consist of edits to Javascript files. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            578
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. Download Files: As we are obtaining a list of valid commits from step 1, we begin downloading the pair: $( s r c _ { b u g g y } , s r c _ { f i x e d } )$ where $s r c _ { b u g g y }$ is the file prior to the commit, and $s r c _ { f i x e d }$ is the file following the commit that contains the changes made. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            627
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. Create Label: For each Javascript file downloaded, we parse the source code into a JSON format of the AST. Our system uses the SHIFT AST 1. Abstract Syntax Tree representations are designed to naturally and intuitively represent the structure of the source code. Because of this design goal, small changes in the source code can often lead to very large changes in the AST. We chose the SHIFT AST representation with consideration to our goal of maximizing the number of commits with only one difference between the ASTs. This component produces a pair of ASTs: $( A S T _ { b u g g y } , A S T _ { f i x e d } )$ at which point a JSON differencing algorithm, fast-json-patch 2 is applied to create a label. The label includes the operation type and node edited for each difference between $A S T _ { b u g g y }$ and $A S T _ { f i x e d }$ . ",
+        "bbox": [
+            173,
+            633,
+            825,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Each step of this process is parallelized in order to grow our corpus as quickly as possible. Our dataset has the advantage that it is continuously growing without human input. ",
+        "bbox": [
+            171,
+            753,
+            821,
+            782
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our system is language independent and highly extensible and modular. For example, it can handle any language so long as it can be parsed into a JSON AST. ",
+        "bbox": [
+            171,
+            789,
+            823,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For each label, we must download two files $s r c _ { b u g g y }$ and $s r c _ { f i x e d }$ . Additionally, if source files cannot be parsed into a SHIFT AST, a label cannot be created. For our learning corpus, we limit the dataset to only include labels with one AST difference. Additionally, in an attempt to limit graph size, we only include data points in which the $A S T _ { b u g g y }$ and $A S T _ { f i x e d }$ have less than 500 nodes. ",
+        "bbox": [
+            174,
+            824,
+            825,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/b9f50c1270c82cbe10f2b785ce7ab64709376e4ed8db18553da7b06aa5df3b01.jpg",
+        "table_caption": [
+            "Table 10: Data collection statistics. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Total Files Downloaded:</td><td rowspan=1 colspan=1>52,719,402</td></tr><tr><td rowspan=1 colspan=1>Total Labelled Data Points:</td><td rowspan=1 colspan=1>15,225,347</td></tr><tr><td rowspan=1 colspan=1># AST differences:</td><td rowspan=1 colspan=1># data points:</td></tr><tr><td rowspan=1 colspan=1>012-1011-2021-5051-100101+</td><td rowspan=1 colspan=1>3,473,3911,863,1933,247,4372,117,9772,047,998858,981921,754</td></tr></table>",
+        "bbox": [
+            344,
+            101,
+            653,
+            305
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0883dab9f4a7fec3bda7f5feb2162d7d71eb6b3b303edf2c63e2002d7a13d51.jpg",
+        "image_caption": [
+            "Figure 5: Distribution of number of edits in the entire crawled dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            371,
+            759,
+            616
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 plots the distribution of number of edits that are recorded in Table 10. We can see the distribution is long tail, with majority of edits as 1 or 2. ",
+        "bbox": [
+            169,
+            678,
+            825,
+            708
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            357,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We tried different graph representations with corresponding graph embedding methods. The multi represents the multi-graph defined by different edge types, with the parameterization of message passing function mentioned in Eq 2; the code2inv is the parameterization used in Si et al. (2018); the single instead uses a single graph with edge types as one-hot edge features. We found that more layers does not lead to better generalization in our setting, and it becomes slower in terms of convergence. So we report the results with 4 layers in our main paper. ",
+        "bbox": [
+            173,
+            125,
+            826,
+            209
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/092ce9089d8364cab4344ee5dc59f50b12684ddda622374a532b067e550ff4e9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>max_lv</td><td>Total</td><td>Operator</td><td>Location</td><td>Value</td><td>Type</td></tr><tr><td>multi</td><td>20</td><td>7.63</td><td>30.0</td><td>13.1</td><td>22.6</td><td>54.5</td></tr><tr><td>multi</td><td>14</td><td>11.05</td><td>48.0</td><td>17.9</td><td>38.6</td><td>61.6</td></tr><tr><td>multi</td><td>4</td><td>13.33</td><td>53.4</td><td>36.2</td><td>38.6</td><td>56.4</td></tr><tr><td>code2inv</td><td>20</td><td>10.3</td><td>18.1</td><td>25.7</td><td>38.8</td><td>57.7</td></tr><tr><td>code2inv</td><td>14</td><td>8.92</td><td>40.0</td><td>18.1</td><td>36.0</td><td>55.9</td></tr><tr><td>code2inv</td><td>4</td><td>13.29</td><td>30.8</td><td>18.9</td><td>28.2</td><td>68.21</td></tr><tr><td>single</td><td>20</td><td>5.00</td><td>20.2</td><td>10.3</td><td>14.2</td><td>44.8</td></tr><tr><td>single</td><td>14</td><td>10.69</td><td>67.7</td><td>18.6</td><td>49.6</td><td>38.7</td></tr><tr><td>single</td><td>4</td><td>12.88</td><td>55.8</td><td>20.8</td><td>43.2</td><td>55.8</td></tr></table>",
+        "bbox": [
+            259,
+            467,
+            738,
+            614
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 11: Ablation study with different graph embedding parameterizations and different number of layers. Full end-to-end repair accuracy as well as the accuracies for each primitives are reported. All the numbers are for top-1 prediction. ",
+        "bbox": [
+            176,
+            626,
+            825,
+            667
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D 30 RANDOM TESTING POINTS FOR TAJS BASELINE STUDY ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            101,
+            704,
+            119
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/44ea087301871a9d9c66cff1744777b2cab5747d15e266494335d1742608ef17.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"1\" rowspan=\"1\">868记2</td><td colspan=\"1\" rowspan=\"1\">记记记7亿</td><td colspan=\"1\" rowspan=\"1\">068u9</td><td colspan=\"1\" rowspan=\"1\">g1uuⅡ</td><td colspan=\"1\" rowspan=\"1\">668L9</td><td colspan=\"1\" rowspan=\"1\">S4ε乙</td><td colspan=\"1\" rowspan=\"1\">U</td></tr><tr><td colspan=\"1\" rowspan=\"1\"> org.civicrm.civicaseDiscordWithDatabasecryptiifo_restkootCaseDetailsFileTab.jshelp.jsROT13.jsindex.jsbefore_router_match.js</td><td colspan=\"1\" rowspan=\"1\"> pizza-totally-rocks geekTalks simple-crafting WTF-AdventurezulipForm.jsindex.jsgather.jsmana.js stream_muting.js</td><td colspan=\"1\" rowspan=\"1\"> matic.js graph-jsCraxi j5-ledsflom-reactgetETHFromFaucet.jspoint.jsdisplay.jsblink.jsquestion.js</td><td colspan=\"1\" rowspan=\"1\">iotdb-mongodbOrca pandora-validationAloChat react-native-with-redux-react-navigation-v2-boilerplatecount.js会index.jsContainer.jssplash.js</td><td colspan=\"1\" rowspan=\"1\">hackcincinnati/siteALFACharts musketeer-shop React-QuizComponent rn-mitrais-mbAdvisors.jscrosshairs.jsorder.jsQuizQuestion.jsListAlbums.js</td><td colspan=\"1\" rowspan=\"1\"> js-dom-and-events-acting-on-events-lab-v-000MEANLetsRollroma2hira js-ajax-hiting-apis-lab--000index.jsarticles.server.route.jsrouter.jsconvert.jsindex.js</td><td colspan=\"1\" rowspan=\"1\">Github Link to Diff</td></tr><tr><td colspan=\"1\" rowspan=\"1\">areAvailable()print（）registerSetting()testRecipesoriginisAllowed()printSplit()addSetting() preferenceoriginTrue</td><td colspan=\"1\" rowspan=\"1\">getRecipecheckTalkOwnershipgetBehaviorthis._superadd_messagesgetRecipescheckCommentOwnershipgetMetathis.superadd_old_messages</td><td colspan=\"1\" rowspan=\"1\">ETHFaucetAddressdatagame.draw()blinkDataTypes.STRINGETHFAUCET_ADDRESSdataManagergame.run（)strobeDataTypes.TEXT</td><td colspan=\"1\" rowspan=\"1\">thenerase()addAsyncSetup PropTypes.stringCOLOR.DARKmakeexplode()addSyncSetup PropTypes.objectCOLOR.PANTOME</td><td colspan=\"1\" rowspan=\"1\">color.primaryMath.floorDECIMAL(obj).instruction_textsinfo.typecolor.accentMath.roundINTEGER(obj).instruction_textinfo.album_type</td><td colspan=\"1\" rowspan=\"1\">(elem).InnerHTMLapp.paramsusername(elem).valuelogin(elem）.innerHTMLapp.paramuserName（elem）.innerHTMLname</td><td colspan=\"1\" rowspan=\"1\">Buggy CodeFixed Code</td></tr><tr><td colspan=\"1\" rowspan=\"1\">868□2</td><td colspan=\"1\" rowspan=\"1\">记记记记2</td><td colspan=\"1\" rowspan=\"1\">068u%</td><td colspan=\"1\" rowspan=\"1\">G切uu</td><td colspan=\"1\" rowspan=\"1\">068  9</td><td colspan=\"1\" rowspan=\"1\">C4c乙</td><td colspan=\"2\" rowspan=\"1\">U</td></tr><tr><td colspan=\"1\" rowspan=\"1\">refactoringrefactoringrefactoringrefactoringrefactoring</td><td colspan=\"1\" rowspan=\"1\">refactoringrefactoringrefactoringrefactoringrefactoring</td><td colspan=\"1\" rowspan=\"1\">refactoringrefactoringfunctional bugfunctional bugfunctional bug</td><td colspan=\"1\" rowspan=\"1\">functional bugfunctional bugfunctional bugfunctional bugfunctional bug</td><td colspan=\"1\" rowspan=\"1\">functional bugfunctional bugfunctional bugundefined propertyundefined property</td><td colspan=\"1\" rowspan=\"1\">undefined propertyundefined propertyundefined propertyundefined propertyundefined property</td><td colspan=\"2\" rowspan=\"1\">Bug Type</td></tr><tr><td colspan=\"1\" rowspan=\"1\">Failed importing library</td><td colspan=\"1\" rowspan=\"1\">Failed importing libraryFailed importing library</td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\">Failed importing library event s</td><td colspan=\"1\" rowspan=\"1\">Undefined pr oces s</td><td colspan=\"1\" rowspan=\"1\">Failed doc.getElem () Undefined processFailed importing library ut ilFailed doc.getElem ()</td><td colspan=\"2\" rowspan=\"1\">False AlarmTAJS</td></tr><tr><td colspan=\"1\" rowspan=\"1\">exports.testRecipesI</td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\">this.game.draw()led.strobe(750)</td><td colspan=\"1\" rowspan=\"1\">serviceProvider.addAsyncSetup(...)</td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\">app.params('.</td><td colspan=\"1\" rowspan=\"1\">Prediction</td><td colspan=\"1\" rowspan=\"4\">HOPPITY</td></tr><tr><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\">八</td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td></tr><tr><td colspan=\"1\" rowspan=\"1\">厂</td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\">厂</td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td></tr><tr><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\"></td><td colspan=\"1\" rowspan=\"1\">厂</td><td colspan=\"1\" rowspan=\"1\"></td></tr></table>",
+        "bbox": [
+            228,
+            122,
+            769,
+            888
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [],
+        "table_footnote": [],
+        "bbox": [
+            227,
+            102,
+            771,
+            779
+        ],
+        "page_idx": 16
+    }
+]

parse/train/SygvTcYee/SygvTcYee.md

@@ -0,0 +1,177 @@
+# PARMAC: DISTRIBUTED OPTIMISATION OF NESTED FUNCTIONS, WITH APPLICATION TO LEARNING BINARY AUTOENCODERS
+
+Miguel A. Carreira-Perpi ´ n˜ an & Mehdi Alizadeh ´ EECS, University of California, Merced http://eecs.ucmerced.edu
+
+# ABSTRACT
+
+Many powerful machine learning models are based on the composition of multiple processing layers, such as deep nets, which gives rise to nonconvex objective functions. A general, recent approach to optimise such “nested” functions is the method of auxiliary coordinates (MAC). MAC introduces an auxiliary coordinate for each data point in order to decouple the nested model into independent submodels. This decomposes the optimisation into steps that alternate between training single layers and updating the coordinates. It has the advantage that it reuses existing single-layer algorithms, introduces parallelism, and does not need to use chain-rule gradients, so it works with nondifferentiable layers. We describe ParMAC, a distributed-computation model for MAC. This trains on a dataset distributed across machines while limiting the amount of communication so it does not obliterate the benefit of parallelism. ParMAC works on a cluster of machines with a circular topology and alternates two steps until convergence: one step trains the submodels in parallel using stochastic updates, and the other trains the coordinates in parallel. Only submodel parameters, no data or coordinates, are ever communicated between machines. ParMAC exhibits high parallelism, low communication overhead, and facilitates data shuffling, load balancing, fault tolerance and streaming data processing. We study the convergence of ParMAC and its parallel speedup, and implement ParMAC using MPI to learn binary autoencoders for fast image retrieval, achieving nearly perfect speedups in a 128-processor cluster with a training set of 100 million high-dimensional points.
+
+# 1 INTRODUCTION
+
+Serial computing has reached a plateau and parallel, distributed architectures are becoming widely available, from machines with a few cores to cloud computing with 1000s of machines. The combination of powerful nested models with large datasets is a key ingredient to solve difficult problems in machine learning, computer vision and other areas, and it underlies recent successes in deep learning (Hinton et al., 2012; Le et al., 2012; Dean et al., 2012). Unfortunately, parallel computation is not easy, and many good serial algorithms do not parallelise well. The cost of communicating (through the memory hierarchy or a network) greatly exceeds the cost of computing, both in time and energy, and will continue to do so for the foreseeable future. Thus, good parallel algorithms must minimise communication and maximise computation per machine, while creating sufficiently many subproblems (ideally independent) to benefit from as many machines as possible. The load (in runtime) on each machine should be approximately equal. Faults become more frequent as the number of machines increases, particularly if they are inexpensive machines. Machines may be heterogeneous and differ in CPU and memory; this is the case with initiatives such as SETI $@$ home, which may become an important source of distributed computation in the future. Big data applications have additional restrictions. The size of the data means it cannot be stored on a single machine, so distributedmemory architectures are necessary. Sending data between machines is prohibitive because of the size of the data and the high communication costs. In some applications, more data is collected than can be stored, so data must be regularly discarded. In others, such as sensor networks, limited battery life and computational power imply that data must be processed locally.
+
+In this paper, we focus on machine learning models of the form $\mathbf { y } = \mathbf { F } _ { K + 1 } ( \ldots \mathbf { F } _ { 2 } ( \mathbf { F } _ { 1 } ( \mathbf { x } ) ) \ldots )$ , i.e., consisting of a nested mapping from the input $\mathbf { x }$ to the output y. Such nested models involve multiple parameterised layers of processing and include deep neural nets, cascades for object recognition in computer vision or for phoneme classification in speech processing, wrapper approaches to classification or regression, and various combinations of feature extraction/learning and preprocessing prior to some learning task. Nested and hierarchical models are ubiquitous in machine learning because they provide a way to construct complex models by the composition of simple layers. However, training nested models is difficult even in the serial case because function composition produces inherently nonconvex functions, which makes gradient-based optimisation difficult and slow, and sometimes inapplicable (e.g. with nonsmooth or discrete layers).
+
+Our starting point is a recently proposed technique to train nested models, the method of auxiliary coordinates (MAC) (Carreira-Perpi ˜n´an and Wang, 2012; 2014). This reformulates the optimisation into an iterative procedure that alternates training submodels independently with coordinating them. It introduces significant model and data parallelism, can often train the submodels using existing algorithms, and has convergence guarantees with differentiable functions to a local stationary point, while it also applies with nondifferentiable or even discrete layers. MAC has been applied to various nested models (Carreira-Perpi ˜n´an and Wang, 2014; Wang and Carreira-Perpi ˜n´an, 2014; Carreira-Perpi ˜n´an and Raziperchikolaei, 2015; Raziperchikolaei and Carreira-Perpi ˜n´an, 2016; Carreira-Perpi ˜n´an and Vladymyrov, 2015). However, the original papers proposing MAC (Carreira-Perpi ˜n´an and Wang, 2012; 2014) did not address how to run MAC on a distributed computing architecture, where communication between machines is far costlier than computation. This paper proposes ParMAC, a parallel, distributed framework to learn nested models using MAC, analyses its parallel speedup and convergence, implements it in MPI for the problem of learning binary autoencoders, and demonstrates its ability to train on large datasets and achieve large speedups on a distributed cluster.
+
+Related work Distributed optimisation and large-scale machine learning have been steadily gaining interest in recent years, with the development of parallel computation abstractions tailored to machine learning, such as Spark (Zaharia et al., 2010), GraphLab (Low et al., 2012), Petuum (Xing et al., 2015) or TensorFlow (Abadi et al., 2015), which have the goal of making cloud computing easily available to train machine learning models. Most work has centred on convex optimisation, particularly when the objective function has the form of empirical risk minimisation (data fitting term plus regulariser) (Cevher et al., 2014). This includes many important models in machine learning, such as linear regression, LASSO, logistic regression or SVMs. Such work is typically based on stochastic gradient descent (SGD) (Bottou, 2010), coordinate descent (CD) (Wright, 2016) or the alternating direction method of multipliers (ADMM) (Boyd et al., 2011). This has resulted in several variations of parallel SGD (Bertsekas, 2011; Zinkevich et al., 2010; Niu et al., 2011), parallel CD (Bradley et al., 2011; Richt´arik and Tak´aˇc, 2013; Liu and Wright, 2015) and parallel ADMM (Boyd et al., 2011; Ouyang et al., 2013; Zhang and Kwok, 2014).
+
+Little work has addressed nonconvex models. Most of it has focused on deep nets (Dean et al., 2012; Le et al., 2012). Google’s DistBelief (Dean et al., 2012) uses asynchronous parallel SGD (with gradients for the full model computed with backpropagation) to achieve data parallelism, and some form of model parallelism. The latter is achieved by carefully partitioning the neural net into pieces and allocating them to machines to compute gradients. This is difficult to do and requires a careful match of the neural net structure (number of layers and hidden units, connectivity, etc.) to the target hardware. Also, parallel SGD can diverge with nonconvex models, which requires heuristics to make sure we average replica models that are close in parameter space and thus associated with the same optimum. Although this has managed to train huge nets on huge datasets by using tens of thousands of CPU cores, the speedups achieved were very modest. Other work has used similar techniques but for GPUs (Coates et al., 2013; Seide et al., 2014).
+
+Finally, there also exist specific approximation techniques for certain types of large-scale machine learning problems, such as spectral problems, using the Nystr ¨om formula or other landmarkbased methods (Williams and Seeger, 2001; Bengio et al., 2004; Drineas and Mahoney, 2005; Talwalkar et al., 2008; Vladymyrov and Carreira-Perpi ˜n´an, 2013; 2016).
+
+ParMAC is specifically designed for nested models, which are typically nonconvex and include deep nets and many other models, some of which have nondifferentiable layers. As we describe below, ParMAC has the advantages of being simple and relatively independent of the target hardware, while achieving high speedups.
+
+Many optimisation problems in machine learning involve mathematically “nested” functions of the form $\mathbf { F } ( \mathbf { x } ; \mathbf { W } ) = \bar { \mathbf { F } } _ { K + 1 } ( . . . \mathbf { F } _ { 2 } ( \mathbf { F } _ { 1 } ( \mathbf { x } ; \mathbf { W } _ { 1 } ) ; \mathbf { W } _ { 2 } ) . . . ; \mathbf { W } _ { K + 1 } )$ with parameters W, such as deep nets. Such problems are traditionally optimised using methods based on gradients computed using the chain rule. However, such gradients may sometimes be inconvenient to use, or may not exist (e.g. if some of the layers are nondifferentiable, as with binary autoencoders). Also, they are hard to parallelise, because of the inherent sequentiality in the chain rule. The method of auxiliary coordinates $( M A C )$ (Carreira-Perpi ˜n´an and Wang, 2012; 2014) is designed to optimise nested models without using chain-rule gradients while introducing parallelism. The idea is to break nested functional relationships judiciously by introducing new variables (the auxiliary coordinates) as equality constraints. These are then solved by optimising a penalised function using alternating optimisation over the original parameters (which we call the W step) and over the coordinates (which we call the $\mathbf { Z }$ step). The result is a coordination-minimisation (CM) algorithm: the minimisation (W) step updates the parameters by splitting the nested model into independent submodels and training them using existing algorithms, and the coordination $\mathbf { \rho } ( \mathbf { Z } )$ step ensures that corresponding inputs and outputs of submodels eventually match. MAC algorithms have been developed for several nested models so far: deep nets (Carreira-Perpi ˜n´an and Wang, 2014), low-dimensional SVMs (Wang and Carreira-Perpi ˜n´an, 2014), binary autoencoders (Carreira-Perpi ˜n´an and Raziperchikolaei, 2015), affinity-based loss functions for binary hashing (Raziperchikolaei and Carreira-Perpi ˜n´an, 2016) and parametric nonlinear embeddings (Carreira-Perpi ˜n´an and Vladymyrov, 2015). Although this paper proposes and analyses ParMAC in general, our MPI implementation is for the particular case of binary autoencoders. These define a nonconvex nondifferentiable problem, yet its MAC algorithm is simple and effective.
+
+MAC algorithm for binary autoencoders A binary autoencoder $( B A )$ is a usual autoencoder but with a binary code layer. It consists of an encoder $\mathbf { h } ( \mathbf { x } )$ that maps a real vector $\textbf { x } \in \mathbb { R } ^ { D }$ onto a binary code vector with $L \ < \ D$ bits, $\mathbf { z } ~ \in ~ \{ 0 , 1 \} ^ { L }$ , and a linear decoder $\mathbf f ( \mathbf z )$ which maps $\mathbf { z }$ back to $\mathbb { R } ^ { D }$ in an effort to reconstruct $\mathbf { x }$ . We will call h a binary hash function (see later). Let us write $\mathbf { h } ( \mathbf { x } ) = \mathcal { \Gamma } ( \mathbf { A x } )$ (A includes a bias by having an extra dimension $x _ { 0 } = 1$ for each $\mathbf { x }$ ) where $\mathbf { A } \in \mathbb { R } ^ { L \times ( D + 1 ) }$ and $\boldsymbol { \mathscr { I } } ( t )$ is a step function applied elementwise, i.e., $\boldsymbol { \mathrm { \Sigma } } ( t ) = 1$ if $t \geq 0$ and $\boldsymbol { \mathrm { { J } } } ( t ) = 0$ otherwise. Given a dataset of $D$ -dimensional patterns $\mathbf { X } = \left( \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { N } \right)$ , our objective function, which involves the nested model $\mathbf { y } _ { \mathrm { { o } } } = \mathbf { f } ( \mathbf { h } ( \mathbf { x } ) )$ , is the usual least-squares reconstruction error $\begin{array} { r } { E _ { \mathrm { B A } } ( \mathbf { h } , \mathbf { f } ) = \sum _ { n = 1 } ^ { N } \| \mathbf { x } _ { n } - \mathbf { f } ( \mathbf { h } ( \mathbf { x } _ { n } ) ) \| ^ { 2 } } \end{array}$ . Optimising this nonconvex, nonsmooth function is NP-complete. Where the gradients do exist wrt A they are zero, so optimisation of $\mathbf { h }$ using chainrule gradients does not apply. We introduce as auxiliary coordinates the outputs of $\mathbf { h }$ , i.e., the codes for each of the $N$ input patterns, and obtain the following equality-constrained problem:
+
+$$
+\operatorname* { m i n } _ { \mathbf { h } , \mathbf { f } , \mathbf { Z } } \sum _ { n = 1 } ^ { N } \left\| \mathbf { x } _ { n } - \mathbf { f } ( \mathbf { z } _ { n } ) \right\| ^ { 2 } \quad \mathrm { s . t . } \quad \mathbf { z } _ { n } = \mathbf { h } ( \mathbf { x } _ { n } ) , \mathbf { z } _ { n } \in \{ 0 , 1 \} ^ { L } , n = 1 , \ldots , N .
+$$
+
+Note the codes are binary. We now apply the quadratic-penalty method and minimise the following objective function while progressively increasing $\mu$ , so the constraints are eventually satisfied:
+
+$$
+E _ { { \cal Q } } ( { \bf h } , { \bf f } , { \bf Z } ; \mu ) = \sum _ { n = 1 } ^ { N } \left\| { \bf x } _ { n } - { \bf f } ( { \bf z } _ { n } ) \right\| ^ { 2 } + \mu \left\| { \bf z } _ { n } - { \bf h } ( { \bf x } _ { n } ) \right\| ^ { 2 } \mathrm { s . t . } { \bf z } _ { n } \in \{ 0 , 1 \} ^ { L } , n = 1 , \ldots , N .
+$$
+
+Finally, we apply alternating optimisation over $\mathbf { Z }$ and $\mathbf { W } = ( \mathbf { h } , \mathbf { f } )$ . This gives the following steps:
+
+Over $\mathbf { Z }$ for fixed $( \mathbf { h } , \mathbf { f } )$ , this is a binary optimisation on $N L$ variables, but it separates into $N$ independent optimisations each on only $L$ variables, with the form of $\mathrm { ^ a }$ binary proximal operator (where we omit the index $n$ ): $\mathrm { m i n } _ { \mathbf { z } } \left\| \mathbf { x } - \mathbf { f } ( \mathbf { z } ) \right\| ^ { 2 } + \mu \| \mathbf { z } - \mathbf { h } ( \mathbf { x } ) \| ^ { 2 } \boldsymbol { \mathfrak { s } }$ s.t. $\mathbf { z } \in \{ 0 , 1 \} ^ { L }$ . This can be solved approximately by alternating optimisation over bits. Over $\mathbf { W } = \left( \mathbf { h } , \mathbf { f } \right)$ for fixed $\mathbf { Z }$ , we obtain $L + D$ independent problems: for each of the $L$ single-bit hash functions (which try to predict $\mathbf { Z }$ optimally from $\mathbf { X }$ ), each solvable by fitting a linear SVM; and for each of the $D$ linear decoders in f (which try to reconstruct $\mathbf { X }$ optimally from $\mathbf { Z }$ ), each a linear least-squares problem.
+
+The user must choose a schedule for the penalty parameter $\mu$ (sequence of values $0 < \mu _ { 1 } < \cdots <$ $\mu _ { \infty } )$ ). This should increase slowly enough that the binary codes can change considerably and explore better solutions before the constraints are satisfied and the algorithm stops. With BAs, MAC stops for a finite value of $\mu$ , which occurs whenever $\mathbf { Z }$ does not change compared to the previous $\mathbf { Z }$ step. This gives a practical stopping criterion. Carreira-Perpi˜n´an and Raziperchikolaei (2015) give proofs of these statements and further details about the algorithm. Fig. 1 gives the MAC algorithm for BAs.
+
+![](images/28e2837e43709b2989c8ca8d4340a5e869997cd4e9c20d0643554b3b04d037df.jpg)  
+Figure 1: MAC algorithm for binary autoencoders. “parfor” indicates a for loop whose iterations are carried out in parallel. The steps over $\mathbf { h }$ and f can be run in parallel as well.
+
+The BA was proposed as a way to learn good binary hash functions for fast, approximate information retrieval (Carreira-Perpi ˜n´an and Raziperchikolaei, 2015). Binary hashing (Grauman and Fergus, 2013) has emerged in recent years as an effective way to do fast, approximate nearest-neighbour searches in image databases. The real-valued, high-dimensional image vectors are mapped onto a binary space with $L$ bits and the search is performed there using Hamming distances at a vastly faster speed and smaller memory (e.g. $N = 1 0 ^ { 9 }$ points with $D = 5 0 0$ take $^ { 2 } \mathrm { T B }$ , but only 8 GB using $L = 6 4$ bits, which easily fits in RAM). As shown by Carreira-Perpi ˜n´an and Raziperchikolaei (2015), training BAs with MAC beats approximate optimisation approaches such as relaxing the codes or the step function in the encoder, and yields state-of-the-art binary hash functions h in unsupervised problems, improving over established approaches such as iterative quantisation (ITQ) (Gong et al., 2013). We focus mostly on linear hash functions because these are, by far, the most used type of hash functions in the literature of binary hashing, due to the fact that computing the binary codes for a test image must be fast at run time.
+
+MAC in general With a nested function with $K$ layers, we can introduce auxiliary coordinates at each layer. For example, with a neural net, this decouples the weight vector of every hidden unit in the W step, which can be solved as a logistic regression (see Carreira-Perpi ˜n´an and Alizadeh, 2016). For a large net with a large dataset, this affords an enormous potential for parallel computation.
+
+MAC and EM MAC is very similar to expectation-maximisation (EM) at a conceptual level. EM (McLachlan and Krishnan, 2008) applies generally to many probabilistic models. The resulting algorithm can be very different (e.g. EM for Gaussian mixtures vs EM for hidden Markov models), but it always alternates two steps that conceptually do the following. The E step updates in parallel the posterior probabilities. This separates over data points and is like the $\mathbf { Z }$ step in MAC, where the posterior probabilities are the auxiliary coordinates, and where the step may be in closed-form or require optimisation, depending on the model. The M step updates in parallel the “submodels”. For a mixture with $M$ components, these are the $M$ Gaussians (means, covariances, proportions). This separates over submodels and is like the W step in MAC. For BAs, the submodels are the $L$ encoders (linear SVMs) and the $D$ decoders (linear regressors); for a neural net, each weight vector of a hidden unit is a submodel (a logistic regressor). For Gaussian mixtures, the M step can be done exactly in one “epoch” because it is a simple average. For MAC, it usually requires optimisation, and so multiple epochs. In fact, ParMAC applies to EM by using $e = 1$ epoch: in the W step, the Gaussians visit each machine circularly and (their averages) are updated on its data; in the $\mathbf { Z }$ step, each machine updates its posterior probabilities.
+
+In the rest of the paper, some readers may find this analogy useful and think of EM for Gaussian mixtures instead of MAC, replacing “submodels” and “auxiliary coordinates” in MAC with “Gaussians” and “posterior probabilities” in EM, respectively.
+
+![](images/0935259ff5ddbeac36f41db147d0b66d8970c89e9d73ac600a82da6a50558ab8.jpg)  
+Figure 2: ParMAC model with $P = 4$ machines, $M = 1 2$ submodels “ ${ \bf w } _ { h }$ ” and $N = 4 0$ data points. Submodels $h$ , $h + M$ , $h + 2 M$ and $h + 3 M$ are copies of submodel $h$ , but only one of them is the most currently updated. At the end of the W step all copies are identical.
+
+# 3 PARMAC: A PARALLEL, DISTRIBUTED COMPUTATION MODEL FOR MAC
+
+A specific MAC algorithm depends on the model and objective function and on how the auxiliary coordinates are introduced. We can achieve steps that are closed-form, convex, nonconvex, binary, or others. However, we will assume the following always hold: (1) Separability over data points. In the $\mathbf { Z }$ step, the $N$ subproblems for $\mathbf { z } _ { 1 } , \ldots , \mathbf { z } _ { N }$ are independent, one per data point. Each $\mathbf { z } _ { n }$ step depends on the current model. (2) Separability over submodels. In the W step, there are $M$ independent submodels, where $M$ depends on the problem. For example, $M$ is the number of hidden units in a deep net, or the number of hash functions and linear decoders in a BA. Each submodel depends on all the data and coordinates. We now show how to turn this into a distributed, low-communication $P a r M A C$ algorithm.
+
+The basic idea in ParMAC is as follows. With large datasets in distributed systems, it is imperative to minimise data movement over the network because the communication time generally far exceeds the computation time in modern architectures. In MAC we have 3 types of data: the original training data $( \mathbf { X } , \mathbf { Y } )$ , the auxiliary coordinates $\mathbf { Z }$ , and the model parameters (the submodels). Usually, the latter type is far smaller. In ParMAC, we never communicate training or coordinate data; each machine keeps a disjoint portion of $( \mathbf { X } , \mathbf { Y } , \mathbf { Z } )$ corresponding to a subset of the points. Only model parameters are communicated, during the W step, following a circular topology, which implicitly implements a stochastic optimisation. The model parameters are the hash functions h and the decoder f for BAs, and the weight vector ${ \bf w } _ { h }$ of each hidden unit $h$ for deep nets. Let us see this in detail (refer to fig. 2).
+
+Assume we have $P$ identical processing machines, each with its own memory and CPU, connected through a network in a circular unidirectional topology. Each machine stores a subset of the data points and corresponding coordinates $\left( \mathbf { x } _ { n } , \mathbf { y } _ { n } , \mathbf { z } _ { n } \right)$ such that the subsets are disjoint and their union is the entire data. Before the $\mathbf { Z }$ step starts, each machine contains all the (just updated) submodels. This means that in the $\mathbf { Z }$ step each machine processes its auxiliary coordinates $\left\{ { \bf z } _ { n } \right\}$ independently of all other machines, i.e., no communication occurs. The W step is more subtle. At the beginning of the W step, each machine will contain all the submodels and its portion of the data and (just updated) coordinates. Each submodel must have access to the entire data and coordinates in order to update itself and, since the data cannot leave its home machine, the submodel must go to the data. We achieve this in the circular topology with an asynchronous processing, as follows. Each machine keeps a queue of submodels to be processed, and repeatedly performs the following operations: extract a submodel from the queue, process it on its data and send it to the machine’s successor (which will insert it in its queue). If the queue is empty, the machine waits until it is nonempty. The queue of each machine is initialised with a portion $M / P$ of submodels associated with that machine (e.g. in fig. 2, machine 1’s queue contains submodels 1–3, machine 2 submodels 4–6, etc.). Each submodel carries a counter that is initially 1 and increases every time it visits a machine. When it reaches $P$ , the submodel has visited all machines in sequence and has completed an epoch. We repeat this for $e$ epochs and, to ensure all machines have all final submodels before starting the $\mathbf { Z }$ step, we run a communication-only epoch $e + 1$ (without computation), where submodels simply move from machine to machine.
+
+Since each submodel is updated as soon as it visits a machine, rather than computing the exact gradient once it has visited all machines and then take a step, the W step is really carrying out stochastic steps for each submodel. For example, if the update is done by a gradient step, we are actually implementing stochastic gradient descent (SGD) where the minibatches are of size $N / P$ (or smaller, if we subdivide a machine’s data portion into minibatches, which should be typically the case in practice). From this point of view, we can regard the W step as doing SGD on each submodel in parallel by having each submodel visit the minibatches in each machine.
+
+As described, and as implemented in our experiments, the entire model parameters are communicated $e + 1$ times in a MAC iteration if running e epochs in the W step. We can also run $e$ epochs with only 2 rounds of communication by having a submodel do e consecutive passes within each machine’s data. This reduces the amount of shuffling, but should not be a problem if the data are randomly distributed over machines.
+
+Extensions of ParMAC Data shuffling, which improves the SGD convergence speed, can be achieved without data movement by accessing the local data in random order at each epoch (withinmachine), and by randomising the circular topology at each epoch (across-machine). Load balancing is simple because the work in both W and $\mathbf { Z }$ steps is proportional to the number of data points $N$ . Hence, if the processing power of machine $p$ is proportional to $\alpha _ { p } \ > \ 0$ , we allocate to it $N \alpha _ { p } / ( \alpha _ { 1 } + \cdot \cdot \cdot + \bar { \alpha _ { P } } )$ data points. Streaming, i.e., discarding old data and adding new data during training, can be done by adding/removing data within-machine, or by adding/removing machines and updating the circular topology. Fault tolerance is possible because we can still learn a good model even if we lose the data from a machine that fails, and because in the W step we can revert to older copies of the lost submodels residing in other machines. See further details in Carreira-Perpi ˜n´an and Alizadeh (2016).
+
+A theoretical model of the parallel speedup We can estimate the runtime of the $\mathbf { W }$ and $\mathbf { Z }$ steps assuming there are $M$ independent submodels of the same size in the W step, using $e$ epochs, on a dataset with $N$ training points, distributed over $P$ identical machines (each with $N / P$ points). Let $t _ { r } ^ { \mathbf { W } }$ be the computation time per submodel and data point in the W step, $t _ { r } ^ { \mathbf { Z } }$ the computation time per data point in the step, and the communication time per submodel in the W step. Then the runtime of the W and $\mathbf { Z }$ steps is $\begin{array} { r } { \tilde { T } ^ { \mathbf { W } } ( P ) = \lceil M / P \rceil ( t _ { r } ^ { \mathbf { W } } \frac { N } { P } + \dot { t } _ { c } ^ { \mathbf { W } } ) P e + \lceil M / P \rceil t _ { c } ^ { \mathbf { W } } P } \end{array}$ and $T ^ { \mathbf { Z } } ( P ) =$ $\textstyle M { \frac { N } { P } } t _ { r } ^ { \mathbf { Z } }$ P  , respectively. Hence the parallel speedup is (see details in Carreira-Perpi ˜n´an and Alizadeh,
+
+$$
+S ( P ) = { \frac { T ( 1 ) } { T ( P ) } } = { \frac { \rho { \frac { 1 } { [ M / P ] } } M P } { { \frac { 1 } { N } } P ^ { 2 } + \rho _ { 2 } P + \rho _ { 1 } { \frac { 1 } { [ M / P ] } } M } } \rho _ { 1 } = t _ { r } ^ { \mathbf { Z } } / ( e + 1 ) t _ { c } ^ { \mathbf { W } } , \rho _ { 2 } = e t _ { r } ^ { \mathbf { W } } / ( e + 1 ) t _ { c } ^ { \mathbf { W } }
+$$
+
+where $\rho , \rho _ { 1 }$ and $\rho _ { 2 }$ are ratios of computation vs communication, dependent on the optimisation algorithm in the W and $\mathbf { Z }$ steps, and on the performace of the distributed system and MPI library.
+
+Hence, if $P \leq M$ and $M$ is divisible by $P$ we have $\begin{array} { r } { S ( P ) = P / ( 1 + \frac { P } { o N } ) } \end{array}$ and if $P > M$ we have $\begin{array} { r } { S ( P ) = \rho M / ( \rho _ { 2 } + \rho _ { 1 } \frac { M } { P } + \frac { P } { N } ) } \end{array}$ . In practice, typically we have $\rho \ll 1$ ρN  (because communication dominates computation in current architectures) and $\rho _ { 2 } N \gg 1$ (large dataset). If we take $P \ll \rho _ { 2 } N$ , then $S ( P ) \approx \bar { P }$ if $P \leq M$ and $\begin{array} { r } { S ( P ) \approx \rho M / ( \rho _ { 2 } + \rho _ { 1 } \frac { M } { P } ) } \end{array}$ if $P > M$ . Hence, the speedup is nearly perfect if using fewer machines than submodels, and otherwise it peaks at $S _ { 1 } ^ { * } = \rho M / ( \rho _ { 2 } +$ $2 \sqrt { \rho _ { 1 } M / N } ) \stackrel { \cdot } { > } M$ for $P = P _ { 1 } ^ { * } = \sqrt { \rho _ { 1 } M N } > M$ and decreases thereafter. This affords very large speedups for large datasets and large models. This theoretical speedup matches well our measured ones (see the experiments section), and can be used to determine optimal values for the number of machines $P$ to use in practice (subject to additional constraints, e.g. cost of the machines).
+
+Eq. (3) also shows that we can leave the speedup unchanged by trading off dataset size and computation/communication times, as long as one of these holds: $\dot { N } t _ { r } ^ { \mathbf { W } }$ and $N t _ { r } ^ { \mathbf { Z } }$ remain constant; or $\mathbf { \Pi } _ { N / t _ { c } ^ { \mathbf { W } } } ^ { \star }$ remains constant; or $t _ { r } ^ { \mathbf { W } } / t _ { c } ^ { \mathbf { W } }$ and $t _ { r } ^ { \mathbf { Z } } / t _ { c } ^ { \mathbf { W } }$ remain constant.
+
+In the BA, we have submodels of different size: encoders of size $D$ and decoders of size $L < D$ . We can model this by “grouping” the $D$ decoders into $L$ groups of $D / L$ decoders each, resulting in $M = 2 L$ equal-size submodels (assuming the ratio of computation and communication times of decoder vs encoder is $L / D < 1 \rangle$ ).
+
+Convergence of ParMAC The only approximation that ParMAC makes to the original MAC algorithm is using SGD in the W step. Since we can guarantee convergence of SGD under certain conditions (e.g. Robbins-Monro schedules), we can recover the original convergence guarantees for MAC to a local stationary point with differentiable layers (see details in Carreira-Perpi ˜n´an and Alizadeh, 2016). This convergence guarantee is independent of the number of layers, models and processors. With nondifferentiable layers, the convergence properties of MAC (and ParMAC) are not well known. In particular, for the binary autoencoder the encoding layer is discrete and the problem is NP-complete. While convergence guarantees are important theoretically, in practical applications with large datasets in a distributed setting one typically runs SGD for just a few epochs, even one or less than one (i.e., we stop SGD before passing through all the data). This typically reduces the objective function to a good enough value as fast as possible, since each pass over the data is very costly. In our experiments, 1–2 epochs in the W step make ParMAC very similar to MAC using an exact step.
+
+Circular vs parameter-server topologies We also considered implementing ParMAC using a parameter-server (PS) topology rather than a circular one, but the latter is better. With a PS we do parallel SGD on each submodel independently, i.e., each worker runs SGD on its own submodel replica for a while, sends it to the PS, and this broadcasts an “average” submodel back to the workers, asynchronously. The circular topology does true SGD on each submodel independently from the others. We can show the runtime per iteration using a PS is equal to that of the circular topology only if the server can communicate with $P$ workers simultaneously (rather than sequentially), otherwise it is slower. The reason is the PS has more communication. The PS has some additional disadvantages: parallel SGD converges more slowly than true SGD and is difficult to apply if the W step is nonconvex; and it needs extra machine(s) to act as parameter server(s). The fundamental issue is that both topologies differ in how they employ the available parallelism: the circular topology updates different, independent submodels, while the PS updates replicas of the same submodels.
+
+# 4 EXPERIMENTS
+
+MPI implementation of ParMAC for BAs. We have used $\mathrm { C } / \mathrm { C } { + + }$ , the GSL and BLAS libraries for mathematical operations, and the Message Passing Interface (MPI) (Gropp et al., 1999) for interprocess communication. MPI is a widely used framework for high-performance parallel computing, available in multiple platforms. It is particularly suitable for ParMAC because of its support of the SPMD (single program, multiple data) model. In MPI, processes in different machines communicate through messages. To receive data, we use the synchronous blocking receive function MPI Recv; the process calling this blocks until the data arrives. To send data we use the buffered blocking send function MPI Bsend. We allocate enough memory and attach it to the system. The process calling MPI Bsend blocks until the buffer is copied to the MPI internal memory; after that, the MPI library takes care of sending the data. See a code snippet in Carreira-Perpi ˜n´an and Alizadeh (2016).
+
+Distributed-memory cluster. We used General Computing Nodes from the UCSD Triton Shared Computing Cluster (TSCC), available to the public for a fee. Each node contains 2 8-core Intel Xeon E5-2670 processors (16 cores in total), 64GB RAM (4GB/processor) and a 500GB hard drive. The nodes are connected through a 10GbE network. We used up to $P \ = \ 1 2 8$ processors. Carreira-Perpi ˜n´an and Alizadeh (2016) give detailed specs as well as experiments in a sharedmemory machine.
+
+Datasets. We have used 3 well-known colour image retrieval benchmarks. (1) CIFAR (Krizhevsky, 2009) contains $6 0 0 0 0$ images $N = 5 0 0 0 0$ training and 10 000 test), represented by $D = 3 2 0$ GIST features. (2) SIFT-1M (J´egou et al., 2011a) contains $N = 1 0 ^ { 6 }$ training and $1 0 ^ { 4 }$ test images, each represented by $D = 1 2 8$ SIFT features. (3) SIFT-1B (J´egou et al., 2011a) has three subsets: $1 0 ^ { 9 }$ base vectors where the search is performed, $N = 1 0 ^ { 8 }$ learning vectors used to train the model and $1 0 ^ { 4 }$ query vectors.
+
+Performance measures. Regarding the quality of the BA and hash functions learnt, we report the retrieval precision $( \% )$ in the test set using as true neighbours the $K$ nearest images in Euclidean distance in the original space, and as retrieved neighbours in the binary space we use the $k$ nearest images in Hamming distance. We set $( K , k ) = \bar { ( } 1 0 0 0 , 1 0 0 )$ for CIFAR and $( 1 0 0 0 0 , 1 0 0 0 0 )$ for SIFT-1M. For SIFT-1B, as suggested by the dataset creators, we report the recall $_ { \ @ \mathrm { R } }$ : the average number of queries for which the nearest neighbour is ranked within the top $R$ positions (for varying values of $R$ ); in case of tied distances, we place the query as top rank. All these measures are computed offline once the BA is trained. Carreira-Perpi ˜n´an and Alizadeh (2016) give additional measures and experiments.
+
+Models and their parameters. We use BAs with linear encoders (linear SVM) except with SIFT-1B, where we also use kernel SVMs. The decoder is always linear. We set $L = 1 6$ bits (hash functions) for CIFAR and SIFT-1M and $L = 6 4$ bits for SIFT-1B. We initialise the binary codes from truncated PCA ran on a subset of the training set (small enough that it fits in one processor). To train the encoder ( $L$ SVMs) and decoder $D$ linear mappings) with stochastic optimisation, we used the SGD code from (Bottou and Bousquet, 2008), using its default parameter settings. The SGD step size is tuned automatically in each iteration by examining the first $1 0 0 0$ datapoints. We use a multiplicative $\mu$ schedule $\mu _ { i } = { \dot { \mu } } _ { 0 } a ^ { i }$ where the initial value $\mu _ { 0 }$ and the factor $a > 1$ are tuned offline in a trial run using a small subset of the data. For CIFAR we use $\mu _ { 0 } = 0 . 0 0 5$ and $a = 1 . 2$ over 26 iterations $( i = 0 , \ldots , 2 5 )$ . For SIFT-1M and SIFT-1B we use $\mu _ { 0 } = 1 0 ^ { - 4 }$ and $a = 2$ over 10 iterations.
+
+Effect of stochastic steps in the W step Fig. 3 shows the effect on the precision on CIFAR of varying the number of epochs within the W step and shuffling the data as a function of the number of processors $P$ . As the number of epochs increases, the W step is solved more exactly (8 epochs is practically exact in this data). Fewer epochs, even just one, cause only a small degradation. The reason is that, although these are relatively small datasets, they contain sufficient redundance that few epochs are sufficient to decrease the error considerably.
+
+This is also helped by the accumulated effect of epochs over MAC iterations. Running more epochs increases the runtime and lowers the parallel speedup in this particular model, because we use few bits $L = 1 6 )$ and therefore few submodels $M = 2 L = 3 2$ ) compared to the number of machines (up to $P = 1 2 8 )$ ), so the W step has less parallelism. The positive effect of data shuffling in the W step is clear: shuffling generally increases the precision with no increase in runtime.
+
+![](images/7a5ec6e3fefe1bf4c4dd3f2095ac22c4753a543c8695ba37fd199b7a1cd3b944.jpg)  
+Figure 3: Precision in CIFAR dataset.
+
+Speedup The fundamental advantage of ParMAC and distributed optimisation in general is the ability to train on datasets that do not fit in a single machine, and the reduction in runtime because of parallel processing. Fig. 4 shows the “strong scaling” speedups achieved, as a function of the number of machines $P$ for fixed problem size (dataset and model), in CIFAR and SIFT-1M ( $N =$ 50K and 1M training points, respectively). Even though these datasets and especially the number of independent submodels $M = 2 L = 3 2$ effective submodels of the same size, as discussed earlier) are relatively small, the speedups we achieve are nearly perfect for $P \leq M$ and hold very well for $P > M$ up to the maximum number of machines we used $P = 1 2 8$ in the distributed system). The speedups flatten as the number of W-step epochs (and consequently the amount of communication) increases, because for this experiment the bottleneck is the W step, whose parallelisation ability (i.e., the number of concurrent processes) is limited by $M = 2 L$ (the $\mathbf { Z }$ step has $N$ independent processes and is never a bottleneck, since $N$ is very large). However, as noted earlier, using 1 to 2 epochs gives a good enough result, very close to doing an exact W step. The runtime for SIFT-1M on $P = 1 2 8$ machines with 8 epochs was 12 minutes and its speedup $1 0 0 \times$ . This is particularly remarkable given that the original, nested model did not have model parallelism.
+
+![](images/32695e824cb9267e2ea8be1d4074f23439f2373aaed6318782695f84d6fc42d4.jpg)  
+Figure 4: Speedup $S ( P )$ as a function of the number of machines $P$ (top: experiment, bottom: theory). The dataset size and number of submodels $( N , M )$ is (50 000, 32) for CIFAR, $( 1 0 ^ { 6 } , 3 2 )$ for SIFT-1M and $( 1 0 ^ { 8 } , 1 2 8 )$ for SIFT-1B.
+
+Fig. 4 also shows the speedups predicted by our theoretical model. We set the parameters $e$ and $N$ to their known values, and $M = 2 L = 3 2$ for CIFAR and SIFT-1M and $M = 2 L = 1 2 8$ for SIFT-1B. For the time parameters, we set $t _ { r } ^ { \mathbf { W } } = 1$ to fix the time units, and we set $t _ { c } ^ { \mathbf { W } }$ and $t _ { r } ^ { \mathbf { Z } }$ by trial and error to achieve a reasonably good fit to the experimental speedups: $t _ { c } ^ { \mathbf { W } } = 1 0 ^ { 4 }$ for both datasets, and $t _ { r } ^ { \mathbf { Z } } = 2 0 0$ for CIFAR and 40 for SIFT-1M. Although these are fudge factors, they are in rough agreement with the fact that communicating a weight vector over the network is orders of magnitude slower than updating it with a gradient step, and that the $\mathbf { Z }$ step is quite slower than the W step because of the binary optimisation it involves.
+
+Large-scale experiment SIFT-1B is one of the largest datasets, if not the largest one, that are publicly available for comparing nearest-neighbour search algorithms with known ground-truth (i.e., precomputed exact Euclidean distances for each query to its $k$ nearest vectors in the base set). The training set contains $N = 1 0 0 \mathrm { { M } }$ vectors, each consisting of 128 SIFT features. We used $L = 6 4$ hash functions $M = 1 2 8$ submodels): linear SVMs as before, and kernel SVMs. These have fixed Gaussian radial basis functions (2 000 centres picked at random from the training set and bandwidth $\sigma = 1 6 0 ^ { \circ }$ ), so the only trainable parameters are the weights, and the MAC algorithm does not change except that it operates on a 2 000-dimensional input vector of kernel values, instead of the 128 SIFT features. We use $e = 2$ epochs with shuffling. All these decisions were based on trials on a subset of the training dataset. We initialised the binary codes from truncated PCA trained on a subset of size 1M (recall $\textcircled { a } \mathrm { R } { = } 1 0 0 ; 5 5 . 2 \%$ ), which gave results comparable to the baseline in (J´egou et al., 2011b).
+
+We ran ParMAC on the whole training set in the distributed system with 128 processors for 6 iterations and achieved a recall $\scriptstyle { \mathcal { Q } } \mathrm { R } = 1 0 0$ of $6 1 . 5 \%$ in 29 hours (linear SVM) and $6 6 . 1 \%$ in 83 hours (kernel SVM). Using a scaled-down model and training set, we estimated that training in one machine (with enough RAM to hold the data and parameters) would take months. The theoretical speedup (fig. 4 right plot, using the same parameters as in SIFT-1M), is nearly perfect (note the plot goes up to $P = 1 0 2 4$ machines, even though our experiments are limited to $P = 1 2 8$ ). This is because $M$ is quite larger and $N$ is much larger than in the previous datasets.
+
+# 5 DISCUSSION
+
+Developing parallel, distributed optimisation algorithms for nonconvex problems in machine learning is challenging, as shown by recent efforts by large teams of researchers (Le et al., 2012; Dean et al., 2012). One important advantage of ParMAC is its simplicity. Data and model parallelism arise naturally thanks to the introduction of auxiliary coordinates. The corresponding optimisation subproblems can often be solved reusing existing code as a black box (as with the SGD training of SVMs and linear mappings in the BA). A circular topology is sufficient to achieve a low communication between machines. There is no close coupling between the model structure and the distributed system architecture. This makes ParMAC suitable for architectures as different as supercomputers and data centres.
+
+Further improvements can be made in specific problems. For example, we may have more parallelisation or less dependencies (e.g. the weights of hidden units in layer $k$ of a neural net depend only on auxiliary coordinates in layers $k$ and $k + 1$ ). This may reduce the communication in the W step, by sending to a given machine only the model portion it needs, or by allocating cores within a multicore machine accordingly. The W and $\mathbf { Z }$ step optimisations can make use of further parallelisation by GPUs or by distributed convex optimisation algorithms. Many more refinements can be done, such as storing or communicating reduced-precision values with little effect of the accuracy. In this paper, we have tried to keep our implementation as simple as possible, because our goal was to understand the parallelisation speedups of ParMAC in a setting as general as possible, rather than trying to achieve the very best performance for a particular dataset, model or distributed system.
+
+# 6 CONCLUSION
+
+We have proposed ParMAC, a distributed model for the method of auxiliary coordinates for training nested, nonconvex models in general, analysed its parallel speedup and convergence, and demonstrated it with an MPI-based implementation for a particular case, to train binary autoencoders. MAC creates parallelism by introducing auxiliary coordinates for each data point to decouple nested terms in the objective function. ParMAC is able to translate the parallelism inherent in MAC into a distributed system by 1) using data parallelism, so that each machine keeps a portion of the original data and its corresponding auxiliary coordinates; and 2) using model parallelism, so that independent submodels visit every machine in a circular topology, effectively executing epochs of a stochastic optimisation, without the need for a parameter server and therefore no communication bottlenecks. The convergence properties of MAC (to a stationary point of the objective function) remain essentially unaltered in ParMAC. The parallel speedup can be theoretically predicted to be nearly perfect when the number of submodels is comparable or larger than the number of machines, and to eventually saturate as one continues to increase the number of machines, and indeed this was confirmed in our experiments. ParMAC also makes it easy to account for data shuffling, load balancing, streaming and fault tolerance. Hence, we expect that ParMAC could be a basic building block, in combination with other techniques, for the distributed optimisation of nested models in big data settings.
+
+# ACKNOWLEDGMENTS
+
+Work supported by a Google Faculty Research Award and by NSF award IIS–1423515. We thank Ramin Raziperchikolaei (UC Merced) for discussions about binary autoencoders, Dong Li (UC Merced) for discussions about MPI and performance evaluation on parallel systems, and Quoc Le (Google) for discussions about Google’s DistBelief system.
+
+# REFERENCES
+
+M. Abadi et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. White paper.   
+Y. Bengio, J.-F. Paiement, P. Vincent, O. Delalleau, N. Le Roux, and M. Ouimet. Out-of-sample extensions for LLE, Isomap, MDS, Eigenmaps, and spectral clustering. NIPS, 2004.   
+D. P. Bertsekas. Incremental gradient, subgradient, and proximal methods for convex optimization: A survey. In S. Sra, S. Nowozin, and S. J. Wright, editors, Optimization for Machine Learning. MIT Press, 2011.   
+L. Bottou. Large-scale machine learning with stochastic gradient descent. COMPSTAT, 2010.   
+L. Bottou and O. Bousquet. The tradeoffs of large scale learning. NIPS, 2008.   
+S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein. Distributed optimization and statistical learning via the alternating direction method of multipliers. Foundations and Trends in Machine Learning, 3, 2011.   
+J. Bradley, A. Kyrola, D. Bickson, and C. Guestrin. Parallel coordinate descent for $L _ { 1 }$ -regularized loss minimization. ICML, 2011.   
+M. A. Carreira-Perpi ˜n´an and M. Alizadeh. ParMAC: Distribut ´ ed optimisation of nested functions, with application to learning binary autoencoders. arXiv:1605.09114 [cs.LG], May 30 2016.   
+M. A. Carreira-Perpi ˜n´an and M. Vladymyrov. A fast, universa ´ l algorithm to learn parametric nonlinear embeddings. NIPS, 2015.   
+M. A. Carreira-Perpi ˜n´an and W. Wang. Distributed optimizat ´ ion of deeply nested systems. arXiv:1212.5921 [cs.LG], Dec. 24 2012.   
+M. A. Carreira-Perpi ˜n´an and W. Wang. Distributed optimizat ´ ion of deeply nested systems. AISTATS, 2014.   
+V. Cevher, S. Becker, and M. Schmidt. Convex optimization for big data: Scalable, randomized, and parallel algorithms for big data analytics. IEEE Signal Processing Magazine, 31(5):32–43, Sept. 2014.   
+A. Coates, B. Huval, T. Wang, D. Wu, B. Catanzaro, and A. Ng. Deep learning with COTS HPC systems. ICML, 2013.   
+J. Dean, G. Corrado, R. Monga, K. Chen, M. Devin, Q. Le, M. Mao, M. Ranzato, A. Senior, P. Tucker, K. Yang, and A. Ng. Large scale distributed deep networks. NIPS, 2012.   
+P. Drineas and M. W. Mahoney. On the Nystr¨om method for approximating a Gram matrix for improved kernel-based learning. J. Machine Learning Research, 6:2153–2175, Dec. 2005.   
+Y. Gong, S. Lazebnik, A. Gordo, and F. Perronnin. Iterative quantization: A Procrustean approach to learning binary codes for large-scale image retrieval. IEEE PAMI, 2013.   
+K. Grauman and R. Fergus. Learning binary hash codes for large-scale image search. In R. Cipolla, S. Battiato, and G. Farinella, editors, Machine Learning for Computer Vision, pages 49–87. Springer-Verlag, 2013.   
+W. Gropp, E. Lusk, and A. Skjellum. Using MPI: Portable Parallel Programming with the Message-Passing Interface. MIT Press, second edition, 1999.   
+G. Hinton, L. Deng, D. Yu, G. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, Nov. 2012.   
+H. J´egou, M. Douze, and C. Schmid. Product quantization for nearest neighbor search. IEEE PAMI, 33, 2011a.   
+H. J´egou, R. Tavenard, M. Douze, and L. Amsaleg. Searching in one billion vectors: Re-rank with source coding. ICASSP, 2011b.   
+A. Krizhevsky. Learning multiple layers of features from tiny images. Master’s thesis, U. Toronto, 2009.   
+Q. Le, M. Ranzato, R. Monga, M. Devin, G. Corrado, K. Chen, J. Dean, and A. Ng. Building high-level features using large scale unsupervised learning. ICML, 2012.   
+J. Liu and S. J. Wright. Asynchronous stochastic coordinate descent: Parallelism and convergence properties. SIAM J. Optimization, 25(1):351–376, 2015.   
+Y. Low, D. Bickson, J. Gonzalez, C. Guestrin, A. Kyrola, and J. M. Hellerstein. Distributed GraphLab: A framework for machine learning and data mining in the cloud. Proc. VLDB Endowment, 5, 2012.   
+G. J. McLachlan and T. Krishnan. The EM Algorithm and Extensions. Wiley, second edition, 2008.   
+F. Niu, B. Recht, C. R´e, and S. J. Wright. HOGWILD!: A lock-free approach to parallelizing stochastic gradient descent. NIPS, 2011.   
+H. Ouyang, N. He, L. Tran, and A. Gray. Stochastic alternating direction method of multipliers. ICML, 2013.   
+R. Raziperchikolaei and M. A. Carreira-Perpi ˜n´an. Optimizing affinity-based binary ´ hashing using auxiliary coordinates. NIPS, 2016.   
+P. Richt´arik and M. Tak´aˇc. Distributed coordinate descent method for learning with big data. arXiv:1310.2059 [stat.ML], Oct. 8 2013.   
+F. Seide, H. Fu, J. Droppo, G. Li, and D. Yu. 1-bit stochastic gradient descent and its application to data-parallel distributed training of speech DNNs. Interspeech, 2014.   
+A. Talwalkar, S. Kumar, and H. Rowley. Large-scale manifold learning. CVPR, 2008.   
+M. Vladymyrov and M. A. Carreira-Perpi ˜n´an. Locally Linear Landmarks for larg ´ e-scale manifold learning. ECML, 2013.   
+M. Vladymyrov and M. A. Carreira-Perpi ˜n´an. The Variational Nystr¨om method f ´ or large-scale spectral problems. ICML, 2016.   
+W. Wang and M. A. Carreira-Perpi ˜n´an. The role of dimensionality reduct ´ ion in classification. AAAI, 2014.   
+C. K. I. Williams and M. Seeger. Using the Nystr¨om method to speed up kernel machines. NIPS, 2001.   
+S. J. Wright. Coordinate descent algorithms. Math. Prog., 151(1):3–34, June 2016.   
+E. P. Xing, Q. Ho, W. Dai, J. K. Kim, J. Wei, S. Lee, X. Zheng, P. Xie, A. Kumar, and Y. Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Trans. Big Data, 1(2):49–67, Apr.–June 2015.   
+M. Zaharia, M. Chowdhury, M. J. Franklin, S. Shenker, and I. Stoica. Spark: Cluster computing with working sets. In Proc. 2nd USENIX Conf. Hot Topics in Cloud Computing (HotCloud 2010), 2010.   
+R. Zhang and J. Kwok. Asynchronous distributed ADMM algorithm for global variable consensus optimization. ICML, 2014.   
+M. Zinkevich, M. Weimer, A. Smola, and L. Li. Parallelized stochastic gradient descent. NIPS, 2010.

parse/train/SygvTcYee/SygvTcYee_content_list.json

@@ -0,0 +1,792 @@
+[
+    {
+        "type": "text",
+        "text": "PARMAC: DISTRIBUTED OPTIMISATION OF NESTED FUNCTIONS, WITH APPLICATION TO LEARNING BINARY AUTOENCODERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Miguel A. Carreira-Perpi ´ n˜ an & Mehdi Alizadeh ´ EECS, University of California, Merced http://eecs.ucmerced.edu ",
+        "bbox": [
+            183,
+            194,
+            521,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            273,
+            542,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many powerful machine learning models are based on the composition of multiple processing layers, such as deep nets, which gives rise to nonconvex objective functions. A general, recent approach to optimise such “nested” functions is the method of auxiliary coordinates (MAC). MAC introduces an auxiliary coordinate for each data point in order to decouple the nested model into independent submodels. This decomposes the optimisation into steps that alternate between training single layers and updating the coordinates. It has the advantage that it reuses existing single-layer algorithms, introduces parallelism, and does not need to use chain-rule gradients, so it works with nondifferentiable layers. We describe ParMAC, a distributed-computation model for MAC. This trains on a dataset distributed across machines while limiting the amount of communication so it does not obliterate the benefit of parallelism. ParMAC works on a cluster of machines with a circular topology and alternates two steps until convergence: one step trains the submodels in parallel using stochastic updates, and the other trains the coordinates in parallel. Only submodel parameters, no data or coordinates, are ever communicated between machines. ParMAC exhibits high parallelism, low communication overhead, and facilitates data shuffling, load balancing, fault tolerance and streaming data processing. We study the convergence of ParMAC and its parallel speedup, and implement ParMAC using MPI to learn binary autoencoders for fast image retrieval, achieving nearly perfect speedups in a 128-processor cluster with a training set of 100 million high-dimensional points. ",
+        "bbox": [
+            233,
+            306,
+            764,
+            598
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            334,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Serial computing has reached a plateau and parallel, distributed architectures are becoming widely available, from machines with a few cores to cloud computing with 1000s of machines. The combination of powerful nested models with large datasets is a key ingredient to solve difficult problems in machine learning, computer vision and other areas, and it underlies recent successes in deep learning (Hinton et al., 2012; Le et al., 2012; Dean et al., 2012). Unfortunately, parallel computation is not easy, and many good serial algorithms do not parallelise well. The cost of communicating (through the memory hierarchy or a network) greatly exceeds the cost of computing, both in time and energy, and will continue to do so for the foreseeable future. Thus, good parallel algorithms must minimise communication and maximise computation per machine, while creating sufficiently many subproblems (ideally independent) to benefit from as many machines as possible. The load (in runtime) on each machine should be approximately equal. Faults become more frequent as the number of machines increases, particularly if they are inexpensive machines. Machines may be heterogeneous and differ in CPU and memory; this is the case with initiatives such as SETI $@$ home, which may become an important source of distributed computation in the future. Big data applications have additional restrictions. The size of the data means it cannot be stored on a single machine, so distributedmemory architectures are necessary. Sending data between machines is prohibitive because of the size of the data and the high communication costs. In some applications, more data is collected than can be stored, so data must be regularly discarded. In others, such as sensor networks, limited battery life and computational power imply that data must be processed locally. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on machine learning models of the form $\\mathbf { y } = \\mathbf { F } _ { K + 1 } ( \\ldots \\mathbf { F } _ { 2 } ( \\mathbf { F } _ { 1 } ( \\mathbf { x } ) ) \\ldots )$ , i.e., consisting of a nested mapping from the input $\\mathbf { x }$ to the output y. Such nested models involve multiple parameterised layers of processing and include deep neural nets, cascades for object recognition in computer vision or for phoneme classification in speech processing, wrapper approaches to classification or regression, and various combinations of feature extraction/learning and preprocessing prior to some learning task. Nested and hierarchical models are ubiquitous in machine learning because they provide a way to construct complex models by the composition of simple layers. However, training nested models is difficult even in the serial case because function composition produces inherently nonconvex functions, which makes gradient-based optimisation difficult and slow, and sometimes inapplicable (e.g. with nonsmooth or discrete layers). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our starting point is a recently proposed technique to train nested models, the method of auxiliary coordinates (MAC) (Carreira-Perpi ˜n´an and Wang, 2012; 2014). This reformulates the optimisation into an iterative procedure that alternates training submodels independently with coordinating them. It introduces significant model and data parallelism, can often train the submodels using existing algorithms, and has convergence guarantees with differentiable functions to a local stationary point, while it also applies with nondifferentiable or even discrete layers. MAC has been applied to various nested models (Carreira-Perpi ˜n´an and Wang, 2014; Wang and Carreira-Perpi ˜n´an, 2014; Carreira-Perpi ˜n´an and Raziperchikolaei, 2015; Raziperchikolaei and Carreira-Perpi ˜n´an, 2016; Carreira-Perpi ˜n´an and Vladymyrov, 2015). However, the original papers proposing MAC (Carreira-Perpi ˜n´an and Wang, 2012; 2014) did not address how to run MAC on a distributed computing architecture, where communication between machines is far costlier than computation. This paper proposes ParMAC, a parallel, distributed framework to learn nested models using MAC, analyses its parallel speedup and convergence, implements it in MPI for the problem of learning binary autoencoders, and demonstrates its ability to train on large datasets and achieve large speedups on a distributed cluster. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related work Distributed optimisation and large-scale machine learning have been steadily gaining interest in recent years, with the development of parallel computation abstractions tailored to machine learning, such as Spark (Zaharia et al., 2010), GraphLab (Low et al., 2012), Petuum (Xing et al., 2015) or TensorFlow (Abadi et al., 2015), which have the goal of making cloud computing easily available to train machine learning models. Most work has centred on convex optimisation, particularly when the objective function has the form of empirical risk minimisation (data fitting term plus regulariser) (Cevher et al., 2014). This includes many important models in machine learning, such as linear regression, LASSO, logistic regression or SVMs. Such work is typically based on stochastic gradient descent (SGD) (Bottou, 2010), coordinate descent (CD) (Wright, 2016) or the alternating direction method of multipliers (ADMM) (Boyd et al., 2011). This has resulted in several variations of parallel SGD (Bertsekas, 2011; Zinkevich et al., 2010; Niu et al., 2011), parallel CD (Bradley et al., 2011; Richt´arik and Tak´aˇc, 2013; Liu and Wright, 2015) and parallel ADMM (Boyd et al., 2011; Ouyang et al., 2013; Zhang and Kwok, 2014). ",
+        "bbox": [
+            174,
+            472,
+            825,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Little work has addressed nonconvex models. Most of it has focused on deep nets (Dean et al., 2012; Le et al., 2012). Google’s DistBelief (Dean et al., 2012) uses asynchronous parallel SGD (with gradients for the full model computed with backpropagation) to achieve data parallelism, and some form of model parallelism. The latter is achieved by carefully partitioning the neural net into pieces and allocating them to machines to compute gradients. This is difficult to do and requires a careful match of the neural net structure (number of layers and hidden units, connectivity, etc.) to the target hardware. Also, parallel SGD can diverge with nonconvex models, which requires heuristics to make sure we average replica models that are close in parameter space and thus associated with the same optimum. Although this has managed to train huge nets on huge datasets by using tens of thousands of CPU cores, the speedups achieved were very modest. Other work has used similar techniques but for GPUs (Coates et al., 2013; Seide et al., 2014). ",
+        "bbox": [
+            173,
+            660,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, there also exist specific approximation techniques for certain types of large-scale machine learning problems, such as spectral problems, using the Nystr ¨om formula or other landmarkbased methods (Williams and Seeger, 2001; Bengio et al., 2004; Drineas and Mahoney, 2005; Talwalkar et al., 2008; Vladymyrov and Carreira-Perpi ˜n´an, 2013; 2016). ",
+        "bbox": [
+            174,
+            819,
+            823,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ParMAC is specifically designed for nested models, which are typically nonconvex and include deep nets and many other models, some of which have nondifferentiable layers. As we describe below, ParMAC has the advantages of being simple and relatively independent of the target hardware, while achieving high speedups. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            938
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Many optimisation problems in machine learning involve mathematically “nested” functions of the form $\\mathbf { F } ( \\mathbf { x } ; \\mathbf { W } ) = \\bar { \\mathbf { F } } _ { K + 1 } ( . . . \\mathbf { F } _ { 2 } ( \\mathbf { F } _ { 1 } ( \\mathbf { x } ; \\mathbf { W } _ { 1 } ) ; \\mathbf { W } _ { 2 } ) . . . ; \\mathbf { W } _ { K + 1 } )$ with parameters W, such as deep nets. Such problems are traditionally optimised using methods based on gradients computed using the chain rule. However, such gradients may sometimes be inconvenient to use, or may not exist (e.g. if some of the layers are nondifferentiable, as with binary autoencoders). Also, they are hard to parallelise, because of the inherent sequentiality in the chain rule. The method of auxiliary coordinates $( M A C )$ (Carreira-Perpi ˜n´an and Wang, 2012; 2014) is designed to optimise nested models without using chain-rule gradients while introducing parallelism. The idea is to break nested functional relationships judiciously by introducing new variables (the auxiliary coordinates) as equality constraints. These are then solved by optimising a penalised function using alternating optimisation over the original parameters (which we call the W step) and over the coordinates (which we call the $\\mathbf { Z }$ step). The result is a coordination-minimisation (CM) algorithm: the minimisation (W) step updates the parameters by splitting the nested model into independent submodels and training them using existing algorithms, and the coordination $\\mathbf { \\rho } ( \\mathbf { Z } )$ step ensures that corresponding inputs and outputs of submodels eventually match. MAC algorithms have been developed for several nested models so far: deep nets (Carreira-Perpi ˜n´an and Wang, 2014), low-dimensional SVMs (Wang and Carreira-Perpi ˜n´an, 2014), binary autoencoders (Carreira-Perpi ˜n´an and Raziperchikolaei, 2015), affinity-based loss functions for binary hashing (Raziperchikolaei and Carreira-Perpi ˜n´an, 2016) and parametric nonlinear embeddings (Carreira-Perpi ˜n´an and Vladymyrov, 2015). Although this paper proposes and analyses ParMAC in general, our MPI implementation is for the particular case of binary autoencoders. These define a nonconvex nondifferentiable problem, yet its MAC algorithm is simple and effective. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MAC algorithm for binary autoencoders A binary autoencoder $( B A )$ is a usual autoencoder but with a binary code layer. It consists of an encoder $\\mathbf { h } ( \\mathbf { x } )$ that maps a real vector $\\textbf { x } \\in \\mathbb { R } ^ { D }$ onto a binary code vector with $L \\ < \\ D$ bits, $\\mathbf { z } ~ \\in ~ \\{ 0 , 1 \\} ^ { L }$ , and a linear decoder $\\mathbf f ( \\mathbf z )$ which maps $\\mathbf { z }$ back to $\\mathbb { R } ^ { D }$ in an effort to reconstruct $\\mathbf { x }$ . We will call h a binary hash function (see later). Let us write $\\mathbf { h } ( \\mathbf { x } ) = \\mathcal { \\Gamma } ( \\mathbf { A x } )$ (A includes a bias by having an extra dimension $x _ { 0 } = 1$ for each $\\mathbf { x }$ ) where $\\mathbf { A } \\in \\mathbb { R } ^ { L \\times ( D + 1 ) }$ and $\\boldsymbol { \\mathscr { I } } ( t )$ is a step function applied elementwise, i.e., $\\boldsymbol { \\mathrm { \\Sigma } } ( t ) = 1$ if $t \\geq 0$ and $\\boldsymbol { \\mathrm { { J } } } ( t ) = 0$ otherwise. Given a dataset of $D$ -dimensional patterns $\\mathbf { X } = \\left( \\mathbf { x } _ { 1 } , \\ldots , \\mathbf { x } _ { N } \\right)$ , our objective function, which involves the nested model $\\mathbf { y } _ { \\mathrm { { o } } } = \\mathbf { f } ( \\mathbf { h } ( \\mathbf { x } ) )$ , is the usual least-squares reconstruction error $\\begin{array} { r } { E _ { \\mathrm { B A } } ( \\mathbf { h } , \\mathbf { f } ) = \\sum _ { n = 1 } ^ { N } \\| \\mathbf { x } _ { n } - \\mathbf { f } ( \\mathbf { h } ( \\mathbf { x } _ { n } ) ) \\| ^ { 2 } } \\end{array}$ . Optimising this nonconvex, nonsmooth function is NP-complete. Where the gradients do exist wrt A they are zero, so optimisation of $\\mathbf { h }$ using chainrule gradients does not apply. We introduce as auxiliary coordinates the outputs of $\\mathbf { h }$ , i.e., the codes for each of the $N$ input patterns, and obtain the following equality-constrained problem: ",
+        "bbox": [
+            173,
+            446,
+            825,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/55661abc8a7c92840d07386c970d4a74287ea68f31df224f935840f943559d8b.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { h } , \\mathbf { f } , \\mathbf { Z } } \\sum _ { n = 1 } ^ { N } \\left\\| \\mathbf { x } _ { n } - \\mathbf { f } ( \\mathbf { z } _ { n } ) \\right\\| ^ { 2 } \\quad \\mathrm { s . t . } \\quad \\mathbf { z } _ { n } = \\mathbf { h } ( \\mathbf { x } _ { n } ) , \\mathbf { z } _ { n } \\in \\{ 0 , 1 \\} ^ { L } , n = 1 , \\ldots , N .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            618,
+            751,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note the codes are binary. We now apply the quadratic-penalty method and minimise the following objective function while progressively increasing $\\mu$ , so the constraints are eventually satisfied: ",
+        "bbox": [
+            176,
+            665,
+            825,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3c7419974cc79f9df00088d9304b3b2b15bbde14cb93715ed88fbce2d2443561.jpg",
+        "text": "$$\nE _ { { \\cal Q } } ( { \\bf h } , { \\bf f } , { \\bf Z } ; \\mu ) = \\sum _ { n = 1 } ^ { N } \\left\\| { \\bf x } _ { n } - { \\bf f } ( { \\bf z } _ { n } ) \\right\\| ^ { 2 } + \\mu \\left\\| { \\bf z } _ { n } - { \\bf h } ( { \\bf x } _ { n } ) \\right\\| ^ { 2 } \\mathrm { s . t . } { \\bf z } _ { n } \\in \\{ 0 , 1 \\} ^ { L } , n = 1 , \\ldots , N .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            696,
+            790,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, we apply alternating optimisation over $\\mathbf { Z }$ and $\\mathbf { W } = ( \\mathbf { h } , \\mathbf { f } )$ . This gives the following steps: ",
+        "bbox": [
+            173,
+            743,
+            815,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Over $\\mathbf { Z }$ for fixed $( \\mathbf { h } , \\mathbf { f } )$ , this is a binary optimisation on $N L$ variables, but it separates into $N$ independent optimisations each on only $L$ variables, with the form of $\\mathrm { ^ a }$ binary proximal operator (where we omit the index $n$ ): $\\mathrm { m i n } _ { \\mathbf { z } } \\left\\| \\mathbf { x } - \\mathbf { f } ( \\mathbf { z } ) \\right\\| ^ { 2 } + \\mu \\| \\mathbf { z } - \\mathbf { h } ( \\mathbf { x } ) \\| ^ { 2 } \\boldsymbol { \\mathfrak { s } }$ s.t. $\\mathbf { z } \\in \\{ 0 , 1 \\} ^ { L }$ . This can be solved approximately by alternating optimisation over bits. Over $\\mathbf { W } = \\left( \\mathbf { h } , \\mathbf { f } \\right)$ for fixed $\\mathbf { Z }$ , we obtain $L + D$ independent problems: for each of the $L$ single-bit hash functions (which try to predict $\\mathbf { Z }$ optimally from $\\mathbf { X }$ ), each solvable by fitting a linear SVM; and for each of the $D$ linear decoders in f (which try to reconstruct $\\mathbf { X }$ optimally from $\\mathbf { Z }$ ), each a linear least-squares problem. ",
+        "bbox": [
+            215,
+            768,
+            825,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The user must choose a schedule for the penalty parameter $\\mu$ (sequence of values $0 < \\mu _ { 1 } < \\cdots <$ $\\mu _ { \\infty } )$ ). This should increase slowly enough that the binary codes can change considerably and explore better solutions before the constraints are satisfied and the algorithm stops. With BAs, MAC stops for a finite value of $\\mu$ , which occurs whenever $\\mathbf { Z }$ does not change compared to the previous $\\mathbf { Z }$ step. This gives a practical stopping criterion. Carreira-Perpi˜n´an and Raziperchikolaei (2015) give proofs of these statements and further details about the algorithm. Fig. 1 gives the MAC algorithm for BAs. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/28e2837e43709b2989c8ca8d4340a5e869997cd4e9c20d0643554b3b04d037df.jpg",
+        "image_caption": [
+            "Figure 1: MAC algorithm for binary autoencoders. “parfor” indicates a for loop whose iterations are carried out in parallel. The steps over $\\mathbf { h }$ and f can be run in parallel as well. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            831,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            333,
+            825,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The BA was proposed as a way to learn good binary hash functions for fast, approximate information retrieval (Carreira-Perpi ˜n´an and Raziperchikolaei, 2015). Binary hashing (Grauman and Fergus, 2013) has emerged in recent years as an effective way to do fast, approximate nearest-neighbour searches in image databases. The real-valued, high-dimensional image vectors are mapped onto a binary space with $L$ bits and the search is performed there using Hamming distances at a vastly faster speed and smaller memory (e.g. $N = 1 0 ^ { 9 }$ points with $D = 5 0 0$ take $^ { 2 } \\mathrm { T B }$ , but only 8 GB using $L = 6 4$ bits, which easily fits in RAM). As shown by Carreira-Perpi ˜n´an and Raziperchikolaei (2015), training BAs with MAC beats approximate optimisation approaches such as relaxing the codes or the step function in the encoder, and yields state-of-the-art binary hash functions h in unsupervised problems, improving over established approaches such as iterative quantisation (ITQ) (Gong et al., 2013). We focus mostly on linear hash functions because these are, by far, the most used type of hash functions in the literature of binary hashing, due to the fact that computing the binary codes for a test image must be fast at run time. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "MAC in general With a nested function with $K$ layers, we can introduce auxiliary coordinates at each layer. For example, with a neural net, this decouples the weight vector of every hidden unit in the W step, which can be solved as a logistic regression (see Carreira-Perpi ˜n´an and Alizadeh, 2016). For a large net with a large dataset, this affords an enormous potential for parallel computation. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "MAC and EM MAC is very similar to expectation-maximisation (EM) at a conceptual level. EM (McLachlan and Krishnan, 2008) applies generally to many probabilistic models. The resulting algorithm can be very different (e.g. EM for Gaussian mixtures vs EM for hidden Markov models), but it always alternates two steps that conceptually do the following. The E step updates in parallel the posterior probabilities. This separates over data points and is like the $\\mathbf { Z }$ step in MAC, where the posterior probabilities are the auxiliary coordinates, and where the step may be in closed-form or require optimisation, depending on the model. The M step updates in parallel the “submodels”. For a mixture with $M$ components, these are the $M$ Gaussians (means, covariances, proportions). This separates over submodels and is like the W step in MAC. For BAs, the submodels are the $L$ encoders (linear SVMs) and the $D$ decoders (linear regressors); for a neural net, each weight vector of a hidden unit is a submodel (a logistic regressor). For Gaussian mixtures, the M step can be done exactly in one “epoch” because it is a simple average. For MAC, it usually requires optimisation, and so multiple epochs. In fact, ParMAC applies to EM by using $e = 1$ epoch: in the W step, the Gaussians visit each machine circularly and (their averages) are updated on its data; in the $\\mathbf { Z }$ step, each machine updates its posterior probabilities. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the rest of the paper, some readers may find this analogy useful and think of EM for Gaussian mixtures instead of MAC, replacing “submodels” and “auxiliary coordinates” in MAC with “Gaussians” and “posterior probabilities” in EM, respectively. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0935259ff5ddbeac36f41db147d0b66d8970c89e9d73ac600a82da6a50558ab8.jpg",
+        "image_caption": [
+            "Figure 2: ParMAC model with $P = 4$ machines, $M = 1 2$ submodels “ ${ \\bf w } _ { h }$ ” and $N = 4 0$ data points. Submodels $h$ , $h + M$ , $h + 2 M$ and $h + 3 M$ are copies of submodel $h$ , but only one of them is the most currently updated. At the end of the W step all copies are identical. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            816,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 PARMAC: A PARALLEL, DISTRIBUTED COMPUTATION MODEL FOR MAC ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            444,
+            803,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A specific MAC algorithm depends on the model and objective function and on how the auxiliary coordinates are introduced. We can achieve steps that are closed-form, convex, nonconvex, binary, or others. However, we will assume the following always hold: (1) Separability over data points. In the $\\mathbf { Z }$ step, the $N$ subproblems for $\\mathbf { z } _ { 1 } , \\ldots , \\mathbf { z } _ { N }$ are independent, one per data point. Each $\\mathbf { z } _ { n }$ step depends on the current model. (2) Separability over submodels. In the W step, there are $M$ independent submodels, where $M$ depends on the problem. For example, $M$ is the number of hidden units in a deep net, or the number of hash functions and linear decoders in a BA. Each submodel depends on all the data and coordinates. We now show how to turn this into a distributed, low-communication $P a r M A C$ algorithm. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The basic idea in ParMAC is as follows. With large datasets in distributed systems, it is imperative to minimise data movement over the network because the communication time generally far exceeds the computation time in modern architectures. In MAC we have 3 types of data: the original training data $( \\mathbf { X } , \\mathbf { Y } )$ , the auxiliary coordinates $\\mathbf { Z }$ , and the model parameters (the submodels). Usually, the latter type is far smaller. In ParMAC, we never communicate training or coordinate data; each machine keeps a disjoint portion of $( \\mathbf { X } , \\mathbf { Y } , \\mathbf { Z } )$ corresponding to a subset of the points. Only model parameters are communicated, during the W step, following a circular topology, which implicitly implements a stochastic optimisation. The model parameters are the hash functions h and the decoder f for BAs, and the weight vector ${ \\bf w } _ { h }$ of each hidden unit $h$ for deep nets. Let us see this in detail (refer to fig. 2). ",
+        "bbox": [
+            174,
+            611,
+            825,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assume we have $P$ identical processing machines, each with its own memory and CPU, connected through a network in a circular unidirectional topology. Each machine stores a subset of the data points and corresponding coordinates $\\left( \\mathbf { x } _ { n } , \\mathbf { y } _ { n } , \\mathbf { z } _ { n } \\right)$ such that the subsets are disjoint and their union is the entire data. Before the $\\mathbf { Z }$ step starts, each machine contains all the (just updated) submodels. This means that in the $\\mathbf { Z }$ step each machine processes its auxiliary coordinates $\\left\\{ { \\bf z } _ { n } \\right\\}$ independently of all other machines, i.e., no communication occurs. The W step is more subtle. At the beginning of the W step, each machine will contain all the submodels and its portion of the data and (just updated) coordinates. Each submodel must have access to the entire data and coordinates in order to update itself and, since the data cannot leave its home machine, the submodel must go to the data. We achieve this in the circular topology with an asynchronous processing, as follows. Each machine keeps a queue of submodels to be processed, and repeatedly performs the following operations: extract a submodel from the queue, process it on its data and send it to the machine’s successor (which will insert it in its queue). If the queue is empty, the machine waits until it is nonempty. The queue of each machine is initialised with a portion $M / P$ of submodels associated with that machine (e.g. in fig. 2, machine 1’s queue contains submodels 1–3, machine 2 submodels 4–6, etc.). Each submodel carries a counter that is initially 1 and increases every time it visits a machine. When it reaches $P$ , the submodel has visited all machines in sequence and has completed an epoch. We repeat this for $e$ epochs and, to ensure all machines have all final submodels before starting the $\\mathbf { Z }$ step, we run a communication-only epoch $e + 1$ (without computation), where submodels simply move from machine to machine. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since each submodel is updated as soon as it visits a machine, rather than computing the exact gradient once it has visited all machines and then take a step, the W step is really carrying out stochastic steps for each submodel. For example, if the update is done by a gradient step, we are actually implementing stochastic gradient descent (SGD) where the minibatches are of size $N / P$ (or smaller, if we subdivide a machine’s data portion into minibatches, which should be typically the case in practice). From this point of view, we can regard the W step as doing SGD on each submodel in parallel by having each submodel visit the minibatches in each machine. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As described, and as implemented in our experiments, the entire model parameters are communicated $e + 1$ times in a MAC iteration if running e epochs in the W step. We can also run $e$ epochs with only 2 rounds of communication by having a submodel do e consecutive passes within each machine’s data. This reduces the amount of shuffling, but should not be a problem if the data are randomly distributed over machines. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Extensions of ParMAC Data shuffling, which improves the SGD convergence speed, can be achieved without data movement by accessing the local data in random order at each epoch (withinmachine), and by randomising the circular topology at each epoch (across-machine). Load balancing is simple because the work in both W and $\\mathbf { Z }$ steps is proportional to the number of data points $N$ . Hence, if the processing power of machine $p$ is proportional to $\\alpha _ { p } \\ > \\ 0$ , we allocate to it $N \\alpha _ { p } / ( \\alpha _ { 1 } + \\cdot \\cdot \\cdot + \\bar { \\alpha _ { P } } )$ data points. Streaming, i.e., discarding old data and adding new data during training, can be done by adding/removing data within-machine, or by adding/removing machines and updating the circular topology. Fault tolerance is possible because we can still learn a good model even if we lose the data from a machine that fails, and because in the W step we can revert to older copies of the lost submodels residing in other machines. See further details in Carreira-Perpi ˜n´an and Alizadeh (2016). ",
+        "bbox": [
+            174,
+            415,
+            825,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A theoretical model of the parallel speedup We can estimate the runtime of the $\\mathbf { W }$ and $\\mathbf { Z }$ steps assuming there are $M$ independent submodels of the same size in the W step, using $e$ epochs, on a dataset with $N$ training points, distributed over $P$ identical machines (each with $N / P$ points). Let $t _ { r } ^ { \\mathbf { W } }$ be the computation time per submodel and data point in the W step, $t _ { r } ^ { \\mathbf { Z } }$ the computation time per data point in the step, and the communication time per submodel in the W step. Then the runtime of the W and $\\mathbf { Z }$ steps is $\\begin{array} { r } { \\tilde { T } ^ { \\mathbf { W } } ( P ) = \\lceil M / P \\rceil ( t _ { r } ^ { \\mathbf { W } } \\frac { N } { P } + \\dot { t } _ { c } ^ { \\mathbf { W } } ) P e + \\lceil M / P \\rceil t _ { c } ^ { \\mathbf { W } } P } \\end{array}$ and $T ^ { \\mathbf { Z } } ( P ) =$ $\\textstyle M { \\frac { N } { P } } t _ { r } ^ { \\mathbf { Z } }$ P  , respectively. Hence the parallel speedup is (see details in Carreira-Perpi ˜n´an and Alizadeh, ",
+        "bbox": [
+            173,
+            588,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9329d623a08c97837dc752f8469563f75e215cec499bfec6a00e7c84780ae98.jpg",
+        "text": "$$\nS ( P ) = { \\frac { T ( 1 ) } { T ( P ) } } = { \\frac { \\rho { \\frac { 1 } { [ M / P ] } } M P } { { \\frac { 1 } { N } } P ^ { 2 } + \\rho _ { 2 } P + \\rho _ { 1 } { \\frac { 1 } { [ M / P ] } } M } } \\rho _ { 1 } = t _ { r } ^ { \\mathbf { Z } } / ( e + 1 ) t _ { c } ^ { \\mathbf { W } } , \\rho _ { 2 } = e t _ { r } ^ { \\mathbf { W } } / ( e + 1 ) t _ { c } ^ { \\mathbf { W } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            710,
+            797,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho , \\rho _ { 1 }$ and $\\rho _ { 2 }$ are ratios of computation vs communication, dependent on the optimisation algorithm in the W and $\\mathbf { Z }$ steps, and on the performace of the distributed system and MPI library. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hence, if $P \\leq M$ and $M$ is divisible by $P$ we have $\\begin{array} { r } { S ( P ) = P / ( 1 + \\frac { P } { o N } ) } \\end{array}$ and if $P > M$ we have $\\begin{array} { r } { S ( P ) = \\rho M / ( \\rho _ { 2 } + \\rho _ { 1 } \\frac { M } { P } + \\frac { P } { N } ) } \\end{array}$ . In practice, typically we have $\\rho \\ll 1$ ρN  (because communication dominates computation in current architectures) and $\\rho _ { 2 } N \\gg 1$ (large dataset). If we take $P \\ll \\rho _ { 2 } N$ , then $S ( P ) \\approx \\bar { P }$ if $P \\leq M$ and $\\begin{array} { r } { S ( P ) \\approx \\rho M / ( \\rho _ { 2 } + \\rho _ { 1 } \\frac { M } { P } ) } \\end{array}$ if $P > M$ . Hence, the speedup is nearly perfect if using fewer machines than submodels, and otherwise it peaks at $S _ { 1 } ^ { * } = \\rho M / ( \\rho _ { 2 } +$ $2 \\sqrt { \\rho _ { 1 } M / N } ) \\stackrel { \\cdot } { > } M$ for $P = P _ { 1 } ^ { * } = \\sqrt { \\rho _ { 1 } M N } > M$ and decreases thereafter. This affords very large speedups for large datasets and large models. This theoretical speedup matches well our measured ones (see the experiments section), and can be used to determine optimal values for the number of machines $P$ to use in practice (subject to additional constraints, e.g. cost of the machines). ",
+        "bbox": [
+            173,
+            796,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Eq. (3) also shows that we can leave the speedup unchanged by trading off dataset size and computation/communication times, as long as one of these holds: $\\dot { N } t _ { r } ^ { \\mathbf { W } }$ and $N t _ { r } ^ { \\mathbf { Z } }$ remain constant; or $\\mathbf { \\Pi } _ { N / t _ { c } ^ { \\mathbf { W } } } ^ { \\star }$ remains constant; or $t _ { r } ^ { \\mathbf { W } } / t _ { c } ^ { \\mathbf { W } }$ and $t _ { r } ^ { \\mathbf { Z } } / t _ { c } ^ { \\mathbf { W } }$ remain constant. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the BA, we have submodels of different size: encoders of size $D$ and decoders of size $L < D$ . We can model this by “grouping” the $D$ decoders into $L$ groups of $D / L$ decoders each, resulting in $M = 2 L$ equal-size submodels (assuming the ratio of computation and communication times of decoder vs encoder is $L / D < 1 \\rangle$ ). ",
+        "bbox": [
+            174,
+            152,
+            825,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Convergence of ParMAC The only approximation that ParMAC makes to the original MAC algorithm is using SGD in the W step. Since we can guarantee convergence of SGD under certain conditions (e.g. Robbins-Monro schedules), we can recover the original convergence guarantees for MAC to a local stationary point with differentiable layers (see details in Carreira-Perpi ˜n´an and Alizadeh, 2016). This convergence guarantee is independent of the number of layers, models and processors. With nondifferentiable layers, the convergence properties of MAC (and ParMAC) are not well known. In particular, for the binary autoencoder the encoding layer is discrete and the problem is NP-complete. While convergence guarantees are important theoretically, in practical applications with large datasets in a distributed setting one typically runs SGD for just a few epochs, even one or less than one (i.e., we stop SGD before passing through all the data). This typically reduces the objective function to a good enough value as fast as possible, since each pass over the data is very costly. In our experiments, 1–2 epochs in the W step make ParMAC very similar to MAC using an exact step. ",
+        "bbox": [
+            173,
+            226,
+            825,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Circular vs parameter-server topologies We also considered implementing ParMAC using a parameter-server (PS) topology rather than a circular one, but the latter is better. With a PS we do parallel SGD on each submodel independently, i.e., each worker runs SGD on its own submodel replica for a while, sends it to the PS, and this broadcasts an “average” submodel back to the workers, asynchronously. The circular topology does true SGD on each submodel independently from the others. We can show the runtime per iteration using a PS is equal to that of the circular topology only if the server can communicate with $P$ workers simultaneously (rather than sequentially), otherwise it is slower. The reason is the PS has more communication. The PS has some additional disadvantages: parallel SGD converges more slowly than true SGD and is difficult to apply if the W step is nonconvex; and it needs extra machine(s) to act as parameter server(s). The fundamental issue is that both topologies differ in how they employ the available parallelism: the circular topology updates different, independent submodels, while the PS updates replicas of the same submodels. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            590
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            325,
+            628
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MPI implementation of ParMAC for BAs. We have used $\\mathrm { C } / \\mathrm { C } { + + }$ , the GSL and BLAS libraries for mathematical operations, and the Message Passing Interface (MPI) (Gropp et al., 1999) for interprocess communication. MPI is a widely used framework for high-performance parallel computing, available in multiple platforms. It is particularly suitable for ParMAC because of its support of the SPMD (single program, multiple data) model. In MPI, processes in different machines communicate through messages. To receive data, we use the synchronous blocking receive function MPI Recv; the process calling this blocks until the data arrives. To send data we use the buffered blocking send function MPI Bsend. We allocate enough memory and attach it to the system. The process calling MPI Bsend blocks until the buffer is copied to the MPI internal memory; after that, the MPI library takes care of sending the data. See a code snippet in Carreira-Perpi ˜n´an and Alizadeh (2016). ",
+        "bbox": [
+            174,
+            645,
+            825,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Distributed-memory cluster. We used General Computing Nodes from the UCSD Triton Shared Computing Cluster (TSCC), available to the public for a fee. Each node contains 2 8-core Intel Xeon E5-2670 processors (16 cores in total), 64GB RAM (4GB/processor) and a 500GB hard drive. The nodes are connected through a 10GbE network. We used up to $P \\ = \\ 1 2 8$ processors. Carreira-Perpi ˜n´an and Alizadeh (2016) give detailed specs as well as experiments in a sharedmemory machine. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We have used 3 well-known colour image retrieval benchmarks. (1) CIFAR (Krizhevsky, 2009) contains $6 0 0 0 0$ images $N = 5 0 0 0 0$ training and 10 000 test), represented by $D = 3 2 0$ GIST features. (2) SIFT-1M (J´egou et al., 2011a) contains $N = 1 0 ^ { 6 }$ training and $1 0 ^ { 4 }$ test images, each represented by $D = 1 2 8$ SIFT features. (3) SIFT-1B (J´egou et al., 2011a) has three subsets: $1 0 ^ { 9 }$ base vectors where the search is performed, $N = 1 0 ^ { 8 }$ learning vectors used to train the model and $1 0 ^ { 4 }$ query vectors. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance measures. Regarding the quality of the BA and hash functions learnt, we report the retrieval precision $( \\% )$ in the test set using as true neighbours the $K$ nearest images in Euclidean distance in the original space, and as retrieved neighbours in the binary space we use the $k$ nearest images in Hamming distance. We set $( K , k ) = \\bar { ( } 1 0 0 0 , 1 0 0 )$ for CIFAR and $( 1 0 0 0 0 , 1 0 0 0 0 )$ for SIFT-1M. For SIFT-1B, as suggested by the dataset creators, we report the recall $_ { \\ @ \\mathrm { R } }$ : the average number of queries for which the nearest neighbour is ranked within the top $R$ positions (for varying values of $R$ ); in case of tied distances, we place the query as top rank. All these measures are computed offline once the BA is trained. Carreira-Perpi ˜n´an and Alizadeh (2016) give additional measures and experiments. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Models and their parameters. We use BAs with linear encoders (linear SVM) except with SIFT-1B, where we also use kernel SVMs. The decoder is always linear. We set $L = 1 6$ bits (hash functions) for CIFAR and SIFT-1M and $L = 6 4$ bits for SIFT-1B. We initialise the binary codes from truncated PCA ran on a subset of the training set (small enough that it fits in one processor). To train the encoder ( $L$ SVMs) and decoder $D$ linear mappings) with stochastic optimisation, we used the SGD code from (Bottou and Bousquet, 2008), using its default parameter settings. The SGD step size is tuned automatically in each iteration by examining the first $1 0 0 0$ datapoints. We use a multiplicative $\\mu$ schedule $\\mu _ { i } = { \\dot { \\mu } } _ { 0 } a ^ { i }$ where the initial value $\\mu _ { 0 }$ and the factor $a > 1$ are tuned offline in a trial run using a small subset of the data. For CIFAR we use $\\mu _ { 0 } = 0 . 0 0 5$ and $a = 1 . 2$ over 26 iterations $( i = 0 , \\ldots , 2 5 )$ . For SIFT-1M and SIFT-1B we use $\\mu _ { 0 } = 1 0 ^ { - 4 }$ and $a = 2$ over 10 iterations. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of stochastic steps in the W step Fig. 3 shows the effect on the precision on CIFAR of varying the number of epochs within the W step and shuffling the data as a function of the number of processors $P$ . As the number of epochs increases, the W step is solved more exactly (8 epochs is practically exact in this data). Fewer epochs, even just one, cause only a small degradation. The reason is that, although these are relatively small datasets, they contain sufficient redundance that few epochs are sufficient to decrease the error considerably. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This is also helped by the accumulated effect of epochs over MAC iterations. Running more epochs increases the runtime and lowers the parallel speedup in this particular model, because we use few bits $L = 1 6 )$ and therefore few submodels $M = 2 L = 3 2$ ) compared to the number of machines (up to $P = 1 2 8 )$ ), so the W step has less parallelism. The positive effect of data shuffling in the W step is clear: shuffling generally increases the precision with no increase in runtime. ",
+        "bbox": [
+            174,
+            535,
+            485,
+            686
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a5ec6e3fefe1bf4c4dd3f2095ac22c4753a543c8695ba37fd199b7a1cd3b944.jpg",
+        "image_caption": [
+            "Figure 3: Precision in CIFAR dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            540,
+            823,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Speedup The fundamental advantage of ParMAC and distributed optimisation in general is the ability to train on datasets that do not fit in a single machine, and the reduction in runtime because of parallel processing. Fig. 4 shows the “strong scaling” speedups achieved, as a function of the number of machines $P$ for fixed problem size (dataset and model), in CIFAR and SIFT-1M ( $N =$ 50K and 1M training points, respectively). Even though these datasets and especially the number of independent submodels $M = 2 L = 3 2$ effective submodels of the same size, as discussed earlier) are relatively small, the speedups we achieve are nearly perfect for $P \\leq M$ and hold very well for $P > M$ up to the maximum number of machines we used $P = 1 2 8$ in the distributed system). The speedups flatten as the number of W-step epochs (and consequently the amount of communication) increases, because for this experiment the bottleneck is the W step, whose parallelisation ability (i.e., the number of concurrent processes) is limited by $M = 2 L$ (the $\\mathbf { Z }$ step has $N$ independent processes and is never a bottleneck, since $N$ is very large). However, as noted earlier, using 1 to 2 epochs gives a good enough result, very close to doing an exact W step. The runtime for SIFT-1M on $P = 1 2 8$ machines with 8 epochs was 12 minutes and its speedup $1 0 0 \\times$ . This is particularly remarkable given that the original, nested model did not have model parallelism. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/32695e824cb9267e2ea8be1d4074f23439f2373aaed6318782695f84d6fc42d4.jpg",
+        "image_caption": [
+            "Figure 4: Speedup $S ( P )$ as a function of the number of machines $P$ (top: experiment, bottom: theory). The dataset size and number of submodels $( N , M )$ is (50 000, 32) for CIFAR, $( 1 0 ^ { 6 } , 3 2 )$ for SIFT-1M and $( 1 0 ^ { 8 } , 1 2 8 )$ for SIFT-1B. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            99,
+            815,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 also shows the speedups predicted by our theoretical model. We set the parameters $e$ and $N$ to their known values, and $M = 2 L = 3 2$ for CIFAR and SIFT-1M and $M = 2 L = 1 2 8$ for SIFT-1B. For the time parameters, we set $t _ { r } ^ { \\mathbf { W } } = 1$ to fix the time units, and we set $t _ { c } ^ { \\mathbf { W } }$ and $t _ { r } ^ { \\mathbf { Z } }$ by trial and error to achieve a reasonably good fit to the experimental speedups: $t _ { c } ^ { \\mathbf { W } } = 1 0 ^ { 4 }$ for both datasets, and $t _ { r } ^ { \\mathbf { Z } } = 2 0 0$ for CIFAR and 40 for SIFT-1M. Although these are fudge factors, they are in rough agreement with the fact that communicating a weight vector over the network is orders of magnitude slower than updating it with a gradient step, and that the $\\mathbf { Z }$ step is quite slower than the W step because of the binary optimisation it involves. ",
+        "bbox": [
+            173,
+            441,
+            825,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Large-scale experiment SIFT-1B is one of the largest datasets, if not the largest one, that are publicly available for comparing nearest-neighbour search algorithms with known ground-truth (i.e., precomputed exact Euclidean distances for each query to its $k$ nearest vectors in the base set). The training set contains $N = 1 0 0 \\mathrm { { M } }$ vectors, each consisting of 128 SIFT features. We used $L = 6 4$ hash functions $M = 1 2 8$ submodels): linear SVMs as before, and kernel SVMs. These have fixed Gaussian radial basis functions (2 000 centres picked at random from the training set and bandwidth $\\sigma = 1 6 0 ^ { \\circ }$ ), so the only trainable parameters are the weights, and the MAC algorithm does not change except that it operates on a 2 000-dimensional input vector of kernel values, instead of the 128 SIFT features. We use $e = 2$ epochs with shuffling. All these decisions were based on trials on a subset of the training dataset. We initialised the binary codes from truncated PCA trained on a subset of size 1M (recall $\\textcircled { a } \\mathrm { R } { = } 1 0 0 ; 5 5 . 2 \\%$ ), which gave results comparable to the baseline in (J´egou et al., 2011b). ",
+        "bbox": [
+            173,
+            570,
+            825,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We ran ParMAC on the whole training set in the distributed system with 128 processors for 6 iterations and achieved a recall $\\scriptstyle { \\mathcal { Q } } \\mathrm { R } = 1 0 0$ of $6 1 . 5 \\%$ in 29 hours (linear SVM) and $6 6 . 1 \\%$ in 83 hours (kernel SVM). Using a scaled-down model and training set, we estimated that training in one machine (with enough RAM to hold the data and parameters) would take months. The theoretical speedup (fig. 4 right plot, using the same parameters as in SIFT-1M), is nearly perfect (note the plot goes up to $P = 1 0 2 4$ machines, even though our experiments are limited to $P = 1 2 8$ ). This is because $M$ is quite larger and $N$ is much larger than in the previous datasets. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            828
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            308,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Developing parallel, distributed optimisation algorithms for nonconvex problems in machine learning is challenging, as shown by recent efforts by large teams of researchers (Le et al., 2012; Dean et al., 2012). One important advantage of ParMAC is its simplicity. Data and model parallelism arise naturally thanks to the introduction of auxiliary coordinates. The corresponding optimisation subproblems can often be solved reusing existing code as a black box (as with the SGD training of SVMs and linear mappings in the BA). A circular topology is sufficient to achieve a low communication between machines. There is no close coupling between the model structure and the distributed system architecture. This makes ParMAC suitable for architectures as different as supercomputers and data centres. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Further improvements can be made in specific problems. For example, we may have more parallelisation or less dependencies (e.g. the weights of hidden units in layer $k$ of a neural net depend only on auxiliary coordinates in layers $k$ and $k + 1$ ). This may reduce the communication in the W step, by sending to a given machine only the model portion it needs, or by allocating cores within a multicore machine accordingly. The W and $\\mathbf { Z }$ step optimisations can make use of further parallelisation by GPUs or by distributed convex optimisation algorithms. Many more refinements can be done, such as storing or communicating reduced-precision values with little effect of the accuracy. In this paper, we have tried to keep our implementation as simple as possible, because our goal was to understand the parallelisation speedups of ParMAC in a setting as general as possible, rather than trying to achieve the very best performance for a particular dataset, model or distributed system. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            353,
+            318,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have proposed ParMAC, a distributed model for the method of auxiliary coordinates for training nested, nonconvex models in general, analysed its parallel speedup and convergence, and demonstrated it with an MPI-based implementation for a particular case, to train binary autoencoders. MAC creates parallelism by introducing auxiliary coordinates for each data point to decouple nested terms in the objective function. ParMAC is able to translate the parallelism inherent in MAC into a distributed system by 1) using data parallelism, so that each machine keeps a portion of the original data and its corresponding auxiliary coordinates; and 2) using model parallelism, so that independent submodels visit every machine in a circular topology, effectively executing epochs of a stochastic optimisation, without the need for a parameter server and therefore no communication bottlenecks. The convergence properties of MAC (to a stationary point of the objective function) remain essentially unaltered in ParMAC. The parallel speedup can be theoretically predicted to be nearly perfect when the number of submodels is comparable or larger than the number of machines, and to eventually saturate as one continues to increase the number of machines, and indeed this was confirmed in our experiments. ParMAC also makes it easy to account for data shuffling, load balancing, streaming and fault tolerance. Hence, we expect that ParMAC could be a basic building block, in combination with other techniques, for the distributed optimisation of nested models in big data settings. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            604
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            326,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Work supported by a Google Faculty Research Award and by NSF award IIS–1423515. We thank Ramin Raziperchikolaei (UC Merced) for discussions about binary autoencoders, Dong Li (UC Merced) for discussions about MPI and performance evaluation on parallel systems, and Quoc Le (Google) for discussions about Google’s DistBelief system. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            284,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Abadi et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. White paper.   \nY. Bengio, J.-F. Paiement, P. Vincent, O. Delalleau, N. Le Roux, and M. Ouimet. Out-of-sample extensions for LLE, Isomap, MDS, Eigenmaps, and spectral clustering. NIPS, 2004.   \nD. P. Bertsekas. Incremental gradient, subgradient, and proximal methods for convex optimization: A survey. In S. Sra, S. Nowozin, and S. J. Wright, editors, Optimization for Machine Learning. MIT Press, 2011.   \nL. Bottou. Large-scale machine learning with stochastic gradient descent. COMPSTAT, 2010.   \nL. Bottou and O. Bousquet. The tradeoffs of large scale learning. NIPS, 2008.   \nS. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein. Distributed optimization and statistical learning via the alternating direction method of multipliers. Foundations and Trends in Machine Learning, 3, 2011.   \nJ. Bradley, A. Kyrola, D. Bickson, and C. Guestrin. Parallel coordinate descent for $L _ { 1 }$ -regularized loss minimization. ICML, 2011.   \nM. A. Carreira-Perpi ˜n´an and M. Alizadeh. ParMAC: Distribut ´ ed optimisation of nested functions, with application to learning binary autoencoders. arXiv:1605.09114 [cs.LG], May 30 2016.   \nM. A. Carreira-Perpi ˜n´an and M. Vladymyrov. A fast, universa ´ l algorithm to learn parametric nonlinear embeddings. NIPS, 2015.   \nM. A. Carreira-Perpi ˜n´an and W. Wang. Distributed optimizat ´ ion of deeply nested systems. arXiv:1212.5921 [cs.LG], Dec. 24 2012.   \nM. A. Carreira-Perpi ˜n´an and W. Wang. Distributed optimizat ´ ion of deeply nested systems. AISTATS, 2014.   \nV. Cevher, S. Becker, and M. Schmidt. Convex optimization for big data: Scalable, randomized, and parallel algorithms for big data analytics. IEEE Signal Processing Magazine, 31(5):32–43, Sept. 2014.   \nA. Coates, B. Huval, T. Wang, D. Wu, B. Catanzaro, and A. Ng. Deep learning with COTS HPC systems. ICML, 2013.   \nJ. Dean, G. Corrado, R. Monga, K. Chen, M. Devin, Q. Le, M. Mao, M. Ranzato, A. Senior, P. Tucker, K. Yang, and A. Ng. Large scale distributed deep networks. NIPS, 2012.   \nP. Drineas and M. W. Mahoney. On the Nystr¨om method for approximating a Gram matrix for improved kernel-based learning. J. Machine Learning Research, 6:2153–2175, Dec. 2005.   \nY. Gong, S. Lazebnik, A. Gordo, and F. Perronnin. Iterative quantization: A Procrustean approach to learning binary codes for large-scale image retrieval. IEEE PAMI, 2013.   \nK. Grauman and R. Fergus. Learning binary hash codes for large-scale image search. In R. Cipolla, S. Battiato, and G. Farinella, editors, Machine Learning for Computer Vision, pages 49–87. Springer-Verlag, 2013.   \nW. Gropp, E. Lusk, and A. Skjellum. Using MPI: Portable Parallel Programming with the Message-Passing Interface. MIT Press, second edition, 1999.   \nG. Hinton, L. Deng, D. Yu, G. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, Nov. 2012.   \nH. J´egou, M. Douze, and C. Schmid. Product quantization for nearest neighbor search. IEEE PAMI, 33, 2011a.   \nH. J´egou, R. Tavenard, M. Douze, and L. Amsaleg. Searching in one billion vectors: Re-rank with source coding. ICASSP, 2011b.   \nA. Krizhevsky. Learning multiple layers of features from tiny images. Master’s thesis, U. Toronto, 2009.   \nQ. Le, M. Ranzato, R. Monga, M. Devin, G. Corrado, K. Chen, J. Dean, and A. Ng. Building high-level features using large scale unsupervised learning. ICML, 2012.   \nJ. Liu and S. J. Wright. Asynchronous stochastic coordinate descent: Parallelism and convergence properties. SIAM J. Optimization, 25(1):351–376, 2015.   \nY. Low, D. Bickson, J. Gonzalez, C. Guestrin, A. Kyrola, and J. M. Hellerstein. Distributed GraphLab: A framework for machine learning and data mining in the cloud. Proc. VLDB Endowment, 5, 2012.   \nG. J. McLachlan and T. Krishnan. The EM Algorithm and Extensions. Wiley, second edition, 2008.   \nF. Niu, B. Recht, C. R´e, and S. J. Wright. HOGWILD!: A lock-free approach to parallelizing stochastic gradient descent. NIPS, 2011.   \nH. Ouyang, N. He, L. Tran, and A. Gray. Stochastic alternating direction method of multipliers. ICML, 2013.   \nR. Raziperchikolaei and M. A. Carreira-Perpi ˜n´an. Optimizing affinity-based binary ´ hashing using auxiliary coordinates. NIPS, 2016.   \nP. Richt´arik and M. Tak´aˇc. Distributed coordinate descent method for learning with big data. arXiv:1310.2059 [stat.ML], Oct. 8 2013.   \nF. Seide, H. Fu, J. Droppo, G. Li, and D. Yu. 1-bit stochastic gradient descent and its application to data-parallel distributed training of speech DNNs. Interspeech, 2014.   \nA. Talwalkar, S. Kumar, and H. Rowley. Large-scale manifold learning. CVPR, 2008.   \nM. Vladymyrov and M. A. Carreira-Perpi ˜n´an. Locally Linear Landmarks for larg ´ e-scale manifold learning. ECML, 2013.   \nM. Vladymyrov and M. A. Carreira-Perpi ˜n´an. The Variational Nystr¨om method f ´ or large-scale spectral problems. ICML, 2016.   \nW. Wang and M. A. Carreira-Perpi ˜n´an. The role of dimensionality reduct ´ ion in classification. AAAI, 2014.   \nC. K. I. Williams and M. Seeger. Using the Nystr¨om method to speed up kernel machines. NIPS, 2001.   \nS. J. Wright. Coordinate descent algorithms. Math. Prog., 151(1):3–34, June 2016.   \nE. P. Xing, Q. Ho, W. Dai, J. K. Kim, J. Wei, S. Lee, X. Zheng, P. Xie, A. Kumar, and Y. Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Trans. Big Data, 1(2):49–67, Apr.–June 2015.   \nM. Zaharia, M. Chowdhury, M. J. Franklin, S. Shenker, and I. Stoica. Spark: Cluster computing with working sets. In Proc. 2nd USENIX Conf. Hot Topics in Cloud Computing (HotCloud 2010), 2010.   \nR. Zhang and J. Kwok. Asynchronous distributed ADMM algorithm for global variable consensus optimization. ICML, 2014.   \nM. Zinkevich, M. Weimer, A. Smola, and L. Li. Parallelized stochastic gradient descent. NIPS, 2010. ",
+        "bbox": [
+            173,
+            742,
+            826,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            126,
+            826,
+            925
+        ],
+        "page_idx": 10
+    }
+]

parse/train/r1drp-WCZ/r1drp-WCZ.md

@@ -0,0 +1,366 @@
+# STATE SPACE LSTM MODELS WITH PARTICLE MCMC INFERENCE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Long Short-Term Memory (LSTM) is one of the most powerful sequence models. Despite the strong performance, however, it lacks the nice interpretability as in state space models. In this paper, we present a way to combine the best of both worlds by introducing State Space LSTM (SSL) models that generalizes the earlier work Zaheer et al. (2017) of combining topic models with LSTM. However, unlike Zaheer et al. (2017), we do not make any factorization assumptions in our inference algorithm. We present an efficient sampler based on sequential Monte Carlo (SMC) method that draws from the joint posterior directly. Experimental results confirms the superiority and stability of this SMC inference algorithm on a variety of domains.
+
+# 1 INTRODUCTION
+
+State space models (SSMs), such as hidden Markov models (HMM) and linear dynamical systems (LDS), have been the workhorse of sequence modeling in the past decades From a graphical model perspective, efficient message passing algorithms (Stratonovich, 1960; Kalman, 1960) are available in compact closed form thanks to their simple linear Markov structure. However, simplicity comes at a cost: real world sequences can have long-range dependencies that cannot be captured by Markov models; and the linearity of transition and emission restricts the flexibility of the model for complex sequences.
+
+A popular alternative is the recurrent neural networks (RNN), for instance the Long Short-Term Memory (LSTM) (Hochreiter & Schmidhuber, 1997) which has become a standard for sequence modeling nowadays. Instead of associating the observations with stochastic latent variables, RNN directly defines the distribution of each observation conditioned on the past, parameterized by a neural network. The recurrent parameterization not only allows RNN to provide a rich function class, but also permits scalable stochastic optimization such as the backpropagation through time (BPTT) algorithm. However, flexibility does not come for free as well: due to the complex form of the transition function, the hidden states of RNN are often hard to interpret. Moreover, it can require large amount of parameters for seemingly simple sequence models (Zaheer et al., 2017).
+
+In this paper, we propose a new class of models State Space LSTM (SSL) that combines the best of both worlds. We show that SSLs can handle nonlinear, non-Markovian dynamics like RNNs, while retaining the probabilistic interpretations of SSMs. The intuition, in short, is to separate the state space from the sample space. In particular, instead of directly estimating the dynamics from the observed sequence, we focus on modeling the sequence of latent states, which may represent the true underlying dynamics that generated the noisy observations. Unlike SSMs, where the same goal is pursued under linearity and Markov assumption, we alleviate the restriction by directly modeling the transition function between states parameterized by a neural network. On the other hand, we bridge the state space and the sample space using classical probabilistic relation, which not only brings additional interpretability, but also enables the LSTM to work with more structured representation rather than the noisy observations.
+
+Indeed, parameter estimation of such models can be nontrivial. Since the LSTM is defined over a sequence of latent variables rather than observations, it is not straightforward to apply the usual BPTT algorithm without making variational approximations. In Zaheer et al. (2017), which is an instance of SSL, an EM-type approach was employed: the algorithm alternates between imputing the latent states and optimizing the LSTM over the imputed sequences. However, as we show below, the inference implicitly assumes the posterior is factorizable through time. This is a restrictive assumption since the benefit of rich state transition brought by the LSTM may be neutralized by breaking down the posterior over time.
+
+We present a general parameter estimation scheme for the proposed class of models based on sequential Monte Carlo (SMC) (Doucet et al., 2001), in particular the Particle Gibbs (Andrieu et al., 2010). Instead of sampling each time point individually, we directly sample from the joint posterior without making limiting factorization assumptions. Through extensive experiments we verify that sampling from the full posterior leads to significant improvement in the performance.
+
+Related works Enhancing state space models using neural networks is not a new idea. Traditional approaches can be traced back to nonlinear extensions of linear dynamical systems, such as extended or unscented Kalman filters (Julier & Uhlmann, 1997), where both state transition and emission are generalized to nonlinear functions. The idea of parameterizing them with neural networks can be found in Ghahramani & Roweis (1999), as well as many recent works (Krishnan et al., 2015; Archer et al., 2015; Johnson et al., 2016; Krishnan et al., 2017; Karl et al., 2017) thanks to the development of recognition networks (Kingma & Welling, 2014; Rezende et al., 2014). Enriching the output distribution of RNN has also regain popularity recently. Unlike conventionally used multinomial output or mixture density networks (Bishop, 1994), recent approaches seek for more flexible family of distributions such as restricted Boltzmann machines (RBM) (Boulanger-Lewandowski et al., 2012) or variational auto-encoders (VAE) (Gregor et al., 2015; Chung et al., 2015).
+
+On the flip side, there have been studies in introducing stochasticity to recurrent neural networks. For instance, Pachitariu & Sahani (2012) and Bayer & Osendorfer (2014) incorporated independent latent variables at each time step; while in Fraccaro et al. (2016) the RNN is attached to both latent states and observations. We note that in our approach the transition and emission are decoupled, not only for interpretability but also for efficient inference without variational assumptions.
+
+On a related note, sequential Monte Carlo methods have recently received attention in approximating the variational objective (Maddison et al., 2017; Le et al., 2017; Naesseth et al., 2017). Despite the similarity, we emphasize that the context is different: we take a stochastic EM approach, where the full expectation in E-step is replaced by the samples from SMC. In contrast, SMC in above works is aimed at providing a tighter lower bound for the variational objective.
+
+# 2 BACKGROUND
+
+In this section, we provide a brief review of some key ingredients of this paper. We first describe the SSMs and the RNNs for sequence modeling, and then outline the SMC methods for sampling from a series of distributions.
+
+# 2.1 STATE SPACE MODELS
+
+Consider a sequence of observations $\boldsymbol { x } _ { 1 : T } = ( x _ { 1 } , \dots , x _ { T } )$ and a corresponding sequence of latent states $z _ { 1 : T } = ( z _ { 1 } , \dots , z _ { T } )$ . The SSMs are a class of graphical models that defines probabilistic dependencies between latent states and the observations. A classical example of SSM is the (Gaussian) LDS, where real-valued states evolve linearly over time under the first-order Markov assumption. Let $\boldsymbol { x } _ { t } \in \mathbb { R } ^ { d }$ and $\boldsymbol { z } _ { t } \in \mathbb { R } ^ { k }$ , the LDS can be expressed by two equations:
+
+$$
+\begin{array} { r l r } { \mathrm { ( T r a n s i t i o n ) } } & { z _ { t } = A z _ { t - 1 } + \eta , \ } & { \eta \sim \mathcal { N } ( 0 , Q ) } \\ { \mathrm { ( E m i s s i o n ) } } & { x _ { t } = C z _ { t } + \epsilon , \ } & { \epsilon \sim \mathcal { N } ( 0 , R ) , } \end{array}
+$$
+
+where $A \in \mathbb { R } ^ { k \times k }$ , $C \in \mathbb { R } ^ { d \times k }$ , and $Q$ and $R$ are covariance matrices of corresponding sizes. They are widely applied in modeling the dynamics of moving objects, with $z _ { t }$ representing the true state of the system, such as location and velocity of the object, and $x _ { t }$ being the noisy observation under zero-mean Gaussian noise.
+
+We mention two important inference tasks (Koller & Friedman, 2009) associated with SSMs. The first tasks is filtering: at any time $t$ , compute $p ( \boldsymbol { z } _ { t } | \boldsymbol { x } _ { 1 : t } )$ , i.e. the most up-to-date belief of the state $z _ { t }$ conditioned on all past and current observations $x _ { 1 : t }$ . The other task is smoothing, which computes $p ( \boldsymbol { z } _ { t } | \boldsymbol { x } _ { 1 : T } )$ , i.e. the update to the belief of a latent state by incorporating future observations. One of the beauties of SSMs is that these inference tasks are available in closed form, thanks
+
+# Algorithm 1 Sequential Monte Carlo
+
+1. Let $z _ { 0 } ^ { p } = z _ { 0 }$ and weights $\alpha _ { 0 } ^ { p } = 1 / P$ for $p = 1 , \ldots , P$ .
+
+2. For $t = 1 , \dots , T$
+
+(a) Sample ancestors $a _ { t - 1 } ^ { p } \sim \alpha _ { t - 1 }$ for $p = 1 , \ldots , P$ .   
+(c) Set (d) Co $z _ { t } ^ { p } \sim f ( z _ { t } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } )$ $p = 1 , \ldots , P$ $z _ { 1 : t } ^ { p } = ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , z _ { t } ^ { p } )$ $p = 1 , \ldots , P$ $\begin{array} { r } { \alpha _ { t } ^ { p } \propto \frac { \pi _ { t } ( z _ { 1 : t } ^ { p } ) } { \pi _ { t - 1 } ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) f ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) } } \end{array}$ $p = 1 , \ldots , P$
+
+to the simple Markovian dynamics of the latent states. For instance, the forward-backward algorithm (Stratonovich, 1960), the Kalman filter (Kalman, 1960), and RTS smoother (Rauch et al., 1965) are widely appreciated in the literature of HMM and LDS.
+
+Having obtained the closed form filtering and smoothing equations, one can make use of the EM algorithm to find the maximum likelihood estimate (MLE) of the parameters given observations. In the case of LDS, the E-step can be computed by RTS smoother and the M-step is simple subproblems such as least-squares regression. We refer to Ghahramani & Hinton (1996) for a full exposition on learning the parameters of LDS using EM iterations.
+
+# 2.2 RECURRENT NEURAL NETWORKS
+
+RNNs have received remarkable attention in recent years due to their strong benchmark performance as well as successful applications in real-world problems. Unlike SSMs, RNNs aim to directly learn the complex generative distribution of $p \big ( x _ { t } | x _ { 1 : t - 1 } \big )$ using a neural network, with the help of a deterministic internal state $s _ { t }$ :
+
+$$
+p ( x _ { t } | x _ { 1 : t - 1 } ) = p ( x _ { t } ; g ( s _ { t } ) ) , \quad s _ { t } = \mathsf { R N N } ( s _ { t - 1 } , x _ { t - 1 } ) ,
+$$
+
+where $\mathsf { R N N } ( \cdot , \cdot )$ is the transition function defined by a neural network, and $g ( \cdot )$ is an arbitrary differentiable function that maps the RNN state $s _ { t }$ to the parameter of the distribution of $x _ { t }$ . The flexibility of the transformation function allows the RNN to learn from complex nonlinear nonGaussian sequences. Moreover, since the state $s _ { t }$ is a deterministic function of the past observations $x _ { 1 : t - 1 }$ , RNNs can capture long-range dependencies, for instance matching brackets in programming languages (Karpathy et al., 2015).
+
+The BPTT algorithm can be used to find the MLE of the parameters of $\mathsf { R N N } ( \cdot , \cdot )$ and $g ( \cdot )$ . However, although RNNs can, in principle, model long-range dependencies, directly applying BPTT can be difficult in practice since the repeated application of a squashing nonlinear activation function, such as tanh or logistic sigmoid, results in an exponential decay in the error signal through time. LSTMs (Hochreiter & Schmidhuber, 1997) are designed to cope with the such vanishing gradient problems, by introducing an extra memory cell that is constructed as a linear combination of the previous state and signal from the input. In this work, we also use LSTMs as building blocks, as in Zaheer et al. (2017).
+
+# 2.3 SEQUENTIAL MONTE CARLO
+
+Sequential Monte Carlo (SMC) (Doucet et al., 2001) is an algorithm that samples from a series of potentially unnormalized densities $\pi _ { 1 } ( z _ { 1 } ) , . . . , \pi _ { T } ( z _ { 1 : T } )$ . At each step $t$ , SMC approximates the target density $\pi _ { t }$ with $P$ weighted particles using importance distribution $f { \big ( } z _ { t } | z _ { 1 : t - 1 } { \big ) }$ :
+
+$$
+\pi _ { t } ( z _ { 1 : t } ) \approx \hat { \pi } _ { t } ( z _ { 1 : t } ) = \sum _ { p } \alpha _ { t } ^ { p } \delta _ { z _ { 1 : t } ^ { p } } ( z _ { 1 : t } ) ,
+$$
+
+where $\alpha _ { t } ^ { p }$ is the importance weight of the $p$ -th particle and $\delta _ { x }$ is the Dirac point mass at $x$ . Repeating this approximation for every $t$ leads to the SMC method, outlined in Algorithm 1.
+
+The key to this method lies in the resampling, which is implemented by repeatedly drawing the ancestors of particles at each step. Intuitively, it encourages the particles with a higher likelihood to survive longer, since the weight reflects the likelihood of the particle path. The final Monte Carlo estimate (4) consists of only survived particle paths, and sampling from this point masses is equivalent to choosing a particle path according to the last weights $\alpha _ { T }$ . We refer to Doucet et al. (2001); Andrieu et al. (2010) for detailed proof of the method.
+
+![](images/442f673772ccac3d53e3d3bb5f66cbecf4789460d88a7c98e79285a39e72b1c0.jpg)  
+Figure 1: Generative process of SSL.
+
+# 3 STATE SPACE LSTM MODELS
+
+In this section, we present the class of State Space LSTM (SSL) models that combines interpretability of SSMs and flexibility of LSTMs.
+
+The key intuition, motivated by SSMs, is to learn dynamics in the state space, rather than in the sample space. However, we do not assume transition in the state space is linear, Gaussian, or Markovian. Existing approaches such as the extended Kalman filter (EKF) attempted to work with a general nonlinear transition function. Unfortunately, additional flexibility also introduced extra difficulty in the parameter estimation: EKF relies heavily on linearizing the nonlinear functions. We propose to use LSTM to model the dynamics in the latent state space, as they can learn from complex sequences without making limiting assumptions. The BPTT algorithm is also well established so that no additional approximation is needed in training the latent dynamics.
+
+Generative process Let $h ( \cdot )$ be the emission function that maps a latent state to a parameter of the sample distribution. As illustrated in Figure 1 (a), the generative process of SSL for a single sequence is:
+
+• For $t = 1 , \dots , T$ : 1. Perform LSTM transition: $\boldsymbol { s } _ { t } = \mathsf { L S T M } \left( \boldsymbol { s } _ { t - 1 } , \boldsymbol { z } _ { t - 1 } \right)$ 2. Draw latent state: $z _ { t } \sim p ( z ; g ( s _ { t } ) )$ 3. Draw observation: $x _ { t } \sim p ( x ; h ( z _ { t } ) )$
+
+The generative process specifies the following joint likelihood, with a similar factorization as SSMs except for the Markov transition:
+
+$$
+p ( x _ { 1 : T } , z _ { 1 : T } ) = \prod _ { t = 1 } ^ { T } p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \phi } ( x _ { t } | z _ { t } ) ,
+$$
+
+where $p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) = p ( z _ { t } ; g ( s _ { t } ) )$ , $\omega$ is the set of parameters of $\mathsf { L S T M } ( \cdot , \cdot )$ and $g ( \cdot )$ , and $\phi$ is the parameters of $h ( \cdot )$ . The structure of the likelihood function is better illustrated in Figure 1 (b), where each latent state $z _ { t }$ is dependent to all previous states $z _ { 1 : t - 1 }$ after substituting $s _ { t }$ recursively. This allows the SSL to have non-Markovian state transition, with parsimonious parameterization thanks to the recurrent structure of LSTMs.
+
+Parameter estimation We continue with a single sequence for the ease of notation. A variational lower bound to the marginal data likelihood is given by
+
+$$
+\log p ( x _ { 1 : T } ) \geq \mathbb { E } _ { q } \left[ \log \frac { p _ { \omega } ( z _ { 1 : T } ) p _ { \phi } ( x _ { 1 : T } | z _ { 1 : T } ) } { q ( z _ { 1 : T } ) } \right] ,
+$$
+
+where $q \big ( z _ { 1 : T } \big )$ is the variational distribution. Following the (stochastic) EM approach, iteratively maximizing the lower bound w.r.t. $q$ and the model parameters $( \omega , \phi )$ leads to the following updates:
+
+• E-step: The optimal variational distribution is given by the posterior:
+
+$$
+\begin{array} { r } { q ^ { \star } ( z _ { 1 : T } ) \propto p _ { \omega } ( z _ { 1 : T } ) p _ { \phi } ( x _ { 1 : T } | z _ { 1 : T } ) . } \end{array}
+$$
+
+In the case of LDS or HMM, efficient smoothing algorithms such as the RTS smoother or the forward-backward algorithm are available for computing the posterior expectations of sufficient statistics. However, without Markovian state transition, although the forward messages can still be computed, the backward recursion can no longer evaluated or efficiently approximated.
+
+• S-step: Due to the difficulties in taking expectations, we take an alternative approach to collect posterior samples instead:
+
+$$
+z _ { 1 : T } ^ { \star } \sim q ^ { \star } ( z _ { 1 : T } ) ,
+$$
+
+given only the filtering equations. We discuss the posterior sampling algorithm in detail in the next section.
+
+• M-step: Given the posterior samples $z _ { 1 : T } ^ { \star }$ , which can be seen as Monte Carlo estimate of the expectations, the subproblem for $\omega$ and $\phi$ are
+
+$$
+\omega ^ { \star } = \underset { \omega } { \mathrm { a r g m a x } } ~ \log p _ { \omega } ( z _ { 1 : T } ^ { \star } ) , \quad \phi ^ { \star } = \underset { \phi } { \mathrm { a r g m a x } } ~ \sum _ { t } \log p _ { \phi } ( x _ { t } | z _ { t } ^ { \star } ) ,
+$$
+
+which is exactly the MLE of an LSTM, with $z _ { 1 : T } ^ { \star }$ serving as the input sequence, and the MLE of the given emission model.
+
+Having seen the generative model and the estimation algorithm, we can now discuss some instances of the proposed class of models. In particular, we provide two examples of SSL, for continuous and discrete latent states respectively.
+
+Example 1 (Gaussian SSL) Suppose $z _ { t }$ and $x _ { t }$ are real-valued vectors. A typical choice of the transition and emission is the Gaussian distribution:
+
+$$
+\begin{array} { r l } & { p ( z _ { t } ; g ( s _ { t } ) ) = \mathcal { N } ( z _ { t } ; g _ { \mu } ( s _ { t } ) , g _ { \sigma } ( s _ { t } ) ) } \\ & { p ( x _ { t } ; h ( z _ { t } ) ) = \mathcal { N } ( x _ { t } ; h _ { \mu } ( z _ { t } ) , h _ { \sigma } ( z _ { t } ) ) , } \end{array}
+$$
+
+where $g _ { \mu } ( \cdot )$ and $g _ { \sigma } ( \cdot )$ map to the mean and the covariance of the Gaussian respectively, and similarly $h _ { \mu } ( \cdot )$ and $h _ { \sigma } ( \cdot )$ . For closed form estimates for the emission parameters, one can further assume
+
+$$
+h _ { \mu } ( z _ { t } ) = C z _ { t } + b , \quad h _ { \sigma } ( z _ { t } ) = R ,
+$$
+
+where $C$ is a matrix that maps from state space to sample space, and $R$ is the covariance matrix with appropriate size. The MLE of $\phi = ( C , b , R )$ is then given by the least squares fit.
+
+Example 2 (Topical SSL, (Zaheer et al., 2017)) Consider $x _ { 1 : T }$ as the sequence of websites a user has visited. One might be tempted to model the user behavior using an LSTM, however due to the enormous size of the Internet, it is almost impossible to even compute a softmax output to get a discrete distribution over the websites. There are approximation methods for large vocabulary problems in RNN, such as the hierarchical softmax (Morin & Bengio, 2005). However, another interesting approach is to operate on a sequence with a “compressed” vocabulary, while learning how to perform such compression at the same time.
+
+Let $z _ { t }$ be the indicator of a “topic”, which is a distribution over the vocabulary as in Blei et al. (2003). Accordingly, define
+
+$$
+\begin{array} { r l } & { p ( z _ { t } ; g ( s _ { t } ) ) = \mathsf { M u l t i n o m i a l } ( z _ { t } ; \mathsf { s o f t m a x } ( W s _ { t } + b ) ) } \\ & { p ( x _ { t } ; h ( z _ { t } ) ) = \mathsf { M u l t i n o m i a l } ( x _ { t } ; \phi _ { z _ { t } } ) , } \end{array}
+$$
+
+where $W$ is a matrix that maps LSTM states to latent states, $b$ is a bias term, and $\phi _ { z _ { t } }$ is a point in the probability simplex. If $z _ { t }$ lies in a lower dimension than $x _ { t }$ , the LSTM is effectively trained over a sequence $z _ { 1 : T }$ with a reduced vocabulary. On the other hand, the probabilistic mapping between $z _ { t }$ and $x _ { t }$ is interpretable, as it learns to group similar $x _ { t }$ ’s together. The estimation of $\phi$ is typically performed under a Dirichlet prior, which then corresponds to the MAP estimate of the Dirichlet distribution (Zaheer et al., 2017).
+
+# 4 INFERENCE WITH PARTICLE GIBBS
+
+In this section, we discuss how to draw samples from the posterior (7), corresponding to the S-step of the stochastic EM algorithm:
+
+$$
+z _ { 1 : T } ^ { \star } \sim p ( z _ { 1 : T } | x _ { 1 : T } ) = \frac { \prod _ { t } p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \phi } ( x _ { t } | z _ { t } ) } { \int \prod _ { t } p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \phi } ( x _ { t } | z _ { t } ) \mathrm { d } z _ { 1 : T } } .
+$$
+
+Assuming the integration and normalization can be performed efficiently, the following quantities can be evaluated in the forward pass without Markov state transition:
+
+$$
+\begin{array} { r l } & { \alpha _ { t } \equiv p ( x _ { t } | z _ { 1 : t - 1 } ) \propto \displaystyle \int p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \phi } ( x _ { t } | z _ { t } ) \mathrm { d } z _ { t } } \\ & { \gamma _ { t } \equiv p ( z _ { t } | z _ { 1 : t - 1 } , x _ { t } ) \propto p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \phi } ( x _ { t } | z _ { t } ) . } \end{array}
+$$
+
+The task is to draw from the joint posterior of $z _ { 1 : T }$ only given access to these forward messages.
+
+One way to circumvent the tight dependencies in $z _ { 1 : T }$ is to make a factorization assumption, as in Zaheer et al. (2017). More concretely, the joint distribution is decomposed as
+
+(factorization assumption)
+
+$$
+p ( z _ { 1 : T } | x _ { 1 : T } ) \propto \prod _ { t } p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ^ { \mathrm { p r e v } } ) p _ { \phi } ( x _ { t } | z _ { t } ) ,
+$$
+
+where $z _ { 1 : t - 1 } ^ { \mathrm { p r e v } }$ is the assignments from the previous inference step. However, as we confirm in the experiments, this assumption can be restrictive since the flexibility of LSTM state transitions is offset by considering each time step independently.
+
+In this work, we propose to use a method based on SMC, which is a principled way of sampling from a sequence of distributions. More importantly, it does not require the model to be Markovian (Frigola et al., 2013; Lindsten et al., 2014). As described earlier, the idea is to approximate the posterior (15) with point masses, i.e., weighted particles. Let $f ( \boldsymbol { z } _ { t } | \boldsymbol { z } _ { 1 : t - 1 } , \boldsymbol { x } _ { t } )$ be the importance density, and $P$ be the number of particles. We then can run Algorithm 1 with $\pi _ { t } ( z _ { 1 : t } ) \stackrel { - } { = } p ( x _ { 1 : t } , z _ { 1 : t } )$ being the unnormalized target distribution at time $t$ , where the weight becomes
+
+$$
+\alpha _ { t } ^ { p } \propto \frac { p ( z _ { 1 : t } ^ { p } , x _ { 1 : t } ) } { p ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { 1 : t - 1 } ) f ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { t } ) } = \frac { p _ { \omega } ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) p _ { \phi } ( x _ { t } | z _ { t } ^ { p } ) } { f ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { t } ) } .
+$$
+
+As for the choice of the proposal distribution $f ( \cdot )$ , one could use the transition density $p _ { \omega } \big ( z _ { t } | z _ { 1 : t - 1 } \big )$ , in which case the algorithm is also referred to as the bootstrap particle filter. An alternative is the predictive distribution, a locally optimal proposal in terms of variance (Andrieu et al., 2010):
+
+$$
+f ^ { \star } ( z _ { t } | z _ { 1 : t - 1 } , x _ { t } ) = \frac { p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \phi } ( x _ { t } | z _ { t } ) } { \int p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \phi } ( x _ { t } | z _ { t } ) \mathrm { d } z _ { t } } ,
+$$
+
+which is precisely one of the available forward messages:
+
+$$
+\gamma _ { t } ^ { p } = f ^ { \star } ( z _ { t } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { t } ) .
+$$
+
+Notice the similarity between terms in (19) and (20). Indeed, with the choice of predictive distribution as the proposal density, the importance weight simplifies to
+
+$$
+\alpha _ { t } ^ { p } \propto \tilde { \alpha } _ { t } ^ { p } = \int p _ { \omega } ( z _ { t } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) p _ { \phi } ( x _ { t } | z _ { t } ) \mathrm { d } z _ { t } , ,
+$$
+
+which is not a coincidence that the name collides with the message $\alpha _ { t }$ . Interestingly, this quantity no longer depends on the current particle $z _ { t } ^ { p }$ . Instead, it marginalizes over all possible particle assignments of the current time step. This is beneficial computationally since the intermediate terms from (20) can be reused in (22). Also note that the optimal proposal relies on the fact that the normalization in (20) can be performed efficiently, otherwise the bootstrap proposal should be used.
+
+After a full pass over the sequence, the algorithm produces Monte Carlo approximation of the posterior and the marginal likelihood:
+
+$$
+\hat { p } ( z _ { 1 : T } | x _ { 1 : T } ) = \sum _ { p } \alpha _ { T } ^ { p } \delta _ { z _ { 1 : T } ^ { p } } \left( z _ { 1 : T } \right) , \quad \hat { p } ( x _ { 1 : T } ) = \prod _ { t } \frac { 1 } { P } \sum _ { p } \tilde { \alpha } _ { t } ^ { p } .
+$$
+
+# Algorithm 2 Inference with Particle Gibbs
+
+1. Let $z _ { 0 } ^ { p } = z _ { 0 }$ and $\alpha _ { 0 } ^ { p } = 1 / P$ for $p = 1 , \ldots , P$ .
+
+2. For $t = 1 , \dots , T$
+
+(a) Fix reference path: set $a _ { t - 1 } ^ { 1 } = 1$ and $z _ { 1 : t } ^ { 1 } = z _ { 1 : t } ^ { \star }$ from previous iteration.   
+(b) Sample ancestors $a _ { t - 1 } ^ { p } \sim \alpha _ { t - 1 }$ for $p = 2 , \ldots , P$ .   
+(c) Sample particles $z _ { t } ^ { p } \sim \gamma _ { t } ^ { p }$ and set $z _ { 1 : t } ^ { p } = ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , z _ { t } ^ { p } )$ for $p = 2 , \ldots , P$ .   
+(d) Compute normalized weights $\alpha _ { t } ^ { p }$ for $p = 1 , \ldots , P$ .
+
+3. Sample $r \sim \alpha _ { T }$ , return the particle path $z _ { 1 : T } ^ { a _ { T } ^ { r } }$
+
+The inference is completed by a final draw from the approximate posterior,
+
+$$
+z _ { 1 : T } ^ { \star } \sim \hat { p } \big ( z _ { 1 : T } | x _ { 1 : T } \big ) ,
+$$
+
+which is essentially sampling a particle path indexed by the last particle. Specifically, the last particle $z _ { T } ^ { p }$ is chosen according to the final weights $\alpha _ { T }$ , and then earlier particles can be obtained by tracing backwards to the beginning of the sequence according to the ancestry indicators $a _ { t } ^ { p }$ at each position.
+
+Since SMC produces a Monte Carlo estimate, as the number of particles $P \to \infty$ the approximate posterior (23) is guaranteed to converge to the true posterior for a fixed sequence. However, as the length of the sequence $T$ increases, the number of particles needed to provide a good approximation grows exponentially. This is the well-known depletion problem of SMC (Andrieu et al., 2010).
+
+One elegant way to avoid simulating enormous number of particles is to marry the idea of MCMC with SMC (Andrieu et al., 2010). The idea of such Particle MCMC (PMCMC) methods is to treat the particle estimate $\hat { p } ( \cdot )$ as a proposal, and design a Markov kernel that leaves the target distribution invariant. Since the invariance is ensured by the MCMC, it does not demand SMC to provide an accurate approximation to the true distribution, but only to give samples that are approximately distributed according to the target. As a result, for any fixed $P > 0$ the PMCMC methods ensure the target distribution is invariant.
+
+We choose the Gibbs kernel that requires minimal modification from the basic SMC. The resulting algorithm is Particle Gibbs (PG), which is a conditional SMC update in a sense that a reference path $z _ { 1 : T } ^ { \mathrm { r e f } }$ with its ancestral lineage is fixed throughout the particle propagation of SMC. It can be shown that this simple modification to SMC produces a transition kernel that is not only invariant, but also ergodic under mild assumptions. In practice, we use the assignments from previous step as the reference path. The final algorithm is summarized in Algorithm 2. Combined with the stochastic EM outer iteration, the final algorithm is an instance of the particle SAEM (Lindsten, 2013; Schon¨ et al., 2015), under non-Markovian state transition.
+
+We conclude this section by deriving forward messages for the previous examples.
+
+Example 1 (Gaussian SSL, continued) The integration and normalization preserves normality thanks to the Gaussian identify. The messages are given by
+
+$$
+\begin{array} { r l } & { \alpha _ { t } = \mathcal { N } \left( x _ { t } ; C g _ { \mu } ( s _ { t } ) + b , R + C [ g _ { \sigma } ( s _ { t } ) ] ^ { - 1 } C ^ { T } \right) } \\ & { \gamma _ { t } = \mathcal { N } \left( z _ { t } ; V \left( C ^ { T } R ^ { - 1 } ( x _ { t } - b ) + [ g _ { \sigma } ( s _ { t } ) ] ^ { - 1 } g _ { \mu } ( s _ { t } ) \right) , V \right) , } \end{array}
+$$
+
+where $V = \left( [ g _ { \sigma } ( s _ { t } ) ] ^ { - 1 } + C ^ { T } R ^ { - 1 } C \right) ^ { - 1 }$
+
+Example 2 (Topical SSL, continued) Let $\theta _ { t } = \mathsf { s o f t m a x } ( W s _ { t } + b )$ . Since the distributions are discrete, we have
+
+$$
+\begin{array} { r } { \alpha _ { t } \propto \left. \theta _ { t } , \phi _ { x _ { t } } \right. , \quad \gamma _ { t } \propto \theta _ { t } \circ \phi _ { x _ { t } } , } \end{array}
+$$
+
+where $\circ$ denotes element-wise product. Note that the integration for $\alpha _ { t }$ corresponds to a summation in the state space. It is then normalized across $P$ particles to form a weight distribution. For $\gamma _ { t }$ the normalization is performed in the state space as well, hence the computation of the messages are manageable.
+
+![](images/c389f9d873dbf3528420ad348381281516867b0bc9855eecef7c4129be37985b.jpg)  
+Figure 2: Tracking a synthetic trajectory. Top row: true trajectory and noisy observations. Middle row: training/testing performance of LSTM. Bottom row: training/testing performance of SSL.
+
+# 5 EXPERIMENTS
+
+We now present empirical studies for our proposed model and inference (denoted as SMC) in order to establish that (1) SSL is flexible in capturing underlying nonlinear dynamics, (2) our inference is accurate yet easily applicable to complicated models, and (3) it opens new avenues for interpretable yet nonlinear and non-Markovian sequence models, previously unthinkable. To illustrate these claims, we evaluate on (1) synthetic sequence tracking of varying difficulties, (2) language modeling, and (3) user modeling utilizing complicated models for capturing the intricate dynamics. For SMC inference, we gradually increase the number of particles $P$ from 1 to $K$ during training.
+
+Software & hardware All the algorithms are implemented on TensorFlow (Abadi et al., 2016). We run our experiments on a commodity machine with Intel
+
+# 5.1 SYNTHETIC SEQUENCE TRACKING
+
+To test the flexibility of SSL, we begin with inference using synthetic data. We consider four different dynamics in 2D space: (i) a straight line, (ii) a sine wave, (iii) a circle, and (iv) a swiss role. Note that we do not add additional states such as velocity, keeping the dynamics nonlinear except for the first case. Data points are generated by adding zero mean Gaussian noise to the true underlying dynamics. The true dynamics and the noisy observations are plotted in the top row of Figure 2. The first $60 \%$ of the sequence is used for training and the rest is left for testing.
+
+The middle and bottom row of Figure 2 show the result of SSL and vanilla LSTM trained for same number of iterations until both are sufficiently converged. The red points refer to the prediction of $z _ { t }$ after observing $x _ { 1 : t }$ , and the green points are blind predictions without observing any data. We can observe that while both methods are capturing the dynamics well in general, the predictions of LSTM tend to be more sensitive to initial predictions. In contrast, even when the initial predictions are not incorrect, SSL can recover in the end by remaining on the latent dynamic.
+
+# 5.2 LANGUAGE MODELING
+
+For Topical SSL, we compare our SMC inference method with the factored old algorithm (Zaheer et al., 2017) on the publicly available Wikipedia dataset, where documents with less than 500 words are excluded and the most frequent $2 0 0 \mathrm { k }$ word types are retained. We train on the first $60 \%$ of the documents and test on the rest, using the same settings in Zaheer et al. (2017). Figure 3 shows the test perplexity (lower is better) and number of nonzeros in the learned word topic count matrix (lower is better). In all cases, the SMC inference method consistently outperforms the old factored method. For comparison, we also run LSTM with the same number of parameters, which gives the lowest test perplexity of 1942.26. However, we note that LSTM needs to perform expensive linear transformation for both embedding and softmax at every step, which depends linearly on the vocabulary size $V$ . In contrast, SSL only depends linearly on number of topics $K \ll V$ .
+
+![](images/0c177253ec0fa3f9b37445f369bed90a7cc1bf22a44e3659e7e2d49ed6e251a6.jpg)  
+Figure 3: Comparison of the new inference method based on SMC to the older one assuming factored model. The top row represents perplexity on the held out set and the lower row represents the non zero entries in the word-topic count matrix. Lower perplexity indicates a better fit to the data and lower NNZ results in a sparser model and usually having better generalization.
+
+Ablation study We also want to explore the benefit of the newer inference as dataset size increases. We observe that in case of natural languages which are highly structured the gap between factored approximation and accurate SMC keeps reducing as dataset size increases. But as we will see in case of user modeling when the dataset is less structured, the factored as
+
+![](images/c781e093801aa6ca163e3cfd923825e549e0a8c317268fc40d76c6def88f5fb6.jpg)  
+Figure 4: Comparison between SMC and factored algorithm bysumption leads to poorer perforvarying number of topics and documentsmance. Also when the data size is fixed and the number of topics are varying, the SMC algorithm gives better perplexity compared to the old algorithm. Therefore we the SMC inference is consistently better in various settings.
+
+Visualizing particle paths In Figure 5, we show the particle paths on a snippet of an article about a music album 1. As we can see from the top row, which plots the particle paths at the initial iteration, the model proposed a number of candidate topic sequences since it is uncertain about the latent semantics yet. However, after 100 epochs, as we can see from the bottom row, the model is much more confident about the underlying topical transition. Moreover, by inspecting the learned parameters $\phi$ of the probabilistic emission, we can see that the topics are highly concentrated on topics related to music and time. This confirms our claim about flexible sequence modeling while retaining interpretability.
+
+![](images/d05a137be6025677c0f4232c7cc46782d72893ccaae0dacc34808e142402d1ff.jpg)  
+Figure 5: Particle paths of a document about a music album. Top row: at epoch 1. Bottom row: at epoch 100. After epoch 100 the document has converged to a sparse set of relevant topics.
+
+# 5.3 USER MODELING
+
+We use an anonymized sample of user search click history to measure the accuracy of different models on predicting users future clicks. An accurate model would enable better user experience by presenting the user with relevant content. The dataset is anonymized by removing all items appearing less than a given threshold, this results in a dataset with 100K vocabulary and we vary the number of users from 500K to 1M.
+
+We fix the number of topics at 500 for all user experiments. We used the same setup to the one used in the experiments over the Wikipedia dataset for parameters. The dataset is less structured than the language modeling task since users click patterns are less predictable than the sequence of words which follow definite syntactic rules. As shown in table 1, the benefit of new inference method is highlighted as it yields much lower perplexity than the factored model.
+
+Table 1: Comparison on user data   
+
+<table><tr><td rowspan="2">Algorithm</td><td colspan="2">#Users</td></tr><tr><td>500k</td><td>1M</td></tr><tr><td>Factored</td><td>2430</td><td>2254</td></tr><tr><td>SMC</td><td>1464</td><td>1447</td></tr></table>
+
+# 6 DISCUSSIONS & CONCLUSION
+
+In this paper we revisited the problem of posterior inference in Latent LSTM models as introduced in Zaheer et al. (2017). We generalized their model to accommodate a wide variety of state space models and most importantly we provided a more principled Sequential Monte-Carlo (SMC) algorithm for posterior inference. Although the newly proposed inference method can be slower, we showed over a variety of dataset that the new SMC based algorithm is far superior and more stable. While computation of the new SMC algorithm scales linearly with the number of particles, this can be naively parallelized. In the future we plan to extend our work to incorporate a wider class of dynamically changing structured objects such as time-evolving graphs.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, and Others. TensorFlow: Large-Scale Machine Learning on Heterogeneous Systems. arXiv preprint arXiv:1603.04467, 2016.
+
+Christophe Andrieu, Arnaud Doucet, and Roman Holenstein. Particle Markov chain Monte Carlo methods. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 72(3):269– 342, 2010.
+
+Evan Archer, Il Memming Park, Lars Buesing, John P. Cunningham, and Liam Paninski. Black box variational inference for state space models. arXiv preprint arXiv:1511.07367, 2015.
+
+Justin Bayer and Christian Osendorfer. Learning Stochastic Recurrent Networks. arXiv preprint arXiv:1411.7610, 2014.
+
+Christopher M. Bishop. Mixture Density Networks. Technical report, 1994.
+
+David M. Blei, Andrew Y. $\mathrm { N g }$ , and Michael I. Jordan. Latent Dirichlet Allocation. Journal of Machine Learning Research, 3:993–1022, 2003. ISSN 15324435.
+
+Nicolas Boulanger-Lewandowski, Yoshua Bengio, and Pascal Vincent. Modeling Temporal Dependencies in High-Dimensional Sequences: Application to Polyphonic Music Generation and Transcription. In ICML, 2012.
+
+Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron Courville, and Yoshua Bengio. A Recurrent Latent Variable Model for Sequential Data. In NIPS, 2015.
+
+Arnaud Doucet, Nando de Freitas, and Neil Gordon. Sequential Monte Carlo Methods in Practice. Springer, 2001.
+
+Marco Fraccaro, Søren Kaae Sønderby, Ulrich Paquet, and Ole Winther. Sequential Neural Models with Stochastic Layers. In NIPS, 2016.
+
+Roger Frigola, Fredrik Lindsten, Thomas B. Schon, and Carl E. Rasmussen. Bayesian Inference and ¨ Learning in Gaussian Process State-Space Models with Particle MCMC. In NIPS, 2013.
+
+Zoubin Ghahramani and Geoffrey E. Hinton. Parameter estimation for linear dynamical systems. Technical report, 1996.
+
+Zoubin Ghahramani and Sam T. Roweis. Learning Nonlinear Dynamical Systems using an EM Algorithm. In NIPS, 1999.
+
+Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. DRAW: A Recurrent Neural Network For Image Generation. In ICML, 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, 1997.
+
+Matthew J. Johnson, David Duvenaud, Alexander B. Wiltschko, Sandeep R. Datta, and Ryan P. Adams. Composing graphical models with neural networks for structured representations and fast inference. In NIPS, 2016.
+
+Simon J. Julier and Jeffrey K. Uhlmann. A new extension of the Kalman filter to nonlinear systems. In Int. symp. aerospace/defense sensing, simul. and controls1, 1997.
+
+Rudolph Emil Kalman. A New Approach to Linear Filtering and Prediction Problems. Journal of Basic Engineering, 82(1):35–45, 1960. ISSN 00219223.
+
+Maximilian Karl, Maximilian Soelch, Justin Bayer, and Patrick van der Smagt. Deep variational Bayes filters: Unsupervised learning of state space models from raw data. In ICLR, 2017.
+
+Andrej Karpathy, Justin Johnson, and Li Fei-Fei. Visualizing and understanding recurrent networks. arXiv preprint arXiv:1506.02078, 2015.
+
+Diederik P. Kingma and Max Welling. Auto-Encoding Variational Bayes. In ICLR, 2014.
+
+Daphne Koller and Nir Friedman. Probabilistic Graphical Models: Principles and Techniques. MIT Press, 2009.   
+Rahul G. Krishnan, Uri Shalit, and David Sontag. Deep Kalman Filters. arXiv preprint arXiv:1511.05121, 2015.   
+Rahul G. Krishnan, Uri Shalit, and David Sontag. Structured Inference Networks for Nonlinear State Space Models. In AAAI, 2017.   
+Tuan Anh Le, Maximilian Igl, Tom Jin, Tom Rainforth, and Frank Wood. Auto-Encoding Sequential Monte Carlo. arXiv preprint arXiv:1705.10306, 2017.   
+Fredrik Lindsten. An efficient stochastic approximation EM algorithm using conditional particle filters. In ICASSP, 2013.   
+Fredrik Lindsten, Michael I. Jordan, and Thomas B. Schon. Particle Gibbs with Ancestor Sampling. ¨ Journal of Machine Learning Research, 15(1):2145–2184, 2014. ISSN 10495258.   
+Chris J. Maddison, Dieterich Lawson, George Tucker, Nicolas Heess, Mohammad Norouzi, Andriy Mnih, Arnaud Doucet, and Yee Whye Teh. Filtering Variational Objectives. In NIPS, 2017.   
+Frederic Morin and Yoshua Bengio. Hierarchical probabilistic neural network language model. In AISTATS, 2005.   
+Christian A. Naesseth, Scott W. Linderman, Rajesh Ranganath, and David M. Blei. Variational Sequential Monte Carlo. arXiv preprint arXiv:1705.11140, 2017.   
+Marius Pachitariu and Maneesh Sahani. Learning visual motion in recurrent neural networks. In NIPS, 2012.   
+Herbert E. Rauch, F. Tung, and Charlotte T. Striebel. Maximum likelihood estimates of linear dynamic systems. AIAA Journal, 3(8):1445–1450, 1965. ISSN 0001-1452.   
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. In ICML, 2014.   
+Thomas B. Schon, Fredrik Lindsten, Johan Dahlin, Johan W ¨ agberg, Christian A. Naesseth, Andreas ˚ Svensson, and Liang Dai. Sequential Monte Carlo Methods for System Identification. In IFAC Symposium on System Identification (SYSID), 2015.   
+Ruslan L. Stratonovich. Conditional markov processes. Theory of Probability and Its Applications, 5(2):156–178, 1960.   
+Manzil Zaheer, Amr Ahmed, and Alexander J. Smola. Latent LSTM Allocation: Joint Clustering and Non-Linear Dynamic Modeling of Sequence Data. In ICML, 2017.

parse/train/r1drp-WCZ/r1drp-WCZ_content_list.json

@@ -0,0 +1,1760 @@
+[
+    {
+        "type": "text",
+        "text": "STATE SPACE LSTM MODELS WITH PARTICLE MCMC INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            534,
+            137
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            162,
+            398,
+            189
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            227,
+            544,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Long Short-Term Memory (LSTM) is one of the most powerful sequence models. Despite the strong performance, however, it lacks the nice interpretability as in state space models. In this paper, we present a way to combine the best of both worlds by introducing State Space LSTM (SSL) models that generalizes the earlier work Zaheer et al. (2017) of combining topic models with LSTM. However, unlike Zaheer et al. (2017), we do not make any factorization assumptions in our inference algorithm. We present an efficient sampler based on sequential Monte Carlo (SMC) method that draws from the joint posterior directly. Experimental results confirms the superiority and stability of this SMC inference algorithm on a variety of domains. ",
+        "bbox": [
+            233,
+            258,
+            764,
+            393
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            424,
+            336,
+            440
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "State space models (SSMs), such as hidden Markov models (HMM) and linear dynamical systems (LDS), have been the workhorse of sequence modeling in the past decades From a graphical model perspective, efficient message passing algorithms (Stratonovich, 1960; Kalman, 1960) are available in compact closed form thanks to their simple linear Markov structure. However, simplicity comes at a cost: real world sequences can have long-range dependencies that cannot be captured by Markov models; and the linearity of transition and emission restricts the flexibility of the model for complex sequences. ",
+        "bbox": [
+            174,
+            457,
+            823,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A popular alternative is the recurrent neural networks (RNN), for instance the Long Short-Term Memory (LSTM) (Hochreiter & Schmidhuber, 1997) which has become a standard for sequence modeling nowadays. Instead of associating the observations with stochastic latent variables, RNN directly defines the distribution of each observation conditioned on the past, parameterized by a neural network. The recurrent parameterization not only allows RNN to provide a rich function class, but also permits scalable stochastic optimization such as the backpropagation through time (BPTT) algorithm. However, flexibility does not come for free as well: due to the complex form of the transition function, the hidden states of RNN are often hard to interpret. Moreover, it can require large amount of parameters for seemingly simple sequence models (Zaheer et al., 2017). ",
+        "bbox": [
+            174,
+            559,
+            825,
+            680
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new class of models State Space LSTM (SSL) that combines the best of both worlds. We show that SSLs can handle nonlinear, non-Markovian dynamics like RNNs, while retaining the probabilistic interpretations of SSMs. The intuition, in short, is to separate the state space from the sample space. In particular, instead of directly estimating the dynamics from the observed sequence, we focus on modeling the sequence of latent states, which may represent the true underlying dynamics that generated the noisy observations. Unlike SSMs, where the same goal is pursued under linearity and Markov assumption, we alleviate the restriction by directly modeling the transition function between states parameterized by a neural network. On the other hand, we bridge the state space and the sample space using classical probabilistic relation, which not only brings additional interpretability, but also enables the LSTM to work with more structured representation rather than the noisy observations. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            834
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Indeed, parameter estimation of such models can be nontrivial. Since the LSTM is defined over a sequence of latent variables rather than observations, it is not straightforward to apply the usual BPTT algorithm without making variational approximations. In Zaheer et al. (2017), which is an instance of SSL, an EM-type approach was employed: the algorithm alternates between imputing the latent states and optimizing the LSTM over the imputed sequences. However, as we show below, the inference implicitly assumes the posterior is factorizable through time. This is a restrictive assumption since the benefit of rich state transition brought by the LSTM may be neutralized by breaking down the posterior over time. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            157
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We present a general parameter estimation scheme for the proposed class of models based on sequential Monte Carlo (SMC) (Doucet et al., 2001), in particular the Particle Gibbs (Andrieu et al., 2010). Instead of sampling each time point individually, we directly sample from the joint posterior without making limiting factorization assumptions. Through extensive experiments we verify that sampling from the full posterior leads to significant improvement in the performance. ",
+        "bbox": [
+            174,
+            165,
+            823,
+            233
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related works Enhancing state space models using neural networks is not a new idea. Traditional approaches can be traced back to nonlinear extensions of linear dynamical systems, such as extended or unscented Kalman filters (Julier & Uhlmann, 1997), where both state transition and emission are generalized to nonlinear functions. The idea of parameterizing them with neural networks can be found in Ghahramani & Roweis (1999), as well as many recent works (Krishnan et al., 2015; Archer et al., 2015; Johnson et al., 2016; Krishnan et al., 2017; Karl et al., 2017) thanks to the development of recognition networks (Kingma & Welling, 2014; Rezende et al., 2014). Enriching the output distribution of RNN has also regain popularity recently. Unlike conventionally used multinomial output or mixture density networks (Bishop, 1994), recent approaches seek for more flexible family of distributions such as restricted Boltzmann machines (RBM) (Boulanger-Lewandowski et al., 2012) or variational auto-encoders (VAE) (Gregor et al., 2015; Chung et al., 2015). ",
+        "bbox": [
+            174,
+            247,
+            825,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On the flip side, there have been studies in introducing stochasticity to recurrent neural networks. For instance, Pachitariu & Sahani (2012) and Bayer & Osendorfer (2014) incorporated independent latent variables at each time step; while in Fraccaro et al. (2016) the RNN is attached to both latent states and observations. We note that in our approach the transition and emission are decoupled, not only for interpretability but also for efficient inference without variational assumptions. ",
+        "bbox": [
+            174,
+            402,
+            825,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On a related note, sequential Monte Carlo methods have recently received attention in approximating the variational objective (Maddison et al., 2017; Le et al., 2017; Naesseth et al., 2017). Despite the similarity, we emphasize that the context is different: we take a stochastic EM approach, where the full expectation in E-step is replaced by the samples from SMC. In contrast, SMC in above works is aimed at providing a tighter lower bound for the variational objective. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            326,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide a brief review of some key ingredients of this paper. We first describe the SSMs and the RNNs for sequence modeling, and then outline the SMC methods for sampling from a series of distributions. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 STATE SPACE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            367,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider a sequence of observations $\\boldsymbol { x } _ { 1 : T } = ( x _ { 1 } , \\dots , x _ { T } )$ and a corresponding sequence of latent states $z _ { 1 : T } = ( z _ { 1 } , \\dots , z _ { T } )$ . The SSMs are a class of graphical models that defines probabilistic dependencies between latent states and the observations. A classical example of SSM is the (Gaussian) LDS, where real-valued states evolve linearly over time under the first-order Markov assumption. Let $\\boldsymbol { x } _ { t } \\in \\mathbb { R } ^ { d }$ and $\\boldsymbol { z } _ { t } \\in \\mathbb { R } ^ { k }$ , the LDS can be expressed by two equations: ",
+        "bbox": [
+            173,
+            679,
+            825,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/276a70eadd7403d62d01155bb49222a5ca1fdb89112bb6fd8bb38f52e7e9b235.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\mathrm { ( T r a n s i t i o n ) } } & { z _ { t } = A z _ { t - 1 } + \\eta , \\ } & { \\eta \\sim \\mathcal { N } ( 0 , Q ) } \\\\ { \\mathrm { ( E m i s s i o n ) } } & { x _ { t } = C z _ { t } + \\epsilon , \\ } & { \\epsilon \\sim \\mathcal { N } ( 0 , R ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            751,
+            655,
+            789
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $A \\in \\mathbb { R } ^ { k \\times k }$ , $C \\in \\mathbb { R } ^ { d \\times k }$ , and $Q$ and $R$ are covariance matrices of corresponding sizes. They are widely applied in modeling the dynamics of moving objects, with $z _ { t }$ representing the true state of the system, such as location and velocity of the object, and $x _ { t }$ being the noisy observation under zero-mean Gaussian noise. ",
+        "bbox": [
+            174,
+            794,
+            823,
+            848
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We mention two important inference tasks (Koller & Friedman, 2009) associated with SSMs. The first tasks is filtering: at any time $t$ , compute $p ( \\boldsymbol { z } _ { t } | \\boldsymbol { x } _ { 1 : t } )$ , i.e. the most up-to-date belief of the state $z _ { t }$ conditioned on all past and current observations $x _ { 1 : t }$ . The other task is smoothing, which computes $p ( \\boldsymbol { z } _ { t } | \\boldsymbol { x } _ { 1 : T } )$ , i.e. the update to the belief of a latent state by incorporating future observations. One of the beauties of SSMs is that these inference tasks are available in closed form, thanks ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Sequential Monte Carlo ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            421,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Let $z _ { 0 } ^ { p } = z _ { 0 }$ and weights $\\alpha _ { 0 } ^ { p } = 1 / P$ for $p = 1 , \\ldots , P$ . ",
+        "bbox": [
+            212,
+            122,
+            588,
+            140
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. For $t = 1 , \\dots , T$ ",
+        "bbox": [
+            212,
+            142,
+            349,
+            156
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(a) Sample ancestors $a _ { t - 1 } ^ { p } \\sim \\alpha _ { t - 1 }$ for $p = 1 , \\ldots , P$ .   \n(c) Set (d) Co $z _ { t } ^ { p } \\sim f ( z _ { t } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } )$ $p = 1 , \\ldots , P$ $z _ { 1 : t } ^ { p } = ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , z _ { t } ^ { p } )$ $p = 1 , \\ldots , P$ $\\begin{array} { r } { \\alpha _ { t } ^ { p } \\propto \\frac { \\pi _ { t } ( z _ { 1 : t } ^ { p } ) } { \\pi _ { t - 1 } ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) f ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) } } \\end{array}$ $p = 1 , \\ldots , P$ ",
+        "bbox": [
+            236,
+            160,
+            794,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "to the simple Markovian dynamics of the latent states. For instance, the forward-backward algorithm (Stratonovich, 1960), the Kalman filter (Kalman, 1960), and RTS smoother (Rauch et al., 1965) are widely appreciated in the literature of HMM and LDS. ",
+        "bbox": [
+            176,
+            290,
+            823,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Having obtained the closed form filtering and smoothing equations, one can make use of the EM algorithm to find the maximum likelihood estimate (MLE) of the parameters given observations. In the case of LDS, the E-step can be computed by RTS smoother and the M-step is simple subproblems such as least-squares regression. We refer to Ghahramani & Hinton (1996) for a full exposition on learning the parameters of LDS using EM iterations. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            407
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 RECURRENT NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            446,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RNNs have received remarkable attention in recent years due to their strong benchmark performance as well as successful applications in real-world problems. Unlike SSMs, RNNs aim to directly learn the complex generative distribution of $p \\big ( x _ { t } | x _ { 1 : t - 1 } \\big )$ using a neural network, with the help of a deterministic internal state $s _ { t }$ : ",
+        "bbox": [
+            173,
+            449,
+            825,
+            503
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29c744f1211baef4e2ce37070b137c8b1fe538fff5227d13467f8ab468bee81a.jpg",
+        "text": "$$\np ( x _ { t } | x _ { 1 : t - 1 } ) = p ( x _ { t } ; g ( s _ { t } ) ) , \\quad s _ { t } = \\mathsf { R N N } ( s _ { t - 1 } , x _ { t - 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            510,
+            679,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathsf { R N N } ( \\cdot , \\cdot )$ is the transition function defined by a neural network, and $g ( \\cdot )$ is an arbitrary differentiable function that maps the RNN state $s _ { t }$ to the parameter of the distribution of $x _ { t }$ . The flexibility of the transformation function allows the RNN to learn from complex nonlinear nonGaussian sequences. Moreover, since the state $s _ { t }$ is a deterministic function of the past observations $x _ { 1 : t - 1 }$ , RNNs can capture long-range dependencies, for instance matching brackets in programming languages (Karpathy et al., 2015). ",
+        "bbox": [
+            173,
+            534,
+            825,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The BPTT algorithm can be used to find the MLE of the parameters of $\\mathsf { R N N } ( \\cdot , \\cdot )$ and $g ( \\cdot )$ . However, although RNNs can, in principle, model long-range dependencies, directly applying BPTT can be difficult in practice since the repeated application of a squashing nonlinear activation function, such as tanh or logistic sigmoid, results in an exponential decay in the error signal through time. LSTMs (Hochreiter & Schmidhuber, 1997) are designed to cope with the such vanishing gradient problems, by introducing an extra memory cell that is constructed as a linear combination of the previous state and signal from the input. In this work, we also use LSTMs as building blocks, as in Zaheer et al. (2017). ",
+        "bbox": [
+            173,
+            621,
+            825,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 SEQUENTIAL MONTE CARLO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            418,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Sequential Monte Carlo (SMC) (Doucet et al., 2001) is an algorithm that samples from a series of potentially unnormalized densities $\\pi _ { 1 } ( z _ { 1 } ) , . . . , \\pi _ { T } ( z _ { 1 : T } )$ . At each step $t$ , SMC approximates the target density $\\pi _ { t }$ with $P$ weighted particles using importance distribution $f { \\big ( } z _ { t } | z _ { 1 : t - 1 } { \\big ) }$ : ",
+        "bbox": [
+            174,
+            771,
+            825,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66adfbe4f1126ad4849ce614e95ff3f6bdc2563461c04279dbd7aedda2bd2a82.jpg",
+        "text": "$$\n\\pi _ { t } ( z _ { 1 : t } ) \\approx \\hat { \\pi } _ { t } ( z _ { 1 : t } ) = \\sum _ { p } \\alpha _ { t } ^ { p } \\delta _ { z _ { 1 : t } ^ { p } } ( z _ { 1 : t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            820,
+            629,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { t } ^ { p }$ is the importance weight of the $p$ -th particle and $\\delta _ { x }$ is the Dirac point mass at $x$ . Repeating this approximation for every $t$ leads to the SMC method, outlined in Algorithm 1. ",
+        "bbox": [
+            173,
+            861,
+            823,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The key to this method lies in the resampling, which is implemented by repeatedly drawing the ancestors of particles at each step. Intuitively, it encourages the particles with a higher likelihood to survive longer, since the weight reflects the likelihood of the particle path. The final Monte Carlo estimate (4) consists of only survived particle paths, and sampling from this point masses is equivalent to choosing a particle path according to the last weights $\\alpha _ { T }$ . We refer to Doucet et al. (2001); Andrieu et al. (2010) for detailed proof of the method. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/442f673772ccac3d53e3d3bb5f66cbecf4789460d88a7c98e79285a39e72b1c0.jpg",
+        "image_caption": [
+            "Figure 1: Generative process of SSL. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            97,
+            821,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            301,
+            825,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 STATE SPACE LSTM MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            376,
+            452,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the class of State Space LSTM (SSL) models that combines interpretability of SSMs and flexibility of LSTMs. ",
+        "bbox": [
+            173,
+            406,
+            821,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The key intuition, motivated by SSMs, is to learn dynamics in the state space, rather than in the sample space. However, we do not assume transition in the state space is linear, Gaussian, or Markovian. Existing approaches such as the extended Kalman filter (EKF) attempted to work with a general nonlinear transition function. Unfortunately, additional flexibility also introduced extra difficulty in the parameter estimation: EKF relies heavily on linearizing the nonlinear functions. We propose to use LSTM to model the dynamics in the latent state space, as they can learn from complex sequences without making limiting assumptions. The BPTT algorithm is also well established so that no additional approximation is needed in training the latent dynamics. ",
+        "bbox": [
+            173,
+            441,
+            825,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generative process Let $h ( \\cdot )$ be the emission function that maps a latent state to a parameter of the sample distribution. As illustrated in Figure 1 (a), the generative process of SSL for a single sequence is: ",
+        "bbox": [
+            176,
+            564,
+            823,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• For $t = 1 , \\dots , T$ : 1. Perform LSTM transition: $\\boldsymbol { s } _ { t } = \\mathsf { L S T M } \\left( \\boldsymbol { s } _ { t - 1 } , \\boldsymbol { z } _ { t - 1 } \\right)$ 2. Draw latent state: $z _ { t } \\sim p ( z ; g ( s _ { t } ) )$ 3. Draw observation: $x _ { t } \\sim p ( x ; h ( z _ { t } ) )$ ",
+        "bbox": [
+            215,
+            616,
+            601,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The generative process specifies the following joint likelihood, with a similar factorization as SSMs except for the Markov transition: ",
+        "bbox": [
+            174,
+            690,
+            823,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92cbcd66796b6ba926f59c99978cb82e9d6b0dadd6e9dc7681805db8865fd9f3.jpg",
+        "text": "$$\np ( x _ { 1 : T } , z _ { 1 : T } ) = \\prod _ { t = 1 } ^ { T } p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \\phi } ( x _ { t } | z _ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            723,
+            643,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) = p ( z _ { t } ; g ( s _ { t } ) )$ , $\\omega$ is the set of parameters of $\\mathsf { L S T M } ( \\cdot , \\cdot )$ and $g ( \\cdot )$ , and $\\phi$ is the parameters of $h ( \\cdot )$ . The structure of the likelihood function is better illustrated in Figure 1 (b), where each latent state $z _ { t }$ is dependent to all previous states $z _ { 1 : t - 1 }$ after substituting $s _ { t }$ recursively. This allows the SSL to have non-Markovian state transition, with parsimonious parameterization thanks to the recurrent structure of LSTMs. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Parameter estimation We continue with a single sequence for the ease of notation. A variational lower bound to the marginal data likelihood is given by ",
+        "bbox": [
+            173,
+            854,
+            821,
+            883
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8e5aa49019bbf76195beb2a5e0d540d39bef3ecb5abc15a9207d8916d2ce69d.jpg",
+        "text": "$$\n\\log p ( x _ { 1 : T } ) \\geq \\mathbb { E } _ { q } \\left[ \\log \\frac { p _ { \\omega } ( z _ { 1 : T } ) p _ { \\phi } ( x _ { 1 : T } | z _ { 1 : T } ) } { q ( z _ { 1 : T } ) } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            887,
+            658,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $q \\big ( z _ { 1 : T } \\big )$ is the variational distribution. Following the (stochastic) EM approach, iteratively maximizing the lower bound w.r.t. $q$ and the model parameters $( \\omega , \\phi )$ leads to the following updates: ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• E-step: The optimal variational distribution is given by the posterior: ",
+        "bbox": [
+            215,
+            141,
+            681,
+            156
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/abfceaf8a281a4416c95a56320984e75d3898a232b53dad5352bb0a9b35a8a8c.jpg",
+        "text": "$$\n\\begin{array} { r } { q ^ { \\star } ( z _ { 1 : T } ) \\propto p _ { \\omega } ( z _ { 1 : T } ) p _ { \\phi } ( x _ { 1 : T } | z _ { 1 : T } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            160,
+            647,
+            178
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the case of LDS or HMM, efficient smoothing algorithms such as the RTS smoother or the forward-backward algorithm are available for computing the posterior expectations of sufficient statistics. However, without Markovian state transition, although the forward messages can still be computed, the backward recursion can no longer evaluated or efficiently approximated. ",
+        "bbox": [
+            225,
+            180,
+            825,
+            250
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• S-step: Due to the difficulties in taking expectations, we take an alternative approach to collect posterior samples instead: ",
+        "bbox": [
+            212,
+            252,
+            823,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9113faf91405793be60e7526a2b019aa808d9e18a77df4ada6b4239874b34ab1.jpg",
+        "text": "$$\nz _ { 1 : T } ^ { \\star } \\sim q ^ { \\star } ( z _ { 1 : T } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            470,
+            284,
+            584,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "given only the filtering equations. We discuss the posterior sampling algorithm in detail in the next section. ",
+        "bbox": [
+            220,
+            304,
+            823,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• M-step: Given the posterior samples $z _ { 1 : T } ^ { \\star }$ , which can be seen as Monte Carlo estimate of the expectations, the subproblem for $\\omega$ and $\\phi$ are ",
+        "bbox": [
+            218,
+            335,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14af51b23d48cbcb5aa6a60318f83c38fe6e778be7f507c3d7f860969fd84e12.jpg",
+        "text": "$$\n\\omega ^ { \\star } = \\underset { \\omega } { \\mathrm { a r g m a x } } ~ \\log p _ { \\omega } ( z _ { 1 : T } ^ { \\star } ) , \\quad \\phi ^ { \\star } = \\underset { \\phi } { \\mathrm { a r g m a x } } ~ \\sum _ { t } \\log p _ { \\phi } ( x _ { t } | z _ { t } ^ { \\star } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            367,
+            740,
+            400
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which is exactly the MLE of an LSTM, with $z _ { 1 : T } ^ { \\star }$ serving as the input sequence, and the MLE of the given emission model. ",
+        "bbox": [
+            233,
+            402,
+            821,
+            431
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Having seen the generative model and the estimation algorithm, we can now discuss some instances of the proposed class of models. In particular, we provide two examples of SSL, for continuous and discrete latent states respectively. ",
+        "bbox": [
+            174,
+            440,
+            823,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Example 1 (Gaussian SSL) Suppose $z _ { t }$ and $x _ { t }$ are real-valued vectors. A typical choice of the transition and emission is the Gaussian distribution: ",
+        "bbox": [
+            173,
+            493,
+            823,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e47a5aa93c9010e5f0d97c4a2b0dc683a0eadd155ccd74b8e103393ae9dcd66.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p ( z _ { t } ; g ( s _ { t } ) ) = \\mathcal { N } ( z _ { t } ; g _ { \\mu } ( s _ { t } ) , g _ { \\sigma } ( s _ { t } ) ) } \\\\ & { p ( x _ { t } ; h ( z _ { t } ) ) = \\mathcal { N } ( x _ { t } ; h _ { \\mu } ( z _ { t } ) , h _ { \\sigma } ( z _ { t } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            523,
+            625,
+            564
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $g _ { \\mu } ( \\cdot )$ and $g _ { \\sigma } ( \\cdot )$ map to the mean and the covariance of the Gaussian respectively, and similarly $h _ { \\mu } ( \\cdot )$ and $h _ { \\sigma } ( \\cdot )$ . For closed form estimates for the emission parameters, one can further assume ",
+        "bbox": [
+            174,
+            565,
+            826,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9272873492992c6de24fd97b0bde736e438574d93998e959e647bd774cf6e37b.jpg",
+        "text": "$$\nh _ { \\mu } ( z _ { t } ) = C z _ { t } + b , \\quad h _ { \\sigma } ( z _ { t } ) = R ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            611,
+            612,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $C$ is a matrix that maps from state space to sample space, and $R$ is the covariance matrix with appropriate size. The MLE of $\\phi = ( C , b , R )$ is then given by the least squares fit. ",
+        "bbox": [
+            171,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Example 2 (Topical SSL, (Zaheer et al., 2017)) Consider $x _ { 1 : T }$ as the sequence of websites a user has visited. One might be tempted to model the user behavior using an LSTM, however due to the enormous size of the Internet, it is almost impossible to even compute a softmax output to get a discrete distribution over the websites. There are approximation methods for large vocabulary problems in RNN, such as the hierarchical softmax (Morin & Bengio, 2005). However, another interesting approach is to operate on a sequence with a “compressed” vocabulary, while learning how to perform such compression at the same time. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            766
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $z _ { t }$ be the indicator of a “topic”, which is a distribution over the vocabulary as in Blei et al. (2003). Accordingly, define ",
+        "bbox": [
+            173,
+            771,
+            821,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8542b7b0f24dedf084f33b09749abb34057eee0d1c20f6c06a04981f16e422bb.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p ( z _ { t } ; g ( s _ { t } ) ) = \\mathsf { M u l t i n o m i a l } ( z _ { t } ; \\mathsf { s o f t m a x } ( W s _ { t } + b ) ) } \\\\ & { p ( x _ { t } ; h ( z _ { t } ) ) = \\mathsf { M u l t i n o m i a l } ( x _ { t } ; \\phi _ { z _ { t } } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            803,
+            669,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W$ is a matrix that maps LSTM states to latent states, $b$ is a bias term, and $\\phi _ { z _ { t } }$ is a point in the probability simplex. If $z _ { t }$ lies in a lower dimension than $x _ { t }$ , the LSTM is effectively trained over a sequence $z _ { 1 : T }$ with a reduced vocabulary. On the other hand, the probabilistic mapping between $z _ { t }$ and $x _ { t }$ is interpretable, as it learns to group similar $x _ { t }$ ’s together. The estimation of $\\phi$ is typically performed under a Dirichlet prior, which then corresponds to the MAP estimate of the Dirichlet distribution (Zaheer et al., 2017). ",
+        "bbox": [
+            173,
+            842,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 INFERENCE WITH PARTICLE GIBBS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            498,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss how to draw samples from the posterior (7), corresponding to the S-step of the stochastic EM algorithm: ",
+        "bbox": [
+            171,
+            132,
+            825,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/77f8fc030349c130bc43e7ec98ce88c5a4f2b26d99b6a3edff6d9db663400fe0.jpg",
+        "text": "$$\nz _ { 1 : T } ^ { \\star } \\sim p ( z _ { 1 : T } | x _ { 1 : T } ) = \\frac { \\prod _ { t } p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \\phi } ( x _ { t } | z _ { t } ) } { \\int \\prod _ { t } p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \\phi } ( x _ { t } | z _ { t } ) \\mathrm { d } z _ { 1 : T } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            164,
+            696,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assuming the integration and normalization can be performed efficiently, the following quantities can be evaluated in the forward pass without Markov state transition: ",
+        "bbox": [
+            173,
+            210,
+            823,
+            238
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d260e9f53befbfdfc5a5c72a4d470dbfecea9a7a5cad0a908bbe3bf8e42563c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\alpha _ { t } \\equiv p ( x _ { t } | z _ { 1 : t - 1 } ) \\propto \\displaystyle \\int p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \\phi } ( x _ { t } | z _ { t } ) \\mathrm { d } z _ { t } } \\\\ & { \\gamma _ { t } \\equiv p ( z _ { t } | z _ { 1 : t - 1 } , x _ { t } ) \\propto p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \\phi } ( x _ { t } | z _ { t } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            242,
+            669,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The task is to draw from the joint posterior of $z _ { 1 : T }$ only given access to these forward messages. ",
+        "bbox": [
+            173,
+            296,
+            800,
+            313
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One way to circumvent the tight dependencies in $z _ { 1 : T }$ is to make a factorization assumption, as in Zaheer et al. (2017). More concretely, the joint distribution is decomposed as ",
+        "bbox": [
+            173,
+            318,
+            821,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(factorization assumption) ",
+        "bbox": [
+            183,
+            354,
+            356,
+            369
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84ca33666937de6e49ca6a3bd2d9e708ea693f5a2988c30eae8c7e99dcca911a.jpg",
+        "text": "$$\np ( z _ { 1 : T } | x _ { 1 : T } ) \\propto \\prod _ { t } p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ^ { \\mathrm { p r e v } } ) p _ { \\phi } ( x _ { t } | z _ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            349,
+            673,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $z _ { 1 : t - 1 } ^ { \\mathrm { p r e v } }$ is the assignments from the previous inference step. However, as we confirm in the experiments, this assumption can be restrictive since the flexibility of LSTM state transitions is offset by considering each time step independently. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose to use a method based on SMC, which is a principled way of sampling from a sequence of distributions. More importantly, it does not require the model to be Markovian (Frigola et al., 2013; Lindsten et al., 2014). As described earlier, the idea is to approximate the posterior (15) with point masses, i.e., weighted particles. Let $f ( \\boldsymbol { z } _ { t } | \\boldsymbol { z } _ { 1 : t - 1 } , \\boldsymbol { x } _ { t } )$ be the importance density, and $P$ be the number of particles. We then can run Algorithm 1 with $\\pi _ { t } ( z _ { 1 : t } ) \\stackrel { - } { = } p ( x _ { 1 : t } , z _ { 1 : t } )$ being the unnormalized target distribution at time $t$ , where the weight becomes ",
+        "bbox": [
+            173,
+            435,
+            826,
+            517
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6bea598060e41c1aa4d575e9184286661ee6b3dd4ba2a4c6509711bcf9871603.jpg",
+        "text": "$$\n\\alpha _ { t } ^ { p } \\propto \\frac { p ( z _ { 1 : t } ^ { p } , x _ { 1 : t } ) } { p ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { 1 : t - 1 } ) f ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { t } ) } = \\frac { p _ { \\omega } ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) p _ { \\phi } ( x _ { t } | z _ { t } ^ { p } ) } { f ( z _ { t } ^ { p } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { t } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            521,
+            723,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As for the choice of the proposal distribution $f ( \\cdot )$ , one could use the transition density $p _ { \\omega } \\big ( z _ { t } | z _ { 1 : t - 1 } \\big )$ , in which case the algorithm is also referred to as the bootstrap particle filter. An alternative is the predictive distribution, a locally optimal proposal in terms of variance (Andrieu et al., 2010): ",
+        "bbox": [
+            176,
+            579,
+            825,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/460d37dcade0c5f40eae9da0542f11090619611a16cdb6cf825489a66d1617a6.jpg",
+        "text": "$$\nf ^ { \\star } ( z _ { t } | z _ { 1 : t - 1 } , x _ { t } ) = \\frac { p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \\phi } ( x _ { t } | z _ { t } ) } { \\int p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ) p _ { \\phi } ( x _ { t } | z _ { t } ) \\mathrm { d } z _ { t } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            626,
+            665,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which is precisely one of the available forward messages: ",
+        "bbox": [
+            176,
+            664,
+            550,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c78e9fe6ddfbaac66ade7130fe9934103548d7c618392a4614cd35f7967ea0c2.jpg",
+        "text": "$$\n\\gamma _ { t } ^ { p } = f ^ { \\star } ( z _ { t } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , x _ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            683,
+            576,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Notice the similarity between terms in (19) and (20). Indeed, with the choice of predictive distribution as the proposal density, the importance weight simplifies to ",
+        "bbox": [
+            173,
+            709,
+            821,
+            737
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc914b86391055d7af175766dc91586188f52b4113bbd45887e277708f54c6c3.jpg",
+        "text": "$$\n\\alpha _ { t } ^ { p } \\propto \\tilde { \\alpha } _ { t } ^ { p } = \\int p _ { \\omega } ( z _ { t } | z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } ) p _ { \\phi } ( x _ { t } | z _ { t } ) \\mathrm { d } z _ { t } , ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            741,
+            642,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which is not a coincidence that the name collides with the message $\\alpha _ { t }$ . Interestingly, this quantity no longer depends on the current particle $z _ { t } ^ { p }$ . Instead, it marginalizes over all possible particle assignments of the current time step. This is beneficial computationally since the intermediate terms from (20) can be reused in (22). Also note that the optimal proposal relies on the fact that the normalization in (20) can be performed efficiently, otherwise the bootstrap proposal should be used. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            845
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After a full pass over the sequence, the algorithm produces Monte Carlo approximation of the posterior and the marginal likelihood: ",
+        "bbox": [
+            171,
+            851,
+            821,
+            880
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f32bb7fd5ce3fc9e150d0c6d02b9d81b978e77b42a9788426bd0164e2ee6ef4.jpg",
+        "text": "$$\n\\hat { p } ( z _ { 1 : T } | x _ { 1 : T } ) = \\sum _ { p } \\alpha _ { T } ^ { p } \\delta _ { z _ { 1 : T } ^ { p } } \\left( z _ { 1 : T } \\right) , \\quad \\hat { p } ( x _ { 1 : T } ) = \\prod _ { t } \\frac { 1 } { P } \\sum _ { p } \\tilde { \\alpha } _ { t } ^ { p } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            883,
+            710,
+            921
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Inference with Particle Gibbs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            457,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. Let $z _ { 0 } ^ { p } = z _ { 0 }$ and $\\alpha _ { 0 } ^ { p } = 1 / P$ for $p = 1 , \\ldots , P$ . ",
+        "bbox": [
+            215,
+            122,
+            532,
+            140
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. For $t = 1 , \\dots , T$ ",
+        "bbox": [
+            212,
+            142,
+            349,
+            156
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(a) Fix reference path: set $a _ { t - 1 } ^ { 1 } = 1$ and $z _ { 1 : t } ^ { 1 } = z _ { 1 : t } ^ { \\star }$ from previous iteration.   \n(b) Sample ancestors $a _ { t - 1 } ^ { p } \\sim \\alpha _ { t - 1 }$ for $p = 2 , \\ldots , P$ .   \n(c) Sample particles $z _ { t } ^ { p } \\sim \\gamma _ { t } ^ { p }$ and set $z _ { 1 : t } ^ { p } = ( z _ { 1 : t - 1 } ^ { a _ { t - 1 } ^ { p } } , z _ { t } ^ { p } )$ for $p = 2 , \\ldots , P$ .   \n(d) Compute normalized weights $\\alpha _ { t } ^ { p }$ for $p = 1 , \\ldots , P$ . ",
+        "bbox": [
+            236,
+            160,
+            735,
+            236
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3. Sample $r \\sim \\alpha _ { T }$ , return the particle path $z _ { 1 : T } ^ { a _ { T } ^ { r } }$ ",
+        "bbox": [
+            212,
+            241,
+            531,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The inference is completed by a final draw from the approximate posterior, ",
+        "bbox": [
+            176,
+            292,
+            665,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/faeb9461d98a8f189192f72e9a93a32b3fbf2c1a18f70f7e2201d89e72e1097c.jpg",
+        "text": "$$\nz _ { 1 : T } ^ { \\star } \\sim \\hat { p } \\big ( z _ { 1 : T } | x _ { 1 : T } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            315,
+            568,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "which is essentially sampling a particle path indexed by the last particle. Specifically, the last particle $z _ { T } ^ { p }$ is chosen according to the final weights $\\alpha _ { T }$ , and then earlier particles can be obtained by tracing backwards to the beginning of the sequence according to the ancestry indicators $a _ { t } ^ { p }$ at each position. ",
+        "bbox": [
+            176,
+            339,
+            825,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since SMC produces a Monte Carlo estimate, as the number of particles $P \\to \\infty$ the approximate posterior (23) is guaranteed to converge to the true posterior for a fixed sequence. However, as the length of the sequence $T$ increases, the number of particles needed to provide a good approximation grows exponentially. This is the well-known depletion problem of SMC (Andrieu et al., 2010). ",
+        "bbox": [
+            174,
+            388,
+            825,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One elegant way to avoid simulating enormous number of particles is to marry the idea of MCMC with SMC (Andrieu et al., 2010). The idea of such Particle MCMC (PMCMC) methods is to treat the particle estimate $\\hat { p } ( \\cdot )$ as a proposal, and design a Markov kernel that leaves the target distribution invariant. Since the invariance is ensured by the MCMC, it does not demand SMC to provide an accurate approximation to the true distribution, but only to give samples that are approximately distributed according to the target. As a result, for any fixed $P > 0$ the PMCMC methods ensure the target distribution is invariant. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We choose the Gibbs kernel that requires minimal modification from the basic SMC. The resulting algorithm is Particle Gibbs (PG), which is a conditional SMC update in a sense that a reference path $z _ { 1 : T } ^ { \\mathrm { r e f } }$ with its ancestral lineage is fixed throughout the particle propagation of SMC. It can be shown that this simple modification to SMC produces a transition kernel that is not only invariant, but also ergodic under mild assumptions. In practice, we use the assignments from previous step as the reference path. The final algorithm is summarized in Algorithm 2. Combined with the stochastic EM outer iteration, the final algorithm is an instance of the particle SAEM (Lindsten, 2013; Schon¨ et al., 2015), under non-Markovian state transition. ",
+        "bbox": [
+            173,
+            550,
+            825,
+            660
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conclude this section by deriving forward messages for the previous examples. ",
+        "bbox": [
+            174,
+            666,
+            714,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Example 1 (Gaussian SSL, continued) The integration and normalization preserves normality thanks to the Gaussian identify. The messages are given by ",
+        "bbox": [
+            173,
+            694,
+            821,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2425c2805018474cc0cc79d4d46a0da3fe5f5d819b18ad1985bfa03c4c01f1a2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\alpha _ { t } = \\mathcal { N } \\left( x _ { t } ; C g _ { \\mu } ( s _ { t } ) + b , R + C [ g _ { \\sigma } ( s _ { t } ) ] ^ { - 1 } C ^ { T } \\right) } \\\\ & { \\gamma _ { t } = \\mathcal { N } \\left( z _ { t } ; V \\left( C ^ { T } R ^ { - 1 } ( x _ { t } - b ) + [ g _ { \\sigma } ( s _ { t } ) ] ^ { - 1 } g _ { \\mu } ( s _ { t } ) \\right) , V \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            728,
+            696,
+            771
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $V = \\left( [ g _ { \\sigma } ( s _ { t } ) ] ^ { - 1 } + C ^ { T } R ^ { - 1 } C \\right) ^ { - 1 }$ ",
+        "bbox": [
+            176,
+            777,
+            444,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Example 2 (Topical SSL, continued) Let $\\theta _ { t } = \\mathsf { s o f t m a x } ( W s _ { t } + b )$ . Since the distributions are discrete, we have ",
+        "bbox": [
+            174,
+            809,
+            821,
+            838
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3233553145d341c11e0868588f66c902723cc3c6207b181a875f6c7bf4b3b7fb.jpg",
+        "text": "$$\n\\begin{array} { r } { \\alpha _ { t } \\propto \\left. \\theta _ { t } , \\phi _ { x _ { t } } \\right. , \\quad \\gamma _ { t } \\propto \\theta _ { t } \\circ \\phi _ { x _ { t } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            845,
+            606,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\circ$ denotes element-wise product. Note that the integration for $\\alpha _ { t }$ corresponds to a summation in the state space. It is then normalized across $P$ particles to form a weight distribution. For $\\gamma _ { t }$ the normalization is performed in the state space as well, hence the computation of the messages are manageable. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c389f9d873dbf3528420ad348381281516867b0bc9855eecef7c4129be37985b.jpg",
+        "image_caption": [
+            "Figure 2: Tracking a synthetic trajectory. Top row: true trajectory and noisy observations. Middle row: training/testing performance of LSTM. Bottom row: training/testing performance of SSL. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            816,
+            378
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            326,
+            468
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now present empirical studies for our proposed model and inference (denoted as SMC) in order to establish that (1) SSL is flexible in capturing underlying nonlinear dynamics, (2) our inference is accurate yet easily applicable to complicated models, and (3) it opens new avenues for interpretable yet nonlinear and non-Markovian sequence models, previously unthinkable. To illustrate these claims, we evaluate on (1) synthetic sequence tracking of varying difficulties, (2) language modeling, and (3) user modeling utilizing complicated models for capturing the intricate dynamics. For SMC inference, we gradually increase the number of particles $P$ from 1 to $K$ during training. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            578
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Software & hardware All the algorithms are implemented on TensorFlow (Abadi et al., 2016). We run our experiments on a commodity machine with Intel\rR Xeon\rR CPU E5-2630 v4 CPU, 256GB RAM, and 4 NVidia\rR Titan X (Pascal) GPU. ",
+        "bbox": [
+            176,
+            585,
+            825,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 SYNTHETIC SEQUENCE TRACKING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            643,
+            455,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To test the flexibility of SSL, we begin with inference using synthetic data. We consider four different dynamics in 2D space: (i) a straight line, (ii) a sine wave, (iii) a circle, and (iv) a swiss role. Note that we do not add additional states such as velocity, keeping the dynamics nonlinear except for the first case. Data points are generated by adding zero mean Gaussian noise to the true underlying dynamics. The true dynamics and the noisy observations are plotted in the top row of Figure 2. The first $60 \\%$ of the sequence is used for training and the rest is left for testing. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            751
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The middle and bottom row of Figure 2 show the result of SSL and vanilla LSTM trained for same number of iterations until both are sufficiently converged. The red points refer to the prediction of $z _ { t }$ after observing $x _ { 1 : t }$ , and the green points are blind predictions without observing any data. We can observe that while both methods are capturing the dynamics well in general, the predictions of LSTM tend to be more sensitive to initial predictions. In contrast, even when the initial predictions are not incorrect, SSL can recover in the end by remaining on the latent dynamic. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            839
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 LANGUAGE MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            377,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For Topical SSL, we compare our SMC inference method with the factored old algorithm (Zaheer et al., 2017) on the publicly available Wikipedia dataset, where documents with less than 500 words are excluded and the most frequent $2 0 0 \\mathrm { k }$ word types are retained. We train on the first $60 \\%$ of the documents and test on the rest, using the same settings in Zaheer et al. (2017). Figure 3 shows the test perplexity (lower is better) and number of nonzeros in the learned word topic count matrix (lower is better). In all cases, the SMC inference method consistently outperforms the old factored method. For comparison, we also run LSTM with the same number of parameters, which gives the lowest test perplexity of 1942.26. However, we note that LSTM needs to perform expensive linear transformation for both embedding and softmax at every step, which depends linearly on the vocabulary size $V$ . In contrast, SSL only depends linearly on number of topics $K \\ll V$ . ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c177253ec0fa3f9b37445f369bed90a7cc1bf22a44e3659e7e2d49ed6e251a6.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of the new inference method based on SMC to the older one assuming factored model. The top row represents perplexity on the held out set and the lower row represents the non zero entries in the word-topic count matrix. Lower perplexity indicates a better fit to the data and lower NNZ results in a sparser model and usually having better generalization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            108,
+            815,
+            345
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            452,
+            825,
+            546
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ablation study We also want to explore the benefit of the newer inference as dataset size increases. We observe that in case of natural languages which are highly structured the gap between factored approximation and accurate SMC keeps reducing as dataset size increases. But as we will see in case of user modeling when the dataset is less structured, the factored as",
+        "bbox": [
+            174,
+            554,
+            387,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c781e093801aa6ca163e3cfd923825e549e0a8c317268fc40d76c6def88f5fb6.jpg",
+        "image_caption": [
+            "Figure 4: Comparison between SMC and factored algorithm bysumption leads to poorer perforvarying number of topics and documentsmance. Also when the data size is fixed and the number of topics are varying, the SMC algorithm gives better perplexity compared to the old algorithm. Therefore we the SMC inference is consistently better in various settings. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            401,
+            569,
+            821,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Visualizing particle paths In Figure 5, we show the particle paths on a snippet of an article about a music album 1. As we can see from the top row, which plots the particle paths at the initial iteration, the model proposed a number of candidate topic sequences since it is uncertain about the latent semantics yet. However, after 100 epochs, as we can see from the bottom row, the model is much more confident about the underlying topical transition. Moreover, by inspecting the learned parameters $\\phi$ of the probabilistic emission, we can see that the topics are highly concentrated on topics related to music and time. This confirms our claim about flexible sequence modeling while retaining interpretability. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            895
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d05a137be6025677c0f4232c7cc46782d72893ccaae0dacc34808e142402d1ff.jpg",
+        "image_caption": [
+            "Figure 5: Particle paths of a document about a music album. Top row: at epoch 1. Bottom row: at epoch 100. After epoch 100 the document has converged to a sparse set of relevant topics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            109,
+            808,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 USER MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            336,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We use an anonymized sample of user search click history to measure the accuracy of different models on predicting users future clicks. An accurate model would enable better user experience by presenting the user with relevant content. The dataset is anonymized by removing all items appearing less than a given threshold, this results in a dataset with 100K vocabulary and we vary the number of users from 500K to 1M. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We fix the number of topics at 500 for all user experiments. We used the same setup to the one used in the experiments over the Wikipedia dataset for parameters. The dataset is less structured than the language modeling task since users click patterns are less predictable than the sequence of words which follow definite syntactic rules. As shown in table 1, the benefit of new inference method is highlighted as it yields much lower perplexity than the factored model. ",
+        "bbox": [
+            174,
+            516,
+            552,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/5290a6648df06ab7817e3dc38a6c9a6263fd1c53e41722f8cd57266d7faa7619.jpg",
+        "table_caption": [
+            "Table 1: Comparison on user data "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Algorithm</td><td colspan=\"2\">#Users</td></tr><tr><td>500k</td><td>1M</td></tr><tr><td>Factored</td><td>2430</td><td>2254</td></tr><tr><td>SMC</td><td>1464</td><td>1447</td></tr></table>",
+        "bbox": [
+            593,
+            531,
+            790,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSIONS & CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            656,
+            459,
+            671
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we revisited the problem of posterior inference in Latent LSTM models as introduced in Zaheer et al. (2017). We generalized their model to accommodate a wide variety of state space models and most importantly we provided a more principled Sequential Monte-Carlo (SMC) algorithm for posterior inference. Although the newly proposed inference method can be slower, we showed over a variety of dataset that the new SMC based algorithm is far superior and more stable. While computation of the new SMC algorithm scales linearly with the number of particles, this can be naively parallelized. In the future we plan to extend our work to incorporate a wider class of dynamically changing structured objects such as time-evolving graphs. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, and Others. TensorFlow: Large-Scale Machine Learning on Heterogeneous Systems. arXiv preprint arXiv:1603.04467, 2016. ",
+        "bbox": [
+            176,
+            125,
+            823,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christophe Andrieu, Arnaud Doucet, and Roman Holenstein. Particle Markov chain Monte Carlo methods. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 72(3):269– 342, 2010. ",
+        "bbox": [
+            174,
+            176,
+            823,
+            217
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Evan Archer, Il Memming Park, Lars Buesing, John P. Cunningham, and Liam Paninski. Black box variational inference for state space models. arXiv preprint arXiv:1511.07367, 2015. ",
+        "bbox": [
+            171,
+            226,
+            823,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Bayer and Christian Osendorfer. Learning Stochastic Recurrent Networks. arXiv preprint arXiv:1411.7610, 2014. ",
+        "bbox": [
+            171,
+            263,
+            823,
+            292
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher M. Bishop. Mixture Density Networks. Technical report, 1994. ",
+        "bbox": [
+            174,
+            300,
+            673,
+            316
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David M. Blei, Andrew Y. $\\mathrm { N g }$ , and Michael I. Jordan. Latent Dirichlet Allocation. Journal of Machine Learning Research, 3:993–1022, 2003. ISSN 15324435. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Boulanger-Lewandowski, Yoshua Bengio, and Pascal Vincent. Modeling Temporal Dependencies in High-Dimensional Sequences: Application to Polyphonic Music Generation and Transcription. In ICML, 2012. ",
+        "bbox": [
+            174,
+            362,
+            823,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron Courville, and Yoshua Bengio. A Recurrent Latent Variable Model for Sequential Data. In NIPS, 2015. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arnaud Doucet, Nando de Freitas, and Neil Gordon. Sequential Monte Carlo Methods in Practice. Springer, 2001. ",
+        "bbox": [
+            174,
+            449,
+            821,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marco Fraccaro, Søren Kaae Sønderby, Ulrich Paquet, and Ole Winther. Sequential Neural Models with Stochastic Layers. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Roger Frigola, Fredrik Lindsten, Thomas B. Schon, and Carl E. Rasmussen. Bayesian Inference and ¨ Learning in Gaussian Process State-Space Models with Particle MCMC. In NIPS, 2013. ",
+        "bbox": [
+            174,
+            523,
+            823,
+            553
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zoubin Ghahramani and Geoffrey E. Hinton. Parameter estimation for linear dynamical systems. Technical report, 1996. ",
+        "bbox": [
+            174,
+            560,
+            823,
+            589
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zoubin Ghahramani and Sam T. Roweis. Learning Nonlinear Dynamical Systems using an EM Algorithm. In NIPS, 1999. ",
+        "bbox": [
+            174,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. DRAW: A Recurrent Neural Network For Image Generation. In ICML, 2015. ",
+        "bbox": [
+            176,
+            635,
+            823,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            174,
+            671,
+            823,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew J. Johnson, David Duvenaud, Alexander B. Wiltschko, Sandeep R. Datta, and Ryan P. Adams. Composing graphical models with neural networks for structured representations and fast inference. In NIPS, 2016. ",
+        "bbox": [
+            174,
+            709,
+            823,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Simon J. Julier and Jeffrey K. Uhlmann. A new extension of the Kalman filter to nonlinear systems. In Int. symp. aerospace/defense sensing, simul. and controls1, 1997. ",
+        "bbox": [
+            171,
+            760,
+            823,
+            789
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rudolph Emil Kalman. A New Approach to Linear Filtering and Prediction Problems. Journal of Basic Engineering, 82(1):35–45, 1960. ISSN 00219223. ",
+        "bbox": [
+            173,
+            797,
+            823,
+            827
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Maximilian Karl, Maximilian Soelch, Justin Bayer, and Patrick van der Smagt. Deep variational Bayes filters: Unsupervised learning of state space models from raw data. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            834,
+            823,
+            863
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrej Karpathy, Justin Johnson, and Li Fei-Fei. Visualizing and understanding recurrent networks. arXiv preprint arXiv:1506.02078, 2015. ",
+        "bbox": [
+            173,
+            871,
+            825,
+            900
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Max Welling. Auto-Encoding Variational Bayes. In ICLR, 2014. ",
+        "bbox": [
+            169,
+            909,
+            759,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daphne Koller and Nir Friedman. Probabilistic Graphical Models: Principles and Techniques. MIT Press, 2009.   \nRahul G. Krishnan, Uri Shalit, and David Sontag. Deep Kalman Filters. arXiv preprint arXiv:1511.05121, 2015.   \nRahul G. Krishnan, Uri Shalit, and David Sontag. Structured Inference Networks for Nonlinear State Space Models. In AAAI, 2017.   \nTuan Anh Le, Maximilian Igl, Tom Jin, Tom Rainforth, and Frank Wood. Auto-Encoding Sequential Monte Carlo. arXiv preprint arXiv:1705.10306, 2017.   \nFredrik Lindsten. An efficient stochastic approximation EM algorithm using conditional particle filters. In ICASSP, 2013.   \nFredrik Lindsten, Michael I. Jordan, and Thomas B. Schon. Particle Gibbs with Ancestor Sampling. ¨ Journal of Machine Learning Research, 15(1):2145–2184, 2014. ISSN 10495258.   \nChris J. Maddison, Dieterich Lawson, George Tucker, Nicolas Heess, Mohammad Norouzi, Andriy Mnih, Arnaud Doucet, and Yee Whye Teh. Filtering Variational Objectives. In NIPS, 2017.   \nFrederic Morin and Yoshua Bengio. Hierarchical probabilistic neural network language model. In AISTATS, 2005.   \nChristian A. Naesseth, Scott W. Linderman, Rajesh Ranganath, and David M. Blei. Variational Sequential Monte Carlo. arXiv preprint arXiv:1705.11140, 2017.   \nMarius Pachitariu and Maneesh Sahani. Learning visual motion in recurrent neural networks. In NIPS, 2012.   \nHerbert E. Rauch, F. Tung, and Charlotte T. Striebel. Maximum likelihood estimates of linear dynamic systems. AIAA Journal, 3(8):1445–1450, 1965. ISSN 0001-1452.   \nDanilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. In ICML, 2014.   \nThomas B. Schon, Fredrik Lindsten, Johan Dahlin, Johan W ¨ agberg, Christian A. Naesseth, Andreas ˚ Svensson, and Liang Dai. Sequential Monte Carlo Methods for System Identification. In IFAC Symposium on System Identification (SYSID), 2015.   \nRuslan L. Stratonovich. Conditional markov processes. Theory of Probability and Its Applications, 5(2):156–178, 1960.   \nManzil Zaheer, Amr Ahmed, and Alexander J. Smola. Latent LSTM Allocation: Joint Clustering and Non-Linear Dynamic Modeling of Sequence Data. In ICML, 2017. ",
+        "bbox": [
+            171,
+            84,
+            826,
+            669
+        ],
+        "page_idx": 11
+    }
+]

parse/train/txC1ObHJ0wB/txC1ObHJ0wB.md

@@ -0,0 +1,279 @@
+# HOW TO TRAIN YOUR SUPER-NET: AN ANALYSIS OF TRAINING HEURISTICS IN WEIGHT-SHARING NAS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Weight sharing promises to make neural architecture search (NAS) tractable even on commodity hardware. Existing methods in this space rely on a diverse set of heuristics to design and train the shared-weight backbone network, a.k.a. the supernet. Since heuristics substantially vary across different methods and have not been carefully studied, it is unclear to which extent they impact super-net training and hence the weight-sharing NAS algorithms. In this paper, we disentangle super-net training from the search algorithm, isolate 14 frequently-used training heuristics, and evaluate them over three benchmark search spaces. Our analysis uncovers that several commonly-used heuristics negatively impact the correlation between supernet and stand-alone performance, whereas simple, but often overlooked factors, such as proper hyper-parameter settings, are key to achieve strong performance. Equipped with this knowledge, we show that simple random search achieves competitive performance to complex state-of-the-art NAS algorithms when the super-net is properly trained.
+
+# 1 INTRODUCTION
+
+Neural architecture search (NAS) has received growing attention in the past few years, yielding stateof-the-art performance on several machine learning tasks (Liu et al., 2019a; Wu et al., 2019; Chen et al., 2019b; Ryoo et al., 2020). One of the milestones that led to the popularity of NAS is weight sharing (Pham et al., 2018; Liu et al., 2019b), which, by allowing all possible network architectures to share the same parameters, has reduced the computational requirements from thousands of GPU hours to just a few. Figure 1 shows the two phases that are common to weight-sharing NAS (WS-NAS) algorithms: the search phase, including the design of the search space and the search algorithm; and the evaluation phase, which encompasses the final training protocol on the proxy task 1.
+
+While most works focus on developing a good sampling algorithm (Cai et al., 2019; Xie et al., 2019) or improving existing ones (Zela et al., 2020a; Nayman et al., 2019; Li et al., 2020), they tend to overlook or gloss over important factors related to the design and training of the shared-weight backbone network, i.e. the super-net. For example, the literature encompasses significant variations of learning hyper-parameter settings, batch normalization and dropout usage, capacities for the initial layers of the network, and depth of the super-net. Furthermore, some of these heuristics are directly transferred from standalone network training to super-net training without carefully studying their impact in this drastically different scenario. For example, the fundamental assumption of batch normalization that the input data follows a slowly changing distribution whose statistics can be tracked during training is violated in WS-NAS, but nonetheless typically assumed to hold.
+
+In this paper, we revisit and systematically evaluate commonly-used super-net design and training heuristics and uncover the strong influence of certain factors on the success of super-net training. To this end, we leverage three benchmark search spaces, NASBench-101 (Ying et al., 2019), NASBench201 (Dong & Yang, 2020), and DARTS-NDS (Radosavovic et al., 2019), for which the ground-truth stand-alone performance of a large number of architectures is available. We report the results of our experiments according to two sets of metrics: i) metrics that directly measure the quality of the super-net, such as the widely-adopted super-net accuracy 2 and a modified Kendall-Tau correlation between the searched architectures and their ground-truth performance, which we refer to as sparse
+
+![](images/8c9f1fb332802d0a69c31ec05ae6a3107427c64b71219d8cedb6fb6cc6b9ad2a.jpg)  
+Figure 1: WS-NAS benchmarking. Green blocks indicate which aspects of NAS are benchmarked in different works. A search algorithm usually consists of a search space that encompass many architectures, and a policy to select the best one. $P$ indicates a training protocol, and $f$ a mapping function from the search space to a neural network. (a) Early works fixed and compared the metrics on the proxy task, which doesn’t allow for a holistic comparison between algorithms. $\mathbf { ( b ) }$ The NASBench benchmark series partially alleviates the problem by sharing the stand-alone training protocol and search space across algorithms. However, the design of the weight-sharing search space and training protocol is still not controlled. (c) We fill this gap by benchmarking existing techniques to construct and train the shared-weight backbone. We provide a controlled evaluation across three benchmark spaces.
+
+Kendall-Tau; ii) proxy metrics such as the ability to surpass random search and the stand-alone accuracy of the model found by the WS-NAS algorithm.
+
+Via our extensive experiments (over 700 GPU days), we uncover that (i) the training behavior of a super-net drastically differs from that of a standalone network, e.g., in terms of feature statistics and loss landscape, thus allowing us to define training factor settings, e.g., for batch-normalization (BN) and learning rate, that are better suited for super-nets; (ii) while some neglected factors, such as the number of training epochs, have a strong impact on the final performance, others, believed to be important, such as path sampling, only have a marginal effect, and some commonly-used heuristics, such as the use of low-fidelity estimates, negatively impact it; (iii) the commonly-adopted super-net accuracy is unreliable to evaluate the super-net quality.
+
+Altogether, our work is the first to systematically analyze the impact of the diverse factors of super-net design and training, and we uncover the factors that are crucial to design a super-net, as well as the non-important ones. Aggregating these findings allows us to boost the performance of simple weight-sharing random search to the point where it reaches that of complex state-of-the-art NAS algorithms across all tested search spaces. We will release our code and trained models so as to establish a solid baseline to facilitate further research.
+
+# 2 PRELIMINARIES AND RELATED WORK
+
+We first introduce the necessary concepts that will be used throughout the paper. As shown in Figure $1 ( a )$ , weight-sharing NAS algorithms consist of three key components: a search algorithm that samples an architecture from the search space in the form of an encoding, a mapping function $f _ { p r o x y }$ that maps the encoding into its corresponding neural network, and a training protocol for a proxy task $P _ { p r o x y }$ for which the network is optimized.
+
+To train the search algorithm, one needs to additionally define the mapping function $f _ { w s }$ that generates the shared-weight network. Note that the mapping $f _ { p r o x y }$ frequently differs from $f _ { w s }$ , since in practice the final model contains many more layers and parameters so as to yield competitive results on the proxy task. After fixing $f _ { w s }$ , a training protocol $P _ { w s }$ is required to learn the super-net. In practice, $P _ { w s }$ often hides factors that are critical for the final performance of an approach, such as hyper-parameter settings or the use of data augmentation strategies to achieve state-of-the-art performance (Liu et al., 2019b; Chu et al., 2019; Zela et al., 2020a). Again, $P _ { w s }$ may differ from $P _ { p r o x y }$ , which is used to train the architecture that has been found by the search. For example, our experiments reveal that the learning rate and the total number of epochs frequently differ due to the different training behavior of the super-net and stand-alone architectures.
+
+Many strategies have been proposed to implement the search algorithm, such as reinforcement learning (Zoph & Le, 2017; Zoph et al., 2018), evolutionary algorithms (Real et al., 2017; Miikkulainen et al., 2019; So et al., 2019; Liu et al., 2018; Lu et al., 2018), gradient-based optimization (Liu et al., 2019b; Xu et al., 2020; Li et al., 2020), Bayesian optimization (Kandasamy et al., 2018; Jin et al., 2019; Zhou et al., 2019; Wang et al., 2020), and separate performance predictors (Liu et al., 2018; Luo et al., 2018). Until very recently, the common trend to evaluate NAS consisted of reporting the searched architecture’s performance on the proxy task (Xie et al., 2019; Real et al., 2019; Ryoo et al., 2020). This, however, hardly provides real insights about the NAS algorithms themselves, because of the many components involved in them. Many factors that differ from one algorithm to another can influence the performance. In practice, the literature even commonly compares NAS methods that employ different protocols to train the final model.
+
+Li & Talwalkar (2019) and Yu et al. (2020b) were the first to systematically compare different algorithms with the same settings for the proxy task and using several random initializations. Their surprising results revealed that many NAS algorithms produce architectures that do not significantly outperform a randomly-sampled architecture. Yang et al. (2020) highlighted the importance of the training protocol $P _ { p r o x y }$ . They showed that optimizing the training protocol can improve the final architecture performance on the proxy task by three percent on CIFAR-10. This non-trivial improvement can be achieved regardless of the chosen sampler, which provides clear evidence for the importance of unifying the protocol to build a solid foundation for comparing NAS algorithms.
+
+In parallel to this line of research, the recent series of “NASBench” works (Ying et al., 2019; Zela et al., 2020b; Dong & Yang, 2020) proposed to benchmark NAS approaches by providing a complete, tabular characterization of a search space. This was achieved by training every realizable stand-alone architecture using a fixed protocol $P _ { p r o x y }$ . Similarly, other works proposed to provide a partial characterization by sampling and training a sufficient number of architectures in a given search space using a fixed protocol (Radosavovic et al., 2019; Zela et al., 2020a; Wang et al., 2020).
+
+While recent advances for systematic evaluation are promising, no work has yet thoroughly studied the influence of the super-net training protocol $P _ { w s }$ and the mapping function $f _ { w s }$ . Previous works (Zela et al., 2020a; Li & Talwalkar, 2019) performed hyper-parameter tuning to evaluate their own algorithms, and focused only on a few parameters. We fill this gap by benchmarking different choices of $P _ { w s }$ and $f _ { w s }$ and by proposing novel variations to improve the super-net quality.
+
+Recent works have shown that sub-nets of super-net training can surpass some human designed models without retraining (Yu et al., 2020a; Cai et al., 2020) and that reinforcement learning can surpass the performance of random search (Bender et al., 2020). However, these findings are still only shown on MobileNet-like search spaces where we only search for the size of convolution kernels and the channel ratio for each layer. This is an effective approach to discover a compact network, but it does not change the fact that on cell-based search space super-net quality remains low.
+
+# 3 EVALUATION METHODOLOGY
+
+We first isolate 14 factors that need to be considered during the design and training of a super-net, and then introduce the metrics to evaluate the quality of the trained super-net. Note that these factors are agnostic to the search policy that is used after training the super-net.
+
+# 3.1 DISENTANGLING THE SUPER-NET FROM THE SEARCH ALGORITHM
+
+Our goal is to evaluate the influence of the super-net mapping $f _ { w s }$ and weight-sharing training protocol $P _ { w s }$ . As shown in Figure 2, $f _ { w s }$ translates an architecture encoding, which typically consists of a discrete number of choices or parameters, into a neural network. Based on a well-defined mapping, the super-net is a network in which every sub-path has a one-to-one mapping with an architecture encoding (Pham et al., 2018). Recent works $\mathrm { { X u } }$ et al., 2020; Li et al., 2020; Ying et al.,
+
+Table 1: Summary of factors   
+
+<table><tr><td colspan="2">WS Mapping fws</td><td colspan="2">WS Protocol Pws</td></tr><tr><td>implementation</td><td>low fidelity</td><td>hyperparam.</td><td>sampling</td></tr><tr><td>Dynamic Channeling OFA Conv WSBN Dropout</td><td>#layer train portion batch size # channels</td><td>batch-norm learning rate epochs weight decay</td><td>FairNAS Random-NAS Random-A</td></tr></table>
+
+![](images/463271dd9cea14da998c14fcf209e360895a954aa979a36fcfdd692e498d3c94.jpg)  
+Figure 2: Constructing a super-net
+
+2019) separate the encoding into cell parameters, which define the basic building blocks of a network, and macro parameters, which define how cells are assembled into a complete architecture.
+
+Weight-sharing mapping $f _ { w s }$ . To make the search space manageable, all cell and macro parameters are fixed during the search, except for the topology of the cell and its possible operations. However, the exact choices for each of these fixed factors differ between algorithms and search spaces. We report the common factors in the left part of Table 1. They include various implementation choices, e.g., the use of convolutions with a dynamic number of channels (Dynamic Channeling), super-convolutional layers that support dynamic kernel sizes (OFA Kernel) (Cai et al., 2020), weight-sharing batchnormalization (WSBN) that tracks independent running statistics and affine parameters for different incoming edges (Luo et al., 2018), and path and global dropout (Pham et al., 2018; Luo et al., 2018; Liu et al., 2019b). They also include the use of low-fidelity estimates (Elsken et al., 2019) to reduce the complexity of super-net training, e.g., by reducing the number of layers (Liu et al., 2019b) and channels (Yang et al., 2020; Chen et al., 2019a), the portion of the training set used for super-net training (Liu et al., 2019b), or the batch size (Liu et al., 2019b; Pham et al., 2018; Yang et al., 2020).
+
+Weight-sharing protocol $P _ { w s }$ . Given a mapping $f _ { w s }$ , different training protocols $P _ { w s }$ can be employed to train the super-net. Protocols can differ in the training hyper-parameters and the sampling strategies they rely on. We will evaluate the different hyper-parameter choices listed in the right part of Table 1. This includes the initial learning rate, the hyper-parameters of batch normalization, the total number of training epochs, and the amount of weight decay.
+
+We randomly sample one path to train the super-net (Guo et al., 2019), which is also known as single-path one-shot (SPOS) or Random-NAS (Li & Talwalkar, 2019). The reason for this choice is that Random-NAS is equivalent to the initial state of many search algorithms (Liu et al., 2019b; Pham et al., 2018; Luo et al., 2018), some of which even freeze the sampler training so as to use random sampling to warm-up the super-net (Xu et al., 2020; Dong & Yang, 2019b). Note that we also evaluated two variants of Random-NAS, but found their improvement to be only marginal. Please see Appendix C.2 for more detail.
+
+In our experiments, for the sake of reproducibility, we ensure that $P _ { w s }$ and $P _ { p r o x y }$ , as well as $f _ { w s }$ and $f _ { p r o x y }$ , are as close to each other as possible. For the hyper-parameters of $P _ { w s }$ , we cross-validate each factor following the order in Table 1, and after each validation, use the value that yields the best performance in $P _ { p r o x y }$ . For all other factors, we change one factor at a time.
+
+Search spaces. We use three commonly-used search spaces, for which a large number of stand-alone architectures have been trained and evaluated on CIFAR-10 (Krizhevsky et al., 2009) to obtain their ground-truth performance. In particular, we use NASBench-101 (Ying et al., 2019), which consists of 423, 624 architectures and is compatible with weight-sharing NAS (Yu et al., 2020b; Zela et al., 2020b); NASBench-201 (Dong & Yang, 2020), which contains more operations than NASBench-101 but fewer nodes; and DARTS-NDS (Radosavovic et al., 2019) that contains over $1 0 ^ { 1 3 }$ architectures of which a subset of 5000 models was sampled and trained in a stand-alone fashion. See Appendix A.2 for a detailed discussion.
+
+# 3.2 SPARSE KENDALL-TAU - A NOVEL SUPER-NET EVALUATION METRIC
+
+We define a novel super-net metric, which we name sparse Kendall-Tau. It is inspired by the KendallTau metric used by Yu et al. (2020b) to measure the discrepancy between the ordering of stand-alone architectures and the ordering that is implied by the trained super-net. An ideal super-net should yield the same ordering of architectures as the stand-alone one and thus would lead to a high Kendall-Tau. However, Kendall-Tau is not robust to negligible performance differences between architectures (c.f. Figure 3). To robustify this metric, we share the rank between two architectures if their stand-alone
+
+accuracies differ by less than a threshold $( 0 . 1 \%$ here). Since the resulting ranks are sparse, we call this metric sparse Kendall-Tau (s-KdT). Note that we also compare Kendall-Tau and Spearman correlation in Appendix A.3, and provide implementation details in Appendix A.4.
+
+<table><tr><td></td><td>Kendall Tau</td></tr><tr><td>original</td><td>0.6444</td></tr><tr><td>sparse</td><td>0.8140</td></tr></table>
+
+Although, sparse Kendall-Tau captures the super-net quality well, it may fail in extreme cases, such as when the top-performing architectures are ranked perfectly while poor ones are ordered randomly. To account for such rare situations and ensure the soundness of our analysis, we also report additional metrics. We define two groups of metrics to holistically evaluate different aspects of a trained super-net. The first
+
+![](images/833d29ee1aac1b8ac81197f787216600f0137c6ca77daf0ba561aada5ab69d2e.jpg)  
+Figure 3: Kendall-Tau vs sparse Kendall-Tau. Kendall-Tau is not robust when many architectures have similar performance. Minor performance differences can lead to large perturbations in the ranking. Our sparse Kendall-Tau alleviates this by dismissing minor differences in performance.
+
+group of metrics directly evaluates the quality of the super-net, including sparse Kendall-Tau and the widely-adopted super-net accuracy. For the super-net accuracy, we report the average accuracy of 200 architectures on the validation set of the dataset of interest. We will refer to this metric simply as accuracy. It is frequently used (Guo et al., 2019; Chu et al., 2019) to assess the quality of the trained super-net, but we will show later that it is in fact a poor predictor of the final stand-alone performance. The metrics in the second group evaluate the search performance of a trained super-net. The first metric is the probability to surpass random search: Given the ground-truth rank $r$ of the best architecture found after $n$ runs and the maximum rank $r _ { m a x }$ , equal to the total number of architectures, the probability that the best architecture found is better than a randomly searched one is given by $p = 1 - \bar { ( 1 - ( r / r _ { m a x } ) ) ^ { n } }$ . Finally, where appropriate, we report the stand-alone accuracy of the model that was found by the complete WS-NAS algorithm. Concretely, we randomly sample 200 architectures, select the 3 best models based on the super-net accuracy and query the ground-truth performance. We then take the mean of these architectures as stand-alone accuracy. Note that the same architectures are used to compute the sparse Kendall-Tau.
+
+# 4 ANALYSIS
+
+We provide an analysis on the impact of the factors that are shown in Table 1 across three different search spaces. Note that, in this section, we present the factors that are the most important for performance; our analysis of the remaining factors is provided in Appendix C.
+
+# 4.1 EVALUATION OF A SUPER-NET
+
+The standalone performance of the architecture that is found by a NAS algorithm is clearly the most important metric to judge its merits. However, in practice, one cannot access this metric—we wouldn’t need NAS if standalone performance was easy to query (the cost of computing stand-alone performance is discussed in Appendix B.2). Furthermore, stand-alone performance inevitably depends the sampling policy, and does not directly evaluate the quality of the super-net (see Appendix B.3). Consequently, it is important to rely on metrics that are well correlated with the final performance but can be queried efficiently. To this end, we collect all our experiments and plot the pairwise correlation between final performance, sparse Kendall-Tau, and super-net accuracy. As shown in Figure 4, the super-net accuracy has a low
+
+![](images/9bbbf88b8ff46e3dc661ad3a1fb9b080e8445bd8a956a4fa0a17624818773028.jpg)  
+Figure 4: Super-net evaluation. We collect all experiments across 3 benchmark spaces. (Top) Pairwise plots of super-net accuracy, final performance, and the sparse Kendall-Tau. Each point corresponds to statistics computed over a trained super-net. (Bottom) Spearman correlation coefficients between the metrics.
+
+correlation with the final performance on NASBench-101 and DARTS-NDS. Only on NASBench-201 does it reach a correlation of 0.52. The sparse Kendall-Tau yields a consistently higher correlation with the final performance. This is evidence that one should not focus too strongly on improving the super-net accuracy. While this metric remains computationally heavy, it serves as a middle ground that is feasible to evaluate in real-world applications.
+
+In the following experiments, we thus mainly rely on sparse Kendall-Tau, and use final search performance as a reference only. We report the training details in Appendix B.1 and the complete results of all metrics in Appendix C.6.
+
+# 4.2 BATCH NORMALIZATION IN THE SUPER-NET
+
+Batch normalization (BN) is commonly used in standalone networks to allow for faster and more stable training. It is thus also employed in most CNN search spaces. However, BN behaves differently in the context of WS-NAS, and special care has to be taken when using it. In a standalone network (c.f. Figure 5 (Top)), a BN layer during training computes the batch statistics $\mu _ { B }$ and $\sigma _ { B }$ , normalizes the activations $f _ { A } ( x )$ as $( f _ { A } ( \boldsymbol { x } ) - \mu _ { B } ) / \sigma _ { B }$ , and finally updates the population statistics using a moving average. For instance, the mean statistics is updated as $\hat { \mu }  \gamma \hat { \mu } + ( 1 - \gamma ) \mu _ { B }$ . At test time, the stored population statistics are used to normalize the feature map. In the standalone setting, both batch and population statistics are unbiased estimators of the population distribution $\mathcal { N } ( \mu , \sigma )$ .
+
+![](images/097b99a6ea8098381ddda49bd7da3b1612f5bd27425fd0a6d7d1e0d2d298b38e.jpg)  
+Figure 5: Batch normalization in standalone and super-net training.
+
+By contrast, when training a super-net (Figure 5 (Bottom)) the population statistics that are computed based on the running average are not unbiased estimators of the population distribution, because the effective architecture before the BN layer varies in each epoch. More formally, let $f _ { A _ { i } }$ denote the $i$ -th architecture. During training, the batch statistics are computed as $\textstyle { \mu _ { B } ^ { i } = \sum _ { j } f _ { A _ { i } } ( \bar { x } _ { j } ) } / m$ , and the output feature follows the distribution $\mathcal { N } ( \mu _ { B } ^ { i } , \sigma _ { B } ^ { i } )$ , where the superscript $i$ indicates that the current batch statistics depends on $A _ { i }$ only. The population mean statistics is then updated as $\hat { \mu }  \gamma \hat { \mu } + ( 1 - \gamma ) \mu _ { B } ^ { i }$ . However, during training, different architecture from the super-net are sampled. Therefore, the population mean statistics essentially becomes a weighted combination of means from different architectures, i.e., $\bar { \mu }  \textstyle \sum { \alpha _ { i } \mu _ { B } ^ { i } } = \textstyle \sum { \alpha _ { i } f _ { A _ { i } } ( x ) }$ , where $\alpha _ { i }$ is the sampling frequency of the $i$ -th architecture. When evaluating a specific architecture $A _ { i }$ at test time, the estimated population statistics thus depend on the other architectures in the super-net. This leads to a train-test discrepancy. One solution to mitigate this problem is to re-calibrate the batch statistics by recomputing the statistics on the entire training set before the the final evaluation (Yu & Huang, 2019). While the cost of doing so is negligible for a standalone network, NAS algorithms typically sample $\sim 1 0 ^ { 5 }$ architectures for evaluation, which makes this approach intractable.
+
+![](images/88a8290dd3f707ce7e1e63af3e468cae9961027ebdce1bdfa8ae1bf61800e9af.jpg)  
+Figure 6: Validation of BN.
+
+In contrast to Dong & Yang (2020) and Bender et al. (2020) who use the training mode also during testing, we formalize a simple, yet effective, approach to tackle the train-test discrepancy of BN in super-net training: we leave the normalization based on batch statistics during training unchanged, but use batch statistics also during testing. Since super-net evaluation is always conducted over a complete dataset, we are free to perform inference in mini-batches of the same size as the ones used during training. This allows us to compute the batch statistics on the fly in the exact same way as during training.
+
+Figure 6 compares standard BN to our proposed modification. Using the tracked population statistics leads to many architectures with an accuracy around $10 \%$ , i.e., performing no better than random guessing. Our proposed modification allows us to significantly increase the fraction of high-performing architectures. Our results also show that the choice of fixing vs. learning an affine transformation in batch normalization should match the standalone protocol $P _ { p r o x y }$ .
+
+![](images/d0bae44d8ba4dbd9c53630d367aa2579be0af1410a58ec098d3341a04a3d50b4.jpg)  
+Figure 7: Loss landscapes.
+
+![](images/18c3e8683febe2570d105043c4ee42b1fe96a8ce5f9b895ab808dfe5ed097d7f.jpg)  
+Figure 8: Learning rate on NASBench-201.
+
+# 4.3 SUPER-NET LOSS LANDSCAPES
+
+The training loss of the super-net encompasses the task losses of all possible architectures. We suspect that the training difficulty increases with the number of architectures represented by the super-net. To better study this, we visualize the loss landscape (Li et al., 2018) of the standalone network and a super-net with $n = 3 0 0$ architectures. Concretely, the landscape is computed over the super-net training loss under the single-path one-shot sampling method,
+
+$$
+\mathcal { L } _ { s } ( x , \theta _ { s } ) = \sum _ { i } \mathcal { L } _ { s } ( x , \theta _ { i } ) , \quad \mathrm { w h e r e } \forall i , \cup _ { i } \theta _ { i } = \theta _ { s } .
+$$
+
+Figure 7 shows that the loss landscape of the super-net is less smooth than that of a standalone architecture, which confirms our intuition. A smoother landscape indicates that optimization will converge more easily to a good local optimum. With a smooth landscape, one can thus use a relatively large learning. By contrast, a less smooth landscape requires using a smaller one.
+
+Our experiments further confirm this observation. In the standalone protocol $P _ { p r o x y }$ , the learning rate is set to 0.2 for NASBench-101, and to 0.1 for NASBench-201 and DARTS-NDS, respectively. All protocols use a cosine learning rate decay. Figure 8 shows that super-net training requires lower learning rates than standalone training. The same trend is shown for other search spaces in Appendix C.1. We set the learning rate to 0.025 to be consistent across the three search spaces.
+
+# .4 LOWER FIDELITY ESTIMATES LOWER THE RANKING CORRELATION
+
+Reducing memory foot-print and training time by proposing smaller super-nets has been an active research direction, and the resulting super-nets are referred to as lower fidelity estimates (Elsken et al., 2019). The impact of this approach on the super-net quality, however, has never been studied systematically over multiple search spaces . We compare four popular strategies in Table 2. We deliberately prolong the training epochs inversely proportionally to the computational budget that would be saved by the low-fidelity estimates, e.g. if the channel number is reduced by half, we train the model for two times more epoch. Note that this provides an upper bound to the performance of low-fidelity estimates.
+
+A commonly-used approach to reduce memory requirements is to decrease the batch size (Yang
+
+Table 2: Low fidelity estimates under same computational budget, reporting final search model accuracy (FSA) and sparse Kendall-Tau (S-KdT) on NASBench-201.   
+
+<table><tr><td>Metrics</td><td colspan="3">Settings</td></tr><tr><td>Repeated cells</td><td>3</td><td>2</td><td>1</td></tr><tr><td>S-KdT FSA</td><td>0.751± 0.09</td><td>0.692 ±0.18</td><td>0.502 ± 0.21</td></tr><tr><td></td><td>91.91 ± 0.09</td><td>91.95 ± 0.10</td><td>90.30 ± 0.71</td></tr><tr><td>Init Channel</td><td>16</td><td>8</td><td>4</td></tr><tr><td>S-KdT FSA</td><td>0.740 ± 0.07 92.92 ± 0.48</td><td>0.677 ± 0.10 92.32 ± 0.37</td><td>0.691 ± 0.15 92.79± 0.85</td></tr><tr><td>Batch-size</td><td></td><td></td><td></td></tr><tr><td>S-KdT</td><td>256</td><td>128</td><td>64</td></tr><tr><td>FSA</td><td>0.740±0.07 92.92 ± 0.48</td><td>0.728 ±0.16 92.37 ± 0.61</td><td>0.703 ± 0.16 92.35 ± 0.34</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Train portion</td><td>0.75</td><td>0.5</td><td>0.25</td></tr><tr><td>S-KdT FSA</td><td>0.751 ± 0.11 92.13 ± 0.51</td><td>0.742 ± 0.12 92.74 ± 0.43</td><td>0.693 ± 0.13 91.47 ± 0.81</td></tr></table>
+
+et al., 2020). Surprisingly, lowering the batch size from 256 to 64 has limited impact on the accuracy, but decreases sparse Kendall-Tau and the final searched model’s performance, the most important metric in practice.
+
+Another approach is to decrease the number of channels in the first layer (Liu et al., 2019b). This reduces the total number of parameters proportionally, since the number of channels in consecutive layers depends on the first one. Table 2 shows that this decreases the sparse Kendall-Tau from 0.7 to 0.5. By contrast, reducing the number of repeated cells (Pham et al., 2018; Chu et al., 2019) by one has little impact. Hence, to train a good super-net, one should avoid changes between $f _ { w s }$ and $f _ { p r o x y }$ , but one can reduce the batch size by a factor $> 0 . 5$ and use only one repeated cell.
+
+Table 3: Dynamic channels on NASBench-101.   
+
+<table><tr><td>Type</td><td>Accuracy</td><td>S-KdT</td><td>P&gt;R</td><td>Final searched model</td></tr><tr><td>Fixed</td><td>71.52 ± 6.94</td><td>0.22</td><td>0.546</td><td>91.79 ± 1.72</td></tr><tr><td>Shuffle</td><td>31.79 ± 10.90</td><td>0.17</td><td>0.391</td><td>90.58 ± 1.58</td></tr><tr><td>Interpolate</td><td>57.53 ± 10.05</td><td>0.37</td><td>0.865</td><td>93.35 ± 3.27</td></tr><tr><td>Baselinet</td><td>76.91 ± 10.05</td><td>0.22</td><td>0.865</td><td>89.43± 4.30</td></tr><tr><td>Baseline-v2</td><td>75.18± 9.28</td><td>0.33</td><td>0.891</td><td>91.27 ± 1.18</td></tr><tr><td>Ours</td><td>76.95 ± 8.29</td><td>0.46</td><td>0.949</td><td>93.65 ± 0.73</td></tr></table>
+
+† See Appendix C.3 for more details.
+
+![](images/84a6e9175d351bc94c6c0098d840e687e17917e206c44657a299f25099c579c6.jpg)  
+Figure 9: NASBench-101 dynamic channel.
+
+The last lower-fidelity factor is the portion of training data that is used (Liu et al., 2019b; Xu et al., 2020). Surprisingly, reducing the training portion only marginally decreases the sparse Kendall-Tau for all three search spaces. On NASBench-201, keeping only $2 5 \%$ of the CIFAR-10 dataset results in a 0.1 drop in sparse Kendall-Tau. This explains why DARTS-based methods typically use only $50 \%$ of the data to train the super-net but can still produce reasonable results.
+
+# 4.5 DYNAMIC CHANNELING HURTS SUPER-NET QUALITY
+
+Dynamic channeling is an implicit factor in many search spaces (Ying et al., 2019; Cai et al., 2019; Guo et al., 2019; Dong & Yang, 2019b). It refers to the fact that the number of channels of the intermediate layers depends on the number of incoming edges to the output node. This is depicted by Figure 9 (a): for a search cell with $n$ intermediate nodes, where $X$ and $Y$ are the input and output node with $C _ { i n }$ and $C _ { o u t }$ channels, respectively. When there are $n = 2$ edges (c.f. Figure 9 $( b )$ ), the associated channel numbers decrease so that their sum equals $C _ { o u t }$ . That is, the intermediate nodes have $\lfloor C _ { o u t } / 2 \rfloor$ channels. In the general case, shown in Figure 9 (c), the number of channels in intermediate nodes is thus $\lfloor C _ { o u t } / n \rfloor$ for $n$ incoming edges. A weight sharing approach has to cope with this architecture-dependent fluctuation of the number of channels during training.
+
+Let $C$ denote the number of channels of a given architecture, and $C _ { m a x }$ the maximum number of channels for a node across the entire search space. All existing approaches allocate $C _ { m a x }$ channels and, during training, extract a subset of these channels. The existing methods then differ in how they extract the channels: Guo et al. (2019) use a fixed chunk of channels, e.g., $[ 0 : C ]$ ; Zhang et al. (2018) randomly shuffle the channels before extracting a fixed chunk; and Dong & Yang (2019a) linearly interpolate the $C _ { m a x }$ channels into $C$ channels using a moving average across neighboring channels.
+
+Instead of sharing the channels between architectures, we propose to disable dynamic channelling completely. As the channel number only depends on the incoming edges, we separate the search space into a discrete number of sub-spaces, each with a fixed number of incoming edges. As shown in Table 3, disabling dynamic channeling improves the sparse Kendall-Tau and the final search performance by a large margin and yields a new state of the art on NASBench101.
+
+We compose another baseline, where we enable dynamic channeling during super-net training. During validation, we compute the average sparse Kendall-Tau of each sub-space, where we sample 200 architectures that shares the same number of channels. We call this baseline-v2. In Table 3, we can see this surpasses the original baseline by a significant margin. It further evidence the importance of disabling dynamic channels. Nonetheless, the best is to disable dynamic channeling during both the training and the validation phase.
+
+# 5 HOW SHOULD YOU TRAIN YOUR SUPER-NET?
+
+Figure 10 summarizes the influence of all tested factors on the final performance. It stands out that properly tuned hyper-parameters lead to the biggest improvements by far. Surprisingly, most other factors and techniques either have a hardly measurable effect or in some cases even lead to worse performance. Based on these findings, here is how you should train your super-net:
+
+![](images/f7b2ac1cd701333de67963633d61df0ce4d2c5a55802cd105796072b2d413fdd.jpg)  
+Figure 10: Influence of factors on the final model. We plot the difference in percent between the searched model’s performance with and without applying the corresponding factor. For the hyper-parameters of $P _ { w s }$ , the baseline is Random NAS, as reported in Table 4. For the other factors, the baseline of each search space uses the best setting of the hyper-parameters. Each experiment was run at least 3 times.
+
+1. Do not use super-net accuracy to judge the quality of your super-net. The sparse Kendall-Tau has much higher correlation with the final search performance.   
+2. When batch normalization is used, do not use the moving average statistics during evaluation. Instead, compute the statistics on the fly over a batch of the same size as used during training.   
+3. The loss landscape of super-nets is less smooth than that of standalone networks. Start from a smaller learning rate than standalone training.   
+4. Do not use other low-fidelity estimates than moderately reducing the training set size to decrease the search time.   
+5. Do not use dynamic channeling in search spaces that have a varying number of channels in the intermediate nodes. Break the search space into multiple sub-spaces such that dynamic channeling is not required.
+
+Comparison to the state of the art. Table 4 shows that carefully controlling the relevant factors and adopting the techniques proposed in Section 4 allow us to considerably improve the performance of Random-NAS. Thanks to our evaluation, we were able to show that simple Random-NAS together with an appropriate training protocol $P _ { w s }$ and mapping function $f _ { w s }$ yields results that are competitive to and sometimes even surpass state-of-the-art algorithms. Our results provide a strong baseline upon which future work can build.
+
+Table 4: Final results. Results on NASBench101 and 201 are from Yu et al. (2020b), and Dong & Yang (2020). We report the mean over 3 runs. Note that NASBench-101 ${ \mathit { n } } = 7 $ ) in ( $\mathrm { T u }$ et al., 2020b) is identical to our setting. Our new strategy significantly surpasses the random search baseline.
+
+<table><tr><td>Method</td><td>NASBench 101 (n=7)</td><td>NASBench 201</td><td>DARTS NDS</td><td>DARTS NDS*</td></tr><tr><td>ENAS</td><td>91.83 ±0.42</td><td>54.30±0.00</td><td>94.45 ± 0.09</td><td>97.11</td></tr><tr><td>DARTS-V2</td><td>92.21 ± 0.61</td><td>54.30 ±0.00</td><td>94.79 ± 0.11</td><td>97.37</td></tr><tr><td>NAO</td><td>92.59 ± 0.59</td><td></td><td></td><td>97.10</td></tr><tr><td>GDAS</td><td>=</td><td>93.51 ± 0.13</td><td></td><td>96.23</td></tr><tr><td>Random NAS</td><td>89.89 ± 3.89</td><td>87.66 ± 1.69</td><td>91.33 ±0.12</td><td>96.74†</td></tr><tr><td>Random NAS (Ours)</td><td>93.12 ±0.06</td><td>92.71 ± 0.15</td><td>94.26±0.05</td><td>97.08</td></tr></table>
+
+†Results from Li & Talwalkar (2019) ?Trained according to Liu et al. (2019b) for 600 epochs. DARTS-V2 (Liu et al., 2019b), ENAS (Pham et al., 2018), NAO (Luo et al., 2018). Random-NAS (Li & Talwalkar, 2019), GDAS (Dong & Yang, 2019b) On NASBench-201, both random NAS and our approach samples 100 final architectures to follow Dong & Yang (2020)
+
+# REFERENCES
+
+Gabriel Bender, Hanxiao Liu, Bo Chen, Grace Chu, Shuyang Cheng, Pieter-Jan Kindermans, and Quoc V. Le. Can weight sharing outperform random architecture search? an investigation with tunas. In CVPR, 2020.
+
+Han Cai, Ligeng Zhu, and Song Han. ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware. In ICLR, 2019.
+
+Han Cai, Chuang Gan, Tianzhe Wang, Zhekai Zhang, and Song Han. Once for all: Train one network and specialize it for efficient deployment. In ICLR, 2020. URL https://openreview.net/ forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HylxE1HKwS.
+
+Xin Chen, Lingxi Xie, Jun Wu, and Qi Tian. Progressive differentiable architecture search: Bridging the depth gap between search and evaluation. In ICCV, 2019a.
+
+Yukang Chen, Tong Yang, Xiangyu Zhang, Gaofeng Meng, Chunhong Pan, and Jian Sun. DetNAS: Neural Architecture Search on Object Detection. NeurIPS, 2019b.
+
+Xiangxiang Chu, Bo Zhang, Ruijun Xu, and Jixiang Li. FairNAS: Rethinking Evaluation Fairness of Weight Sharing Neural Architecture Search. arXiv:, 2019.
+
+Xuanyi Dong and Yi Yang. Network pruning via transformable architecture search. In Advances in Neural Information Processing Systems, pp. 760–771, 2019a.
+
+Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In CVPR, 2019b.
+
+Xuanyi Dong and Yi Yang. NAS-Bench-201: Extending the scope of reproducible neural architecture search. In ICLR, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HJxyZkBKDr.
+
+Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. Journal of Machine Learning Research, 20(55):1–21, 2019.
+
+Zichao Guo, Xiangyu Zhang, Haoyuan Mu, Wen Heng, Zechun Liu, Yichen Wei, and Jian Sun. Single Path One-Shot Neural Architecture Search with Uniform Sampling. ECCV, 2019.
+
+Haifeng Jin, Qingquan Song, and Xia Hu. Auto-Keras: An efficient neural architecture search system. In International Conference on Knowledge Discovery & Data Mining, 2019.
+
+Kirthevasan Kandasamy, Willie Neiswanger, Jeff Schneider, Barnabas Poczos, and Eric P Xing. Neural architecture search with bayesian optimisation and optimal transport. In NeurIPS, 2018.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. CIFAR-10 (canadian institute for advanced research). 2009.
+
+Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In NeurIPS, 2018.
+
+Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. UAI, 2019.
+
+Xiang Li, Chen Lin, Chuming Li, Ming Sun, Wei Wu, Junjie Yan, and Wanli Ouyang. Improving one-shot NAS by suppressing the posterior fading. CVPR, 2020.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In ECCV, 2018.
+
+Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan Yuille, and Li Fei-Fei. Auto-DeepLab: Hierarchical Neural Architecture Search for Semantic Image Segmentation. CVPR, 2019a.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. ICLR, 2019b.
+
+Zhichao Lu, Ian Whalen, Vishnu Boddeti, Yashesh Dhebar, Kalyanmoy Deb, Erik Goodman, and Wolfgang Banzhaf. NSGA-NET: A multi-objective genetic algorithm for neural architecture search. arXiv:1810.03522, 2018.
+
+Renqian Luo, Fei Tian, Tao Qin, En-Hong Chen, and Tie-Yan Liu. Neural architecture optimization. In NeurIPS, 2018.
+
+Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Daniel Fink, Olivier Francon, Bala Raju, Hormoz Shahrzad, Arshak Navruzyan, Nigel Duffy, et al. Evolving deep neural networks. In Artificial Intelligence in the Age of Neural Networks and Brain Computing, pp. 293–312. 2019.
+
+Niv Nayman, Asaf Noy, Tal Ridnik, Itamar Friedman, Rong Jin, and Lihi Zelnik. Xnas: Neural architecture search with expert advice. In NeurIPS, 2019.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. ICML, 2018.
+
+Ilija Radosavovic, Justin Johnson, Saining Xie, Wan-Yen Lo, and Piotr Dollar. On Network Design ´ Spaces for Visual Recognition. In ICCV, 2019.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V. Le, and Alexey Kurakin. Large-scale evolution of image classifiers. ICML, 2017.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. AAAI, 2019.
+
+Michael S. Ryoo, AJ Piergiovanni, Mingxing Tan, and Anelia Angelova. Assemblenet: Searching for multi-stream neural connectivity in video architectures. In ICLR, 2020. URL https:// openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ SJgMK64Ywr.
+
+David R. So, Chen Liang, and Quoc V. Le. The evolved transformer. In ICML, 2019.
+
+Linnan Wang, Saining Xie, Teng Li, Rodrigo Fonseca, and Yuandong Tian. Neural architecture search by learning action space for monte carlo tree search. AAAI, 2020. URL https://openreview. net/forum?id ${ . } = { }$ SklR6aEtwH.
+
+Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. FBNet: Hardware-Aware Efficient ConvNet Design via Differentiable Neural Architecture Search. CVPR, 2019.
+
+Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: Stochastic neural architecture search. ICLR, 2019.
+
+Yuhui Xu, Lingxi Xie, Xiaopeng Zhang, Xin Chen, Guo-Jun Qi, Qi Tian, and Hongkai Xiong. PC-DARTS: Partial channel connections for memory-efficient architecture search. In ICLR, 2020. URL https://openreview.net/forum?id $=$ BJlS634tPr.
+
+Antoine Yang, Pedro M. Esperanc¸a, and Fabio M. Carlucci. NAS evaluation is frustratingly hard. In ICLR, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HygrdpVKvr.
+
+Chris Ying, Aaron Klein, Esteban Real, Eric Christiansen, Kevin Murphy, and Frank Hutter. NASBench-101: Towards reproducible neural architecture search. ICLR, 2019.
+
+Jiahui Yu and Thomas S. Huang. Network slimming by slimmable networks: Towards one-shot architecture search for channel numbers. ICLR, 2019.
+
+Jiahui Yu, Pengchong Jin, Hanxiao Liu, Gabriel Bender, Pieter-Jan Kindermans, Mingxing Tan, Thomas Huang, Xiaodan Song, Ruoming Pang, and Quoc Le. BigNAS: Scaling Up Neural Architecture Search with Big Single-Stage Models. ECCV, 2020a.
+
+Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In ICLR, 2020b. URL https://openreview. net/forum?id ${ . } = { }$ H1loF2NFwr.
+
+Arber Zela, Thomas Elsken, Tonmoy Saikia, Yassine Marrakchi, Thomas Brox, and Frank Hutter. Understanding and robustifying differentiable architecture search. In ICLR, 2020a. URL https: //openreview.net/forum?id ${ . } =$ H1gDNyrKDS.
+
+Arber Zela, Julien Siems, and Frank Hutter. NAS-Bench-1Shot1: Benchmarking and dissecting one-shot neural architecture search. In ICLR, 2020b. URL https://openreview.net/ forum?id $_ { \cdot } =$ SJx9ngStPH.
+
+Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In CVPR, 2018.
+
+Hongpeng Zhou, Minghao Yang, Jun Wang, and Wei Pan. BayesNAS: A bayesian approach for neural architecture search. In ICML, 2019.
+
+Barret Zoph and Quoc V. Le. Neural Architecture Search with Reinforcement Learning. ICLR, 2017.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In CVPR, 2018.

parse/train/txC1ObHJ0wB/txC1ObHJ0wB_content_list.json

@@ -0,0 +1,1536 @@
+[
+    {
+        "type": "text",
+        "text": "HOW TO TRAIN YOUR SUPER-NET: AN ANALYSIS OF TRAINING HEURISTICS IN WEIGHT-SHARING NAS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Weight sharing promises to make neural architecture search (NAS) tractable even on commodity hardware. Existing methods in this space rely on a diverse set of heuristics to design and train the shared-weight backbone network, a.k.a. the supernet. Since heuristics substantially vary across different methods and have not been carefully studied, it is unclear to which extent they impact super-net training and hence the weight-sharing NAS algorithms. In this paper, we disentangle super-net training from the search algorithm, isolate 14 frequently-used training heuristics, and evaluate them over three benchmark search spaces. Our analysis uncovers that several commonly-used heuristics negatively impact the correlation between supernet and stand-alone performance, whereas simple, but often overlooked factors, such as proper hyper-parameter settings, are key to achieve strong performance. Equipped with this knowledge, we show that simple random search achieves competitive performance to complex state-of-the-art NAS algorithms when the super-net is properly trained. ",
+        "bbox": [
+            233,
+            265,
+            766,
+            457
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            336,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural architecture search (NAS) has received growing attention in the past few years, yielding stateof-the-art performance on several machine learning tasks (Liu et al., 2019a; Wu et al., 2019; Chen et al., 2019b; Ryoo et al., 2020). One of the milestones that led to the popularity of NAS is weight sharing (Pham et al., 2018; Liu et al., 2019b), which, by allowing all possible network architectures to share the same parameters, has reduced the computational requirements from thousands of GPU hours to just a few. Figure 1 shows the two phases that are common to weight-sharing NAS (WS-NAS) algorithms: the search phase, including the design of the search space and the search algorithm; and the evaluation phase, which encompasses the final training protocol on the proxy task 1. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While most works focus on developing a good sampling algorithm (Cai et al., 2019; Xie et al., 2019) or improving existing ones (Zela et al., 2020a; Nayman et al., 2019; Li et al., 2020), they tend to overlook or gloss over important factors related to the design and training of the shared-weight backbone network, i.e. the super-net. For example, the literature encompasses significant variations of learning hyper-parameter settings, batch normalization and dropout usage, capacities for the initial layers of the network, and depth of the super-net. Furthermore, some of these heuristics are directly transferred from standalone network training to super-net training without carefully studying their impact in this drastically different scenario. For example, the fundamental assumption of batch normalization that the input data follows a slowly changing distribution whose statistics can be tracked during training is violated in WS-NAS, but nonetheless typically assumed to hold. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            768
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we revisit and systematically evaluate commonly-used super-net design and training heuristics and uncover the strong influence of certain factors on the success of super-net training. To this end, we leverage three benchmark search spaces, NASBench-101 (Ying et al., 2019), NASBench201 (Dong & Yang, 2020), and DARTS-NDS (Radosavovic et al., 2019), for which the ground-truth stand-alone performance of a large number of architectures is available. We report the results of our experiments according to two sets of metrics: i) metrics that directly measure the quality of the super-net, such as the widely-adopted super-net accuracy 2 and a modified Kendall-Tau correlation between the searched architectures and their ground-truth performance, which we refer to as sparse ",
+        "bbox": [
+            174,
+            776,
+            825,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c9f1fb332802d0a69c31ec05ae6a3107427c64b71219d8cedb6fb6cc6b9ad2a.jpg",
+        "image_caption": [
+            "Figure 1: WS-NAS benchmarking. Green blocks indicate which aspects of NAS are benchmarked in different works. A search algorithm usually consists of a search space that encompass many architectures, and a policy to select the best one. $P$ indicates a training protocol, and $f$ a mapping function from the search space to a neural network. (a) Early works fixed and compared the metrics on the proxy task, which doesn’t allow for a holistic comparison between algorithms. $\\mathbf { ( b ) }$ The NASBench benchmark series partially alleviates the problem by sharing the stand-alone training protocol and search space across algorithms. However, the design of the weight-sharing search space and training protocol is still not controlled. (c) We fill this gap by benchmarking existing techniques to construct and train the shared-weight backbone. We provide a controlled evaluation across three benchmark spaces. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            66,
+            741,
+            332
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Kendall-Tau; ii) proxy metrics such as the ability to surpass random search and the stand-alone accuracy of the model found by the WS-NAS algorithm. ",
+        "bbox": [
+            176,
+            491,
+            821,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Via our extensive experiments (over 700 GPU days), we uncover that (i) the training behavior of a super-net drastically differs from that of a standalone network, e.g., in terms of feature statistics and loss landscape, thus allowing us to define training factor settings, e.g., for batch-normalization (BN) and learning rate, that are better suited for super-nets; (ii) while some neglected factors, such as the number of training epochs, have a strong impact on the final performance, others, believed to be important, such as path sampling, only have a marginal effect, and some commonly-used heuristics, such as the use of low-fidelity estimates, negatively impact it; (iii) the commonly-adopted super-net accuracy is unreliable to evaluate the super-net quality. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Altogether, our work is the first to systematically analyze the impact of the diverse factors of super-net design and training, and we uncover the factors that are crucial to design a super-net, as well as the non-important ones. Aggregating these findings allows us to boost the performance of simple weight-sharing random search to the point where it reaches that of complex state-of-the-art NAS algorithms across all tested search spaces. We will release our code and trained models so as to establish a solid baseline to facilitate further research. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            524,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first introduce the necessary concepts that will be used throughout the paper. As shown in Figure $1 ( a )$ , weight-sharing NAS algorithms consist of three key components: a search algorithm that samples an architecture from the search space in the form of an encoding, a mapping function $f _ { p r o x y }$ that maps the encoding into its corresponding neural network, and a training protocol for a proxy task $P _ { p r o x y }$ for which the network is optimized. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To train the search algorithm, one needs to additionally define the mapping function $f _ { w s }$ that generates the shared-weight network. Note that the mapping $f _ { p r o x y }$ frequently differs from $f _ { w s }$ , since in practice the final model contains many more layers and parameters so as to yield competitive results on the proxy task. After fixing $f _ { w s }$ , a training protocol $P _ { w s }$ is required to learn the super-net. In practice, $P _ { w s }$ often hides factors that are critical for the final performance of an approach, such as hyper-parameter settings or the use of data augmentation strategies to achieve state-of-the-art performance (Liu et al., 2019b; Chu et al., 2019; Zela et al., 2020a). Again, $P _ { w s }$ may differ from $P _ { p r o x y }$ , which is used to train the architecture that has been found by the search. For example, our experiments reveal that the learning rate and the total number of epochs frequently differ due to the different training behavior of the super-net and stand-alone architectures. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Many strategies have been proposed to implement the search algorithm, such as reinforcement learning (Zoph & Le, 2017; Zoph et al., 2018), evolutionary algorithms (Real et al., 2017; Miikkulainen et al., 2019; So et al., 2019; Liu et al., 2018; Lu et al., 2018), gradient-based optimization (Liu et al., 2019b; Xu et al., 2020; Li et al., 2020), Bayesian optimization (Kandasamy et al., 2018; Jin et al., 2019; Zhou et al., 2019; Wang et al., 2020), and separate performance predictors (Liu et al., 2018; Luo et al., 2018). Until very recently, the common trend to evaluate NAS consisted of reporting the searched architecture’s performance on the proxy task (Xie et al., 2019; Real et al., 2019; Ryoo et al., 2020). This, however, hardly provides real insights about the NAS algorithms themselves, because of the many components involved in them. Many factors that differ from one algorithm to another can influence the performance. In practice, the literature even commonly compares NAS methods that employ different protocols to train the final model. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            330
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Li & Talwalkar (2019) and Yu et al. (2020b) were the first to systematically compare different algorithms with the same settings for the proxy task and using several random initializations. Their surprising results revealed that many NAS algorithms produce architectures that do not significantly outperform a randomly-sampled architecture. Yang et al. (2020) highlighted the importance of the training protocol $P _ { p r o x y }$ . They showed that optimizing the training protocol can improve the final architecture performance on the proxy task by three percent on CIFAR-10. This non-trivial improvement can be achieved regardless of the chosen sampler, which provides clear evidence for the importance of unifying the protocol to build a solid foundation for comparing NAS algorithms. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In parallel to this line of research, the recent series of “NASBench” works (Ying et al., 2019; Zela et al., 2020b; Dong & Yang, 2020) proposed to benchmark NAS approaches by providing a complete, tabular characterization of a search space. This was achieved by training every realizable stand-alone architecture using a fixed protocol $P _ { p r o x y }$ . Similarly, other works proposed to provide a partial characterization by sampling and training a sufficient number of architectures in a given search space using a fixed protocol (Radosavovic et al., 2019; Zela et al., 2020a; Wang et al., 2020). ",
+        "bbox": [
+            174,
+            454,
+            825,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While recent advances for systematic evaluation are promising, no work has yet thoroughly studied the influence of the super-net training protocol $P _ { w s }$ and the mapping function $f _ { w s }$ . Previous works (Zela et al., 2020a; Li & Talwalkar, 2019) performed hyper-parameter tuning to evaluate their own algorithms, and focused only on a few parameters. We fill this gap by benchmarking different choices of $P _ { w s }$ and $f _ { w s }$ and by proposing novel variations to improve the super-net quality. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recent works have shown that sub-nets of super-net training can surpass some human designed models without retraining (Yu et al., 2020a; Cai et al., 2020) and that reinforcement learning can surpass the performance of random search (Bender et al., 2020). However, these findings are still only shown on MobileNet-like search spaces where we only search for the size of convolution kernels and the channel ratio for each layer. This is an effective approach to discover a compact network, but it does not change the fact that on cell-based search space super-net quality remains low. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 EVALUATION METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            452,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first isolate 14 factors that need to be considered during the design and training of a super-net, and then introduce the metrics to evaluate the quality of the trained super-net. Note that these factors are agnostic to the search policy that is used after training the super-net. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DISENTANGLING THE SUPER-NET FROM THE SEARCH ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            671,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to evaluate the influence of the super-net mapping $f _ { w s }$ and weight-sharing training protocol $P _ { w s }$ . As shown in Figure 2, $f _ { w s }$ translates an architecture encoding, which typically consists of a discrete number of choices or parameters, into a neural network. Based on a well-defined mapping, the super-net is a network in which every sub-path has a one-to-one mapping with an architecture encoding (Pham et al., 2018). Recent works $\\mathrm { { X u } }$ et al., 2020; Li et al., 2020; Ying et al., ",
+        "bbox": [
+            174,
+            854,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/51fabc8d7e550e124f2e594edf2fb9a728c1b7b5111cdab7dc06856d2c09ce65.jpg",
+        "table_caption": [
+            "Table 1: Summary of factors "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">WS Mapping fws</td><td colspan=\"2\">WS Protocol Pws</td></tr><tr><td>implementation</td><td>low fidelity</td><td>hyperparam.</td><td>sampling</td></tr><tr><td>Dynamic Channeling OFA Conv WSBN Dropout</td><td>#layer train portion batch size # channels</td><td>batch-norm learning rate epochs weight decay</td><td>FairNAS Random-NAS Random-A</td></tr></table>",
+        "bbox": [
+            176,
+            95,
+            485,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/463271dd9cea14da998c14fcf209e360895a954aa979a36fcfdd692e498d3c94.jpg",
+        "image_caption": [
+            "Figure 2: Constructing a super-net "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            93,
+            818,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2019) separate the encoding into cell parameters, which define the basic building blocks of a network, and macro parameters, which define how cells are assembled into a complete architecture. ",
+        "bbox": [
+            169,
+            227,
+            825,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Weight-sharing mapping $f _ { w s }$ . To make the search space manageable, all cell and macro parameters are fixed during the search, except for the topology of the cell and its possible operations. However, the exact choices for each of these fixed factors differ between algorithms and search spaces. We report the common factors in the left part of Table 1. They include various implementation choices, e.g., the use of convolutions with a dynamic number of channels (Dynamic Channeling), super-convolutional layers that support dynamic kernel sizes (OFA Kernel) (Cai et al., 2020), weight-sharing batchnormalization (WSBN) that tracks independent running statistics and affine parameters for different incoming edges (Luo et al., 2018), and path and global dropout (Pham et al., 2018; Luo et al., 2018; Liu et al., 2019b). They also include the use of low-fidelity estimates (Elsken et al., 2019) to reduce the complexity of super-net training, e.g., by reducing the number of layers (Liu et al., 2019b) and channels (Yang et al., 2020; Chen et al., 2019a), the portion of the training set used for super-net training (Liu et al., 2019b), or the batch size (Liu et al., 2019b; Pham et al., 2018; Yang et al., 2020). ",
+        "bbox": [
+            174,
+            265,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Weight-sharing protocol $P _ { w s }$ . Given a mapping $f _ { w s }$ , different training protocols $P _ { w s }$ can be employed to train the super-net. Protocols can differ in the training hyper-parameters and the sampling strategies they rely on. We will evaluate the different hyper-parameter choices listed in the right part of Table 1. This includes the initial learning rate, the hyper-parameters of batch normalization, the total number of training epochs, and the amount of weight decay. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            510
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We randomly sample one path to train the super-net (Guo et al., 2019), which is also known as single-path one-shot (SPOS) or Random-NAS (Li & Talwalkar, 2019). The reason for this choice is that Random-NAS is equivalent to the initial state of many search algorithms (Liu et al., 2019b; Pham et al., 2018; Luo et al., 2018), some of which even freeze the sampler training so as to use random sampling to warm-up the super-net (Xu et al., 2020; Dong & Yang, 2019b). Note that we also evaluated two variants of Random-NAS, but found their improvement to be only marginal. Please see Appendix C.2 for more detail. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, for the sake of reproducibility, we ensure that $P _ { w s }$ and $P _ { p r o x y }$ , as well as $f _ { w s }$ and $f _ { p r o x y }$ , are as close to each other as possible. For the hyper-parameters of $P _ { w s }$ , we cross-validate each factor following the order in Table 1, and after each validation, use the value that yields the best performance in $P _ { p r o x y }$ . For all other factors, we change one factor at a time. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            675
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Search spaces. We use three commonly-used search spaces, for which a large number of stand-alone architectures have been trained and evaluated on CIFAR-10 (Krizhevsky et al., 2009) to obtain their ground-truth performance. In particular, we use NASBench-101 (Ying et al., 2019), which consists of 423, 624 architectures and is compatible with weight-sharing NAS (Yu et al., 2020b; Zela et al., 2020b); NASBench-201 (Dong & Yang, 2020), which contains more operations than NASBench-101 but fewer nodes; and DARTS-NDS (Radosavovic et al., 2019) that contains over $1 0 ^ { 1 3 }$ architectures of which a subset of 5000 models was sampled and trained in a stand-alone fashion. See Appendix A.2 for a detailed discussion. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 SPARSE KENDALL-TAU - A NOVEL SUPER-NET EVALUATION METRIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            818,
+            687,
+            832
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We define a novel super-net metric, which we name sparse Kendall-Tau. It is inspired by the KendallTau metric used by Yu et al. (2020b) to measure the discrepancy between the ordering of stand-alone architectures and the ordering that is implied by the trained super-net. An ideal super-net should yield the same ordering of architectures as the stand-alone one and thus would lead to a high Kendall-Tau. However, Kendall-Tau is not robust to negligible performance differences between architectures (c.f. Figure 3). To robustify this metric, we share the rank between two architectures if their stand-alone ",
+        "bbox": [
+            174,
+            845,
+            826,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "accuracies differ by less than a threshold $( 0 . 1 \\%$ here). Since the resulting ranks are sparse, we call this metric sparse Kendall-Tau (s-KdT). Note that we also compare Kendall-Tau and Spearman correlation in Appendix A.3, and provide implementation details in Appendix A.4. ",
+        "bbox": [
+            174,
+            125,
+            485,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/149043d346fa3ba4e64d9b60d0a73598d90d0dd4b86ffd5a08f10756c4196450.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Kendall Tau</td></tr><tr><td>original</td><td>0.6444</td></tr><tr><td>sparse</td><td>0.8140</td></tr></table>",
+        "bbox": [
+            727,
+            137,
+            820,
+            183
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although, sparse Kendall-Tau captures the super-net quality well, it may fail in extreme cases, such as when the top-performing architectures are ranked perfectly while poor ones are ordered randomly. To account for such rare situations and ensure the soundness of our analysis, we also report additional metrics. We define two groups of metrics to holistically evaluate different aspects of a trained super-net. The first ",
+        "bbox": [
+            174,
+            215,
+            485,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/833d29ee1aac1b8ac81197f787216600f0137c6ca77daf0ba561aada5ab69d2e.jpg",
+        "image_caption": [
+            "Figure 3: Kendall-Tau vs sparse Kendall-Tau. Kendall-Tau is not robust when many architectures have similar performance. Minor performance differences can lead to large perturbations in the ranking. Our sparse Kendall-Tau alleviates this by dismissing minor differences in performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            126,
+            712,
+            227
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "group of metrics directly evaluates the quality of the super-net, including sparse Kendall-Tau and the widely-adopted super-net accuracy. For the super-net accuracy, we report the average accuracy of 200 architectures on the validation set of the dataset of interest. We will refer to this metric simply as accuracy. It is frequently used (Guo et al., 2019; Chu et al., 2019) to assess the quality of the trained super-net, but we will show later that it is in fact a poor predictor of the final stand-alone performance. The metrics in the second group evaluate the search performance of a trained super-net. The first metric is the probability to surpass random search: Given the ground-truth rank $r$ of the best architecture found after $n$ runs and the maximum rank $r _ { m a x }$ , equal to the total number of architectures, the probability that the best architecture found is better than a randomly searched one is given by $p = 1 - \\bar { ( 1 - ( r / r _ { m a x } ) ) ^ { n } }$ . Finally, where appropriate, we report the stand-alone accuracy of the model that was found by the complete WS-NAS algorithm. Concretely, we randomly sample 200 architectures, select the 3 best models based on the super-net accuracy and query the ground-truth performance. We then take the mean of these architectures as stand-alone accuracy. Note that the same architectures are used to compute the sparse Kendall-Tau. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            290,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We provide an analysis on the impact of the factors that are shown in Table 1 across three different search spaces. Note that, in this section, we present the factors that are the most important for performance; our analysis of the remaining factors is provided in Appendix C. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EVALUATION OF A SUPER-NET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            423,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The standalone performance of the architecture that is found by a NAS algorithm is clearly the most important metric to judge its merits. However, in practice, one cannot access this metric—we wouldn’t need NAS if standalone performance was easy to query (the cost of computing stand-alone performance is discussed in Appendix B.2). Furthermore, stand-alone performance inevitably depends the sampling policy, and does not directly evaluate the quality of the super-net (see Appendix B.3). Consequently, it is important to rely on metrics that are well correlated with the final performance but can be queried efficiently. To this end, we collect all our experiments and plot the pairwise correlation between final performance, sparse Kendall-Tau, and super-net accuracy. As shown in Figure 4, the super-net accuracy has a low ",
+        "bbox": [
+            174,
+            678,
+            485,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9bbbf88b8ff46e3dc661ad3a1fb9b080e8445bd8a956a4fa0a17624818773028.jpg",
+        "image_caption": [
+            "Figure 4: Super-net evaluation. We collect all experiments across 3 benchmark spaces. (Top) Pairwise plots of super-net accuracy, final performance, and the sparse Kendall-Tau. Each point corresponds to statistics computed over a trained super-net. (Bottom) Spearman correlation coefficients between the metrics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            488,
+            678,
+            815,
+            814
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "correlation with the final performance on NASBench-101 and DARTS-NDS. Only on NASBench-201 does it reach a correlation of 0.52. The sparse Kendall-Tau yields a consistently higher correlation with the final performance. This is evidence that one should not focus too strongly on improving the super-net accuracy. While this metric remains computationally heavy, it serves as a middle ground that is feasible to evaluate in real-world applications. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the following experiments, we thus mainly rely on sparse Kendall-Tau, and use final search performance as a reference only. We report the training details in Appendix B.1 and the complete results of all metrics in Appendix C.6. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 BATCH NORMALIZATION IN THE SUPER-NET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            244,
+            519,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Batch normalization (BN) is commonly used in standalone networks to allow for faster and more stable training. It is thus also employed in most CNN search spaces. However, BN behaves differently in the context of WS-NAS, and special care has to be taken when using it. In a standalone network (c.f. Figure 5 (Top)), a BN layer during training computes the batch statistics $\\mu _ { B }$ and $\\sigma _ { B }$ , normalizes the activations $f _ { A } ( x )$ as $( f _ { A } ( \\boldsymbol { x } ) - \\mu _ { B } ) / \\sigma _ { B }$ , and finally updates the population statistics using a moving average. For instance, the mean statistics is updated as $\\hat { \\mu }  \\gamma \\hat { \\mu } + ( 1 - \\gamma ) \\mu _ { B }$ . At test time, the stored population statistics are used to normalize the feature map. In the standalone setting, both batch and population statistics are unbiased estimators of the population distribution $\\mathcal { N } ( \\mu , \\sigma )$ . ",
+        "bbox": [
+            173,
+            272,
+            823,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            348,
+            581,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/097b99a6ea8098381ddda49bd7da3b1612f5bd27425fd0a6d7d1e0d2d298b38e.jpg",
+        "image_caption": [
+            "Figure 5: Batch normalization in standalone and super-net training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            598,
+            357,
+            825,
+            488
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "By contrast, when training a super-net (Figure 5 (Bottom)) the population statistics that are computed based on the running average are not unbiased estimators of the population distribution, because the effective architecture before the BN layer varies in each epoch. More formally, let $f _ { A _ { i } }$ denote the $i$ -th architecture. During training, the batch statistics are computed as $\\textstyle { \\mu _ { B } ^ { i } = \\sum _ { j } f _ { A _ { i } } ( \\bar { x } _ { j } ) } / m$ , and the output feature follows the distribution $\\mathcal { N } ( \\mu _ { B } ^ { i } , \\sigma _ { B } ^ { i } )$ , where the superscript $i$ indicates that the current batch statistics depends on $A _ { i }$ only. The population mean statistics is then updated as $\\hat { \\mu }  \\gamma \\hat { \\mu } + ( 1 - \\gamma ) \\mu _ { B } ^ { i }$ . However, during training, different architecture from the super-net are sampled. Therefore, the population mean statistics essentially becomes a weighted combination of means from different architectures, i.e., $\\bar { \\mu }  \\textstyle \\sum { \\alpha _ { i } \\mu _ { B } ^ { i } } = \\textstyle \\sum { \\alpha _ { i } f _ { A _ { i } } ( x ) }$ , where $\\alpha _ { i }$ is the sampling frequency of the $i$ -th architecture. When evaluating a specific architecture $A _ { i }$ at test time, the estimated population statistics thus depend on the other architectures in the super-net. This leads to a train-test discrepancy. One solution to mitigate this problem is to re-calibrate the batch statistics by recomputing the statistics on the entire training set before the the final evaluation (Yu & Huang, 2019). While the cost of doing so is negligible for a standalone network, NAS algorithms typically sample $\\sim 1 0 ^ { 5 }$ architectures for evaluation, which makes this approach intractable. ",
+        "bbox": [
+            174,
+            452,
+            583,
+            744
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/88a8290dd3f707ce7e1e63af3e468cae9961027ebdce1bdfa8ae1bf61800e9af.jpg",
+        "image_caption": [
+            "Figure 6: Validation of BN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            599,
+            541,
+            815,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            744,
+            823,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In contrast to Dong & Yang (2020) and Bender et al. (2020) who use the training mode also during testing, we formalize a simple, yet effective, approach to tackle the train-test discrepancy of BN in super-net training: we leave the normalization based on batch statistics during training unchanged, but use batch statistics also during testing. Since super-net evaluation is always conducted over a complete dataset, we are free to perform inference in mini-batches of the same size as the ones used during training. This allows us to compute the batch statistics on the fly in the exact same way as during training. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 compares standard BN to our proposed modification. Using the tracked population statistics leads to many architectures with an accuracy around $10 \\%$ , i.e., performing no better than random guessing. Our proposed modification allows us to significantly increase the fraction of high-performing architectures. Our results also show that the choice of fixing vs. learning an affine transformation in batch normalization should match the standalone protocol $P _ { p r o x y }$ . ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0bae44d8ba4dbd9c53630d367aa2579be0af1410a58ec098d3341a04a3d50b4.jpg",
+        "image_caption": [
+            "Figure 7: Loss landscapes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            485,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/18c3e8683febe2570d105043c4ee42b1fe96a8ce5f9b895ab808dfe5ed097d7f.jpg",
+        "image_caption": [
+            "Figure 8: Learning rate on NASBench-201. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            514,
+            104,
+            820,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            168,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 SUPER-NET LOSS LANDSCAPES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            276,
+            429,
+            290
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The training loss of the super-net encompasses the task losses of all possible architectures. We suspect that the training difficulty increases with the number of architectures represented by the super-net. To better study this, we visualize the loss landscape (Li et al., 2018) of the standalone network and a super-net with $n = 3 0 0$ architectures. Concretely, the landscape is computed over the super-net training loss under the single-path one-shot sampling method, ",
+        "bbox": [
+            173,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d56e1f0ba139e03078041a501a308dfff2b7571ca1d554a52e787e3f8b199aba.jpg",
+        "text": "$$\n\\mathcal { L } _ { s } ( x , \\theta _ { s } ) = \\sum _ { i } \\mathcal { L } _ { s } ( x , \\theta _ { i } ) , \\quad \\mathrm { w h e r e } \\forall i , \\cup _ { i } \\theta _ { i } = \\theta _ { s } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            377,
+            665,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows that the loss landscape of the super-net is less smooth than that of a standalone architecture, which confirms our intuition. A smoother landscape indicates that optimization will converge more easily to a good local optimum. With a smooth landscape, one can thus use a relatively large learning. By contrast, a less smooth landscape requires using a smaller one. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            474
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiments further confirm this observation. In the standalone protocol $P _ { p r o x y }$ , the learning rate is set to 0.2 for NASBench-101, and to 0.1 for NASBench-201 and DARTS-NDS, respectively. All protocols use a cosine learning rate decay. Figure 8 shows that super-net training requires lower learning rates than standalone training. The same trend is shown for other search spaces in Appendix C.1. We set the learning rate to 0.025 to be consistent across the three search spaces. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": ".4 LOWER FIDELITY ESTIMATES LOWER THE RANKING CORRELATION ",
+        "text_level": 1,
+        "bbox": [
+            186,
+            568,
+            676,
+            580
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Reducing memory foot-print and training time by proposing smaller super-nets has been an active research direction, and the resulting super-nets are referred to as lower fidelity estimates (Elsken et al., 2019). The impact of this approach on the super-net quality, however, has never been studied systematically over multiple search spaces . We compare four popular strategies in Table 2. We deliberately prolong the training epochs inversely proportionally to the computational budget that would be saved by the low-fidelity estimates, e.g. if the channel number is reduced by half, we train the model for two times more epoch. Note that this provides an upper bound to the performance of low-fidelity estimates. ",
+        "bbox": [
+            174,
+            593,
+            483,
+            813
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A commonly-used approach to reduce memory requirements is to decrease the batch size (Yang ",
+        "bbox": [
+            174,
+            820,
+            483,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc205529a1ad9fb2961cfe3b6d8e2ca764ce84ce8f191007d387241844c417ac.jpg",
+        "table_caption": [
+            "Table 2: Low fidelity estimates under same computational budget, reporting final search model accuracy (FSA) and sparse Kendall-Tau (S-KdT) on NASBench-201. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Metrics</td><td colspan=\"3\">Settings</td></tr><tr><td>Repeated cells</td><td>3</td><td>2</td><td>1</td></tr><tr><td>S-KdT FSA</td><td>0.751± 0.09</td><td>0.692 ±0.18</td><td>0.502 ± 0.21</td></tr><tr><td></td><td>91.91 ± 0.09</td><td>91.95 ± 0.10</td><td>90.30 ± 0.71</td></tr><tr><td>Init Channel</td><td>16</td><td>8</td><td>4</td></tr><tr><td>S-KdT FSA</td><td>0.740 ± 0.07 92.92 ± 0.48</td><td>0.677 ± 0.10 92.32 ± 0.37</td><td>0.691 ± 0.15 92.79± 0.85</td></tr><tr><td>Batch-size</td><td></td><td></td><td></td></tr><tr><td>S-KdT</td><td>256</td><td>128</td><td>64</td></tr><tr><td>FSA</td><td>0.740±0.07 92.92 ± 0.48</td><td>0.728 ±0.16 92.37 ± 0.61</td><td>0.703 ± 0.16 92.35 ± 0.34</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Train portion</td><td>0.75</td><td>0.5</td><td>0.25</td></tr><tr><td>S-KdT FSA</td><td>0.751 ± 0.11 92.13 ± 0.51</td><td>0.742 ± 0.12 92.74 ± 0.43</td><td>0.693 ± 0.13 91.47 ± 0.81</td></tr></table>",
+        "bbox": [
+            500,
+            659,
+            821,
+            845
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "et al., 2020). Surprisingly, lowering the batch size from 256 to 64 has limited impact on the accuracy, but decreases sparse Kendall-Tau and the final searched model’s performance, the most important metric in practice. ",
+        "bbox": [
+            174,
+            848,
+            826,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another approach is to decrease the number of channels in the first layer (Liu et al., 2019b). This reduces the total number of parameters proportionally, since the number of channels in consecutive layers depends on the first one. Table 2 shows that this decreases the sparse Kendall-Tau from 0.7 to 0.5. By contrast, reducing the number of repeated cells (Pham et al., 2018; Chu et al., 2019) by one has little impact. Hence, to train a good super-net, one should avoid changes between $f _ { w s }$ and $f _ { p r o x y }$ , but one can reduce the batch size by a factor $> 0 . 5$ and use only one repeated cell. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/31285ec242fcc9471e705d94021b62779ae73c786bf6695087b454cb45a0b937.jpg",
+        "table_caption": [
+            "Table 3: Dynamic channels on NASBench-101. "
+        ],
+        "table_footnote": [
+            "† See Appendix C.3 for more details. "
+        ],
+        "table_body": "<table><tr><td>Type</td><td>Accuracy</td><td>S-KdT</td><td>P&gt;R</td><td>Final searched model</td></tr><tr><td>Fixed</td><td>71.52 ± 6.94</td><td>0.22</td><td>0.546</td><td>91.79 ± 1.72</td></tr><tr><td>Shuffle</td><td>31.79 ± 10.90</td><td>0.17</td><td>0.391</td><td>90.58 ± 1.58</td></tr><tr><td>Interpolate</td><td>57.53 ± 10.05</td><td>0.37</td><td>0.865</td><td>93.35 ± 3.27</td></tr><tr><td>Baselinet</td><td>76.91 ± 10.05</td><td>0.22</td><td>0.865</td><td>89.43± 4.30</td></tr><tr><td>Baseline-v2</td><td>75.18± 9.28</td><td>0.33</td><td>0.891</td><td>91.27 ± 1.18</td></tr><tr><td>Ours</td><td>76.95 ± 8.29</td><td>0.46</td><td>0.949</td><td>93.65 ± 0.73</td></tr></table>",
+        "bbox": [
+            176,
+            121,
+            485,
+            194
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/84a6e9175d351bc94c6c0098d840e687e17917e206c44657a299f25099c579c6.jpg",
+        "image_caption": [
+            "Figure 9: NASBench-101 dynamic channel. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            97,
+            823,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            243,
+            825,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The last lower-fidelity factor is the portion of training data that is used (Liu et al., 2019b; Xu et al., 2020). Surprisingly, reducing the training portion only marginally decreases the sparse Kendall-Tau for all three search spaces. On NASBench-201, keeping only $2 5 \\%$ of the CIFAR-10 dataset results in a 0.1 drop in sparse Kendall-Tau. This explains why DARTS-based methods typically use only $50 \\%$ of the data to train the super-net but can still produce reasonable results. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 DYNAMIC CHANNELING HURTS SUPER-NET QUALITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            398,
+            580,
+            412
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dynamic channeling is an implicit factor in many search spaces (Ying et al., 2019; Cai et al., 2019; Guo et al., 2019; Dong & Yang, 2019b). It refers to the fact that the number of channels of the intermediate layers depends on the number of incoming edges to the output node. This is depicted by Figure 9 (a): for a search cell with $n$ intermediate nodes, where $X$ and $Y$ are the input and output node with $C _ { i n }$ and $C _ { o u t }$ channels, respectively. When there are $n = 2$ edges (c.f. Figure 9 $( b )$ ), the associated channel numbers decrease so that their sum equals $C _ { o u t }$ . That is, the intermediate nodes have $\\lfloor C _ { o u t } / 2 \\rfloor$ channels. In the general case, shown in Figure 9 (c), the number of channels in intermediate nodes is thus $\\lfloor C _ { o u t } / n \\rfloor$ for $n$ incoming edges. A weight sharing approach has to cope with this architecture-dependent fluctuation of the number of channels during training. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Let $C$ denote the number of channels of a given architecture, and $C _ { m a x }$ the maximum number of channels for a node across the entire search space. All existing approaches allocate $C _ { m a x }$ channels and, during training, extract a subset of these channels. The existing methods then differ in how they extract the channels: Guo et al. (2019) use a fixed chunk of channels, e.g., $[ 0 : C ]$ ; Zhang et al. (2018) randomly shuffle the channels before extracting a fixed chunk; and Dong & Yang (2019a) linearly interpolate the $C _ { m a x }$ channels into $C$ channels using a moving average across neighboring channels. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Instead of sharing the channels between architectures, we propose to disable dynamic channelling completely. As the channel number only depends on the incoming edges, we separate the search space into a discrete number of sub-spaces, each with a fixed number of incoming edges. As shown in Table 3, disabling dynamic channeling improves the sparse Kendall-Tau and the final search performance by a large margin and yields a new state of the art on NASBench101. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            715
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compose another baseline, where we enable dynamic channeling during super-net training. During validation, we compute the average sparse Kendall-Tau of each sub-space, where we sample 200 architectures that shares the same number of channels. We call this baseline-v2. In Table 3, we can see this surpasses the original baseline by a significant margin. It further evidence the importance of disabling dynamic channels. Nonetheless, the best is to disable dynamic channeling during both the training and the validation phase. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 HOW SHOULD YOU TRAIN YOUR SUPER-NET? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            833,
+            581,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 10 summarizes the influence of all tested factors on the final performance. It stands out that properly tuned hyper-parameters lead to the biggest improvements by far. Surprisingly, most other factors and techniques either have a hardly measurable effect or in some cases even lead to worse performance. Based on these findings, here is how you should train your super-net: ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7b2ac1cd701333de67963633d61df0ce4d2c5a55802cd105796072b2d413fdd.jpg",
+        "image_caption": [
+            "Figure 10: Influence of factors on the final model. We plot the difference in percent between the searched model’s performance with and without applying the corresponding factor. For the hyper-parameters of $P _ { w s }$ , the baseline is Random NAS, as reported in Table 4. For the other factors, the baseline of each search space uses the best setting of the hyper-parameters. Each experiment was run at least 3 times. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            163,
+            99,
+            818,
+            204
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "1. Do not use super-net accuracy to judge the quality of your super-net. The sparse Kendall-Tau has much higher correlation with the final search performance.   \n2. When batch normalization is used, do not use the moving average statistics during evaluation. Instead, compute the statistics on the fly over a batch of the same size as used during training.   \n3. The loss landscape of super-nets is less smooth than that of standalone networks. Start from a smaller learning rate than standalone training.   \n4. Do not use other low-fidelity estimates than moderately reducing the training set size to decrease the search time.   \n5. Do not use dynamic channeling in search spaces that have a varying number of channels in the intermediate nodes. Break the search space into multiple sub-spaces such that dynamic channeling is not required. ",
+        "bbox": [
+            173,
+            290,
+            826,
+            440
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison to the state of the art. Table 4 shows that carefully controlling the relevant factors and adopting the techniques proposed in Section 4 allow us to considerably improve the performance of Random-NAS. Thanks to our evaluation, we were able to show that simple Random-NAS together with an appropriate training protocol $P _ { w s }$ and mapping function $f _ { w s }$ yields results that are competitive to and sometimes even surpass state-of-the-art algorithms. Our results provide a strong baseline upon which future work can build. ",
+        "bbox": [
+            174,
+            453,
+            485,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Final results. Results on NASBench101 and 201 are from Yu et al. (2020b), and Dong & Yang (2020). We report the mean over 3 runs. Note that NASBench-101 ${ \\mathit { n } } = 7 $ ) in ( $\\mathrm { T u }$ et al., 2020b) is identical to our setting. Our new strategy significantly surpasses the random search baseline. ",
+        "bbox": [
+            498,
+            452,
+            825,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/8087fd2c3ebf063ea4ca715db29a52b27cd0c8f0ef774988a074025af964b69b.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "†Results from Li & Talwalkar (2019) ?Trained according to Liu et al. (2019b) for 600 epochs. DARTS-V2 (Liu et al., 2019b), ENAS (Pham et al., 2018), NAO (Luo et al., 2018). Random-NAS (Li & Talwalkar, 2019), GDAS (Dong & Yang, 2019b) On NASBench-201, both random NAS and our approach samples 100 final architectures to follow Dong & Yang (2020) "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>NASBench 101 (n=7)</td><td>NASBench 201</td><td>DARTS NDS</td><td>DARTS NDS*</td></tr><tr><td>ENAS</td><td>91.83 ±0.42</td><td>54.30±0.00</td><td>94.45 ± 0.09</td><td>97.11</td></tr><tr><td>DARTS-V2</td><td>92.21 ± 0.61</td><td>54.30 ±0.00</td><td>94.79 ± 0.11</td><td>97.37</td></tr><tr><td>NAO</td><td>92.59 ± 0.59</td><td></td><td></td><td>97.10</td></tr><tr><td>GDAS</td><td>=</td><td>93.51 ± 0.13</td><td></td><td>96.23</td></tr><tr><td>Random NAS</td><td>89.89 ± 3.89</td><td>87.66 ± 1.69</td><td>91.33 ±0.12</td><td>96.74†</td></tr><tr><td>Random NAS (Ours)</td><td>93.12 ±0.06</td><td>92.71 ± 0.15</td><td>94.26±0.05</td><td>97.08</td></tr></table>",
+        "bbox": [
+            500,
+            546,
+            820,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Bender, Hanxiao Liu, Bo Chen, Grace Chu, Shuyang Cheng, Pieter-Jan Kindermans, and Quoc V. Le. Can weight sharing outperform random architecture search? an investigation with tunas. In CVPR, 2020. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Ligeng Zhu, and Song Han. ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware. In ICLR, 2019. ",
+        "bbox": [
+            169,
+            176,
+            823,
+            205
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Chuang Gan, Tianzhe Wang, Zhekai Zhang, and Song Han. Once for all: Train one network and specialize it for efficient deployment. In ICLR, 2020. URL https://openreview.net/ forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HylxE1HKwS. ",
+        "bbox": [
+            174,
+            214,
+            823,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xin Chen, Lingxi Xie, Jun Wu, and Qi Tian. Progressive differentiable architecture search: Bridging the depth gap between search and evaluation. In ICCV, 2019a. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yukang Chen, Tong Yang, Xiangyu Zhang, Gaofeng Meng, Chunhong Pan, and Jian Sun. DetNAS: Neural Architecture Search on Object Detection. NeurIPS, 2019b. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiangxiang Chu, Bo Zhang, Ruijun Xu, and Jixiang Li. FairNAS: Rethinking Evaluation Fairness of Weight Sharing Neural Architecture Search. arXiv:, 2019. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong and Yi Yang. Network pruning via transformable architecture search. In Advances in Neural Information Processing Systems, pp. 760–771, 2019a. ",
+        "bbox": [
+            173,
+            378,
+            823,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In CVPR, 2019b. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong and Yi Yang. NAS-Bench-201: Extending the scope of reproducible neural architecture search. In ICLR, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HJxyZkBKDr. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. Journal of Machine Learning Research, 20(55):1–21, 2019. ",
+        "bbox": [
+            173,
+            491,
+            823,
+            521
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zichao Guo, Xiangyu Zhang, Haoyuan Mu, Wen Heng, Zechun Liu, Yichen Wei, and Jian Sun. Single Path One-Shot Neural Architecture Search with Uniform Sampling. ECCV, 2019. ",
+        "bbox": [
+            173,
+            529,
+            825,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haifeng Jin, Qingquan Song, and Xia Hu. Auto-Keras: An efficient neural architecture search system. In International Conference on Knowledge Discovery & Data Mining, 2019. ",
+        "bbox": [
+            171,
+            566,
+            823,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kirthevasan Kandasamy, Willie Neiswanger, Jeff Schneider, Barnabas Poczos, and Eric P Xing. Neural architecture search with bayesian optimisation and optimal transport. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            604,
+            823,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. CIFAR-10 (canadian institute for advanced research). 2009. ",
+        "bbox": [
+            173,
+            641,
+            825,
+            670
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In NeurIPS, 2018. ",
+        "bbox": [
+            171,
+            679,
+            825,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. UAI, 2019. ",
+        "bbox": [
+            171,
+            717,
+            825,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiang Li, Chen Lin, Chuming Li, Ming Sun, Wei Wu, Junjie Yan, and Wanli Ouyang. Improving one-shot NAS by suppressing the posterior fading. CVPR, 2020. ",
+        "bbox": [
+            171,
+            755,
+            823,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In ECCV, 2018. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan Yuille, and Li Fei-Fei. Auto-DeepLab: Hierarchical Neural Architecture Search for Semantic Image Segmentation. CVPR, 2019a. ",
+        "bbox": [
+            174,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. ICLR, 2019b. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhichao Lu, Ian Whalen, Vishnu Boddeti, Yashesh Dhebar, Kalyanmoy Deb, Erik Goodman, and Wolfgang Banzhaf. NSGA-NET: A multi-objective genetic algorithm for neural architecture search. arXiv:1810.03522, 2018. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Renqian Luo, Fei Tian, Tao Qin, En-Hong Chen, and Tie-Yan Liu. Neural architecture optimization. In NeurIPS, 2018. ",
+        "bbox": [
+            171,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Daniel Fink, Olivier Francon, Bala Raju, Hormoz Shahrzad, Arshak Navruzyan, Nigel Duffy, et al. Evolving deep neural networks. In Artificial Intelligence in the Age of Neural Networks and Brain Computing, pp. 293–312. 2019. ",
+        "bbox": [
+            174,
+            194,
+            823,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Niv Nayman, Asaf Noy, Tal Ridnik, Itamar Friedman, Rong Jin, and Lihi Zelnik. Xnas: Neural architecture search with expert advice. In NeurIPS, 2019. ",
+        "bbox": [
+            173,
+            246,
+            823,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. ICML, 2018. ",
+        "bbox": [
+            174,
+            285,
+            823,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilija Radosavovic, Justin Johnson, Saining Xie, Wan-Yen Lo, and Piotr Dollar. On Network Design ´ Spaces for Visual Recognition. In ICCV, 2019. ",
+        "bbox": [
+            174,
+            324,
+            823,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V. Le, and Alexey Kurakin. Large-scale evolution of image classifiers. ICML, 2017. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. AAAI, 2019. ",
+        "bbox": [
+            171,
+            401,
+            825,
+            430
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael S. Ryoo, AJ Piergiovanni, Mingxing Tan, and Anelia Angelova. Assemblenet: Searching for multi-stream neural connectivity in video architectures. In ICLR, 2020. URL https:// openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ SJgMK64Ywr. ",
+        "bbox": [
+            173,
+            440,
+            823,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David R. So, Chen Liang, and Quoc V. Le. The evolved transformer. In ICML, 2019. ",
+        "bbox": [
+            174,
+            492,
+            730,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Linnan Wang, Saining Xie, Teng Li, Rodrigo Fonseca, and Yuandong Tian. Neural architecture search by learning action space for monte carlo tree search. AAAI, 2020. URL https://openreview. net/forum?id ${ . } = { }$ SklR6aEtwH. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. FBNet: Hardware-Aware Efficient ConvNet Design via Differentiable Neural Architecture Search. CVPR, 2019. ",
+        "bbox": [
+            176,
+            569,
+            825,
+            612
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: Stochastic neural architecture search. ICLR, 2019. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuhui Xu, Lingxi Xie, Xiaopeng Zhang, Xin Chen, Guo-Jun Qi, Qi Tian, and Hongkai Xiong. PC-DARTS: Partial channel connections for memory-efficient architecture search. In ICLR, 2020. URL https://openreview.net/forum?id $=$ BJlS634tPr. ",
+        "bbox": [
+            176,
+            660,
+            826,
+            703
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antoine Yang, Pedro M. Esperanc¸a, and Fabio M. Carlucci. NAS evaluation is frustratingly hard. In ICLR, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HygrdpVKvr. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Ying, Aaron Klein, Esteban Real, Eric Christiansen, Kevin Murphy, and Frank Hutter. NASBench-101: Towards reproducible neural architecture search. ICLR, 2019. ",
+        "bbox": [
+            171,
+            752,
+            823,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu and Thomas S. Huang. Network slimming by slimmable networks: Towards one-shot architecture search for channel numbers. ICLR, 2019. ",
+        "bbox": [
+            169,
+            790,
+            823,
+            819
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu, Pengchong Jin, Hanxiao Liu, Gabriel Bender, Pieter-Jan Kindermans, Mingxing Tan, Thomas Huang, Xiaodan Song, Ruoming Pang, and Quoc Le. BigNAS: Scaling Up Neural Architecture Search with Big Single-Stage Models. ECCV, 2020a. ",
+        "bbox": [
+            178,
+            829,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In ICLR, 2020b. URL https://openreview. net/forum?id ${ . } = { }$ H1loF2NFwr. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arber Zela, Thomas Elsken, Tonmoy Saikia, Yassine Marrakchi, Thomas Brox, and Frank Hutter. Understanding and robustifying differentiable architecture search. In ICLR, 2020a. URL https: //openreview.net/forum?id ${ . } =$ H1gDNyrKDS. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arber Zela, Julien Siems, and Frank Hutter. NAS-Bench-1Shot1: Benchmarking and dissecting one-shot neural architecture search. In ICLR, 2020b. URL https://openreview.net/ forum?id $_ { \\cdot } =$ SJx9ngStPH. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongpeng Zhou, Minghao Yang, Jun Wang, and Wei Pan. BayesNAS: A bayesian approach for neural architecture search. In ICML, 2019. ",
+        "bbox": [
+            173,
+            242,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V. Le. Neural Architecture Search with Reinforcement Learning. ICLR, 2017. ",
+        "bbox": [
+            174,
+            280,
+            825,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            304,
+            823,
+            333
+        ],
+        "page_idx": 11
+    }
+]