Add files using upload-large-folder tool

parse/train/BJrFC6ceg/BJrFC6ceg.md

@@ -0,0 +1,170 @@
+# PIXELCNN++: IMPROVING THE PIXELCNN WITH DISCRETIZED LOGISTIC MIXTURE LIKELIHOOD AND OTHER MODIFICATIONS
+
+Tim Salimans, Andrej Karpathy, Xi Chen, Diederik P. Kingma {tim,karpathy,peter,dpkingma}@openai.com
+
+# ABSTRACT
+
+PixelCNNs are a recently proposed class of powerful generative models with tractable likelihood. Here we discuss our implementation of PixelCNNs which we make available at https://github.com/openai/pixel-cnn. Our implementation contains a number of modifications to the original model that both simplify its structure and improve its performance. 1) We use a discretized logistic mixture likelihood on the pixels, rather than a 256-way softmax, which we find to speed up training. 2) We condition on whole pixels, rather than R/G/B sub-pixels, simplifying the model structure. 3) We use downsampling to efficiently capture structure at multiple resolutions. 4) We introduce additional short-cut connections to further speed up optimization. 5) We regularize the model using dropout. Finally, we present state-of-the-art log likelihood results on CIFAR-10 to demonstrate the usefulness of these modifications.
+
+# 1 INTRODUCTION
+
+The PixelCNN, introduced by van den Oord et al. (2016b), is a generative model of images with a tractable likelihood. The model fully factorizes the probability density function on an image $\mathbf { x }$ over all its sub-pixels (color channels in a pixel) as $\begin{array} { r } { p ( \mathbf { x } ) = \prod _ { i } p ( x _ { i } | \boldsymbol { x } _ { < i } ) } \end{array}$ . The conditional distributions $p ( x _ { i } | \boldsymbol x _ { < i } )$ are parameterized by convolutional neural networks and all share parameters. The PixelCNN is a powerful model as the functional form of these conditionals is very flexible. In addition it is computationally efficient as all conditionals can be evaluated in parallel on a GPU for an observed image $\mathbf { x }$ . Thanks to these properties, the PixelCNN represents the current state-of-the-art in generative modeling when evaluated in terms of log-likelihood. Besides being used for modeling images, the PixelCNN model was recently extended to model audio (van den Oord et al., 2016a), video (Kalchbrenner et al., 2016b) and text (Kalchbrenner et al., 2016a).
+
+For use in our research, we developed our own internal implementation of PixelCNN and made a number of modifications to the base model to simplify its structure and improve its performance. We now release our implementation at https://github.com/openai/pixel-cnn, hoping that it will be useful to the broader community. Our modifications are discussed in Section 2, and evaluated experimentally in Section 3. State-of-the-art log-likelihood results confirm their usefulness.
+
+# 2 MODIFICATIONS TO PIXELCNN
+
+We now describe the most important modifications we have made to the PixelCNN model architecure as described by van den Oord et al. (2016c). For complete details see our code release at https://github.com/openai/pixel-cnn.
+
+# 2.1 DISCRETIZED LOGISTIC MIXTURE LIKELIHOOD
+
+The standard PixelCNN model specifies the conditional distribution of a sub-pixel, or color channel of a pixel, as a full 256-way softmax. This gives the model a lot of flexibility, but it is also very costly in terms of memory. Moreover, it can make the gradients with respect to the network parameters very sparse, especially early in training. With the standard parameterization, the model does not know that a value of 128 is close to a value of 127 or 129, and this relationship first has to be learned before the model can move on to higher level structures. In the extreme case where a particular sub-pixel value is never observed, the model will learn to assign it zero probability. This would be especially problematic for data with higher accuracy on the observed pixels than the usual 8 bits: In the extreme case where very high precision values are observed, the PixelCNN, in its current form, would require a prohibitive amount of memory and computation, while learning very slowly. We therefore propose a different mechanism for computing the conditional probability of the observed discretized pixel values. In our model, like in the VAE of Kingma et al. (2016), we assume there is a latent color intensity $\nu$ with a continuous distribution, which is then rounded to its nearest 8-bit representation to give the observed sub-pixel value $x$ . By choosing a simple continuous distribution for modeling $\nu$ (like the logistic distribution as done by Kingma et al. (2016)) we obtain a smooth and memory efficient predictive distribution for $x$ . Here, we take this continuous univariate distribution to be a mixture of logistic distributions which allows us to easily calculate the probability on the observed discretized value $x$ , as shown in equation (2). For all sub-pixel values $x$ excepting the edge cases 0 and 255 we have:
+
+$$
+\begin{array} { l l l } { \displaystyle \nu } & { \sim } & { \displaystyle \sum _ { i = 1 } ^ { K } \pi _ { i } \mathrm { l o g i s t i c } ( \mu _ { i } , s _ { i } ) } \\ { P ( x | \pi , \mu , s ) } & { = } & { \displaystyle \sum _ { i = 1 } ^ { K } \pi _ { i } \left[ \sigma ( ( x + 0 . 5 - \mu _ { i } ) / s _ { i } ) - \sigma ( ( x - 0 . 5 - \mu _ { i } ) / s _ { i } ) \right] , } \end{array}
+$$
+
+where $\sigma ( )$ is the logistic sigmoid function. For the edge case of 0, replace $x - 0 . 5$ by $- \infty$ , and for 255 replace $x + 0 . 5$ by $+ \infty$ . Our provided code contains a numerically stable implementation for calculating the log of the probability in equation 2.
+
+Our approach follows earlier work using continuous mixture models (Domke et al., 2008; Theis et al., 2012; Uria et al., 2013; Theis & Bethge, 2015), but avoids allocating probability mass to values outside the valid range of [0, 255] by explicitly modeling the rounding of $\nu$ to $x$ . In addition, we naturally assign higher probability to the edge values 0 and 255 than to their neighboring values, which corresponds well with the observed data distribution as shown in Figure 1. Experimentally, we find that only a relatively small number of mixture components, say 5, is needed to accurately model the conditional distributions of the pixels. The output of our network is thus of much lower dimension, yielding much denser gradients of the loss with respect to our parameters. In our experiments this greatly sped up convergence during optimization, especially early on in training. However, due to the other changes in our architecture compared to that of van den Oord et al. (2016c) we cannot say with certainty that this would also apply to the original PixelCNN model.
+
+![](images/3eb5f29602b706d00be758d95223055ef088f0d6f7535514155c2b83996845a1.jpg)  
+Figure 1: Marginal distribution of all sub-pixel values in CIFAR-10. The edge value of 255 is much more frequent than its neighbouring values: This is easy to model using our rounding based approach, but harder using continuous or truncated distributions.
+
+# 2.2 CONDITIONING ON WHOLE PIXELS
+
+The pixels in a color image consist of three real numbers, giving the intensities of the red, blue and green colors. The original PixelCNN factorizes the generative model over these 3 sub-pixels. This allows for very general dependency structure, but it also complicates the model: besides keeping track of the spatial location of feature maps, we now have to separate out all feature maps in 3 groups depending on whether or not they can see the R/G/B sub-pixel of the current location. This added complexity seems to be unnecessary as the dependencies between the color channels of a pixel are likely to be relatively simple and do not require a deep network to model. Therefore, we instead condition only on whole pixels up and to the left in an image, and output joint predictive distributions over all 3 channels of a predicted pixel. The predictive distribution on a pixel itself can be interpreted as a simple factorized model: We first predict the red channel using a discretized mixture of logistics as described in section 2.1. Next, we predict the green channel using a predictive distribution of the same form. Here we allow the means of the mixture components to linearly depend on the value of the red sub-pixel. Finally, we model the blue channel in the same way, where we again only allow linear dependency on the red and green channels. For the pixel $( r _ { i , j } , g _ { i , j } , b _ { i , j } )$ at location $( i , j )$ in our image, the distribution conditional on the context $C _ { i , j }$ , consisting of the mixture indicator and the previous pixels, is thus
+
+$$
+\begin{array} { r c l } { p ( r _ { i , j } , g _ { i , j } , b _ { i , j } | C _ { i , j } ) } & { = } & { P ( r _ { i , j } | \mu _ { r } ( C _ { i , j } ) , s _ { r } ( C _ { i , j } ) ) \times P ( g _ { i , j } | \mu _ { g } ( C _ { i , j } , r _ { i , j } ) , s _ { g } ( C _ { i , j } ) ) } \\ & & { \times P ( b _ { i , j } | \mu _ { b } ( C _ { i , j } , r _ { i , j } , g _ { i , j } ) , s _ { b } ( C _ { i , j } ) ) } \\ { \mu _ { g } ( C _ { i , j } , r _ { i , j } ) } & { = } & { \mu _ { g } ( C _ { i , j } ) + \alpha ( C _ { i , j } ) r _ { i , j } } \\ { \mu _ { b } ( C _ { i , j } , r _ { i , j } , g _ { i , j } ) } & { = } & { \mu _ { b } ( C _ { i , j } ) + \beta ( C _ { i , j } ) r _ { i , j } + \gamma ( C _ { i , j } ) b _ { i , j } , } \end{array}
+$$
+
+with $\alpha , \beta , \gamma$ scalar coefficients depending on the mixture component and previous pixels.
+
+The mixture indicator is shared across all 3 channels; i.e. our generative model first samples a mixture indicator for a pixel, and then samples the color channels one-by-one from the corresponding mixture component. Had we used a discretized mixture of univariate Gaussians for the sub-pixels, instead of logistics, this would have been exactly equivalent to predicting the complete pixel using a (discretized) mixture of 3-dimensional Gaussians with full covariance. The logistic and Gaussian distributions are very similar, so this is indeed very close to what we end up doing. For full implementation details we refer to our code at https://github.com/openai/pixel-cnn.
+
+# 2.3 DOWNSAMPLING VERSUS DILATED CONVOLUTION
+
+The original PixelCNN only uses convolutions with small receptive field. Such convolutions are good at capturing local dependencies, but not necessarily at modeling long range structure. Although we find that capturing these short range dependencies is often enough for obtaining very good log-likelihood scores (see Table 2), explicitly encouraging the model to capture long range dependencies can improve the perceptual quality of generated images (compare Figure 3 and Figure 5). One way of allowing the network to model structure at multiple resolutions is to introduce dilated convolutions into the model, as proposed by van den Oord et al. (2016a) and Kalchbrenner et al. (2016b). Here, we instead propose to use downsampling by using convolutions of stride 2. Downsampling accomplishes the same multi-resolution processing afforded by dilated convolutions, but at a reduced computational cost: where dilated convolutions operate on input of ever increasing size (due to zero padding), downsampling reduces the input size by a factor of 4 (for stride of 2 in 2 dimensions) at every downsampling. The downside of using downsampling is that it loses information, but we can compensate for this by introducing additional short-cut connections into the network as explained in the next section. With these additional short-cut connections, we found the performance of downsampling to be the same as for dilated convolution.
+
+# 2.4 ADDING SHORT-CUT CONNECTIONS
+
+For input of size $3 2 \times 3 2$ our suggested model consists of 6 blocks of 5 ResNet layers. In between the first and second block, as well as the second and third block, we perform subsampling by strided convolution. In between the fourth and fifth block, as well as the fifth and sixth block, we perform upsampling by transposed strided convolution. This subsampling and upsampling process loses information, and we therefore introduce additional short-cut connections into the model to recover this information from lower layers in the model. The short-cut connections run from the ResNet layers in the first block to the corresponding layers in the sixth block, and similarly between blocks two and five, and blocks three and four. This structure resembles the VAE model with top down inference used by Kingma et al. (2016), as well as the U-net used by Ronneberger et al. (2015) for image segmentation. Figure 2 shows our model structure graphically.
+
+![](images/3f81f206ca60c33dd83bbf40a35f5c25d0ea6f0e3501311e8063634cc76fc2fb.jpg)  
+Figure 2: Like van den Oord et al. (2016c), our model follows a two-stream (downward, and downward+rightward) convolutional architecture with residual connections; however, there are two significant differences in connectivity. First, our architecture incorporates downsampling and upsampling, such that the inner parts of the network operate over larger spatial scale, increasing computational efficiency. Second, we employ long-range skip-connections, such that each $k$ -th layer provides a direct input to the $( K - k )$ -th layer, where $K$ is the total number of layers in the network. The network is grouped into sequences of six layers, where most sequences are separated by downsampling or upsampling.
+
+# 2.5 REGULARIZATION USING DROPOUT
+
+The PixelCNN model is powerful enough to overfit on training data. Moreover, rather than just reproducing the training images, we find that overfitted models generate images of low perceptual quality, as shown in Figure 8. One effective way of regularizing neural networks is dropout (Srivastava et al., 2014). For our model, we apply standard binary dropout on the residual path after the first convolution. This is similar to how dropout is applied in the wide residual networks of Zagoruyko & Komodakis (2016). Using dropout allows us to successfully train high capacity models while avoiding overfitting and producing high quality generations (compare figure 8 and figure 3).
+
+# 3 EXPERIMENTS
+
+We apply our model to modeling natural images in the CIFAR-10 data set. We achieve state-of-theart results in terms of log-likelihood, and generate images with coherent global structure.
+
+# 3.1 UNCONDITIONAL GENERATION ON CIFAR-10
+
+We apply our PixelCNN model, with the modifications as described above, to generative modeling of the images in the CIFAR-10 data set. For the encoding part of the PixelCNN, the model uses 3 Resnet blocks consisting of 5 residual layers, with $2 \times 2$ downsampling in between. The same architecture is used for the decoding part of the model, but with upsampling instead of downsampling in between blocks. All residual layers use 192 feature maps and a dropout rate of 0.5. Table 1 shows the stateof-the-art test log-likelihood obtained by our model. Figure 3 shows some samples generated by the model.
+
+![](images/e4d07f082bb953fee8ce4d571c386f753fa1a09e0bb5fe9a588e78bae6af2346.jpg)
+
+Figure 3: Samples from our PixelCNN model trained on CIFAR-10.   
+Table 1: Negative log-likelihood for generative models on CIFAR-10 expressed as bits per sub-pixel.   
+
+<table><tr><td>Model</td><td>Bits per sub-pixel</td></tr><tr><td>Deep Diffusion (Sohl-Dickstein et al.,2015)</td><td>5.40</td></tr><tr><td>NICE (Dinh et al., 2014)</td><td>4.48</td></tr><tr><td>DRAW (Gregor et al., 2015)</td><td>4.13</td></tr><tr><td>Deep GMMs (van den Oord &amp; Dambre,2015)</td><td>4.00</td></tr><tr><td>Conv DRAW (Gregor et al.,2016)</td><td>3.58</td></tr><tr><td>Real NVP (Dinh et al., 2016)</td><td>3.49</td></tr><tr><td>PixelCNN (van den Oord et al., 2016b)</td><td>3.14</td></tr><tr><td>VAE with IAF (Kingma et al., 2016)</td><td>3.11</td></tr><tr><td>Gated PixelCNN(van den Oord et al.,2016c)</td><td>3.03</td></tr><tr><td>PixelRNN (van den Oord et al., 2016b)</td><td>3.00</td></tr><tr><td>PixelCNN++</td><td>2.92</td></tr></table>
+
+# 3.2 CLASS-CONDITIONAL GENERATION
+
+Next, we follow van den Oord et al. (2016c) in making our generative model conditional on the class-label of the CIFAR-10 images. This is done by linearly projecting a one-hot encoding of the class-label into a separate class-dependent bias vector for each convolutional unit in our network. We find that making the model class-conditional makes it harder to avoid overfitting on the training data: our best test log-likelihood is 2.94 in this case. Figure 4 shows samples from the class-conditional model, with columns 1-10 corresponding the 10 classes in CIFAR-10. The images clearly look qualitatively different across the columns and for a number of them we can clearly identify their class label.
+
+![](images/b2cb2c56961b306aa36c80029bc12acffe8a2014ea5599add8547cbedde90394.jpg)  
+Figure 4: Class-conditional samples from our PixelCNN for CIFAR-10 (left) and real CIFAR-10 images for comparison (right).
+
+# 3.3 EXAMINING NETWORK DEPTH AND FIELD OF VIEW SIZE
+
+It is hypothesized that the size of the receptive field and additionally the removal of blind spots in the receptive field are important for PixelCNN’s performance (van den Oord et al., 2016b). Indeed van den Oord et al. (2016c) specifically introduced an improvement over the previous PixelCNN model to remove the blind spot in the receptive field that was present in their earlier model.
+
+Here we present the surprising finding that in fact a PixelCNN with rather small receptive field can attain competitive generative modelling performance on CIFAR-10 as long as it has enough capacity. Specifically, we experimented with our proposed PixelC $\mathrm { N N } { + } { + }$ model without downsampling blocks and reduce the number of layers to limit the receptive field size. We investigate two receptive field sizes: 11x5 and $1 5 \mathrm { x } 8$ , and a receptive field size of 11x5, for example, means that the conditional distribution of a pixel can depends on a rectangle above the pixel of size 11x5 as well as $\frac { 1 1 - 1 } { 2 } = 5 \mathrm { x } 1$ block to the left of the pixel.
+
+As we limit the size of the receptive field, the capacity of the network also drops significantly since it contains many fewer layers than a normal PixelCNN. We call the type of PixelCNN that’s simply limited in depth “Plain” Small PixelCNN. Interestingly, this model already has better performance than the original PixelCNN in van den Oord et al. (2016b) which had a blind spot. To increase capacity, we introduced two simple variants that make Small PixelCNN more expressive without growing the receptive field:
+
+• NIN (Network in Network): insert additional gated ResNet blocks with 1x1 convolution between regular convolution blocks that grow receptive field. In this experiment, we inserted 3 NIN blocks between every other layer.   
+• Autoregressive Channel: skip connections between sets of channels via 1x1 convolution gated ResNet block.
+
+Both modifications increase the capacity of the network, resulting in improved log-likelihood as shown in Table 2. Although the model with small receptive field already achieves an impressive likelihood score, its samples do lack global structure, as seen in Figure 5.
+
+Table 2: CIFAR-10 bits per sub-pixel for Small PixelCNN   
+
+<table><tr><td>Model</td><td>Bits per sub-pixel</td></tr><tr><td>Field=11x5,Plain</td><td>3.11</td></tr><tr><td>Field=11x5,NIN</td><td>3.09</td></tr><tr><td>Field=11x5,Autoregressive Channel</td><td>3.07</td></tr><tr><td>Field=15x8,Plain</td><td>3.07</td></tr><tr><td>Field=15x8,NIN</td><td>3.04</td></tr><tr><td>Field=15x8,Autoregressive Channel</td><td>3.03</td></tr></table>
+
+![](images/7252158f2d5b882f2532bb5f5449b4e70642790b49bc421ad0e1511996423391.jpg)  
+Figure 5: Samples from 3.03 bits/dim Small PixelCNN
+
+# 3.4 ABLATION EXPERIMENTS
+
+In order to test the effect of our modifications to PixelCNN, we run a number of ablation experiments where for each experiment we remove a specific modification.
+
+# 3.4.1 SOFTMAX LIKELIHOOD INSTEAD OF DISCRETIZED LOGISTIC MIXTURE
+
+In order to test the contribution of our logistic mixture likelihood, we re-run our CIFAR-10 experiment with the 256-way softmax as the output distribution instead. We allow the 256 logits for each sub-pixel to linearly depend on the observed value of previous sub-pixels, with coefficients that are given as output by the model. Our model with softmax likelihood is thus strictly more flexible than our model with logistic mixture likelihood, although the parameterization is quite different from that used by van den Oord et al. (2016c). The model now outputs 1536 numbers per pixel, describing the logits on the 256 potential values for each sub-pixel, as well as the coefficients for the dependencies between the sub-pixels. Figure 6 shows that this model trains more slowly than our original model. In addition, the running time per epoch is significantly longer for our tensorflow implementation. For our architecture, the logistic mixture model thus clearly performs better. Since our architecture differs from that of van den Oord et al. (2016c) in other ways as well, we cannot say whether this would also apply to their model.
+
+# .4.2 CONTINUOUS MIXTURE LIKELIHOOD INSTEAD OF DISCRETIZATIO
+
+Instead of directly modeling the discrete pixel values in an image, it is also possible to de-quantize them by adding noise from the standard uniform distribution, as used by Uria et al. (2013) and others, and modeling the data as being continuous. The resulting model can be interpreted as a variational autoencoder (Kingma & Welling, 2013; Rezende et al., 2014), where the dequantized pixels $\mathbf { z }$ form a latent code whose prior distribution is captured by our model. Since the original discrete pixels $\mathbf { x }$ can be perfectly reconstructed from z under this model, the usual reconstruction term vanishes from the variational lower bound. The entropy of the standard uniform distribution is zero, so the term that remains is the log likelihood of the dequantized pixels, which thus gives us a variational lower bound on the log likelihood of our original data.
+
+![](images/17e311b1eab8e1283700c0982015329e0bb4177418b9d6c5aa4d2f720c658d48.jpg)  
+Figure 6: Training curves for our model with logistic mixture likelihood versus our model with softmax likelihood.
+
+We re-run our model for CIFAR-10 using the same model settings as those used for the 2.92 bits per dimension result in Table 1, but now we remove the discretization in our likelihood model and instead add standard uniform noise to the image data. The resulting model is a continuous mixture model in the same class as that used by Theis et al. (2012); Uria et al. (2013); Theis & Bethge (2015) and others. After optimization, this model gives a variational lower bound on the data log likelihood of 3.11 bits per dimension. The difference with the reported 2.92 bits per dimension shows the benefit of using discretization in the likelihood model.
+
+# 3.4.3 NO SHORT-CUT CONNECTIONS
+
+Next, we test the importance of the additional parallel short-cut connections in our model, indicated by the dotted lines in Figure 2. We re-run our unconditional CIFAR-10 experiment, but remove the short-cut connections from the model. As seen in Figure 7, the model fails to train without these connections. The reason for needing these extra short-cuts is likely to be our use of sub-sampling, which discards information that otherwise cannot easily be recovered,
+
+![](images/3504f8cc6fc6f22a914ea293871691ae422d571e32d658c2d248bb92f640307b.jpg)  
+Figure 7: Training curves for our model with and without short-cut connections.
+
+# 3.4.4 NO DROPOUT
+
+We re-run our CIFAR-10 model without dropout regularization. The log-likelihood we achieve on the training set is below 2.0 bits per sub-pixel, but the final test log-likelihood is above 6.0 bits per
+
+sub-pixel. At no point during training does the unregularized model get a test-set log-likelihood below 3.0 bits per sub-pixel. Contrary to what we might naively expect, the perceptual quality of the generated images by the overfitted model is not great, as shown in Figure 8.
+
+![](images/fda31fb58b29b704927fea59a22a5277f3be82b1bce04228585bdb18cfb6742a.jpg)  
+Figure 8: Samples from intentionally overfitted PixelCNN model trained on CIFAR-10, with train log-likelihood of 2.0 bits per dimension: Overfitting does not result in great perceptual quality.
+
+# 4 CONCLUSION
+
+We presented $\mathrm { P i x e l C N N + + }$ , a modification of PixelCNN using a discretized logistic mixture likelihood on the pixels among other modifications. We demonstrated the usefulness of these modifications with state-of-the-art results on CIFAR-10. Our code is made available at https: //github.com/openai/pixel-cnn and can easily be adapted for use on other data sets.
+
+# REFERENCES
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.
+
+Justin Domke, Alap Karapurkar, and Yiannis Aloimonos. Who killed the directed model? In Computer Vision and Pattern Recognition, 2008. CVPR 2008. IEEE Conference on, pp. 1–8. IEEE, 2008.
+
+Karol Gregor, Ivo Danihelka, Alex Graves, and Daan Wierstra. Draw: A recurrent neural network for image generation. In Proceedings of the 32nd International Conference on Machine Learning, 2015.
+
+Karol Gregor, Frederic Besse, Danilo Jimenez Rezende, Ivo Danihelka, and Daan Wierstra. Towards conceptual compression. arXiv preprint arXiv:1604.08772, 2016.
+
+Nal Kalchbrenner, Lasse Espeholt, Karen Simonyan, Aaron van den Oord, Alex Graves, and Koray Kavukcuoglu. Neural machine translation in linear time. arXiv preprint arXiv:1610.10099, 2016a.
+
+Nal Kalchbrenner, Aaron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. arXiv preprint arXiv:1610.00527, 2016b.
+
+Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. Proceedings of the 2nd International Conference on Learning Representations, 2013.
+
+Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improving variational inference with inverse autoregressive flow. In Advances in Neural Information Processing Systems, 2016.   
+Danilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In ICML, pp. 1278–1286, 2014.   
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pp. 234–241. Springer, 2015.   
+Jascha Sohl-Dickstein, Eric A. Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In Proceedings of the 32nd International Conference on Machine Learning, 2015.   
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.   
+Lucas Theis and Matthias Bethge. Generative image modeling using spatial lstms. In Advances in Neural Information Processing Systems, pp. 1927–1935, 2015.   
+Lucas Theis, Reshad Hosseini, and Matthias Bethge. Mixtures of conditional gaussian scale mixtures applied to multiscale image representations. PloS one, 7(7):e39857, 2012.   
+Benigno Uria, Iain Murray, and Hugo Larochelle. Rnade: The real-valued neural autoregressive density-estimator. In Advances in Neural Information Processing Systems, pp. 2175–2183, 2013.   
+Aaron van den Oord and Joni Dambre. Locally-connected transformations for deep gmms. In International Conference on Machine Learning (ICML) : Deep learning Workshop, 2015.   
+Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016a.   
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In International Conference on Machine Learning (ICML), 2016b.   
+Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional image generation with pixelcnn decoders. arXiv preprint arXiv:1606.05328, 2016c.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.

parse/train/BJrFC6ceg/BJrFC6ceg_content_list.json

@@ -0,0 +1,881 @@
+[
+    {
+        "type": "text",
+        "text": "PIXELCNN++: IMPROVING THE PIXELCNN WITH DISCRETIZED LOGISTIC MIXTURE LIKELIHOOD AND OTHER MODIFICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Andrej Karpathy, Xi Chen, Diederik P. Kingma {tim,karpathy,peter,dpkingma}@openai.com ",
+        "bbox": [
+            183,
+            194,
+            620,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "PixelCNNs are a recently proposed class of powerful generative models with tractable likelihood. Here we discuss our implementation of PixelCNNs which we make available at https://github.com/openai/pixel-cnn. Our implementation contains a number of modifications to the original model that both simplify its structure and improve its performance. 1) We use a discretized logistic mixture likelihood on the pixels, rather than a 256-way softmax, which we find to speed up training. 2) We condition on whole pixels, rather than R/G/B sub-pixels, simplifying the model structure. 3) We use downsampling to efficiently capture structure at multiple resolutions. 4) We introduce additional short-cut connections to further speed up optimization. 5) We regularize the model using dropout. Finally, we present state-of-the-art log likelihood results on CIFAR-10 to demonstrate the usefulness of these modifications. ",
+        "bbox": [
+            233,
+            291,
+            764,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            336,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The PixelCNN, introduced by van den Oord et al. (2016b), is a generative model of images with a tractable likelihood. The model fully factorizes the probability density function on an image $\\mathbf { x }$ over all its sub-pixels (color channels in a pixel) as $\\begin{array} { r } { p ( \\mathbf { x } ) = \\prod _ { i } p ( x _ { i } | \\boldsymbol { x } _ { < i } ) } \\end{array}$ . The conditional distributions $p ( x _ { i } | \\boldsymbol x _ { < i } )$ are parameterized by convolutional neural networks and all share parameters. The PixelCNN is a powerful model as the functional form of these conditionals is very flexible. In addition it is computationally efficient as all conditionals can be evaluated in parallel on a GPU for an observed image $\\mathbf { x }$ . Thanks to these properties, the PixelCNN represents the current state-of-the-art in generative modeling when evaluated in terms of log-likelihood. Besides being used for modeling images, the PixelCNN model was recently extended to model audio (van den Oord et al., 2016a), video (Kalchbrenner et al., 2016b) and text (Kalchbrenner et al., 2016a). ",
+        "bbox": [
+            174,
+            515,
+            825,
+            654
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For use in our research, we developed our own internal implementation of PixelCNN and made a number of modifications to the base model to simplify its structure and improve its performance. We now release our implementation at https://github.com/openai/pixel-cnn, hoping that it will be useful to the broader community. Our modifications are discussed in Section 2, and evaluated experimentally in Section 3. State-of-the-art log-likelihood results confirm their usefulness. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            744
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 MODIFICATIONS TO PIXELCNN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            470,
+            781
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We now describe the most important modifications we have made to the PixelCNN model architecure as described by van den Oord et al. (2016c). For complete details see our code release at https://github.com/openai/pixel-cnn. ",
+        "bbox": [
+            176,
+            796,
+            823,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2.1 DISCRETIZED LOGISTIC MIXTURE LIKELIHOOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            540,
+            869
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The standard PixelCNN model specifies the conditional distribution of a sub-pixel, or color channel of a pixel, as a full 256-way softmax. This gives the model a lot of flexibility, but it is also very costly in terms of memory. Moreover, it can make the gradients with respect to the network parameters very sparse, especially early in training. With the standard parameterization, the model does not know that a value of 128 is close to a value of 127 or 129, and this relationship first has to be learned before the model can move on to higher level structures. In the extreme case where a particular sub-pixel value is never observed, the model will learn to assign it zero probability. This would be especially problematic for data with higher accuracy on the observed pixels than the usual 8 bits: In the extreme case where very high precision values are observed, the PixelCNN, in its current form, would require a prohibitive amount of memory and computation, while learning very slowly. We therefore propose a different mechanism for computing the conditional probability of the observed discretized pixel values. In our model, like in the VAE of Kingma et al. (2016), we assume there is a latent color intensity $\\nu$ with a continuous distribution, which is then rounded to its nearest 8-bit representation to give the observed sub-pixel value $x$ . By choosing a simple continuous distribution for modeling $\\nu$ (like the logistic distribution as done by Kingma et al. (2016)) we obtain a smooth and memory efficient predictive distribution for $x$ . Here, we take this continuous univariate distribution to be a mixture of logistic distributions which allows us to easily calculate the probability on the observed discretized value $x$ , as shown in equation (2). For all sub-pixel values $x$ excepting the edge cases 0 and 255 we have: ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            325
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/266a0ad0bf8b168cae5317bd643fd0af1bdc7db02cb694f77d32d2b10f0cf5e7.jpg",
+        "text": "$$\n\\begin{array} { l l l } { \\displaystyle \\nu } & { \\sim } & { \\displaystyle \\sum _ { i = 1 } ^ { K } \\pi _ { i } \\mathrm { l o g i s t i c } ( \\mu _ { i } , s _ { i } ) } \\\\ { P ( x | \\pi , \\mu , s ) } & { = } & { \\displaystyle \\sum _ { i = 1 } ^ { K } \\pi _ { i } \\left[ \\sigma ( ( x + 0 . 5 - \\mu _ { i } ) / s _ { i } ) - \\sigma ( ( x - 0 . 5 - \\mu _ { i } ) / s _ { i } ) \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            343,
+            745,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma ( )$ is the logistic sigmoid function. For the edge case of 0, replace $x - 0 . 5$ by $- \\infty$ , and for 255 replace $x + 0 . 5$ by $+ \\infty$ . Our provided code contains a numerically stable implementation for calculating the log of the probability in equation 2. ",
+        "bbox": [
+            176,
+            450,
+            823,
+            493
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach follows earlier work using continuous mixture models (Domke et al., 2008; Theis et al., 2012; Uria et al., 2013; Theis & Bethge, 2015), but avoids allocating probability mass to values outside the valid range of [0, 255] by explicitly modeling the rounding of $\\nu$ to $x$ . In addition, we naturally assign higher probability to the edge values 0 and 255 than to their neighboring values, which corresponds well with the observed data distribution as shown in Figure 1. Experimentally, we find that only a relatively small number of mixture components, say 5, is needed to accurately model the conditional distributions of the pixels. The output of our network is thus of much lower dimension, yielding much denser gradients of the loss with respect to our parameters. In our experiments this greatly sped up convergence during optimization, especially early on in training. However, due to the other changes in our architecture compared to that of van den Oord et al. (2016c) we cannot say with certainty that this would also apply to the original PixelCNN model. ",
+        "bbox": [
+            173,
+            500,
+            825,
+            654
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/3eb5f29602b706d00be758d95223055ef088f0d6f7535514155c2b83996845a1.jpg",
+        "image_caption": [
+            "Figure 1: Marginal distribution of all sub-pixel values in CIFAR-10. The edge value of 255 is much more frequent than its neighbouring values: This is easy to model using our rounding based approach, but harder using continuous or truncated distributions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            695,
+            629,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 CONDITIONING ON WHOLE PIXELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            454,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The pixels in a color image consist of three real numbers, giving the intensities of the red, blue and green colors. The original PixelCNN factorizes the generative model over these 3 sub-pixels. This allows for very general dependency structure, but it also complicates the model: besides keeping track of the spatial location of feature maps, we now have to separate out all feature maps in 3 groups depending on whether or not they can see the R/G/B sub-pixel of the current location. This added complexity seems to be unnecessary as the dependencies between the color channels of a pixel are likely to be relatively simple and do not require a deep network to model. Therefore, we instead condition only on whole pixels up and to the left in an image, and output joint predictive distributions over all 3 channels of a predicted pixel. The predictive distribution on a pixel itself can be interpreted as a simple factorized model: We first predict the red channel using a discretized mixture of logistics as described in section 2.1. Next, we predict the green channel using a predictive distribution of the same form. Here we allow the means of the mixture components to linearly depend on the value of the red sub-pixel. Finally, we model the blue channel in the same way, where we again only allow linear dependency on the red and green channels. For the pixel $( r _ { i , j } , g _ { i , j } , b _ { i , j } )$ at location $( i , j )$ in our image, the distribution conditional on the context $C _ { i , j }$ , consisting of the mixture indicator and the previous pixels, is thus ",
+        "bbox": [
+            174,
+            131,
+            825,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/540476c0beb7a4c0ee5cb8283c68e465931422790c0c28087971655dac21deab.jpg",
+        "text": "$$\n\\begin{array} { r c l } { p ( r _ { i , j } , g _ { i , j } , b _ { i , j } | C _ { i , j } ) } & { = } & { P ( r _ { i , j } | \\mu _ { r } ( C _ { i , j } ) , s _ { r } ( C _ { i , j } ) ) \\times P ( g _ { i , j } | \\mu _ { g } ( C _ { i , j } , r _ { i , j } ) , s _ { g } ( C _ { i , j } ) ) } \\\\ & & { \\times P ( b _ { i , j } | \\mu _ { b } ( C _ { i , j } , r _ { i , j } , g _ { i , j } ) , s _ { b } ( C _ { i , j } ) ) } \\\\ { \\mu _ { g } ( C _ { i , j } , r _ { i , j } ) } & { = } & { \\mu _ { g } ( C _ { i , j } ) + \\alpha ( C _ { i , j } ) r _ { i , j } } \\\\ { \\mu _ { b } ( C _ { i , j } , r _ { i , j } , g _ { i , j } ) } & { = } & { \\mu _ { b } ( C _ { i , j } ) + \\beta ( C _ { i , j } ) r _ { i , j } + \\gamma ( C _ { i , j } ) b _ { i , j } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            358,
+            787,
+            434
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with $\\alpha , \\beta , \\gamma$ scalar coefficients depending on the mixture component and previous pixels. ",
+        "bbox": [
+            169,
+            438,
+            754,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The mixture indicator is shared across all 3 channels; i.e. our generative model first samples a mixture indicator for a pixel, and then samples the color channels one-by-one from the corresponding mixture component. Had we used a discretized mixture of univariate Gaussians for the sub-pixels, instead of logistics, this would have been exactly equivalent to predicting the complete pixel using a (discretized) mixture of 3-dimensional Gaussians with full covariance. The logistic and Gaussian distributions are very similar, so this is indeed very close to what we end up doing. For full implementation details we refer to our code at https://github.com/openai/pixel-cnn. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 DOWNSAMPLING VERSUS DILATED CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            563,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The original PixelCNN only uses convolutions with small receptive field. Such convolutions are good at capturing local dependencies, but not necessarily at modeling long range structure. Although we find that capturing these short range dependencies is often enough for obtaining very good log-likelihood scores (see Table 2), explicitly encouraging the model to capture long range dependencies can improve the perceptual quality of generated images (compare Figure 3 and Figure 5). One way of allowing the network to model structure at multiple resolutions is to introduce dilated convolutions into the model, as proposed by van den Oord et al. (2016a) and Kalchbrenner et al. (2016b). Here, we instead propose to use downsampling by using convolutions of stride 2. Downsampling accomplishes the same multi-resolution processing afforded by dilated convolutions, but at a reduced computational cost: where dilated convolutions operate on input of ever increasing size (due to zero padding), downsampling reduces the input size by a factor of 4 (for stride of 2 in 2 dimensions) at every downsampling. The downside of using downsampling is that it loses information, but we can compensate for this by introducing additional short-cut connections into the network as explained in the next section. With these additional short-cut connections, we found the performance of downsampling to be the same as for dilated convolution. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 ADDING SHORT-CUT CONNECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            460,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For input of size $3 2 \\times 3 2$ our suggested model consists of 6 blocks of 5 ResNet layers. In between the first and second block, as well as the second and third block, we perform subsampling by strided convolution. In between the fourth and fifth block, as well as the fifth and sixth block, we perform upsampling by transposed strided convolution. This subsampling and upsampling process loses information, and we therefore introduce additional short-cut connections into the model to recover this information from lower layers in the model. The short-cut connections run from the ResNet layers in the first block to the corresponding layers in the sixth block, and similarly between blocks two and five, and blocks three and four. This structure resembles the VAE model with top down inference used by Kingma et al. (2016), as well as the U-net used by Ronneberger et al. (2015) for image segmentation. Figure 2 shows our model structure graphically. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f81f206ca60c33dd83bbf40a35f5c25d0ea6f0e3501311e8063634cc76fc2fb.jpg",
+        "image_caption": [
+            "Figure 2: Like van den Oord et al. (2016c), our model follows a two-stream (downward, and downward+rightward) convolutional architecture with residual connections; however, there are two significant differences in connectivity. First, our architecture incorporates downsampling and upsampling, such that the inner parts of the network operate over larger spatial scale, increasing computational efficiency. Second, we employ long-range skip-connections, such that each $k$ -th layer provides a direct input to the $( K - k )$ -th layer, where $K$ is the total number of layers in the network. The network is grouped into sequences of six layers, where most sequences are separated by downsampling or upsampling. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            198,
+            813,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5 REGULARIZATION USING DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            487,
+            459,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The PixelCNN model is powerful enough to overfit on training data. Moreover, rather than just reproducing the training images, we find that overfitted models generate images of low perceptual quality, as shown in Figure 8. One effective way of regularizing neural networks is dropout (Srivastava et al., 2014). For our model, we apply standard binary dropout on the residual path after the first convolution. This is similar to how dropout is applied in the wide residual networks of Zagoruyko & Komodakis (2016). Using dropout allows us to successfully train high capacity models while avoiding overfitting and producing high quality generations (compare figure 8 and figure 3). ",
+        "bbox": [
+            174,
+            512,
+            825,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            326,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We apply our model to modeling natural images in the CIFAR-10 data set. We achieve state-of-theart results in terms of log-likelihood, and generate images with coherent global structure. ",
+        "bbox": [
+            174,
+            662,
+            823,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 UNCONDITIONAL GENERATION ON CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            534,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We apply our PixelCNN model, with the modifications as described above, to generative modeling of the images in the CIFAR-10 data set. For the encoding part of the PixelCNN, the model uses 3 Resnet blocks consisting of 5 residual layers, with $2 \\times 2$ downsampling in between. The same architecture is used for the decoding part of the model, but with upsampling instead of downsampling in between blocks. All residual layers use 192 feature maps and a dropout rate of 0.5. Table 1 shows the stateof-the-art test log-likelihood obtained by our model. Figure 3 shows some samples generated by the model. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e4d07f082bb953fee8ce4d571c386f753fa1a09e0bb5fe9a588e78bae6af2346.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            104,
+            655,
+            345
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f05f508ce1681f4478c92fa2d56485d321d9b091fe4b9cb20a21f5f48c019b6.jpg",
+        "table_caption": [
+            "Figure 3: Samples from our PixelCNN model trained on CIFAR-10. ",
+            "Table 1: Negative log-likelihood for generative models on CIFAR-10 expressed as bits per sub-pixel. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Bits per sub-pixel</td></tr><tr><td>Deep Diffusion (Sohl-Dickstein et al.,2015)</td><td>5.40</td></tr><tr><td>NICE (Dinh et al., 2014)</td><td>4.48</td></tr><tr><td>DRAW (Gregor et al., 2015)</td><td>4.13</td></tr><tr><td>Deep GMMs (van den Oord &amp; Dambre,2015)</td><td>4.00</td></tr><tr><td>Conv DRAW (Gregor et al.,2016)</td><td>3.58</td></tr><tr><td>Real NVP (Dinh et al., 2016)</td><td>3.49</td></tr><tr><td>PixelCNN (van den Oord et al., 2016b)</td><td>3.14</td></tr><tr><td>VAE with IAF (Kingma et al., 2016)</td><td>3.11</td></tr><tr><td>Gated PixelCNN(van den Oord et al.,2016c)</td><td>3.03</td></tr><tr><td>PixelRNN (van den Oord et al., 2016b)</td><td>3.00</td></tr><tr><td>PixelCNN++</td><td>2.92</td></tr></table>",
+        "bbox": [
+            267,
+            387,
+            728,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 CLASS-CONDITIONAL GENERATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            460,
+            623
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we follow van den Oord et al. (2016c) in making our generative model conditional on the class-label of the CIFAR-10 images. This is done by linearly projecting a one-hot encoding of the class-label into a separate class-dependent bias vector for each convolutional unit in our network. We find that making the model class-conditional makes it harder to avoid overfitting on the training data: our best test log-likelihood is 2.94 in this case. Figure 4 shows samples from the class-conditional model, with columns 1-10 corresponding the 10 classes in CIFAR-10. The images clearly look qualitatively different across the columns and for a number of them we can clearly identify their class label. ",
+        "bbox": [
+            173,
+            635,
+            825,
+            747
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2cb2c56961b306aa36c80029bc12acffe8a2014ea5599add8547cbedde90394.jpg",
+        "image_caption": [
+            "Figure 4: Class-conditional samples from our PixelCNN for CIFAR-10 (left) and real CIFAR-10 images for comparison (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            103,
+            812,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 EXAMINING NETWORK DEPTH AND FIELD OF VIEW SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            602,
+            422
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is hypothesized that the size of the receptive field and additionally the removal of blind spots in the receptive field are important for PixelCNN’s performance (van den Oord et al., 2016b). Indeed van den Oord et al. (2016c) specifically introduced an improvement over the previous PixelCNN model to remove the blind spot in the receptive field that was present in their earlier model. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we present the surprising finding that in fact a PixelCNN with rather small receptive field can attain competitive generative modelling performance on CIFAR-10 as long as it has enough capacity. Specifically, we experimented with our proposed PixelC $\\mathrm { N N } { + } { + }$ model without downsampling blocks and reduce the number of layers to limit the receptive field size. We investigate two receptive field sizes: 11x5 and $1 5 \\mathrm { x } 8$ , and a receptive field size of 11x5, for example, means that the conditional distribution of a pixel can depends on a rectangle above the pixel of size 11x5 as well as $\\frac { 1 1 - 1 } { 2 } = 5 \\mathrm { x } 1$ block to the left of the pixel. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            595
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As we limit the size of the receptive field, the capacity of the network also drops significantly since it contains many fewer layers than a normal PixelCNN. We call the type of PixelCNN that’s simply limited in depth “Plain” Small PixelCNN. Interestingly, this model already has better performance than the original PixelCNN in van den Oord et al. (2016b) which had a blind spot. To increase capacity, we introduced two simple variants that make Small PixelCNN more expressive without growing the receptive field: ",
+        "bbox": [
+            176,
+            602,
+            825,
+            685
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• NIN (Network in Network): insert additional gated ResNet blocks with 1x1 convolution between regular convolution blocks that grow receptive field. In this experiment, we inserted 3 NIN blocks between every other layer.   \n• Autoregressive Channel: skip connections between sets of channels via 1x1 convolution gated ResNet block. ",
+        "bbox": [
+            215,
+            696,
+            825,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Both modifications increase the capacity of the network, resulting in improved log-likelihood as shown in Table 2. Although the model with small receptive field already achieves an impressive likelihood score, its samples do lack global structure, as seen in Figure 5. ",
+        "bbox": [
+            176,
+            785,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4528c6ce469c927b3846a3d909f5688bbc03d68a101e1c89c51466c67a39cee7.jpg",
+        "table_caption": [
+            "Table 2: CIFAR-10 bits per sub-pixel for Small PixelCNN "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Bits per sub-pixel</td></tr><tr><td>Field=11x5,Plain</td><td>3.11</td></tr><tr><td>Field=11x5,NIN</td><td>3.09</td></tr><tr><td>Field=11x5,Autoregressive Channel</td><td>3.07</td></tr><tr><td>Field=15x8,Plain</td><td>3.07</td></tr><tr><td>Field=15x8,NIN</td><td>3.04</td></tr><tr><td>Field=15x8,Autoregressive Channel</td><td>3.03</td></tr></table>",
+        "bbox": [
+            299,
+            126,
+            696,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7252158f2d5b882f2532bb5f5449b4e70642790b49bc421ad0e1511996423391.jpg",
+        "image_caption": [
+            "Figure 5: Samples from 3.03 bits/dim Small PixelCNN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            239,
+            658,
+            488
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 ABLATION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            392,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to test the effect of our modifications to PixelCNN, we run a number of ablation experiments where for each experiment we remove a specific modification. ",
+        "bbox": [
+            173,
+            565,
+            823,
+            593
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4.1 SOFTMAX LIKELIHOOD INSTEAD OF DISCRETIZED LOGISTIC MIXTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            714,
+            623
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to test the contribution of our logistic mixture likelihood, we re-run our CIFAR-10 experiment with the 256-way softmax as the output distribution instead. We allow the 256 logits for each sub-pixel to linearly depend on the observed value of previous sub-pixels, with coefficients that are given as output by the model. Our model with softmax likelihood is thus strictly more flexible than our model with logistic mixture likelihood, although the parameterization is quite different from that used by van den Oord et al. (2016c). The model now outputs 1536 numbers per pixel, describing the logits on the 256 potential values for each sub-pixel, as well as the coefficients for the dependencies between the sub-pixels. Figure 6 shows that this model trains more slowly than our original model. In addition, the running time per epoch is significantly longer for our tensorflow implementation. For our architecture, the logistic mixture model thus clearly performs better. Since our architecture differs from that of van den Oord et al. (2016c) in other ways as well, we cannot say whether this would also apply to their model. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            800
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": ".4.2 CONTINUOUS MIXTURE LIKELIHOOD INSTEAD OF DISCRETIZATIO ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            816,
+            681,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Instead of directly modeling the discrete pixel values in an image, it is also possible to de-quantize them by adding noise from the standard uniform distribution, as used by Uria et al. (2013) and others, and modeling the data as being continuous. The resulting model can be interpreted as a variational autoencoder (Kingma & Welling, 2013; Rezende et al., 2014), where the dequantized pixels $\\mathbf { z }$ form a latent code whose prior distribution is captured by our model. Since the original discrete pixels $\\mathbf { x }$ can be perfectly reconstructed from z under this model, the usual reconstruction term vanishes from the variational lower bound. The entropy of the standard uniform distribution is zero, so the term that remains is the log likelihood of the dequantized pixels, which thus gives us a variational lower bound on the log likelihood of our original data. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/17e311b1eab8e1283700c0982015329e0bb4177418b9d6c5aa4d2f720c658d48.jpg",
+        "image_caption": [
+            "Figure 6: Training curves for our model with logistic mixture likelihood versus our model with softmax likelihood. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            351,
+            116,
+            633,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            356,
+            825,
+            398
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We re-run our model for CIFAR-10 using the same model settings as those used for the 2.92 bits per dimension result in Table 1, but now we remove the discretization in our likelihood model and instead add standard uniform noise to the image data. The resulting model is a continuous mixture model in the same class as that used by Theis et al. (2012); Uria et al. (2013); Theis & Bethge (2015) and others. After optimization, this model gives a variational lower bound on the data log likelihood of 3.11 bits per dimension. The difference with the reported 2.92 bits per dimension shows the benefit of using discretization in the likelihood model. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            502
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4.3 NO SHORT-CUT CONNECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            439,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, we test the importance of the additional parallel short-cut connections in our model, indicated by the dotted lines in Figure 2. We re-run our unconditional CIFAR-10 experiment, but remove the short-cut connections from the model. As seen in Figure 7, the model fails to train without these connections. The reason for needing these extra short-cuts is likely to be our use of sub-sampling, which discards information that otherwise cannot easily be recovered, ",
+        "bbox": [
+            173,
+            541,
+            825,
+            612
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3504f8cc6fc6f22a914ea293871691ae422d571e32d658c2d248bb92f640307b.jpg",
+        "image_caption": [
+            "Figure 7: Training curves for our model with and without short-cut connections. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            351,
+            640,
+            632,
+            811
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4.4 NO DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            323,
+            885
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We re-run our CIFAR-10 model without dropout regularization. The log-likelihood we achieve on the training set is below 2.0 bits per sub-pixel, but the final test log-likelihood is above 6.0 bits per ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "sub-pixel. At no point during training does the unregularized model get a test-set log-likelihood below 3.0 bits per sub-pixel. Contrary to what we might naively expect, the perceptual quality of the generated images by the overfitted model is not great, as shown in Figure 8. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/fda31fb58b29b704927fea59a22a5277f3be82b1bce04228585bdb18cfb6742a.jpg",
+        "image_caption": [
+            "Figure 8: Samples from intentionally overfitted PixelCNN model trained on CIFAR-10, with train log-likelihood of 2.0 bits per dimension: Overfitting does not result in great perceptual quality. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            162,
+            658,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            318,
+            493
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented $\\mathrm { P i x e l C N N + + }$ , a modification of PixelCNN using a discretized logistic mixture likelihood on the pixels among other modifications. We demonstrated the usefulness of these modifications with state-of-the-art results on CIFAR-10. Our code is made available at https: //github.com/openai/pixel-cnn and can easily be adapted for use on other data sets. ",
+        "bbox": [
+            174,
+            508,
+            823,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            287,
+            601
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014. ",
+        "bbox": [
+            173,
+            608,
+            821,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016. ",
+        "bbox": [
+            173,
+            645,
+            821,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Domke, Alap Karapurkar, and Yiannis Aloimonos. Who killed the directed model? In Computer Vision and Pattern Recognition, 2008. CVPR 2008. IEEE Conference on, pp. 1–8. IEEE, 2008. ",
+        "bbox": [
+            173,
+            681,
+            823,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor, Ivo Danihelka, Alex Graves, and Daan Wierstra. Draw: A recurrent neural network for image generation. In Proceedings of the 32nd International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            173,
+            733,
+            823,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor, Frederic Besse, Danilo Jimenez Rezende, Ivo Danihelka, and Daan Wierstra. Towards conceptual compression. arXiv preprint arXiv:1604.08772, 2016. ",
+        "bbox": [
+            173,
+            784,
+            823,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Lasse Espeholt, Karen Simonyan, Aaron van den Oord, Alex Graves, and Koray Kavukcuoglu. Neural machine translation in linear time. arXiv preprint arXiv:1610.10099, 2016a. ",
+        "bbox": [
+            174,
+            820,
+            823,
+            851
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Aaron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. arXiv preprint arXiv:1610.00527, 2016b. ",
+        "bbox": [
+            174,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. Proceedings of the 2nd International Conference on Learning Representations, 2013. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improving variational inference with inverse autoregressive flow. In Advances in Neural Information Processing Systems, 2016.   \nDanilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In ICML, pp. 1278–1286, 2014.   \nOlaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pp. 234–241. Springer, 2015.   \nJascha Sohl-Dickstein, Eric A. Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In Proceedings of the 32nd International Conference on Machine Learning, 2015.   \nNitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.   \nLucas Theis and Matthias Bethge. Generative image modeling using spatial lstms. In Advances in Neural Information Processing Systems, pp. 1927–1935, 2015.   \nLucas Theis, Reshad Hosseini, and Matthias Bethge. Mixtures of conditional gaussian scale mixtures applied to multiscale image representations. PloS one, 7(7):e39857, 2012.   \nBenigno Uria, Iain Murray, and Hugo Larochelle. Rnade: The real-valued neural autoregressive density-estimator. In Advances in Neural Information Processing Systems, pp. 2175–2183, 2013.   \nAaron van den Oord and Joni Dambre. Locally-connected transformations for deep gmms. In International Conference on Machine Learning (ICML) : Deep learning Workshop, 2015.   \nAaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016a.   \nAaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In International Conference on Machine Learning (ICML), 2016b.   \nAaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional image generation with pixelcnn decoders. arXiv preprint arXiv:1606.05328, 2016c.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            171,
+            95,
+            826,
+            675
+        ],
+        "page_idx": 9
+    }
+]

parse/train/HJeYSxHFDS/HJeYSxHFDS.md

@@ -0,0 +1,532 @@
+# GAUGE EQUIVARIANT SPHERICAL CNNS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Spherical CNNs are convolutional neural networks that can process signals on the sphere, such as global climate and weather patterns or omnidirectional images. Over the last few years, a number of spherical convolution methods have been proposed, based on generalized spherical FFTs, graph convolutions, and other ideas. However, none of these methods is simultaneously equivariant to 3D rotations, able to detect anisotropic patterns, computationally efficient, agnostic to the type of sample grid used, and able to deal with signals defined on only a part of the sphere. To address these limitations, we introduce the Gauge Equivariant Spherical CNN. Our method is based on the recently proposed theory of Gauge Equivariant CNNs, which is in principle applicable to signals on any manifold, and which can be computed on any set of local charts covering all of the manifold or only part of it. In this paper we show how this method can be implemented efficiently for the sphere, and show that the resulting method is fast, numerically accurate, and achieves good results on the widely used benchmark problems of climate pattern segmentation and omnidirectional semantic segmentation.
+
+# 1 INTRODUCTION
+
+In many disciplines of science and engineering, spherical signals emerge naturally. In the earth and climate sciences, globally distributed sensor arrays collect measurements like temperature, pressure, wind directions, and many other variables. Cosmologists are interested in identifying physical model parameters from real and simulated cosmic microwave background measurements sampled on spherical sky maps. In robotics, especially in applications like SLAM and visual odometry, omnidirectional and fish-eye cameras are widely used. Thus, it is clear that efficient CNNs that can directly operate on spherical signals are necessary.
+
+When designing Spherical CNNs for these applications, there are a number of practical considerations that need to be taken into account. Firstly, whereas planar images are always sampled on a square grid, there is a wide variety of spherical grids, and the choice of sampling grid is usually dictated by hardware or task-dependent requirements. Secondly, several applications require the analysis of very high resolution spherical maps. Most existing algorithms cannot handle this scale. Thirdly, in some cases data is only available on a part of the sphere. Fourthly, whereas several graph-based and spectral methods can only learn isotropic blob-like filters, some problems require the detection of anisotropic patterns. Finally, in almost all cases, equivariance to rotations is a sought-after property since results should never depend on how we orient the sphere.
+
+The method we propose in this paper is based on the recently proposed theory of Gauge CNNs (Cohen et al., 2019). This framework has several appealing properties: $( i )$ it provides a principled way to achieve spatial and rotational weight-sharing on the sphere, (ii) it naturally allows for processing geometric features such as scalar, vector and tensor fields in an anisotropic and equivariant manner, and (iii) it makes it possible in principle to process a signal on overlapping local charts, in case data is not available for the whole sphere or when the whole signal does not fit in memory. To the best of our knowledge, we present the first implementation of a Gauge CNNs on a manifold with non-trivial curvature. We describe an efficient implementation which is, in principle, applicable to any grid on the sphere. Experiments on spherical segmentation of climate patterns and omnidirectional images demonstrate the effectiveness of our method. We show that our method is scalable and fast while being as numerically accurate as the best existing Spherical CNNs.
+
+# 2 RELATED WORK
+
+Conventional CNNs for Spherical Images. A line of prior work (Su & Grauman, 2017; Coors et al., 2018) considers using planar CNNs on intrinsically spherical tasks such as omnidirectional image segmentation. These approaches represent the spherical data on $\mathbb { R } ^ { 2 }$ via equirectangular projection which introduces position-dependent distortion rates due to curvature. In order to counteract the varying distortion rates, Su & Grauman (2017) uses kernels with increasing support towards the poles thus limiting parameter-sharing to only longitudes. Contrastingly, Coors et al. (2018) use fixed-sized kernels sampled on the tangent plane of spherical signal for better parameter-sharing and distortion invariance. Both methods assume a preferred orientation and are not SO(3) equivariant.
+
+Spherical CNNs. Another line of work operates directly on $S ^ { 2 }$ alleviating the issues related to distortions caused by projection. Boomsma & Frellsen (2017) proposes spherical convolutions for molecular modeling in both volumetric and mesh representations. Perraudin et al. (2018) proposes a graph-based spherical convolution for cosmological model classification. A subset of this line (Kondor et al., 2018; Cohen et al., 2018; Esteves et al., 2018) extends group equivariance (Cohen & Welling (2016)) over SO(3). Esteves et al. (2018) uses spherical convolutions computed by spherical FFTs. Similarly, Cohen et al. (2018) proposes a spherical correlation operation based on the SO(3)- FFT. As a result both methods have inbuilt rotation equivariance property. However, the Generalized FFT algorithms used only work on inhomogeneous grids that over-sample the poles, and in practice the FFT-based methods are slow.
+
+Recently, a number of spherical CNNs that parametrize the sphere with icosahedral tiling have been proposed (Jiang et al., 2019; Zhang et al., 2019; Liu et al., 2019; Cohen et al., 2019). These methods are tailored for the icosphere grid since this grid is quite regular and its charts can be easily mapped on $\mathbb { R } ^ { 2 }$ allowing highly optimized convolution routines to be used. Out of these methods, Gauge Equivariant Icosahedral CNN of Cohen et al. (2019) is the most similar to our method. However, their model operates on the icosahedron, which is only an approximation of the sphere, while ours operates on the sphere. Even though their method is fast and accurate, it is only equivariant to discrete icosahedral symmetries, while our method is fully SO(3)-equivariant. In comparison to all methods in this category, our method is agnostic to sampling grid used and better suited for larger scale problems.
+
+Geometric Deep Learning. There have been a number of attempts to generalize convolution operator to manifolds in the geometric deep learning field (Bronstein et al., 2017). The key issue with manifold convolution is the lack of globally consistent reference frames attached to points over a manifold. Therefore, unlike shifting a filter over a flat image grid with a clear sense of up/down and left/right, it is not clear how to place the convolution kernel. To overcome this issue, Bruna et al. (2014); Boscaini et al. (2015) have used isotropic filters at the expense of kernel expressivity. Masci et al. (2015) have applied filters in fixed number of orientations and accumulated the responses via max pooling, losing the orientation information. Recently proposed Gauge Equivariant CNNs (Cohen et al., 2019) have shown that it is possible to have both expressive kernels and orientation information by allowing the network response change equivariantly with respect to arbitrarily chosen local reference frames (i.e. gauges).
+
+# 3 CONTINUOUS THEORY OF GAUGE CNNS
+
+In this section we will review the mathematical theory of gauge CNNs on general manifolds, as presented in Cohen et al. (2019). Specifically, we will define a mathematical model of feature spaces as fields, and show how one can define a convolution-like operation that only makes use of the intrinsic structure of the manifold.
+
+# 3.1 GEOMETRICAL FEATURES & GAUGE TRANSFORMATIONS
+
+The feature spaces in Gauge CNNs are modelled as fields $f$ over a manifold $M$ . For example, the input data could be a vector field of wind directions on earth, or a scalar field of intensity values on the plane (a grayscale image), or a field of diffusion tensors on $\mathbb { R } ^ { 3 }$ . We will refer to such quantities (scalars, vectors, tensors, and others) as geometrical features and speak of a field of geometrical features or geometrical feature field. Even if the input data consists only of scalars, one might want to use other kinds of fields for the internal representation learned by the network, so we will describe Gauge CNNs for general fields. Because we are primarily interested in the 2-sphere $S ^ { 2 }$ , we will specialize to the case of $d = 2$ dimensional Riemannian manifolds.
+
+In computer science it is common to think of a vector or tensor as a list or array of numbers, but from a physical or mathematical perspective these are geometrical quantities that exist independent of a coordinatization / choice of basis. To represent a geometrical feature numerically however, we need to choose a frame for the tangent space $T _ { p } M$ at each position $p \in M$ . A smooth choice of frame is also known as a gauge. Mathematically, a gauge can be defined as a smoothly parameterized set of linear maps $\breve { w _ { p } } : \mathbb { R } ^ { d } \to T _ { p } M$ (see Fig. 1).
+
+Since the choice of gauge is arbitrary, we should consider what happens to the coefficients of geometric features if we change it (i.e. apply a gauge transformation). Consider first the coefficients $f ( p ) = v$ of a tangent vector $V$ in the tangent space $T _ { p } M$ at $p \in M$ , expressed as a pair of numbers $v = ( \dot { v } _ { 1 } , v _ { 2 } )$ relative to an orthogonal frame $( w _ { p } ( e _ { 1 } ) , w _ { p } ( e _ { 2 } ) )$ at $p$ . If we rotate the frame at $p$ by $r \in \mathrm { S O } ( 2 )$ , i.e. $w _ { p } \mapsto w _ { p } \circ r$ , then the coefficient vector transforms as ${ \dot { v } } \mapsto r ^ { - 1 } v$ . The vector itself is an abstract geometrical quantity, invariant to gauge transformations: $V = \dot { ( w _ { p } r ) } r ^ { \dot { - } 1 } v = w _ { p } v$ .
+
+![](images/5aec994a82a2b423c568b035b4427bd36a9e4538f8141f0e73325e23442e6580.jpg)  
+Figure 1: The exponential map and the gauge $w _ { p } : \mathbb { R } ^ { 2 } \to T _ { p } ^ { \star } M$ . The exponential map takes a tangent vector $V \in T _ { p } M$ and follows the geodesic starting at $p$ with speed $\| V \|$ for one unit of time, to arrive at $q _ { v } = \exp _ { p } V \in$ $M$ . Figure courtesy of Cohen et al. (2019).
+
+Note that we are free to change the gauge not just at one point, but at all positions simultaneously in an arbitrary (smooth) way. However, since we will only want to work with right-handed orthogonal frames, we only need to consider rotations of the frames. Thus, for our purposes we can define a gauge transformation as a smoothly varying choice of rotation $r _ { p } \in \mathrm { S O } ( 2 )$ .
+
+Beyond scalars (which are invariant to gauge transformations) and vectors (which transform like $f ( \dot { p } ) \mapsto r _ { p } ^ { - 1 } f ( p ) )$ , we will want to consider more general kinds of geometrical features. A $( 2 , 0 )$ - tensor, for instance, is (a linear combination of) tensor products $V \otimes W$ of vectors $V , W \in T _ { p } M$ . Given a frame, such a tensor is represented as a $d \times d$ matrix. Under a change of frame, a matrix $f ( \boldsymbol p )$ will transform like $f ( p ) \mapsto { \dot { r } } _ { p } f ( p ) r _ { p } ^ { - 1 }$ . We can also flatten the matrix into a $d ^ { 2 }$ -dimensional coordinate vector $f ( \boldsymbol p )$ , and write the transformation as $f ( p ) \mapsto ( r _ { p } \otimes r _ { p } ) f ( p )$ , where $r _ { p } \otimes r _ { p }$ is the Kronecker product.
+
+The tensor product $\rho ( r ) = r \otimes r$ is an example of a group representation. This is a map $\rho : G $ ${ \mathrm { G L } } ( C , \mathbb { R } )$ taking each element $r$ of $G$ (the rotation group SO(2) in our case) to an invertible matrix $\rho ( r )$ that acts on an $C$ -dimensional feature vector. To be called a representation, it has to satisfy $\begin{array} { r } { \dot { \rho ( \boldsymbol { r } \boldsymbol { r ^ { \prime } } ) } = \rho ( \boldsymbol { r } ) \rho ( \boldsymbol { r ^ { \prime } } ) . } \end{array}$ , which is easily checked for the tensor / Kronecker product.
+
+Thus, we can generalize to geometric feature fields that transform like $f ( p ) \mapsto \rho ( r _ { p } ^ { - 1 } ) f ( p )$ under gauge transformations, for any group representation $\rho$ of SO(2). We will refer to such fields as a $\rho$ -field or a field of type $\rho$ . In a gauge equivariant CNN, one chooses for each feature space of the network such a representation $\rho$ that determines the kind of features learned by that layer. The network is constructed such that a gauge transformation applied to the input will result in a corresponding gauge transformation in each feature space. The dimension $C$ of $\rho$ is equal to what is normally called the number of channels in the feature space. Typically, one would choose $\rho$ to be block-diagonal, containing for instance a number of scalar fields ( $1 \times 1$ blocks $\rho _ { i } ( r ) = 1 { \dot { } } ,$ ), a number of vector fields, etc. The number of copies of each type of feature is called its multiplicity.
+
+# 3.2 GAUGE EQUIVARIANT CONVOLUTION
+
+For each layer of the network, we want to interpret both the input and output as fields of geometrical features. If we apply a gauge transformation, the input coefficients change $( f ( p ) \mapsto \rho \bar { ( } r _ { p } ^ { - 1 } ) f ( p ) ) _ { . }$ , and we want the same to happen to the output (gauge equivariance), so that we may interpret it as the coefficients of a geometrical quantity relative to a gauge. In this section we will define a convolution-like operation that has this property.
+
+The classical convolution operation involves summing or integrating the product of a filter and the input signal over a local region. If we want to generalize this to fields on a manifold, we run into a difficulty: the geometric feature $f ( \boldsymbol p )$ and $f ( q )$ at different points $p$ and $q$ in $M$ live in a different vector space, and so we cannot directly compare them or add them up. For instance, if we have two tangent vectors $V \in T _ { p } M$ and $W \in T _ { q } M$ , how can we say that they are “the same” or add them up? Having chosen a frame for $T _ { p } M$ and $T _ { q } M$ we could add the coordinate vectors $v \in \mathbb { R } ^ { 2 }$ and $w \in \mathbb { R } ^ { 2 }$ , but because we can change the gauge of both tangent spaces independently, the result is not the coefficient vector of any invariant geometrical quantity.
+
+The solution is to apply parallel transport to the feature vectors before adding them up. Given a curve from $q$ to $p$ , we can transport a vector $W \in T _ { q } M$ to $T _ { p } M$ by applying a rotation $r _ { p  q } \in \mathrm { S O } ( 2 )$ to its coefficient vector $w$ . Since we can interpret $r _ { p  q } w$ as a vector in $T _ { p } M$ , the quantity $v + r _ { p  q } w$ is well-defined. In general, for other kinds of geometrical features, parallel transport acts via $\rho$ , i.e. we can add $v + \rho ( r _ { p  q } ) w$ . We will use this in the definition of the gauge equivariant convolution.
+
+Following Masci et al. (2015), we parameterize a local neighborhood around $p \in M$ by the tangent plane $T _ { p } \mathbf { \breve { M } } \simeq \mathbb { R } ^ { 2 }$ via exponential map (see Fig. 1). That is, we index nearby points $q$ by tangent vectors using the exponential map, by defining $q _ { v } = \exp _ { p } w _ { p } v$ for $v \in \mathbb { R } ^ { 2 }$ (“Riemannian normal coordinates”). The convolution is then defined by transporting for each nearby point $q _ { v }$ the feature vector $f ( q _ { v } )$ to $p$ by computing $\rho ( r _ { p  q _ { v } } ) f ( q _ { v } )$ , transforming the resulting features at $p$ using a learned kernel $K : \mathbb { R } ^ { 2 }  \mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } }$ , and integrating the result over the support of $K$ in $\mathbb { R } ^ { 2 }$ :
+
+$$
+\psi \star f ( p ) = \int _ { \mathbb { R } ^ { 2 } } K ( v ) \rho _ { \mathrm { i n } } ( r _ { p  q _ { v } } ) f ( q _ { v } ) d v .
+$$
+
+As shown by Cohen et al. (2019), this operation is gauge equivariant if and only if $K ( v )$ satisfies
+
+$$
+K ( r ^ { - 1 } v ) = \rho _ { \mathrm { o u t } } ( r ^ { - 1 } ) K ( v ) \rho _ { \mathrm { i n } } ( r ) .
+$$
+
+In section 4.2 we show how we can parameterize such a kernel via rotational weight-sharing.
+
+# 3.3 EQUIVARIANCE TO SO(3)
+
+In addition to gauge equivariance, SO(3) equivariance is a desirable property for a Spherical CNN (Cohen et al., 2018). This means that if we apply a 3D rotation to the input of the network, the output is also rotated. In this section we show that the gauge equivariant convolution as defined is also equivariant to SO(3).
+
+Consider a local patch on the sphere (e.g. the support of the kernel), and the signal defined there. When we rotate the sphere, the patch is moved to another place, and it may change its orientation. Moving the patch is not a problem: at the new position we apply the same kernel $K$ , so one expects that the convolution result at the new position equals the convolution result of the original signal at the old position. However, since the orientation of the kernel is determined by the gauge (which is arbitrary but fixed) and because we can arbitrarily change the orientation of the patch by rotating around its center, the kernel and the patch may be matched in a different relative orientation after applying the rotation. Fortunately, because the kernel satisfies Eq. 2, the result will be equivalent up to a gauge transformation acting by $\rho _ { \mathrm { o u t } }$ , and so we have SO(3) equivariance.
+
+Thus, in the continuous theory, the gauge equivariant convolution is also SO(3) equivariant. However, as we will see, making sure that this holds in a discrete implementation is not entirely trivial.
+
+# 4 DISCRETE IMPLEMENTATION OF SPHERICAL GAUGE CNNS
+
+The theory covered so far tells us how, mathematically, we can define a convolution-like operation that is gauge equivariant. However, it does not tell us exactly how to implement it on a computer, in order to process discretely sampled signals on a manifold. How we do this exactly can have a large effect on the efficiency and numerical accuracy of the method.
+
+A signal is represented as a list of values $f _ { i } ~ = ~ f ( p _ { i } )$ associated with a finite number of points $p _ { i } \in \mathcal { V } \subset S ^ { 2 }$ (see Sec. 4.1). We assume that the kernel $K ( v )$ has local support, so $K ( v ) = 0$ whenever $\| v \| > R$ for some radius $R$ . Equivalently, we can say that $q \in S ^ { 2 }$ only contributes to the convolution result at $p \in S ^ { 2 }$ if the geodesic distance between $p$ and $q$ is smaller than $R$ . Accordingly, we define the set of neighbors $\mathcal { N } ( \boldsymbol { p } )$ of $p$ as the set of points $q$ within radius $R$ from $p$ .
+
+A simple way of discretizing the gauge convolution (Eq. 1) is to replace the integral over $\mathbb { R } ^ { 2 }$ (identified with $T _ { p } M )$ by a sum over neighbors of $p$ . Each neighbor can be associated with a tangent vector via the logarithmic map: $v _ { p q } = \log _ { p } q$ . This yields the following approximation:
+
+$$
+\psi \star f ( p ) = \sum _ { q \in \mathcal { N } ( p ) } K ( v _ { p q } ) \rho _ { \mathrm { i n } } ( r _ { p  q } ) f ( q )
+$$
+
+At this point it is worth comparing Eq. 3 to the simplest form of message-passing based graph convolution (Kipf & Welling, 2017; Gilmer et al., 2017). In both cases, the result of convolution is computed as a sum of messages comming from neighbors. In the case of graph CNNs, these messages are computed as $A f ( q )$ , where $A$ is a weight matrix that is shared by all neighbors. So graph convolutions use isotropic filters that cannot distinguish where the message comes from.
+
+The gauge convolution sums messages of the form $K ( v _ { p q } ) \rho _ { \mathrm { i n } } ( r _ { p  q } ) f ( q )$ . Thus, the feature vectors $f ( q )$ of neighbors $q$ are transformed in a way that depends i) on the intrinsic geometry of the manifold via $r _ { p  q }$ and $v _ { p q }$ , and ii) by a non-isotropic (but gauge-equivariant) learnable kernel $K ( v _ { p q } )$ . We can thus think of gauge convolutions (implemented in this way) as a more powerful version of graph convolution that leverages the additional topological and metric structure of a Riemannian manifold to process geometrical data in a more flexible manner.
+
+The discrete gauge convolution is computed in a few steps, some of which are done during precomputation and some during the forward pass: i) the logarithmic map $v _ { p q } = \log _ { p } q$ , ii) the parallel transporter $r _ { p  q }$ , iii) the construction / parameterization of the kernel $K ( v )$ , iv) the linear contraction of the kernel and the signal.
+
+Steps (i) and (ii) can be complicated for a general manifold or mesh, but for the sphere are easily and exactly computable in closed form with standard operations, which are detailed in Appendix B. We will discuss our method for selecting the finite number of points on the sphere, as well as steps (iii) and (iv) in the following sections.
+
+# 4.1 THE ICOSPHERE GRID
+
+Even though our method uses the exact geometry of the sphere, a grid of points on the sphere must nevertheless be chosen on which the features will live. The sphere does not admit perfectly symmetrical and homogeneous high resolution grids. A grid that is fairly homogeneous and has been used successfully in Spherical CNNs before is what we call the icosphere grid (Jiang et al., 2019; Liu et al., 2019; Cohen et al., 2019). The icosphere grid can be computed at different levels of resolution. The lowest resolution $s = 0$ has as points $p _ { i }$ the 12 corners of the icosahedron. Higher resolutions are obtained by repeated subdivision of the triangular faces of the icosahedron into 4 sub-triangles, followed by a projection of all points to the sphere. The result is a grid $\mathcal { H } _ { s }$ with $5 \times 2 ^ { 2 s + 1 } + 2$ points at subdivision level $s$ . We emphasize that our method is not in any way tailored to this grid, and other options such as HEALPix (Gorski et al., 2005) could easily be substituted. ´
+
+![](images/53ff143d5d4f2a46feff1f915557bca857a2e994748542ffd58ab992b6e4bd3f.jpg)  
+Figure 2: Icosphere with $s \ = \ 2$ . The orange points are the 2-ring neighbours of the red point. The green arrow is the logarithmic map corresponding to the yellow path.
+
+# 4.2 PARAMETERIZATION OF THE KERNEL
+
+The kernel $K ( v )$ is defined as a continuous matrix-valued function of $\mathbb { R } ^ { 2 }$ that satisfies the kernel constraint (Eq. 2). In a classical CNN, where we are dealing with a homogeneous grid of pixels in $\mathbb { R } ^ { 2 }$ , we can define a small (e.g. $3 \times 3$ ) set of neighboring pixels $\mathcal { N } ( p ) \stackrel {  } { = } \{ p + \stackrel {  } { v } ^ { ( i ) } \} _ { i }$ so that we only ever need to evaluate the kernel at a small number (e.g. 9) of points $v ^ { ( i ) }$ . This results in a parameterization of $K$ as an array with $C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } \times 3 \times 3$ learnable coefficients.
+
+On the sphere there are no perfectly homogeneous grids, so depending on the point $p \in \mathcal V$ where we are evaluating the convolution $\psi \star f$ , the neighborhood structure $\mathcal { N } ( \boldsymbol { p } )$ may look quite different.
+
+Hence, the points $v _ { p q } \in \mathbb { R } ^ { 2 }$ where we need to evaluate $K$ will differ as well. For this reason, we parameterize $K$ as a linear combination of analytically determined continuous basis kernels. The linear coefficients will be learned.
+
+We assume that $\rho _ { \mathrm { i n } }$ and $\rho _ { \mathrm { o u t } }$ are block-diagonal with irreducible representations (irreps) as blocks (any SO(2) representation can be brought to this form by a change of basis). In this case the kernel takes on a block structure as well, with each block corresponding to a particular input/output irrep (Cohen & Welling, 2017), with irreps labelled by integer frequency $n \geq 0$ (Worrall et al., 2017) (see Appendix D). So we will focus on the case where both input and output representation consist of a single irrep, and construct the full kernel block-wise as described in Appendix A.
+
+As derived in Appendix D, the analytical solutions to Eq. 2 can be split in a independent radial part and angular part. The solutions for the angular part $K ( \theta )$ are shown in Table 1, while the radial part is unconstrained. So if a set of radial functions $\{ R _ { a } ( \dot { r } ) \}$ are chosen, and $\{ K _ { b } ( \theta ) \}$ is the complete set of angular solutions, the parameterized kernel is: $\begin{array} { r } { \dot { K } ( r , \theta ) = \sum _ { a b } w _ { a b } \dot { R } _ { l } ( a ) \dot { K } _ { b } ( \theta ) } \end{array}$ for weights $w$ . Hereafter, we denote one such solution as $K _ { i }$ , so that the parameterized kernel is $\textstyle \sum _ { i } w _ { i } K _ { i }$ . The number of basis-kernels is called num_basis.
+
+Table 1: Solutions to the angular kernel constraint for kernels that map from $\rho _ { n }$ to $\rho _ { m }$ . We denote $c _ { \pm } = c o s ( m \pm n ) \theta$ , $s _ { \pm } = \sin ( m \pm n ) \theta$ .   
+
+<table><tr><td>Pin →pout</td><td>Linearly independent solutions for K(0)</td></tr><tr><td>po→po</td><td>1</td></tr><tr><td>pn→po</td><td>(cos nθ sin nθ),(sin nθ-cos nθ) (cosmθ) sin mθ</td></tr><tr><td>po→pm</td><td>sinmθ -cosmθ</td></tr><tr><td>pn→pm</td><td>-s_ s_ c_ c+ S+ -S+ c_ ， -C_ S_ ， S+ -C+ C+</td></tr></table>
+
+Since the geometry and grid are fixed, we can precompute the basis kernels evaluated at all required points. That is, for each $p \in \mathcal V$ and $q \in \mathcal { N } ( p )$ we evaluate each basis kernel contracted with the input representation $K _ { i } ( v _ { p q } ) \rho _ { \mathrm { i n } } ( r _ { p  q } )$ where $r _ { p  q }$ and $v _ { p q }$ are as computed in Section B.1 and B.2. The result of this precomputation is an array of shape num_basis $\times$ $\mathrm { \Delta \ n u m \_ v \times n u m \_ n e i g h \times c \_ o u t \times c \_ i n , }$ , where $\mathtt { C \_ i n }$ and c_out are the dimensionality of $\rho _ { \mathrm { i n } }$ and $\rho _ { \mathrm { o u t } }$ and also the number of channels of the input and output sig
+
+nals.
+
+# 4.3 COMPUTING THE CONVOLUTION
+
+Having computed the basis kernels at each $v _ { p q }$ , we can compute the discretized gauge convolution (Eq. 3) as a linear contraction. This is done in two steps. Initially, we expand the signal $f ( \boldsymbol p )$ , which has shape n $\mathtt { l m \_ v } \times \mathtt { c \_ i n }$ , to $\hat { f }$ of shape $\mathrm { n u m \_ v \times n u m \_ n e i g h \times c \_ i n }$ . This is done so that $\hat { f } _ { p q }$ is the value of the signal at the $q$ -th neighbor of $p$ .
+
+Subsequently, we contract the signal $\hat { f }$ with basis kernels $K _ { i } ( v _ { p q } ) \rho _ { \mathrm { i n } } ( r _ { p  q } )$ and weights $w _ { i }$ to obtain the convolution result $\psi \star f$ of shape $\mathtt { n u m \_ v } \times \mathtt { c \_ o u t }$ . Since a basis-kernel $K _ { i }$ only acts on one in/out irrep pair, it is mostly zero. In Appendix A, we detail how this block-sparsity can get exploited for computational efficiency. We note that $\psi \star f$ can easily be computed for a subset $\overrightarrow { \nu } \subset \nu$ .
+
+# 4.4 NONLINEARITIES
+
+For the network to be gauge equivariant, every layer should be gauge equivariant, including nonlinearities. Irrep features do not commute with pointwise nonlinearities (Worrall et al., 2017; Thomas et al., 2018; Weiler et al., 2018; Kondor et al., 2018). However, we can perform a basis transformation to a basis in which pointwise non linearities are approximately gauge equivariant. Afterwards, we transform the basis back to the irreps.
+
+For simplicity, we assume that the representation is $U$ copies of $\rho _ { 0 } \oplus \rho _ { 1 } \oplus . . . \oplus \rho _ { M }$ . One such copy can be treated as the discrete Fourier modes of a circular signal with band limit $M$ . An inverse Discrete Fourier Transform (DFT) matrix can map these modes to $N$ spatial samples. Under a gauge transformation of a multiple of $2 \pi / N$ , the samples are cyclically shifted. The resulting representation can thus be called a regular representation and hence our procedure a RegularNonlinearity. Non linearities that act pointwise on these samples, such as the ReLU, commute with such gauge transformations. The procedure is however only approximately gauge equivariant under gauge transformations of angles that are not multiples of $2 \pi / N$ . Nevertheless, we prove in Appendix E that in (a) Any spherical grid is irregular. For example, when the the sphere is rotated, point $p$ , with 5 nearby neighbors, can be mapped to a grid point $p ^ { \prime }$ , which has 6 neighbors. As a result, the naive method may fail to be rotation equivariant.
+
+![](images/048d7c01245d24193c4a8cd31bb76357e54ba8b41d6372860cfcda117bd87330.jpg)  
+(b) For each quadrature point $c \in \ \mathcal { Z }$ (green), the signal interpolated from the neighbors $\mathcal { N } ( \boldsymbol { p } )$ (red). The convolution is equal to the sum over quadrature points, but we only sum over neighbors during the forward pass.   
+Figure 3: Quadrature Integration
+
+the limit $N  \infty$ , exact equivariance is restored and we provide a finite error bound, which can help selecting $N$ .
+
+# 5 QUADRATURE INTEGRATION
+
+The implementation described in the previous section satisfies gauge equivariance exactly. In addition to gauge symmetry, the sphere has global rotational / SO(3) symmetry, and like previous methods we would like our method to be equivariant to 3D rotations as well. In the continuous case, gauge equivariance implies $\mathrm { S O ( 3 ) }$ equivariance, but the scheme above is not exactly SO(3) equivariant due to discretization (see Figure 3a). In this section we describe a numerical method that improves SO(3) equivariance at no additional computational cost during training.
+
+Our general approach for computing $\psi \star f ( p )$ will be to interpolate the sample values at $\mathcal { N } ( \boldsymbol { p } )$ to obtain a continuous function on $\mathbb { R } ^ { 2 }$ , and then use quadrature integration to get a more precise value for the integral. Quadrature is a general numerical technique for approximating integrals with finite sums. For some region $A$ and function $g$ , the integral ${ \bar { J } } _ { A } g ( x ) { \bar { d } } { \bar { x } }$ can be approximated by $\begin{array} { r } { \sum _ { x \in \mathbb { Z } } \omega _ { x } g ( x ) } \\ { . } \end{array}$ , where $\mathcal { T } \subset A$ is some finite set of quadrature points, each with a weight $\omega _ { x }$ . The goal is selecting $\mathcal { T }$ and $\omega _ { x }$ such that the approximation is accurate (or even exact), for functions $g$ satisfying some regularity assumptions (e.g. being band-limited). In our case, the region $A$ is a disk with as radius the support radius $R$ of the kernel. The quadrature rule is described in Appendix C.
+
+The signal at $c \in \mathcal { Z }$ is inferred from the signals at $\mathcal { N } ( \boldsymbol { p } )$ by interpolation:
+
+$$
+\tilde { f } _ { p } ( c ) = \frac { 1 } { Z ( p , c ) } \sum _ { q \in N ( p ) } k ( c , q ) \rho _ { \mathrm { i n } } ( g _ { p  q } ) f ( q )
+$$
+
+where $k ( c , q ) = \exp { ( - | | c - \log _ { p } ( q ) | | ^ { 2 } / \sigma ^ { 2 } ) }$ is a Gaussian kernel with scale $\sigma$ , measuring distance between $c$ and $q$ in the tangent space, and $\begin{array} { r } { Z ( p , c ) = \sum _ { q \in \mathcal { N } ( p ) } k ( c , q ) } \end{array}$ is a normalizing constant.
+
+We can now compute the integral over $\mathbb { R } ^ { 2 }$ by quadrature integration:
+
+$$
+\psi \star f ( p ) = \sum _ { c \in \mathbb { Z } } \omega _ { c } K ( c ) \tilde { f } _ { p } ( c )
+$$
+
+The convolution Eq. 5 sums over a homogenized neighborhood and is thus more equivariant to rotations of the sphere. See Figure 3b for an illustration. Equivariance improves if a large number of quadrature points are used, which increases the computational cost. Luckily, since the composition
+
+of linear operations is linear, we simplify:
+
+$$
+\psi \star f ( p ) = \sum _ { c \in \mathcal { X } _ { p } } \omega _ { c } K ( c ) \tilde { f } _ { p } ( c ) = \sum _ { q \in N ( p ) } \sum _ { c \in \mathcal { Z } _ { p } } \frac { \omega _ { c } k ( c , q ) } { Z ( p , c ) } K ( c ) \rho _ { \mathrm { i n } } ( g _ { p  q } ) f ( q ) = \sum _ { q \in N ( p ) } \hat { K } ( p , q ) f ( q )
+$$
+
+for a new kernel Kˆ (p, q) = Pc∈Ip ωck(c,q)Z(p,c) $\begin{array} { r } { \hat { K } ( p , q ) = \sum _ { c \in \mathbb { Z } _ { p } } \frac { \omega _ { c } k ( c , q ) } { Z ( p , c ) } K ( c ) \rho _ { \mathrm { i n } } ( g _ { p  q } ) } \end{array}$ . The new kernel $\hat { K }$ can be pre-computed once, so that the convolution during run-time involves only a sum over the neighbors, just as in the naive convolution (Eq. 3). The interpolation thus does not affect computational cost.
+
+# 6 EXPERIMENTS
+
+In this section, we present experimental results on three benchmark problems. Throughout this section, we will refer to the gauge equivariant convolutions described in 4.3 as IrrepConvolution and similarly refer to tailored batch normalization and nonlinearities as IrrepBatchNorm (normalizing irreps instead of channels) and RegularNonlinearity as we name in our implementation. An IrrepConvolution and other operations are defined by specifying the number of input and output multiplicities for each irrep order, in analogy to number of channels in regular CNNs. In addition, we need to specify the types of irreps by their angular frequency. We do that by max freq argument which determines the cutoff frequency. We will describe $\rho$ by a parameter max freq and multiplicity, and include each frequency 0, . . . , max freq with the same multiplicity.
+
+# 6.1 SPHERICAL MNIST
+
+We perform a series of experiments on a toy dataset to validate the equivariance and generalization properties of our gauge-equivariant spherical CNN. Specifically, we compare our method with different filter sizes (1-ring, 2-ring) with and without interpolation, to three prior methods, as well as an isotropic baseline. The isotropic baseline uses only scalar features and isotropic kernels, but is similar in number of parameters to our model.
+
+We follow a setup similar to that of Cohen et al. (2019) and generate Spherical MNIST in randomly Rotated (R) and Non-rotated (N) conditions. For all experiments, we represent the signals on an icospherical grid at level $s = 4$ . For network architecture and training procedure, see Appendix F.1.
+
+We present our results in Table 2 on three configurations of the Spherical MNIST dataset: N/N, N/R and R/R, where X/Y means we train on X and test on Y. In addition, we run an ablation study to test the effect of quadrature integration on equivariance. Whether interpolation is used or not, our method performs similarly to two relevant spherical CNN baselines in terms of classification score on N/N. We observe that our method automatically generalizes to 3D rotations without data augmentation and thus compares favorably against IcoCNN in the N/R condition. However, in the ablation study, we observe that our method’s generalization capability against 3D rotations drops in the absence of interpolation, particularly when smaller (1-ring) filters are used. This result shows the usefulness of quadrature integration when using small filters.
+
+Our model outperforms FFS2CNN in all categories. Furthermore, it performs better than the isotropic baseline, which illustrates the importance of anisotropic filters and non-scalar features for the MNIST dataset. This is to be expected, as detection of line direction is naturally expressed in anisotropic filters.
+
+As a final note, our results confirm the theoretical result that gauge equivariance implies SO(3)- equivariance (Sec. 3.3).
+
+# 6.2 CLIMATE PATTERN SEGMENTATION
+
+We put our model to the test on a climate pattern segmentation dataset proposed by Mudigonda et al. (2017). The dataset is collection of simulated climate variables over 20 years from the Community Atmosphere Model CAM-5.0 (Neale et al., 2010). The task is to segment out regions of Atmospheric Rivers (AR) and Tropical Cyclones (TC) from background (BG). We use the preprocessed data released by Jiang et al. (2019) as is. The data consist of 16 channels sampled on an icospherical grid at level $s = 5$ (i.e. 10242 vertices).
+
+Table 2: Spherical MNIST results   
+
+<table><tr><td>Method</td><td>N/N</td><td>N/R</td><td>R/R</td><td>Time /epoch</td><td>Complexity</td></tr><tr><td>S2CNN (Cohen et al., 2018)1</td><td>99.38</td><td>99.38</td><td>99.12</td><td>380s</td><td>O(N log N)</td></tr><tr><td>IcoCNN (Cohen et al., 2019)</td><td>99.43</td><td>69.99</td><td>99.31</td><td>72s</td><td>O(N)</td></tr><tr><td>FFS2CNN (Kondor et al., 2018)</td><td>96.4</td><td>96</td><td>96.6</td><td></td><td>O(N)</td></tr><tr><td>Isotropic (2-ring, interpolation)</td><td>98.27</td><td>95.31</td><td>97.18</td><td>87s</td><td>O(N)</td></tr><tr><td>Ours s (1-ring, interpolation)</td><td>99.47</td><td>97.65</td><td>99.24</td><td>94s</td><td>O(N)</td></tr><tr><td>Ours (2-ring,interpolation)</td><td>99.51</td><td>99.32</td><td>99.43</td><td>284s</td><td>O(N)</td></tr><tr><td>Ours (1-ring,no interpolation)</td><td>99.30</td><td>91.60</td><td>99.17</td><td>94s</td><td>O(N)</td></tr><tr><td>Ours (2-ring, no interpolation)</td><td>99.45</td><td>98.48</td><td>99.28</td><td>284s</td><td>O(N)</td></tr></table>
+
+For this experiment, we use a residual U-Net architecture. Our residual blocks contain two blocks of [IrrepConvolution, IrrepBatchNorm, RegularNonlinearity] and a skip connection. We set the multiplicity to 2 at the input resolution $s = 5$ and fix max freq $= 2$ throughout. The rest of the encoder stream progressively reduces the grid resolution down to $s = 0$ while doubling the multiplicities (and thus the number of channels) every time the resolution is decreased, resulting in 196 channels. The decoder stream is mirror-symmetrical to the encoder, replacing downsampling layers with upsampling layers. We use 2 residual blocks at each resolution level. The network is trained for 60 epochs with an initial learning rate of 0.01 which is reduced by a factor of 0.4 every 30 epochs. Batch size is 64. We use a weighted cross-entropy loss, due to class imbalance following the setup of Jiang et al. (2019), with Adam optimizer (Kingma & Ba, 2015).
+
+In Table 3, we present our results. Our model compares favorably against the two spherical CNNs that have reported results on this dataset (Jiang et al., 2019; Zhang et al., 2019). Both methods operate on the same icospherical grid as our method. Our method is on par with the Icosahedral CNN of Cohen et al. (2019) on accuracy while significantly outperforming on the more relevant mAP metric. We attribute this gain to the fact that our model reflects the geometry of the signal more faithfully than IcoCNN which operates on an approximated sphere, namely, icosahedron.
+
+# 6.3 OMNIDIRECTIONAL SEMANTIC SEGMENTATION
+
+Next, we run our model in omnidirectional semantic segmentation task. For this experiment, we use Stanford 2D3DS dataset which consists of 1413 omnidirectional RGBD images acquired in 6 different locations with labels of 13 semantic categories. We are following the experimental setups in (Jiang et al., 2019; Cohen et al., 2019) and report averages over 3 cross-validation splits.
+
+We use a residual U-Net similar to what is described in 6.2. The only difference is that we use 4 residual blocks per resolution instead of 2. We train the network using weighted cross-entropy loss and Adam optimizer for 100 epochs. We set batch size to 16 and initial learning rate to 0.01. Learning rate is reduced by a factor of 0.7 every 20 epochs.
+
+We report our results in Table 4. We observe that our rotation equivariant network performs similar to the orientation-aware network of Zhang et al. (2019) while outperforming IcoCNN which is only equivariant up to discrete subgroup, A5 (i.e. icosahedral group), of SO(3). We note that 2D3DS is acquired with a preferred camera orientation rendering an additional challenge to our equivariant model which assumes no preferred orientation. Yet, the comparison against orientation-aware model of Zhang et al. (2019) reflects the expressive capability of ours despite the disadvantage.
+
+Table 3: Results on Climate Pattern Segmentation   
+
+<table><tr><td>Method</td><td>BG</td><td>TC</td><td>AR</td><td>Average (%)</td><td>mAP(%)</td></tr><tr><td>Jiang et al. (2019)</td><td>97.0</td><td>94.0</td><td>93.0</td><td>94.7</td><td>N/A</td></tr><tr><td>Zhang et al. (2019)</td><td>97.3</td><td>96.3</td><td>97.5</td><td>97.0</td><td>55.5</td></tr><tr><td>Cohen et al. (2019)</td><td>97.4</td><td>97.9</td><td>97.3</td><td>97.7</td><td>75.9</td></tr><tr><td>Ours</td><td>97.0</td><td>96.7</td><td>97.6</td><td>97.1</td><td>80.6</td></tr></table>
+
+Table 4: Results on Stanford 2D3DS   
+
+<table><tr><td>Method</td><td>Mean Acc. (%)</td><td>Mean IoU (%)</td></tr><tr><td>Jiang et al. (2019)</td><td>54.7</td><td>38.3</td></tr><tr><td>Cohen et al. (2019)</td><td>55.9</td><td>39.4</td></tr><tr><td>Zhang et al. (2019)</td><td>58.6</td><td>43.3</td></tr><tr><td>Ours</td><td>58.2</td><td>39.7</td></tr></table>
+
+# 6.4 ATOMIZATION ENERGY PREDICTION
+
+In this experiment, we test our method on molecular energy regression task given the molecular geometry and charges associated with each atom. To this end, we use QM7 dataset (Blum & Reymond, 2009; Rupp et al., 2012) which consists of molecules with varying number of atoms $N$ $( \leq 2 3 )$ ). The molecules considered in this dataset are made up of $T = 5$ different elements (i.e. H, C, N, O and S). Each molecule is defined by a tuple $( p _ { i } , z _ { i } )$ with $i$ indexing the atoms. We follow the setup for signal representation outlined in Cohen et al. (2018) and represent geometry of molecules with spheres, $s _ { i }$ , of constant radius centered at atomic positions, $p _ { i }$ , in a careful arrangement such that no two spheres intersect in a molecule. Finally, each atom $i$ is associated with $T$ -channel spherical potential functions describing atomic interactions within the molecule with $\begin{array} { r } { U _ { z } ( x ) _ { x \in s _ { i } } = \stackrel { - } \sum _ { j \not = i , z _ { j } = z } ( z _ { i } z ) / \left| x - p _ { i } \right| , } \end{array}$ .
+
+We use a similar architecture to that of Cohen et al. (2018) in terms of parameters. The details of network and training is available in Appendix F.2. Our method achieves the lowest RMSE error in comparison to the spherical baselines as shown in Table 5.
+
+Table 5: Results on QM7 Atomization Energy Prediction task.   
+
+<table><tr><td>Model</td><td>RMS error</td></tr><tr><td>MLP/Random CM (Montavon et al., 2012)</td><td>5.96</td></tr><tr><td>FFS2CNN (Kondor et al.,2018)</td><td>7.97</td></tr><tr><td>S2CNN (Cohen et al., 2018)1</td><td>5.13</td></tr><tr><td>Ours</td><td>4.99</td></tr></table>
+
+Table 6: Results on Cosmology dataset. Split level 4.   
+
+<table><tr><td></td><td>g=0.0</td><td>σ=0.5</td><td>σ=1.0</td><td>g=1.5</td><td>g=2.0</td></tr><tr><td>DeepSphere (FCN)</td><td>100.0</td><td>99.79</td><td>97.70</td><td>92.52</td><td>86.84</td></tr><tr><td>DeepSphere (CNN)</td><td>100.0</td><td>99.71</td><td>97.18</td><td>91.25</td><td>83.61</td></tr><tr><td>Ours</td><td>99.27</td><td>98.23</td><td>96.29</td><td>91.80</td><td>84.90</td></tr></table>
+
+6.5 COSMOLOGICAL MODEL CLASSIFICATION
+
+We test our model on cosmological model classification task which is an interesting test bed to demonstrate our algorithm’s flexibility in admitted sampling scheme and scalability aspects. To this end, we use a dataset released by Perraudin et al. (2018). This dataset consists of cosmological convergence maps which are generated by whole-sky N-body simulations for two different parameter settings of $\Lambda { \bf C D M }$ cosmological model. Both cosmological models are simulated 30 times. For testing, 20 simulations are held out. The remaining 40 simulations are further split into training and validation sets of size 32 and 8, respectively. The signals are represented on HEALPix grid.We refer the reader to the original article for more information.
+
+We follow the experimental setup described in (Perraudin et al., 2018) for evaluation. We split the maps into $1 2 \times { \bar { o ^ { 2 } } }$ patches where $o = 4$ indexes the hierarchical level of the patches in HEALPix sampling scheme. We then obtain signals of dimensionality $( N _ { s i d e } / o ) ^ { 2 }$ where $N _ { s i d e }$ , i.e. number of pixels on one side of HEALPix patch, is set to $2 ^ { 1 0 }$ . During training, we apply additive Gaussian noise with varying standard deviation, $\sigma _ { n o i s e } \in \{ 0 , 0 . 5 , 1 , 1 . 5 , 2 \}$ and report results separately on each setting. The details of network architecture and training are available in Appendix F.3. The results in Table 6 show that our model performs similarly to the graph-based approach.
+
+# 7 CONCLUSION
+
+We have introduced the gauge equivariant spherical CNN, which is simultaneously efficient, numerically accurate, flexible with respect to the pixel grid used, and which can in principle be applied to data that is defined on local parts of the sphere only. Additionally, it is the first implementation of the theory of gauge CNNs for a manifold that is not locally flat. Our experimental results show that the method is accurate and achieves strong performance on various benchmark problems. Moreover, our method can be adapted to work on meshes, and we plan to work on this in the future.
+
+# REFERENCES
+
+L. C. Blum and J.-L. Reymond. 970 million druglike small molecules for virtual screening in the chemical universe database GDB-13. J. Am. Chem. Soc., 2009.
+
+Wouter Boomsma and Jes Frellsen. Spherical convolutions and their application in molecular modelling. In NIPS, 2017.
+
+Davide Boscaini, Jonathan Masci, Simone Melzi, Michael M Bronstein, Umberto Castellani, and Pierre Vandergheynst. Learning class-specific descriptors for deformable shapes using localized spectral convolutional networks. In Computer Graphics Forum, 2015.
+
+Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: Going beyond euclidean data. IEEE Signal Processing Magazine, 2017.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. In ICLR, 2014.
+
+Taco Cohen and Max Welling. Group equivariant convolutional networks. In ICML, 2016.
+
+Taco Cohen, Mario Geiger, Jonas Kohler, and Max Welling. Spherical CNNs. In ¨ ICLR, 2018.
+
+Taco Cohen, Maurice Weiler, Berkay Kicanaoglu, and Max Welling. Gauge equivariant convolutional networks and the icosahedral cnn. In ICML, 2019.
+
+Taco S Cohen and Max Welling. Steerable CNNs. In ICLR, 2017.
+
+Benjamin Coors, Alexandru Condurache, and Andreas Geiger. Spherenet: Learning spherical representations for detection and classification in omnidirectional images. In ECCV, 2018.
+
+Carlos Esteves, Christine Allen-Blanchette, Ameesh Makadia, and Kostas Daniilidis. Learning so(3) equivariant representations with spherical cnns. In ECCV, 2018.
+
+Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural Message Passing for Quantum Chemistry. In ICML, 2017.
+
+K. M. Gorski, E. Hivon, A. J. Banday, B. D. Wandelt, F. K. Hansen, M. Reinecke, and M. Bartel-´ mann. HEALPix: A Framework for High-Resolution Discretization and Fast Analysis of Data Distributed on the Sphere. The Astrophysical Journal, 2005.
+
+Francis Begnaud Hildebrand. Introduction to numerical analysis. Courier Corporation, 1987.
+
+Chiyu Max Jiang, Jingwei Huang, Karthik Kashinath, Prabhat, Philip Marcus, and Matthias Nießner. Spherical cnns on unstructured grids. In ICLR, 2019.
+
+D Kingma and J Ba. Adam: A Method for Stochastic Optimization. In ICLR, 2015.
+
+Thomas N Kipf and Max Welling. Semi-Supervised Classification with Graph Convolutional Networks. In ICLR, 2017.
+
+Risi Kondor, Zhen Lin, and Shubhendu Trivedi. Clebsch-gordan nets: a fully fourier space spherical convolutional neural network. In NIPS, 2018.
+
+Min Liu, Fupin Yao, Chiho Choi, Ayan Sinha, and Karthik Ramani. Deep learning 3d shapes using alt-az anisotropic 2-sphere convolution. In ICLR, 2019.
+
+Jonathan Masci, Davide Boscaini, Michael M. Bronstein, and Pierre Vandergheynst. Geodesic convolutional neural networks on riemannian manifolds. ICCVW, 2015.
+
+Gregoire Montavon, Katja Hansen, Siamac Fazli, Matthias Rupp, Franziska Biegler, Andreas Ziehe, ´ Alexandre Tkatchenko, Anatole V Lilienfeld, and Klaus-Robert Muller. Learning invariant rep- ¨ resentations of molecules for atomization energy prediction. In NeurIPS, 2012.
+
+Mayur Mudigonda, Sookyung Kim, Ankur Mahesh, Samira Kahou, Karthik Kashinath, Dean Williams, Vincent Michalski, Travis OBrien, and Mr Prabhat. Segmenting and tracking extreme climate events using neural networks. 2017.
+
+Richard B Neale et al. Description of the ncar community atmosphere model (cam 5.0). 2010.
+
+Nathanael Perraudin, Michael Defferrard, Tomasz Kacprzak, and Raphael Sgier. Deepsphere: Effi-¨ cient spherical convolutional neural network with healpix sampling for cosmological applications. ArXiv, 2018.
+
+M. Rupp, A. Tkatchenko, K.-R. Muller, and O. A. von Lilienfeld. Fast and accurate modeling of ¨ molecular atomization energies with machine learning. Physical Review Letters, 2012.
+
+Yu-Chuan Su and Kristen Grauman. Learning spherical convolution for fast features from 360 imagery. In NIPS, 2017.
+
+Nathaniel Thomas, Tess Smidt, Steven Kearnes, Lusann Yang, Li Li, Kai Kohlhoff, and Patrick Riley. Tensor Field Networks: Rotation- and Translation-Equivariant Neural Networks for 3D Point Clouds. 2018.
+
+Maurice Weiler, Mario Geiger, Max Welling, Wouter Boomsma, and Taco Cohen. 3D Steerable CNNs: Learning Rotationally Equivariant Features in Volumetric Data. In NeurIPS, 2018.
+
+Daniel E Worrall, Stephan J Garbin, Daniyar Turmukhambetov, and Gabriel J Brostow. Harmonic Networks: Deep Translation and Rotation Equivariance. In CVPR, 2017.
+
+Chao Zhang, Stephan Liwicki, William Smith, and Roberto Cipolla. Orientation-aware semantic segmentation on icosahedron spheres. In ICCV, 2019.
+
+# A IMPLEMENTATION OUTLINE
+
+This section outlines how the Gauge equivariant convolution is implemented. PyTorch notation is used and some details are omitted. During pre-computation, the kernel tensor is constructed, which is used during runtime to perform the convolution.
+
+A naive implementation would construct for each basis kernel a large matrix mapping from all input channels to all output channels. The parametrized kernel is then obtained from contracting these with a weight vector, which has a weight for each basis kernel. However, this stack of basis kernels would be very large for two reasons. Firstly, since the grid is irregular, a separate copy needs to be stored for each point on the sphere. Secondly, it is common to use irreps of low orders, but use many copies of those (so with a multiplicity larger than one), each having the same set of basis kernels.
+
+We prevent creation of this large stack of basis kernels by exploiting the fact that each basis kernel is a very sparse linear transformation, as it only has one irrep as input and one as output, making it block-sparse. This allows us to group the basis kernels mapping from and to the same irrep. So we can exploit the block-sparsity and also prevent allocating a kernel basis for each multiplicity.
+
+The kernels between two irreps can be constructed as follows. Arguments are the orders of the input and output irreps, a set of radial activation functions, and for each point $p$ and neighbor $q$ , the radius and angle of the log map from $p$ to $q$ in the gauge at $p$ , the parallel transport angle.
+
+def build_kernel(order_in, order_out, radial_functions, log_map_r, log_map_angle, transport, mask): """Last four arguments are [num_v, num_neigh]. Return [num_basis, num_v, num_neigh, dim_out, dim_in].""" a_in $=$ order_in $\star$ (log_map_angle - transport) a_out $=$ order_out $\star$ log_map_angle cos_min $=$ np.cos(a_out-a_in) cos_plus $=$ np.cos(a_out+a_in) sin_min $=$ np.sin(a_out-a_in) sin_plus $=$ np.sin(a_out+a_in) if order_in $\qquad = = \quad 0$ or order_out $\qquad = = \quad 0$ :
+
+# else:
+
+[[cos_min, -sin_min], [sin_min, cos_min]], [[sin_min, cos_min], [-cos_min, sin_min]], [[cos_plus, sin_plus], [sin_plus, -cos_plus]], [[-sin_plus, cos_plus], [cos_plus, sin_plus]], ]) radial_part $=$ np.array([f(log_map_r) for f in radial_functions]) kernel $=$ np.einsum( 'rpq,pq,bijpq->brpqij', radial_part, mask, angular_part) return kernel.reshape((-1, $\star$ kernel.shape[2:]))
+
+Given such kernels for all irrep orders, we subsequently can define the gauge equivariant convolution.
+
+Basically, we iterate over each irrep in the in dimension and each irrep in the out dimension. For each block, we have $m _ { i n } * d i m ( o r d e r _ { i n } )$ input dimensions and $m _ { o u t } { * } d i m ( o r d e r _ { o u t } )$ output dimensions.
+
+$\mathrm { ~  ~ x ~ } = \mathrm { ~  ~ \cdot ~ } \cdot \mathrm { ~  ~ \cdot ~ }$ $\#$ [num_batch, num_v, c_in]   
+2 # The layout of the channels is:   
+3 # cat(flatten((irrep order, irrep multiplicity, irrep dimension)))   
+4 neighbors $=$ ... # [num_v, num_neigh]   
+5 reps_in $=$ [(0, 4), (1, 4)] # 4 irreps of order 0, 4 of order 1   
+6 reps_out $=$ [(0, 4), (1, 3)] # 4 irreps of order 0, 3 of order 1   
+7 kernels $=$ .   
+8 # {(order_out, order_in): [num_basis, num_v, num_neigh, d_out, d_in]}   
+9   
+10 # One weight for each:   
+11 # in/out irrep $\star$ number of basis kernels $\star$ multiplicities in/out   
+12 weights $=$ torch.randn(sum(   
+13 len(kernels[(order_out, order_in)]) $\star$ m_out $\star$ m_in   
+14 for order_out, m_out in reps_out   
+15 for order_in, m_in in reps_in))   
+16   
+17 # Neighborhood expansion   
+18 x_e = x[:, neighbors]   
+19 num_batch, num_v, num_neigh, c_in $=$ x_e.shape   
+20   
+21 # Dimension of representation of order l   
+22 dim $=$ lambda order: 1 if order $\qquad = = \quad 0$ else 2   
+23   
+24 c_out $=$ sum(dim(l) $\star$ m for l, m in reps_out)   
+25 y = torch.zeros(num_batch, num_v, c_out)   
+26 y_idx $\qquad = \quad 0$   
+27 w_idx $\qquad = \quad 0$   
+28 # Iterate over in/out irreps. Concatenate over out irreps   
+29 for order_out, m_out in reps_out:   
+30 x_idx = 0   
+31 for order_in, m_in in reps_in: # Sum over in irreps   
+32 $\begin{array} { r l } { \mathrm { k } } & { { } = } \end{array}$ kernels[(order_out, order_in)]   
+33 x_rep = x_e[:, :, :, x_idx:x_idx $^ +$ m_in $\star$ dim(order_in)] \   
+34 .view(num_batch, num_v, num_neigh, m_in, dim(order_in))   
+35 w_rep $=$ weights[w_idx:w_idx $^ +$ len(k) $\star$ m_out $\star$ m_in] \   
+36 .view(len(k), m_out, m_in)   
+37 y[:, :, y_idx:y_idx $^ +$ dim(order_out) $\star$ m_out] $+ =$ torch.einsum(   
+38 'uvb,bpqij,npqvj->npui', w_rep, k, x_rep)   
+39 x_idx $+ =$ m_in $\star$ dim(order_in)   
+40 w_idx $+ =$ len(k) $\star$ m_out $\star$ m_in   
+41 y_idx $+ =$ dim(order_out) $^ { \star }$ m_out   
+42 return y
+
+# B SPHERICAL GEOMETRY
+
+To compute the logarithmic map at $p$ whose exponential map lands at $q$ , and to compute the parallel transporter from $q$ to $p$ along a geodesic, we do the following.
+
+# B.1 PARALLEL TRANSPORTERS
+
+Since $r _ { p  q }$ is a planar rotation, it is determined by where it sends a single (non-zero) vector. We take the first basis vector $b _ { 1 } ^ { q } = w _ { q } ( ( 1 , 0 ) )$ and express it in 3D Euclidean coordinates. We then rotate this vector by the angle $\check { \angle ( p , q ) } = \operatorname { a r c c o s } { \langle p , q \rangle }$ between $p$ and $q$ around the axis $p \times q$ which is orthogonal to the $p q$ plane. The resulting vector lies in the tangent plane at $p$ . Then $r _ { p  q }$ is determined as the angle between this vector and the first basis vector $b _ { 1 } ^ { p } = w _ { p } ( ( 1 , 0 ) )$ in $T _ { p } S ^ { 2 }$ .
+
+We precompute the transport angles for every point $p$ in the grid $\nu$ and every $q \in \mathcal { N } ( p )$ . This results in an array of angles of size num_v $\times$ num_neigh where nu $\ n _ { - } \ v \ = \ | \nu |$ and num_neigh $=$ $\mathrm { m a x } _ { p \in \mathcal { V } } | \dot { \mathcal { N } } ( p ) |$ is the maximum neighborhood size. For nodes with a non-maximal number of neighbors, we pad with zeros.
+
+# B.2 LOGARITHMIC MAPS
+
+For each $p \in \mathcal V$ and $q \in \mathcal { N } ( p )$ we need to compute $v _ { p q } = \log _ { p } q$ , which is the vector in $T _ { p } S ^ { 2 }$ that points in the direction of $q$ and has length equal to the geodesic distance between $p$ and $q$ . One way to compute the log map is to project the 3 dimensional vector pointing from $p$ to $q$ to the tangent plane. This is done by subtracting from $q - p$ the component parallel to the $p$ vector, as the $p$ vector is orthogonal to the tangent plane at $p$ . This produces a vector $\tilde { v } \propto ( q - p ) - \langle p , q - p \rangle p = q - \langle p , q \rangle p$ which has the right direction. Then one can scale the length of $\tilde { v }$ so that it matches the geodesic distance $d ( p , q )$ (the arclength):
+
+$$
+\log _ { p } q = d ( p , q ) { \frac { q - \langle p , q \rangle p } { \lVert q - \langle p , q \rangle p \rVert } }
+$$
+
+We express the result $v _ { p q } = \log _ { p } q$ in polar coordinates relative to the gauge at $p$ . This gives two arrays log_map_r (the length / radial coordinate of $v$ ) and log_map_angle (the angular part of $v$ , relative to the gauge at $p$ ). Both are shaped num_ $_ { , \lor } \times$ num_neigh as before. Since the geometry and grid are fixed, these arrays are computed only once before training.
+
+# C QUADRATURE
+
+The goal of selecting the quadrature points and weights is to approximate an integral $\begin{array} { r } { \int _ { D } g ( x ) d x } \end{array}$ , where $D \subset \mathbb { R } ^ { 2 }$ is the unit disk, with a finite sum $\textstyle \sum _ { x \in \mathbb { Z } } w _ { x } g ( x )$ , for a set of points $\mathcal { T } \subset D$ and each with weight $w _ { x }$ . We use a simple method of selecting $\mathcal { T }$ and $w _ { x }$ . We desire a rotational symmetry, so the points lie on $N _ { R }$ radial rings, each with $N _ { \Theta }$ points.
+
+First, we use Gauss-Legendre quadrature (Hildebrand, 1987) to obtain $N _ { R }$ quadrature points $u$ with weights $w _ { u }$ over the interval $[ - 1 , 1 ]$ . We map this to radial weights and points by $r =$ $\sqrt { ( u + 1 ) / 2 } , w _ { r } = w _ { u } / 2$ . For the angular component, we take a uniform grid of $N _ { \Theta }$ points on $( - \pi , \pi ]$ . The integration points on the disk are then $x = ( r , \theta )$ with weights $w _ { x } = w _ { r } / N _ { \Theta }$ .
+
+This gives accurate integration, because points $( u + 1 ) / 2$ and weights $w _ { u } / 2$ create a quadrature scheme on $[ 0 , 1 ]$ . The square root creates a uniform polar grid, as the integration measure for the disk is $r d r d \theta = d u d \theta / 2$ .
+
+D SOLVING THE SO(2) KERNEL CONSTRAINT   
+
+<table><tr><td>m,n</td><td>d(pmpn)</td><td>Linearly independent solutions for K(0)</td></tr><tr><td>0,0</td><td>0 -n)</td><td>1 (cos nθ sin nθ),(sin nθ-cos n0)</td></tr><tr><td>0,n</td><td>0 n 0 -m</td><td></td></tr><tr><td>m,0</td><td>0 m /0 -n</td><td>0 (2 2).(2 2）.（2) (2 s)</td></tr><tr><td>m,n</td><td>n 0 m 0 10 m</td><td>-m 0 -m 0 -n n 0</td></tr></table>
+
+Table 7: Solutions to the kernel constraint for kernels that map from $\rho _ { n }$ to $\rho _ { m }$ . We denote $c _ { \pm } = c o s ( m \pm n ) \theta , s _ { \pm } = \sin ( m \pm n ) \theta$ .
+
+Consider a kernel $K$ a function on the tangent space $T _ { p } M$ , such that for all $v \in T _ { p } M , K ( v )$ is a linear map from features in representation $\rho _ { \mathrm { o u t } }$ to features in a representation $\rho _ { \mathrm { o u t } }$ . This kernel is equivariant if $\forall v \in T _ { p } M$ and $\forall g \in \mathrm { S O } ( 2 )$ the following kernel constraint is satisfied:
+
+$$
+K ( g ^ { - 1 } v ) = \rho _ { \mathrm { o u t } } ( g ^ { - 1 } ) K ( v ) \rho _ { \mathrm { i n } } ( g ) . \quad \forall v \in T _ { p } M , g \in S O ( 2 )
+$$
+
+We immediately see that this constraint is independent for each radius, so we can solve the constraint independently for each radial ring, giving rise to the angular constraint on each ring:
+
+$$
+K ( \theta - g ) = \rho _ { \mathrm { o u t } } ( - g ) K ( \theta ) \rho _ { \mathrm { i n } } ( g ) . \quad \forall \theta \in S ^ { 1 } , g \in S O ( 2 )
+$$
+
+where we note that the circle equals SO(2) and the action of SO(2) on itself is simply an addition of angles. Any representation $\rho$ can be written as equivalent to a direct sum of the irreducible representations (irreps) of SO(2), which are the following, indexed by their order $n \in \mathbb { N }$ :
+
+$$
+\rho _ { 0 } ( g ) = 1 , \quad \rho _ { n } ( g ) = { \binom { \cos n g \quad - \sin n g } { \sin n g \quad \cos n g } } , n \in \mathbb { N } _ { > 0 }
+$$
+
+This means that for any representation $\rho$ , we can always find an invertible matrix $A$ such: $\forall g \ :$ $\rho ( g ) = A ^ { - 1 }$ block $\mathrm { d i a g } ( \rho _ { n _ { 1 } } , . . . \rho _ { n _ { N } } ) { \cal A }$ , where $\{ n _ { 1 } , . . . , \stackrel { . } { n _ { N } } \}$ indicate the orders of the constituent irreps. Hence, we can solve the angular kernel constraint (Eq. 9) for two irreps, $\rho _ { \mathrm { i n } } = \rho _ { n }$ and $\rho _ { \mathrm { o u t } } =$ $\rho _ { m }$ , and construct the solution for general representations $\rho _ { \mathrm { i n } }$ and $\rho _ { \mathrm { o u t } }$ from the obtained solutions. Noting that all irreps are orthogonal in our chosen basis are orthogonal, so that $\rho _ { n } ( g ) ^ { T } = \rho ( - g )$ , we see that, introducing explicit indices:
+
+$$
+\begin{array} { c } { { K ( \theta - g ) _ { i j } = \rho _ { m } ( - g ) _ { i l } K ( \theta ) _ { l k } \rho _ { n } ( g ) _ { k j } } } \\ { { { } } } \\ { { { } = \rho _ { m } ( - g ) _ { i l } \rho _ { n } ( - g ) _ { j k } K ( \theta ) _ { l k } } } \\ { { { } } } \\ { { { } = ( \rho _ { m } \otimes \rho _ { n } ) ( - g ) _ { ( i j ) , ( l k ) } K ( \theta ) _ { l k } } } \end{array}
+$$
+
+As this equation is ought to be satisfied for any $g \in \mathrm { S O } ( 2 )$ and $\mathrm { S O } ( 2 )$ is a one-dimensional Lie group, we can equivalently require it to be satisfied by an infinitesimal element of SO(2) close to the identity, creating an ordinary differential equation:
+
+$$
+\begin{array} { c } { { \displaystyle \dot { K } ( \theta ) = d ( \rho _ { m } \otimes \rho _ { n } ) K ( \theta ) , } } \\ { { \mathrm { w h e r e } \quad d ( \rho _ { m } \otimes \rho _ { n } ) : = \displaystyle \left( \frac { \partial } { \partial g } ( \rho _ { m } \otimes \rho _ { n } ) ( g ) \right) \vert _ { g = 0 } , } } \end{array}
+$$
+
+For various $m , n$ , we can construct $( \rho _ { m } \otimes \rho _ { n } ) ( g )$ , take the derivative with respect to $g$ and set $g$ to 0 to obtain the matrix $d ( \rho _ { m } \otimes \rho _ { n } )$ . Subsequently, any computer algebra system can solve the ODE. The
+
+solutions can be found in Table 7. Now, for a general $\rho _ { \mathrm { i n } } ( g ) = A ^ { - 1 }$ block $\mathrm { d i a g } ( \rho _ { n _ { 1 } } , . . . \rho _ { n _ { N } } ) ( g ) A$ , $\rho _ { \mathrm { o u t } } ( g ) = B ^ { - 1 }$ block $\mathrm { . d i a g } ( \rho _ { m _ { 1 } } , . . . \rho _ { m _ { M } } ) ( g ) B$ , a general solution has the form:
+
+$$
+\boldsymbol { K } ( \boldsymbol { \theta } ) = \boldsymbol { B } ^ { - 1 } \left( \begin{array} { c c c } { K _ { m _ { 1 } , n _ { 1 } } ( \boldsymbol { \theta } ) } & { \cdots } & { K _ { m _ { 1 } , n _ { N } } ( \boldsymbol { \theta } ) } \\ { \vdots } & { \ddots } & { \vdots } \\ { K _ { m _ { M } , n _ { 1 } } ( \boldsymbol { \theta } ) } & { \cdots } & { K _ { m _ { M } , n _ { N } } ( \boldsymbol { \theta } ) } \end{array} \right) \boldsymbol { A }
+$$
+
+where $K _ { m , n } ( \theta )$ is a solution from Table 7 mapping from irrep $\rho _ { n }$ to $\rho _ { m }$ . For each in/out irrep pair, we get a linear solution space of 1, 2 or 4 dimensions. For general $\rho _ { \mathrm { i n } } , \rho _ { \mathrm { o u t } }$ , the solution space is the product of the solution spaces of each in/out irrep pair. A parameterized kernel can thus be constructed by assigning a weight to each independent solution of each in/out irrep pair.
+
+# E EQUIVARIANCE ERROR BOUNDS ON REGULAR NON-LINEARITY
+
+The regular non-linearity acts on each point on the sphere in the following way. For simplicity, we assume that the representation is $U$ copies of $\rho _ { 0 } \oplus \rho _ { 1 } \oplus \ldots \oplus \rho _ { M }$ . One such copy can be treated as the discrete Fourier modes of a circular signal with band limit $M$ . We map these Fourier modes to $N$ spatial samples with an inverse Discrete Fourier Transform (DFT) matrix. Then apply to those samples a point-wise non-linearity, like ReLU, and map back to the Fourier modes with a Discrete Fourier Transform Matrix.
+
+This procedure is exactly equivariant for gauge transformation with angles multiple of $2 \pi / N$ , but approximately equivariant for small rotations in between.
+
+In equations, we start with Fourier modes $x _ { 0 } , ( x _ { \alpha } ( m ) , x _ { \beta } ( m ) ) _ { m = 1 } ^ { B }$ at some point on the sphere and result in Fourier modes $z _ { 0 } , ( z _ { \alpha } ( m ) , z _ { \beta } ( m ) ) _ { m = 1 } ^ { B }$ . We let $t = 0 , . . . , N - 1$ index the spatial samples.
+
+$$
+\begin{array} { c } { { \displaystyle x ( t ) = x _ { 0 } + \sum _ { m } x _ { \alpha } ( m ) \cos \left( \frac { 2 \pi } N m t \right) + \sum _ { m } x _ { \beta } ( m ) \sin \left( \frac { 2 \pi } N m t \right) } } \\ { { \displaystyle y ( t ) = f ( x ( t ) ) } } \\ { { \displaystyle z _ { 0 } = \frac 1 N \sum _ { t } y ( t ) } } \\ { { \displaystyle z _ { \alpha } ( m ) = \frac 2 N \sum _ { t } \cos \left( \frac { 2 \pi } N m t \right) y ( t ) } } \\ { { \displaystyle z _ { \beta } ( m ) = \frac 2 N \sum _ { t } \sin \left( \frac { 2 \pi } N m t \right) y ( t ) } } \end{array}
+$$
+
+Note that Nyquist’s sampling theorem requires us to pick $N \geq 2 B + 1$ , as otherwise information is always lost. The normalization is chosen so that $z _ { \alpha } ( m ) = x _ { \alpha } ( m )$ if $f$ is the identity.
+
+Now we are interested in the equivariance error between the following two terms, for small rotation $\delta \in [ 0 , 1 )$ . Any larger rotation can be expressed in a rotation by a multiple of $2 \pi / N$ , which is exactly equivariant, followed by a smaller rotation. We let $z _ { \alpha } ^ { F T } ( m ) ^ { }$ be the resulting Fourier mode if first the input is gauge-transformed and then the regular non-linearity is applied, and let $z _ { \alpha } ^ { T F } ( m )$ be the result of first applying the regular non-linearity, followed by the gauge transformation.
+
+$$
+\begin{array} { l l l } { { z _ { \alpha } ^ { F T } ( m ) = \displaystyle \frac { 2 } { N } \sum _ { t } \cos \left( \frac { 2 \pi } { N } m t \right) y ( t + \delta ) = \displaystyle \frac { 2 } { N } \sum _ { t } c _ { m } ( t ) y ( t + \delta ) } } \\ { { z _ { \alpha } ^ { T F } ( m ) = \displaystyle \frac { 2 } { N } \sum _ { t } \cos \left( \frac { 2 \pi } { N } m ( t - \delta ) \right) y ( t ) = \displaystyle \frac { 2 } { N } \sum _ { t } c _ { m } ( t - \delta ) y ( t ) } } \end{array}
+$$
+
+where we defined for convenience $c _ { m } ( t ) = \cos ( 2 \pi m t / N )$ . We define norms $\vert \vert x \vert \vert _ { 1 } = \vert x _ { 0 } \vert +$ $\begin{array} { r } { \sum _ { m } ( | x _ { \alpha } ( m ) | + | x _ { \beta } ( m ) | ) } \end{array}$ and $\begin{array} { r } { \vert \vert \partial x \vert \vert _ { 1 } = \sum _ { m } m ( \vert x _ { \alpha } ( m ) \vert + \vert x _ { \beta } ( m ) \vert ) } \end{array}$ .
+
+Theorem 1. If the input $x$ is band limited by $B$ , the output $z$ is band limited by $B ^ { \prime }$ , $N$ samples are used and the non-linearity has Lipschitz constant $L _ { f }$ , then the error to the gauge equivariance of the regular non-linearity bounded by:
+
+$$
+| | z ^ { F T } - z ^ { T F } | | _ { 1 } \leq \frac { 4 \pi L _ { f } } { N } \left( ( 2 B ^ { \prime } + \frac 1 2 ) | | \partial x | | _ { 1 } + B ^ { \prime } ( B ^ { \prime } + 1 ) | | x | | _ { 1 } \right)
+$$
+
+which goes to zero as $N \to \infty$ .
+
+Proof. First, we note, since the Lipschitz constant of the cosine and sine is 1:
+
+$$
+\begin{array} { c } { \displaystyle | c _ { m } ( t - \delta ) - c _ { m } ( t ) | \leq \frac { 2 \pi m \delta } { N } \leq \frac { 2 \pi m } { N } } \\ { \displaystyle | x ( t + \delta ) - x ( t ) | \leq \frac { 2 \pi } { N } \sum _ { m } m ( | x _ { \alpha } ( m ) | + | x _ { \beta } ( m ) | ) = \frac { 2 \pi } { N } | | \partial x | | _ { 1 } } \\ { \displaystyle | y ( t + \delta ) - y ( t ) | \leq L _ { f } \frac { 2 \pi } { N } | | \partial x | | _ { 1 } } \\ { \displaystyle | c _ { m } ( t ) | \leq 1 } \\ { \displaystyle | x ( t ) | \leq | x _ { 0 } | + \sum _ { m } ( | x _ { \alpha } ( m ) | + | x _ { \beta } ( m ) | ) = | | x | | _ { 1 } } \\ { \displaystyle | y ( t ) | \leq L _ { f } | | x | | _ { 1 } } \end{array}
+$$
+
+Then:
+
+$$
+\begin{array} { l } { \displaystyle \left| c _ { m } ( t ) y ( t + \delta ) - c _ { m } ( t - \delta ) y ( t ) \right| } \\ { \displaystyle = \lvert c _ { m } ( t ) [ y ( t + \delta ) - y ( t ) ] - y ( t ) [ c _ { m } ( t - \delta ) - c _ { m } ( t ) ] \rvert } \\ { \displaystyle \le \lvert c _ { m } ( t ) \rvert \lvert y ( t + \delta ) - y ( t ) \rvert + \lvert y ( t ) \rvert \lvert c _ { m } ( t - \delta ) - c _ { m } ( t ) \rvert } \\ { \displaystyle \le L _ { f } \frac { 2 \pi } { N } \lvert | \partial x \rvert | _ { 1 } + L _ { f } \lvert | x \rvert | _ { 1 } \frac { 2 \pi m } { N } } \\ { \displaystyle = \frac { 2 \pi L _ { f } } { N } \left( \lvert | \partial x \rvert | _ { 1 } + m \lvert | x \rvert | _ { 1 } \right) } \end{array}
+$$
+
+So that finally:
+
+$$
+\begin{array} { c l } { \displaystyle | z _ { \alpha } ^ { F T } ( { m } ) - z _ { \alpha } ^ { T F } ( { m } ) | } \\ { \displaystyle \leq \frac { 2 } { N } \sum _ { t } | c _ { m } ( t ) y ( t + \delta ) - c _ { m } ( t - \delta ) y ( t ) | } \\ { \displaystyle \leq \frac { 4 \pi L _ { f } } { N } \left( | | \partial x | | _ { 1 } + m | | x | | _ { 1 } \right) } \end{array}
+$$
+
+The sinus component $| z _ { \beta } ^ { F T } ( m ) - z _ { \beta } ^ { T F } ( m ) |$ has the same bound, while $| z _ { 0 } ^ { F T } - z _ { 0 } ^ { T F } | = | y ( t + \delta ) - \rrangle$ $y ( t ) |$ , which is derived above. So if $z$ is band-limited by $B ^ { \prime }$ :
+
+$$
+\begin{array} { l } { \displaystyle | | z ^ { F T } - z ^ { T F } | | _ { 1 } = | z _ { 0 } ^ { F T } - z _ { 0 } ^ { T F } | + \sum _ { m = 1 } ^ { B ^ { \prime } } | z _ { \alpha } ^ { F T } ( m ) - z _ { \alpha } ^ { T F } ( m ) | + | z _ { \beta } ^ { F T } ( m ) - z _ { \beta } ^ { T F } ( m ) | } \\ { \displaystyle \qquad \leq \frac { 4 \pi L _ { f } } { N } \left( ( 2 B ^ { \prime } + \frac { 1 } { 2 } ) | | \partial x | | _ { 1 } + \sum _ { m = 1 } ^ { B ^ { \prime } } 2 m | | x | | _ { 1 } \right) } \\ { \displaystyle \qquad = \frac { 4 \pi L _ { f } } { N } \left( ( 2 B ^ { \prime } + \frac { 1 } { 2 } ) | | \partial x | | _ { 1 } + B ^ { \prime } ( B ^ { \prime } + 1 ) | | x | | _ { 1 } \right) } \end{array}
+$$
+
+Since $| | \partial \boldsymbol { x } | | _ { 1 } = \mathcal { O } ( B | | \boldsymbol { x } | | _ { 1 } )$ , we get $\begin{array} { r } { | | z ^ { F T } - z ^ { T F } | | _ { 1 } = \mathcal { O } ( \frac { B B ^ { \prime } + B ^ { \prime 2 } } { N } | | x | | _ { 1 } ) } \end{array}$ , which obviously vanishes as $N \to \infty$ .
+
+# F EXPERIMENTAL DETAILS
+
+In the following subsections, we provide with more details regarding experiments on MNIST, Atomization Energy Prediction and Cosmological Model Classification.
+
+# F.1 MNIST
+
+For the MNIST experiments, we disambiguate two variants, both used with interpolation and without. The first variant uses only the 1-ring of 7 nearest neighbors and representations $\rho _ { 0 } \oplus \rho _ { 1 }$ . This version uses three radial functions: one that covers the self-interaction and one that covers the other neighbors.
+
+The second variant uses the 2-ring of 19 nearest neighbors and representations $\rho _ { 0 } \oplus \rho _ { 1 } \oplus \rho _ { 2 }$ . This version uses three radial functions: one for the self-interaction, one for the neighbors on the 1-ring and one for the neighbors on the 2-ring.
+
+For either variant, we build a network consisting of 8 convolutional layers, with stride after each 2 layers. A stride layer selects the vertices that are present in the IcoSphere with one fewer subdivision, and divides the number of vertices by roughly 4. The input is a scalar feature. After convolution, the irrep features with multiplicity after each layer: [16, 16, 32, 32, 64, 64, 64, 64]. The last convolution layer maps to a scalar feature of multiplicity 64. Then the signal is averaged over the vertices, creating a gauge invariant network. This is then processed by 2 layer of MLP mapping to multiplicity 50 and then to the 10 classification logits.
+
+Nonlinearities are ReLU for scalar features and the RegularNonlinearity for all other features. Batchnorm is used, as well as dropout with drop probability $10 \%$ .
+
+# F.2 ATOMIZATION ENERGY PREDICTION
+
+Our network architecture used in this experiment is depicted in Table 8. We use four blocks of gauge equivariant convolutions followed by batchnorm and regular nonlinearities. We also deploy pooling / downsampling layers in blocks (1-3) to reduce the resolution of the spherical maps progressively. Rest of the network consists of linear layers followed by batchnorm and ReLU. We sum-pool over the atoms before the loss function (see block-7) to become invariant against permutations of them.
+
+We train the model with batch size 32 and an initial learning rate of 1e−3 for 30 epochs using mean-squared-error (MSE) as loss function. The learning rate is reduced by 0.1 every tenth epoch.
+
+Table 8: Network architecture used in Atomization Energy Prediction experiment.   
+
+<table><tr><td>block</td><td>Operators</td><td>Multiplicity (in/out) |Order (pinl pout)</td><td></td></tr><tr><td>1</td><td>[Convolution, Downsample,BatchNorm, Regular Nonlinearity]</td><td>5/16</td><td>0/1</td></tr><tr><td>2</td><td>[Convolution, Downsample,BatchNorm,Regular Nonlinearity]</td><td>16/32</td><td>1/2</td></tr><tr><td>3</td><td>[Convolution, Downsample,BatchNorm,Regular Nonlinearity]|</td><td>32/64</td><td>2/1</td></tr><tr><td>4</td><td>[Convolution,BatchNorm,ReLU]</td><td>64/64</td><td>1/0</td></tr><tr><td>5</td><td>[Linear, BatchNormld,ReLU]</td><td>64/256</td><td>0/0</td></tr><tr><td>6</td><td>[Linear,BatchNormld,ReLU]</td><td>256/64</td><td>0/0</td></tr><tr><td>7</td><td>AtomPool</td><td>64/64</td><td>0/0</td></tr><tr><td>8</td><td>[Linear,BatchNorm1d,ReLU]</td><td>64/512</td><td>0/0</td></tr><tr><td>9</td><td>[Linear, BatchNorm1d,ReLU]</td><td>512/1</td><td>0/0</td></tr></table>
+
+# F.3 COSMOLOGICAL MODEL CLASSIFICATION
+
+For this experiment, we use HEALpix sampling on split level $o = 4$ following Perraudin et al. (2018) which covers $0 . 5 \%$ of the spherical manifold and has signal dimensionality of $6 5 \mathrm { k }$ .
+
+For the experiments, we use a network architecture identical to the one described in (Perraudin et al., 2018) by replacing their graph convolutions with our gauge equivariant convolutions. We elaborate the architecture in Table 9.
+
+For each noise factor, we train an instance of this model with batch size 16 and an initial learning rate of 1e−4 for 120 epochs. Finally, we use Binary Cross Entropy as the loss function.
+
+Table 9: Network architecture used in Cosmological Model Classification experiment.   
+
+<table><tr><td rowspan=1 colspan=3>block |                        Operators                        |Multiplicity (in/out)|Order (ρin/pout)</td><td rowspan=1 colspan=1>Order(pinlpout)</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=2>[Convolution,Downsample,BatchNorm,Regular Nonlinearity]        1/10</td><td rowspan=1 colspan=1>0/1</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>[Convolution,Downsample,BatchNorm,Regular Nonlinearity]</td><td rowspan=1 colspan=1>10/20</td><td rowspan=1 colspan=1>1/1</td></tr><tr><td rowspan=1 colspan=2>3   [Convolution,Downsample,BatchNorm,Regular Nonlinearity]</td><td rowspan=1 colspan=1>20/40</td><td rowspan=1 colspan=1>1/1</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>[Convolution,Downsample,BatchNorm,Regular Nonlinearity]</td><td rowspan=1 colspan=1>40/40</td><td rowspan=1 colspan=1>1/1</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>[Convolution, Downsample,BatchNorm,Regular Nonlinearity]</td><td rowspan=1 colspan=1>40/40</td><td rowspan=1 colspan=1>1/1</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>[Convolution,Downsample,BatchNorm]</td><td rowspan=1 colspan=1>40/2</td><td rowspan=1 colspan=1>1/0</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=1>2/2</td><td rowspan=1 colspan=1>0/0</td></tr></table>

parse/train/SJSVuReCZ/SJSVuReCZ.md

@@ -0,0 +1,322 @@
+# SHADE: SHANNON DECAY INFORMATION-BASED REGULARIZATION FOR DEEP LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Regularization is a big issue for training deep neural networks. In this paper, we propose a new information-theory-based regularization scheme named SHADE for SHAnnon DEcay. The originality of the approach is to define a prior based on conditional entropy, which explicitly decouples the learning of invariant representations in the regularizer and the learning of correlations between inputs and labels in the data fitting term. We explain why this quantity makes our model able to achieve invariance with respect to input variations. We empirically validate the efficiency of our approach to improve classification performances compared to standard regularization schemes on several standard architectures.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have shown impressive state-of-the-art results in the last years on numerous tasks and especially for image classification (Krizhevsky et al., 2012; He et al., 2016). One key element is the use of very deep models with a huge number of parameters. Accordingly, DNNs need to be trained on a lot of data (e.g. ImageNet). Regularization methods such as weight decay (Krogh & Hertz, 1992), dropout (Srivastava et al., 2014) or batch normalization (Ioffe & Szegedy, 2016) are common practice to mitigate the ratio between the numbers of training samples and model parameters. Despite constant progress of DNNs performance, their generalization ability is still largely misunderstood and theoretical tools such as PAC-based analysis seem limited to explain it. Meanwhile, the question of DNN regularization remains open as demonstrated by Zhang et al. (2017).
+
+Information Bottleneck (IB) is an interesting framework to address regularization (Tishby et al., 1999). It suggests that it is possible to compare the generalization ability of different models by studying the compression rate of their representations: a model that is able to remove more information from the input while providing enough information about the label is more likely to generalize well. Considering an input variable $X$ , label $C$ and its deep representation $Y = h { \dot { ( } } X )$ , IB regularizes the training by minimizing the mutual information $I ( X , Y )$ at constant mutual information $I ( C , Y )$ . Along with IB also come some theoretical investigations, with the definition of generalization bounds in Shamir et al. (2010).
+
+A challenge for applying IB principles to DNNs is the definition of information-based regularizers that are differentiable and easily computable in order to be efficiently trained using back-propagation (LeCun et al., 1998). There are recent attempts in this direction. For example, Alemi et al. (2017) proposes a DNN that predicts the parameters of the distribution of the random representation variables conditionally to the input and use it to compute IB measures with variational bounds. Achille $\&$ Soatto (2016) model the information about the data in the learned weights and propose to minimize it.
+
+In this paper, we propose a new regularization loss minimizing $H ( Y \mid C )$ , the entropy of the representation variable conditionally to the label variable, instead of the mutual information ${ \dot { I } } ( X , Y )$ For a deterministic model, meaning that the entropy $H ( Y \mid X )$ is null, we have $I ( X , Y ) =$ $I ( C , Y ) + H ( Y \mid C ) ^ { 1 }$ . By minimizing directly $H ( Y \mid C )$ we explicitly decouple the data fitting term $I ( C , Y )$ , which attempts at finding correlations between inputs and labels, and a term which represents the compression rate of the representation $H ( Y \mid C )$ .
+
+Our contributions are three-fold. First, we derive in Section 2 a new regularization scheme, called SHADE for SHAnnon DEcay, to tackle the difficulty of getting an accurate, differentiable and scalable estimate of $H ( Y \mid C )$ . It is based on a latent code $Z$ representing the activation state of a neuron $Y$ , allowing us to express a complete tractable loss with few additional computation. Second, we discuss the interest of our regularization framework based on conditional entropy in Section 3. In particular, we argue that this measure $H ( Y \mid C )$ is well designed to compare representations in terms of invariance while still taking the target task into account. Finally, we extensively experiment our SHADE regularizer on different deep learning models and several challenging datasets (CIFAR-10, ImageNet, MNIST-M) in Section 4.
+
+# 2 SHADE: A NEW REGULARIZATION METHOD BASED ON $H ( Y \mid C )$
+
+Notations and definitions. $X$ is the input from input space $\mathcal { X }$ with high dimensionality and $C$ is the class label from finite class space $\mathcal { C } = \{ 1 , 2 , . . , | \mathcal { C } | \}$ . A hypothesis space is designed with a family of parametric (continuous) functions $\mathcal { H } = \{ h ( w , . ) : \mathcal { X } \to \mathcal { Y }$ ; $w \in \mathcal { W } = \mathbb { R } ^ { m } \bar  \}$ . A model $h \in \mathcal H$ outputs a representation of the input from which a class is predicted. In many tasks like image classification, the representation $Y = h ( X )$ of an input $X$ usually defines a distribution, noted $q _ { Y \mid X }$ , on the class space (e.g. obtained by applying a softmax function). The training in supervised learning consists in finding the parameters $w$ of $h$ minimizing the expectancy of a loss function $\mathcal { L } _ { \mathrm { c l s } } ( Y , \bar { C } )$ that quantifies the difference between the prediction and the label. It is usually the cross-entropy between the obtained distribution $q _ { Y \mid X }$ and the one-hot distribution with unit probability for the class $C$ noted $p _ { C }$ : $\begin{array} { r } { \ell _ { \mathrm { c l s } } ( Y , C ) = - \sum _ { c \in \mathcal { C } } p _ { C } ( c ) \log \big ( q _ { Y | X } ( c ) \big ) } \end{array}$ . A regularization term $\Omega ( \cdot )$ with a coefficient $\beta$ is often added to the classification loss, aiming at influencing the learning toward models with lower complexity2. In image classification, the most commonly used regularization criterion is the weight decay: $\Omega ( w ) = | | w | | _ { 2 } ^ { 2 }$ . In the IB framework, the regularization term would be $\Omega ( w ) = I \big ( h ( w , X ) , X \big )$ . The final loss for supervised learning is:
+
+$$
+\begin{array} { r } { \mathcal { L } = \mathbb { E } _ { ( Y , C ) } \big ( \ell _ { \mathrm { c l s } } ( Y , C ) + \beta \Omega ( w ) \big ) . } \end{array}
+$$
+
+In this section, we will further describe SHADE, a new regularization term based on the conditional entropy $H ( Y \mid C )$ designed to drive the optimization toward more invariant representation.
+
+# 2.1 ENTROPY-BASED REGULARIZATION FOR DEEP NEURAL NETWORKS
+
+Layer-wise regularization. A DNN is composed of a number $L$ of layers that transform sequentially the input. Each one can be seen as an intermediate representation variable, noted $Y _ { \ell }$ for layer $\ell$ , that is determined by the output of the previous layer and a set of parameters $\mathbf { w } _ { \ell }$ . Each layer filters out a certain part of the information from the initial input. Thus, from the data processing inequality in Cover & Thomas (1991) can be derived the following inequalities for any $\ell$ :
+
+$$
+H ( Y _ { \ell } \mid C ) \leq H ( Y _ { \ell - 1 } \mid C ) \leq \ldots \leq H ( Y _ { 1 } \mid C ) \leq H ( X \mid C ) .
+$$
+
+Similarly to the recommendation of Tishby & Zaslavsky (2015), we apply regularization to all the layers, using a layer-wise criterion $H ( Y _ { \ell } \mid C )$ , and producing a global criterion:
+
+$$
+\Omega _ { \mathrm { l a y e r s } } = \sum _ { \ell = 1 } ^ { L } H ( Y _ { \ell } \mid C ) .
+$$
+
+Unit-wise regularization. Examining one layer $\ell$ , its representation variable is a random vector of coordinates $Y _ { \ell , i }$ and of dimension $D _ { \ell }$ : $Y _ { \ell } \doteq ( Y _ { \ell , 1 } , . . . , { \bar { Y } } _ { \ell , D _ { \ell } } )$ . The upper bound3 $H ( Y _ { \ell } \mid C ) \le$ $\textstyle \sum _ { i = 1 } ^ { D _ { \ell } } H ( Y _ { \ell , i } \mid C )$ \` enables to define a unit-wise criterion that SHADE seeks to minimize. For each
+
+unit $i$ of every layer $\ell$ we design a loss $\omega _ { \mathrm { u n i t } } ( Y _ { \ell , i } \mid C ) = H ( Y _ { \ell , i } \mid C )$ that will be part of the global regularization loss:
+
+$$
+\Omega _ { \mathrm { l a y e r s } } \leq \Omega _ { \mathrm { u n i t s } } = \sum _ { l = 1 } ^ { L } \sum _ { i = 1 } ^ { D _ { \ell } } \underbrace { H ( Y _ { \ell , i } \mid C ) } _ { \omega _ { \mathrm { u n i t } } ( Y _ { \ell , i } \mid C ) } .
+$$
+
+Later in the paper, we use the notation $Y$ instead of $Y _ { \ell , i }$ for simplicity since the coordinates are all considered independently to define $\omega _ { \mathrm { u n i t } } ( Y _ { \ell , i } \mid C )$ .
+
+# 2.2 ESTIMATING ENTROPY
+
+In this section, we describe how to define a loss based on the measure $H ( Y \mid C )$ with $Y$ being one coordinate variable of one layer. Defining this loss is not obvious as the gradient of $H ( Y \mid C )$ with respect to the layer’s parameters may be computationally intractable. $Y$ has an unknown distribution and without modeling it properly it is not possible to compute $H ( Y \mid C )$ precisely for the following reasons.
+
+Since $\begin{array} { r } { H ( Y \mid C ) = \sum _ { c \in { \mathcal { C } } } p ( c ) H ( Y \mid c ) } \end{array}$ it is necessary to compute $| { \mathcal { C } } |$ different entropies $H ( Y \mid c )$ This means that, given a batch, the number of samples used to estimate one of these entropies is divided by $| { \mathcal { C } } |$ on average which becomes particularly problematic when dealing with a large number of classes such as the 1,000 classes of ImageNet. Furthermore, entropy estimators are extremely inaccurate considering the number of samples in a batch. For example, LME estimators of entropy in Paninski (2003) converge in ${ \mathcal { O } } { ( ( \log K ) ^ { 2 } { \bar { / } } K ) }$ for $K$ samples. Finally, most estimators such as LME require discretizing the space in order to approximate the distribution via a histogram. This raises issues on the bins definition considering that the variable distribution is unknown and varies during the training in addition to the fact that having a histogram for each neuron is computationally and memory consuming.
+
+To tackle these drawbacks we investigate the two following tricks: the introduction of a latent variable that enables to use more examples to estimate the entropy; and a bound on the entropy of the variable by an increasing function of its variance to avoid the issue of entropy estimation with a histogram and make the computation tractable and scalable.
+
+Latent code. First, inspecting a neuron $Y$ (before ReLU), the ReLU activation makes it act as a detector, returning a signal when a certain pattern is present on the input. If the pattern is absent the signal is zero, otherwise, it quantifies the resemblance with it. We therefore propose to associate a binomial variable $Z$ with each unit variable $Y$ (before ReLU). This variable $Z$ indicates if a particular pattern is present on the input ( $Z = 1$ when $Y \gg 0$ ) or not $Z = 0$ when $Y \ll 0$ ). It acts like a latent code in variational models (e.g. Kingma & Welling, 2014) or in generative models (e.g. Chen et al., 2016). In our implementation, we chose a binomial distribution $p ( Z = 1 \mid Y ) = \operatorname { s i g m o i d } ( Y )$ that matches this intuition, as detailed in Sec. 2.3.
+
+Furtherfore, it is very likely that most intermediate features of a DNN can take similar values for inputs of different classes – this is especially true for low-level features. The semantic information provided by a feature is thus more about a particular pattern than about the class itself. Only the association of features allows determining the class. So $Z$ represents a semantically meaningful factor about the class $C$ and from which the input $X$ is generated. The feature value $Y$ is then a quantification of the possibility for this semantic attribute $Z$ to be present in the input or not.
+
+Then, we assume the Markov chain $C  Z  X  Y$ . Indeed, during the training, the distribution of $Y$ varies in order to get as close as possible to a sufficient statistic of $X$ for $C$ (see definition in Cover & Thomas, 1991). Therefore, we expect $Z$ to be such that $Y$ draws near a sufficient statistic of $Z$ for $C$ as well. By assuming the sufficient statistic relation $I ( Y , C ) = I ( Y , Z )$ we get the equivalent equality $H ( Y \mid C ) = H ( Y \mid Z )$ , and finally obtain:
+
+$$
+\omega _ { \mathrm { u n i t } } ( Y \mid C ) = H ( Y \mid C ) = H ( Y \mid Z ) = \sum _ { z \in \{ 0 , 1 \} } p ( z ) H ( Y \mid Z = z ) .
+$$
+
+This modeling of $Z$ as a binomial variable (one for each unit) has the advantage of enabling good estimators of conditional entropy since we only divide the batch into two sets for the estimation $z = 0$ and 1) regardless of the number of classes.
+
+Algorithm 1 Moving average updates: for $z \in \{ 0 , 1 \} , p ^ { z }$ estimates $p ( Z = z )$ and $\mu ^ { z }$ estimates $\mathbb { E } ( { \bar { Y } } \mid Z = z )$
+
+<table><tr><td>2:</td><td>1: Initialize: μ°= -1,μ¹ =1,p°=p¹ = 0.5,入= 0.8 for each mini-batch {y(k),k ∈1..K} do</td></tr><tr><td>3:</td><td>for z∈{0,1}do</td></tr><tr><td>4:</td><td>p²←xp²+（1-）∑k=1p(z丨y()） &gt;Kp(z丨y(k）)</td></tr><tr><td>5:</td><td>μ²←λμ²+(1-)∑=1 y(k） p</td></tr><tr><td>6:</td><td>end for</td></tr><tr><td>7: end for</td><td></td></tr><tr><td></td><td></td></tr></table>
+
+Variance bound. The previous trick allows computing fewer entropy estimates to obtain the global conditional entropy, thus increasing the sample size used for each entropy estimation. Unfortunately, it does not solve the bin definition issue. To address this, we propose to use the following bound on $H ( Y \mid Z )$ , that does not require the definition of bins:
+
+$$
+H ( Y \mid Z ) \leq { \frac { 1 } { 2 } } \ln { \big ( } 2 \pi e \mathbb { V } \ a \mathbf { r } ( Y \mid Z ) { \big ) } .
+$$
+
+This bound holds for any continuous distributions $Y$ and there is equality if the distribution is Gaussian. For many other distributions such as the exponential one, the entropy is also equal to an increasing function of the variance. In addition, one main advantage is that variance estimators are much more robust than entropy estimators, converging in $\mathcal { O } ( { 1 } / { \bar { \kappa } } )$ for $K$ samples instead of $\mathcal { O } ( \log ( K ) ^ { 2 } / K )$ .
+
+Finally, the ln function being one-to-one and increasing, we only keep the simpler term $\mathbb { V } \mathrm { a r } ( Y \mid Z )$ to design our final loss:
+
+$$
+\Omega _ { \mathrm { S H A D E } } = \sum _ { \ell = 1 } ^ { L } \sum _ { i = 1 } ^ { D _ { \ell } } \sum _ { z \in \{ 0 , 1 \} } p ( Z _ { \ell , i } = z \mid Y ) \mathrm { V a r } ( Y \mid Z _ { \ell , i } = z ) .
+$$
+
+In next section, we detail the definition of the differential loss using $\mathbb { V } \mathrm { a r } ( Y \mid Z )$ as a criterion computed on a mini-batch.
+
+# 2.3 INSTANTIATING SHADE
+
+For one unit of one layer, the previous criterion writes:
+
+$$
+\begin{array} { l } { \displaystyle \operatorname { V a r } ( Y \mid Z ) = \int _ { \mathcal { V } } p ( y ) \int _ { { \mathcal Z } } p ( z \mid y ) \big ( y - \mathbb { E } ( Y \mid z ) \big ) ^ { 2 } \mathrm { d } z \mathrm { d } y } \\ { \displaystyle \approx \frac { 1 } { K } \sum _ { k = 1 } ^ { K } \left[ \int _ { { \mathcal Z } } p ( z \mid y ^ { ( k ) } ) \big ( y ^ { ( k ) } - \mathbb { E } ( Y \mid z ) \big ) ^ { 2 } \mathrm { d } z \right] . } \end{array}
+$$
+
+The quantity $\mathbb { V } \mathrm { a r } ( Y \mid Z )$ can be estimated with Monte-Carlo sampling on a mini-batch of input-target pairs $\left\{ ( x ^ { ( k ) } , c ^ { ( k ) } ) \right\} _ { 1 \leq k \leq K }$ of intermediate representations $\left\{ y ^ { ( k ) } \right\} _ { 1 \leq k \leq K }$ as in Eq. (9).
+
+$p ( Z \mid y )$ interpreted as the probability of presence of attribute $Z$ on the input, it should clearly be modeled such that $p ( Z = \bar { 1 ~ } | ~ y )$ increases with $y$ . The more similarities between the input and the pattern represented by $y$ , the higher the probability of presence for $Z$ . We suggest using:
+
+$$
+p ( Z = 1 \mid y ) = \sigma ( y ) \qquad p ( Z = 0 \mid y ) = 1 - \sigma ( y ) \qquad { \mathrm { w i t h ~ s i g m o i d ~ f u n c t i o n ~ } } \sigma ( y ) = { \frac { 1 } { 1 + e ^ { - y } } } .
+$$
+
+For the expected values $\mu ^ { z } = \operatorname { \mathbb { E } } ( Y \mid z )$ we use a classic moving average that is updated after each batch as described in Algorithm 1. Note that the expected values are not changed by the optimization since they have no influence on the entropy $H ( Y \mid Z )$ .
+
+The concrete behavior of SHADE can be interpreted by analyzing its gradient as described in Appendix C.
+
+For this proposed instantiation, our SHADE regularization penalty takes the form:
+
+$$
+\Omega _ { \mathrm { S H A D E } } = \sum _ { \ell = 1 } ^ { L } \sum _ { i = 1 } ^ { D _ { \ell } } \sum _ { k = 1 } ^ { K } \sum _ { z \in \left\{ 0 , 1 \right\} } p \left( Z _ { \ell , i } = z \left| y _ { \ell , i } ^ { ( k ) } \right. \right) \left( y _ { \ell , i } ^ { ( k ) } - \mu _ { \ell , i } ^ { z } \right) ^ { 2 } .
+$$
+
+We have presented a regularizer that is applied layer-wise and that can be integrated into the usual optimization process of a DNN. The additional computation and memory usage induced by SHADE is almost negligible (computation and storage of two moving averages per neuron). Namely, SHADE adds half as many parameters as batch normalization does.
+
+# 3 CONDITIONAL ENTROPY AS INVARIANCE MEASURE FOR CLASSIFICATION
+
+Inspired by the IB framework, we have derived a criterion that SHADE loss aims at minimizing. In this section, we further explore the relevance of our conditional entropy term for regularization. We first establish a connection between the entropy $H ( Y )$ of a representation and its invariance. Then we explain why $H ( Y \mid C )$ seems to be a better fitting criterion for a classification task.
+
+$H ( Y )$ to measure invariance. For an input $X$ and a deterministic mapping $f ( X ) = Y$ , we have $H ( Y \mid X ) = 0$ and therefore:
+
+$$
+H ( Y ) = I ( X , Y ) + H ( Y \mid X ) = I ( X , Y ) = H ( X ) - H ( X \mid Y ) .
+$$
+
+$H ( X )$ being fixed, $H ( Y )$ is inversely related to $H ( X \mid Y )$ . Besides, we assume that $H ( X \mid Y )$ is a good measure to quantify how invariant a representation is. Indeed, if a representation is invariant to many transformations, many inputs have the same representation. Consequently, given a representation sample, it is difficult to guess from which input it has been computed. These properties are perfectly captured by $H ( X \mid Y )$ , representing the uncertainty in $X$ knowing $Y$ . The bigger the uncertainty, the harder it is to predict $X$ precisely. Concretely, when trying to guess $X$ knowing $Y$ , we can lower bound the error made in the best case, with an increasing function of the conditional entropy as developed in Appendix A. Therefore, it seems that $H ( Y )$ is a good measure of the invariance of the model.
+
+In the particular case of deep learning, He et al. (2016) explain that the stacking of multiple layers is responsible for improving the generalization of DNN. This fact can be explained by the data processing inequality (Cover & Thomas, 1991). In the case of finite input space, each layer is responsible for filtering a certain amount of information. As clearly illustrated in Tishby & Zaslavsky (2015), for each stage, the representation has a lower entropy than the representation of the preceding layer. Increasing the depth increases the capacity of the network to reduce the overall entropy of the DNN representation thus increasing their invariance.
+
+$H ( Y )$ as a regularizer. From this intuition, one can use a variance bound similar to Eq. (6): $H ( \dot { Y } ) \stackrel { \cdot } { \leq } 1 / 2 \ln ( \bar { 2 } \pi e \mathbb { V } \mathrm { a r } ( Y ) )$ to derive a loss in order to minimize the representations’ entropy $H ( Y )$ . For instance, we can show that the weight decay reduces this variance under some approximations. In fact when $Y = \mathbf { w } ^ { \top } X + \mathbf { b }$ , by estimating $\Lambda = \mathbb { C } \mathrm { o v } ( X )$ , the variance takes the immediate form $\mathbb { V } \mathrm { a r } ( Y ) = \mathbf { w } ^ { \top } \Lambda \mathbf { w }$ . If $\Lambda = I d$ , meaning that the input coordinates are considered independent with unit variance, then $\mathbb { V } \mathrm { a r } ( Y ) = | | \mathbf { w } | | _ { 2 } ^ { 2 }$ . It corresponds to the weight decay regularization or $L _ { 2 }$ penalty. Even if within a DNN layer, the batch normalization tends to enforce this unit variance hypothesis and the depth of DNN tends to ensure the independence hypothesis the weight decay remains poor at improving generalization as illustrated in Zhang et al. (2017). Considering fewer assumptions, it is possible to reduce the variance of an output coordinate by penalizing its empirical variance on a batch during the training. We introduce an alternative loss on the variance called VarEntropy, constructed the same way SHADE has been derived, but avoiding the introduction of a latent variable $Z$ :
+
+$$
+\Omega _ { \mathrm { V a r E n t r o p y } } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } \left( y ^ { ( k ) } - \mathbb { E } ( Y ) \right) ^ { 2 } .
+$$
+
+Even if experimentally, VarEntropy regularization seems to behave better than simple weight decay, it is not as efficient as SHADE and we try to explain why below.
+
+Importance of conditional entropy. We have seen that lowering the entropy of the representation enables to make it more invariant. However, another fact reported by He et al. (2016) is that stacking layers increases the difficulty to train the network. Indeed, when reducing too much the entropy, there is a risk that the information about the label is filtered as well. The representation is so invariant that it is no longer possible to distinguish between the classes. In He et al. (2016), they solve this issue by forcing the transmission of additional information through skip-connections while IB prescribes to maximize the compression rate at constant information about the label. All this highlights the fact that having invariant representations is interesting if it is intra-class invariant. Since we do not want two inputs from different classes to have the same representation, we prefer to focus on a criterion quantifying the intra-class compression rate in order to maximize intra-class invariance: $H ( Y \mid C )$ .
+
+As mentioned in the introduction, $H ( Y \mid C )$ thus differs from standard IB frameworks based on $I ( X , Y )$ (Achille & Soatto, 2016; Alemi et al., 2017). Contrarily to the mutual information $I ( X , Y ) = H ( Y \mid C ) + I ( C , Y )$ , our regularizer applied to $H ( Y \mid { \dot { C } } )$ ignores $I ( C , Y )$ . When minimizing $I ( X , Y )$ , there is no control on how both terms $H ( Y \mid { \dot { C } } )$ and $I ( C , Y )$ are modified. Our regularizer is therefore beneficial in the sense that minimizing $H ( Y \mid C )$ does not conflict with the mutual information $I ( C , Y )$ between the representation and the label, information that is therefore for classification and should not be penalized.
+
+# 4 EXPERIMENTS
+
+4.1 IMAGE CLASSIFICATION WITH VARIOUS ARCHITECTURES ON CIFAR-10
+
+Table 1: Classification accuracy $( \% )$ on CIFAR-10 test set.   
+
+<table><tr><td></td><td>MLP</td><td>AlexNet</td><td>ResNet</td><td>Inception</td></tr><tr><td>No regul.</td><td>62.38</td><td>83.25</td><td>89.84</td><td>90.97</td></tr><tr><td>Weight decay</td><td>62.69</td><td>83.54</td><td>91.71</td><td>91.87</td></tr><tr><td>Dropout</td><td>65.37</td><td>85.95</td><td>89.94</td><td>91.11</td></tr><tr><td>VarEntropy</td><td>63.70</td><td>83.61</td><td>91.72</td><td>91.83</td></tr><tr><td>SHADE</td><td>66.05</td><td>85.45</td><td>92.15</td><td>93.28</td></tr><tr><td>SHADE+D</td><td>66.12</td><td>86.71</td><td>92.03</td><td>92.51</td></tr></table>
+
+We perform image classification on the CIFAR-10 dataset, which contains $5 0 \mathrm { k }$ training images and $1 0 \mathrm { k }$ test images of $3 2 \times 3 2$ RGB pixels, fairly distributed within 10 classes (see Krizhevsky, 2009, for details). Following the architectures used in Zhang et al. (2017), we use a small Inception model, a three-layer MLP, and an AlexNet-like model with 3 convolutional and 2 fully connected layers. We also use a ResNet architecture from Zagoruyko & Komodakis (2016). Those architectures represent a large family of DNN and some have been well studied in Zhang et al. (2017) within the generalization scope. For training, we use randomly cropped images of size $2 8 \times 2 8$ with random horizontal flips. For testing, we simply center-crop $2 8 \times 2 8$ images. We use momentum SGD for optimization (same protocol as Zhang et al., 2017).
+
+We compare SHADE with three regularization methods, namely weight decay, dropout and VarEntropy presented in Eq. (12). For all architectures, the regularization parameters have been crossvalidated to find the best ones for each method and the obtained accuracies on the test set are reported in Table 1.
+
+We obtain the same trends as Zhang et al. (2017), which get a small improvement of $0 . 3 1 \%$ with weight decay on AlexNet. The improvement with weight decay is slightly more important with ResNet and Inception $0 . 8 7 \%$ and $0 . 9 0 \%$ ) probably thanks to the use of batch normalization. In our experiments dropout improves generalization performances only for AlexNet and MLP. It is known that the use of batch normalization lowers the benefit of dropout, which is in fact not used in He et al. (2016).
+
+We first notice that for all kind of architectures the use of SHADE significantly improves the generalization performance. It demonstrates the ability of SHADE to regularize the training of deep architectures. Moreover, SHADE systematically outperforms other regularizations of the same type (c) Examples of MNIST-M images misclassified by the baseline and correctly classified using SHADE, both trained with 250 samples.
+
+![](images/49ccdbc583baf44e56977412cf65af2ec0ff5a197c1316558d668390f3c30309.jpg)
+
+Figure 1: Results when training with a limited number of samples in the training set for MNIST-M and CIFAR-10 with and without SHADE.
+
+such as weight decay or VarEntropy, illustrating the advantage of minimizing the conditional entropy instead of the entropy directly.
+
+Finally, SHADE shows better performances than dropout on all architecture except on AlexNet, for which they seem to be complementary, probably because of the very large number of parameters in the fully-connected layers, with best performances obtained with SHADE coupled with dropout (named SHADE $+ \mathbf { D }$ ). This association is also beneficial for MLP. On Inception and ResNet, even if dropout and SHADE independently improve generalization performances, their association is not as good as SHADE alone, probably because it enforces too much regularization.
+
+# 4.2 LARGE SCALE CLASSIFICATION ON IMAGENET
+
+In order to experiment SHADE regularization on very large scale dataset, we train on ImageNet (Russakovsky et al., 2015) a WELDON network from Durand et al. (2016) adapted from ResNet-101. This architecture changes the forward and pooling strategy by using the network in a fully-convolutional way and adding a max+min pooling, thus improving the performance of the baseline network. We used the pre-trained weights of ResNet-101 (from the torchvision package of PyTorch) giving performances on the test set of $7 7 . 5 6 \%$ for top-1 accuracy and $9 3 . 8 9 \%$ for top-5 accuracy. Provided with the pre-trained weights, the WELDON architecture obtains $78 . 5 1 \%$ for top-1 accuracy and $9 4 . 6 5 \%$ for top-5 accuracy. After fine tuning the network using SHADE for regularization we finally obtained $8 0 . 1 4 \%$ for top-1 accuracy and $9 5 . 3 5 \%$ for top-5 accuracy for a concrete improvement. This demonstrates the ability to apply SHADE on very large scale image classification successfully.
+
+# 4.3 TRAINING WITH A LIMITED NUMBER OF SAMPLES
+
+When datasets are small, DNNs tend to overfit quickly and regularization becomes essential. Because it tends to filter out information and make the network more invariant, SHADE seems to be well fitted for this task. To investigate this, we propose to train DNNs with and without SHADE on CIFAR-10 and MNIST-M with different numbers of samples in the training set.
+
+First, we tested this approach on the digits dataset MNIST-M (Ganin & Lempitsky, 2015). This dataset consists of the MNIST digits where the background and digit have been replaced by colored and textured information (see Fig. 1c for examples). The interest of this dataset is that it contains lots of unnecessary information that should be filtered out, and is therefore well adapted to measure the effect of SHADE. A simple convolutional network has been trained with different numbers of samples of MNIST-M and the optimal regularization weight for SHADE have been determined on the validation set (see training details in Appendix D). The results can be seen on Figure 1a. We can see that especially for small numbers of training samples $( < 1 0 0 0 )$ , SHADE provides an important gain of 10 to $15 \%$ points over the baseline. This shows that SHADE helped the model in finding invariant and discriminative patterns using less data samples.
+
+![](images/568825dcc9f49bca296cae21f75540c5e8b3f250d3cc74c8ef1b04787d5ed891.jpg)  
+Figure 2: Evolution of the accuracy of a pre-trained Inception model on CIFAR-10 when only applying regularization.
+
+Additionally, Figure 1c shows samples that are misclassified by the baseline model but correctly classified when using SHADE. These images contain a large amount of intra-class variance (color, texture, etc.) that is not useful for the classification tasks, explaining why adding SHADE, that encourages the model to discard information, allows important performance gains on this dataset and especially when only few training samples are given.
+
+Finally, to confirm this behavior, we also applied the same procedure in a more conventional setting by training an Inception model on CIFAR-10. Figure 1b shows the results in that case. We can see that once again SHADE helps the model gain in performance and that this behavior is more noticeable when the number of samples is limited, allowing a gain of $6 \%$ when using 4000 samples.
+
+# 4.4 CLASS-INFORMATION PRESERVATION BY CONDITIONAL ENTROPY
+
+The main difference between SHADE and VarEntropy is the introduction of the latent variable $Z$ , supposed to contain the information about the label $C$ . The motivation of this extension is that minimizing $H ( Y \mid C )$ instead of $H ( Y )$ enables to save the class information during the optimization of the regularization loss, as explained in Section 3. To illustrate this benefit, we compare the impact of the two regularization losses on the classification performances of a pre-trained model. To do so, we fine tune a pre-trained Inception model only with a regularization loss, either based on $\mathbb { V } \mathrm { a r } ( Y )$ or $\mathbb { V } \mathrm { a r } ( Y \mid Z )$ ; without any label data or classification loss. The network performance obviously declines for both regularizers as we can see on Figure 2. However, this decline is slower with SHADE than VarEntropy. This confirms the intuition that $Z$ contains class-information and that SHADE produces less class-information filtering. This is explained by the optimization of the metric $\operatorname { V a r } ( Y \mid { \overline { { Z } } } )$ that uses implicitly-learned information encoded in the network.
+
+# 5 CONCLUSION
+
+In this paper, we introduced a new regularization method for DNNs training, SHADE, which focuses on minimizing the entropy of the representation conditionally to the labels. This regularization aims at increasing the intra-class invariance of the model while keeping class information. SHADE is tractable, adding only a small computational overhead when included into an efficient SGD training. We show that our SHADE regularization method significantly outperforms standard approaches such as weight decay or dropout with various DNN architectures on CIFAR-10. We also validate the scalability of SHADE by applying it on ImageNet. The invariance potential brought out by SHADE is further illustrated by its ability to ignore irrelevant visual information (texture, color) on MNIST-M. Finally, we also highlight the increasing benefit of our regularizer when the number of training examples becomes small.
+
+REFERENCES   
+A. Achille and S. Soatto. Information dropout: learning optimal representations through noisy computation. ArXiv, 2016.   
+A. A. Alemi, I. Fischer, J. V Dillon, and K. Murphy. Deep variational information bottleneck. In ICLR, 2017.   
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In NIPS, Jun 2016.   
+T. Cover and J. Thomas. Elements of information theory. Wiley New York, 1991.   
+Thibaut Durand, Nicolas Thome, and Matthieu Cord. WELDON: Weakly Supervised Learning of Deep Convolutional Neural Networks. In CVPR, 2016.   
+Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In ICML, pp. 1180–1189, 2015.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. JMLR, 2016.   
+Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014.   
+A. Krizhevsky. Learning multiple layers of features from tiny images. PhD thesis, Computer Science Department University of Toronto, 2009.   
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.), NIPS, 2012.   
+Anders Krogh and John A. Hertz. A simple weight decay can improve generalization. In NIPS, 1992.   
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient based learning applied to document recognition. Proceedings of the IEEE, 1998.   
+Liam Paninski. Estimation of entropy and mutual information. Neural Computation, 2003.   
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual recognition challeng. ICJV, 2015.   
+O. Shamir, S. Sabato, and N. Tishby. Learning and generalization with the information bottleneck. Theoretical Computer Science, 2010.   
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014.   
+N. Tishby, F. C. Pereira, and W. Bialek. The information bottleneck method. Annual Allerton Conference on Communication, Control and Computing, 1999.   
+Naftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. In Information Theory Workshop (ITW). IEEE, 2015.   
+David A. van Dyk and Xiao-Li Meng. The art of data augmentation. Journal of Computational and Graphical Statistics, 2001.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In arXiv, 2016.   
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. ICLR, 2017.
+
+# A ENTROPY BOUNDING THE RECONSTRUCTION ERROR
+
+In section 3 we highlight a link between the entropy $H ( X \mid Y )$ and the difficulty to recover the input $X$ from its representation $Y$ . Here we exhibit a concrete relation between the reconstruction error, that quantifies the error made by a strategy that predicts $X$ from $Y$ , and the conditional entropy. This relation takes the form of an inequality, bounding the error measure in the best case (with the reconstruction strategy that minimizes the error) by an increasing function of the entropy. We note ${ \hat { x } } ( Y ) \in { \mathcal { X } }$ the reconstruction model that tries to guess $X$ from $Y$ .
+
+The discrete case In case the input space is discrete, we consider the zero-one reconstruction error for one representation point $Y$ $\ ' \colon \varepsilon ( { \bar { Y } } ) = E _ { X } [ \mathbb { 1 } ( { \hat { x } } ( Y ) \neq X ) ]$ . This is the probability of error when predicting ${ \hat { x } } ( Y )$ from $Y$ . The function that minimizes the expected error $\mathcal { E } = \mathbb { E } _ { Y } ( \varepsilon ( Y ) )$ is ${ \hat { x } } ( Y ) = \arg \operatorname* { m a x } _ { x \in { \mathcal { X } } } p ( x \mid Y )$ as shown in Proof 1. We derive the following inequality:
+
+$$
+{ \frac { H ( X \mid Y ) - 1 } { \log | { \mathcal { X } } | } } \leq { \mathcal { E } } \leq 1 - 2 ^ { - H ( X \mid Y ) } .
+$$
+
+The left side of the inequality uses Fano’s inequality in Cover & Thomas (1991), the right one is developed in proof 2. This first bound shows how the reconstruction error and the entropy are related. For very invariant representations, it is hard to recover the input from $Y$ and the entropy of $H ( X \mid Y )$ is high.
+
+Besides, there can be an underlying continuity in the input space and it could be unfair to penalize predictions close to the input as much as predictions far from it. We expose another case below that takes this proximity into account.
+
+The continuous case In the case of convex input space and input variable with continuous density, we consider the 2-norm distance as reconstruction error: $\varepsilon ( Y ) = \mathbb { E } _ { X \mid Y } \left[ | | X - \hat { X } ( Y ) | | _ { 2 } ^ { 2 } \right]$ . This error penalizes the average distance of the input and its reconstruction from $Y$ . The function that minimizes the expected error $\mathcal { E } = \mathbb { E } _ { Y } [ \varepsilon ( Y ) ]$ is the conditional expected value: ${ \hat { x } } ( y ) = \operatorname { \mathbb { E } } [ X \mid Y = y ]$ . Then ${ \mathcal { E } } = { \bar { \mathbb { V } } } \mathrm { a r } ( X \mid Y )$ . Helped by the well-known inequality $H ( X \mid Y ) \leq { \textstyle { \frac { 1 } { 2 } } } \ln ( 2 { \bar { \pi } } e \mathbb { V } \mathrm { a r } ( X \mid Y ) )$ we obtain:
+
+$$
+{ \frac { e ^ { 2 H ( X \mid Y ) } } { 2 \pi e } } \leq { \mathcal { E } } .
+$$
+
+Here again, notice that a high entropy $H ( X \mid Y )$ implies a high reconstruction error in the best case.
+
+# A.1 PROOF 1
+
+We have
+
+$$
+\begin{array} { r l } {  { \mathcal E = \int _ { \mathscr y } p ( \boldsymbol y ) \boldsymbol \varepsilon ( \boldsymbol y ) \mathrm d \boldsymbol y } } \\ & { = \int _ { \mathscr y } p ( \boldsymbol y ) p ( \boldsymbol X \neq \hat { \boldsymbol x } ( \boldsymbol y ) \mid \boldsymbol y ) \mathrm d \boldsymbol y } \\ & { = \int _ { \mathscr y } p ( \boldsymbol y ) ( 1 - p ( \hat { \boldsymbol x } ( \boldsymbol y ) \mid \boldsymbol y ) ) \mathrm d \boldsymbol y . } \end{array}
+$$
+
+Since
+
+$$
+p ( \hat { x } ( y ) \mid y ) \le p ( \operatorname * { a r g m a x } _ { x \in X } p ( x \mid y ) \mid y ) ,
+$$
+
+the reconstruction that minimizes the error is ${ \hat { x } } ( y ) = \arg \operatorname* { m a x } _ { x \in X } p ( x \mid y )$ . However, this is theoretical because in most cases $p ( x \mid Y )$ is unknown.
+
+A.2 PROOF 2
+
+We have:
+
+$$
+\begin{array} { r l } & { \log ( 1 - \mathcal { E } ) = \log \left( \displaystyle \int _ { y } p ( y ) ( 1 - \varepsilon ( y ) ) \mathrm { d } y \right) } \\ & { \qquad = \log \left( \displaystyle \int _ { y } p ( y ) p ( \hat { x } ( y ) \mid y ) \right) \mathrm { d } y } \\ & { \qquad \ge \displaystyle \int _ { y } p ( y ) \log \bigl ( p ( \hat { x } ( y ) \mid y ) \bigr ) \mathrm { d } y } \\ & { \qquad = \displaystyle \int _ { y } p ( y ) \int _ { x } p ( x \mid y ) \log \bigl ( p ( \hat { x } ( y ) \mid y ) \bigr ) \mathrm { d } x \mathrm { d } y } \\ & { \qquad \ge \displaystyle \int _ { y } p ( y ) \int _ { x } p ( x \mid y ) \log \bigl ( p ( x \mid y ) \bigr ) \mathrm { d } x \mathrm { d } y } \\ & { \qquad = - H ( X \mid Y ) . } \end{array}
+$$
+
+The Eq. (21) is obtained using Jensen inequality and Eq. (23) is obtained using the result of Proof 1. Thus,
+
+$$
+\mathcal { E } \leq 1 - 2 ^ { - H ( X | Y ) } .
+$$
+
+# B DEVELOPMENT OF SHADE LOSS
+
+Below is the detail of the development of Equation (8).
+
+$$
+\begin{array} { r l } {  { \operatorname { V a r } ( Y \mid Z ) = \int _ { \mathcal { Z } } p ( z ) \operatorname { V a r } ( Y \mid z ) \mathrm { d } z } } \\ & { = \int _ { \mathcal { Z } } p ( z ) \int _ { \mathcal { Y } } p ( y \mid z ) ( y - \operatorname { E } ( Y \mid z ) ) ^ { 2 } \mathrm { d } y \mathrm { d } z } \\ & { = \int _ { \mathcal { Y } } \int _ { \mathcal { Z } } p ( z ) p ( y \mid z ) ( y - \operatorname { E } ( Y \mid z ) ) ^ { 2 } \mathrm { d } y \mathrm { d } z } \\ & { = \int _ { \mathcal { Y } } \int _ { \mathcal { Z } } p ( y ) p ( z \mid y ) ( y - \operatorname { \mathbb { F } } ( Y \mid z ) ) ^ { 2 } \mathrm { d } y \mathrm { d } z } \\ & { = \int _ { \mathcal { Y } } p ( y ) \int _ { \mathcal { Z } } p ( z \mid y ) ( y - \operatorname { \mathbb { F } } ( Y \mid z ) ) ^ { 2 } \mathrm { d } y \mathrm { d } z } \\ & { = \int _ { \mathcal { Y } } p ( y ) \int _ { \mathcal { Z } } p ( z \mid y ) ( y - \operatorname { \mathbb { E } } ( Y \mid z ) ) ^ { 2 } \mathrm { d } y \mathrm { d } z . } \end{array}
+$$
+
+# C SHADE GRADIENTS
+
+Here is studied the influence of SHADE on a gradient descent step for a single neuron $Y$ of a single layer and for one training sample $X$ . The considered case of a linear layer, we have: $Y = \mathbf { w } ^ { \top } X + b$ .
+
+The gradient of $\Omega _ { \mathrm { S H A D E } }$ with respect to w is:
+
+$$
+\begin{array} { r l } & { \nabla _ { \mathbf { w } } \Omega _ { \mathrm { S H A D E } } = ( \delta _ { 1 } + \delta _ { 2 } ) \mathbf { x } } \\ & { \qquad \mathrm { w i t h } \ \delta _ { 1 } = \sigma ( y ) ( 1 - \sigma ( y ) ) \big ( ( y - \mu ^ { 1 } ) ^ { 2 } - ( y - \mu ^ { 0 } ) ^ { 2 } \big ) } \\ & { \qquad \mathrm { a n d } \ \delta _ { 2 } = 2 \sigma ( y ) ( y - \mu ^ { 1 } ) + 2 ( 1 - \sigma ( y ) ) ( y - \mu ^ { 0 } ) . } \end{array}
+$$
+
+We can interpret the direction of this gradient by analyzing the two terms $\delta _ { 1 }$ and $\delta _ { 2 }$ as follows:
+
+• $\delta _ { 1 }$ : If $( y - \mu ^ { 0 } ) ^ { 2 }$ is bigger than $( y - \mu ^ { 1 } ) ^ { 2 }$ that means that $y$ is closer to $\mu ^ { 1 }$ than it is to $\mu ^ { 0 }$ . Then $\delta _ { 1 }$ is positive and it contributes to increasing $y$ meaning that it increases the probability of $Z$ being from mode 1. In a way it increases the average margin between positive and negative detections. Note that if there is no ambiguity about the mode of $Z$ meaning that $\sigma ( \bar { y } )$ or $1 - \sigma ( y )$ is very small then this term has negligible effect.
+
+• $\delta _ { 2 }$ : This term moves $y$ toward the $\mu ^ { z }$ of the mode that presents the bigger probability. This has the effect of concentrating the outputs around their expectancy depending on their mode to get sparser activation.
+
+# D EXPERIMENTS DETAILS ON MNIST-M
+
+Dataset splits and creation. To create MNIST-M, we kept the provided splits of MNIST, so we have 55,000 training samples, 5,000 validation samples, and 10,000 test samples. Each digit of MNIST is processed to add color and texture by taking a crop in images from BST dataset. This procedure is explained in Ganin & Lempitsky (2015).
+
+Subsets of limited size. To create the training sets of limited size $N$ , we keep $N / 1 0$ (since there are 10 classes) randomly picked samples from each class. When increasing $N$ we keep the previously picked samples so the training samples for $N = 1 0 0$ are a subset of the ones for $N = 2 5 0$ . The samples chosen for a given value of $N$ are the same across all models trained using this number of samples.
+
+Image preprocessing. The only preprocessing applied to the input images is that their values are rescaled from [0, 1] to $[ - 1 , 1 ]$ .
+
+Optimization. For the training, we use mini-batch of size 50 and use Adam optimizer with the recommended parameters, i.e. λr = 0.001, β1 = 0.9, β2 = 0.999,  = 10−8.
+
+Hyperparameter tuning. For weight decay and SHADE, the optimal regularization weight of each model (for each value of $N$ ) has been chosen to maximize the accuracy on the validation sets. We tried the values $\{ 1 0 ^ { - i } , i = 1 . . 7 \}$ .
+
+Model architecture. The model have the following architecture:
+
+• 2D convolution $6 4 \times 5 \times 5$ kernel, padding 2, stride 1) $^ +$ ReLU   
+• MaxPooling $2 \times 2$   
+• 2D convolution $6 4 \times 3 \times 3$ kernel, padding 1, stride 1) $^ +$ ReLU   
+• MaxPooling $2 \times 2$   
+• 2D convolution $( 6 4 \times 3 \times 3$ kernel, padding 1, stride 1) $^ +$ ReLU   
+• MaxPooling $2 \times 2$   
+• Fully connected (1024 inputs, 10 outputs) $^ +$ SoftMax
+
+# E EXPERIMENTS DETAILS ON IMAGENET
+
+The fine tuning in the experiment section 4.2 has been done with momentum-SGD with a learning rate of $1 0 ^ { - 5 }$ and a momentum of 0.9 and a batch size of 16 images. It took 8 epochs to converge.

parse/train/SJSVuReCZ/SJSVuReCZ_content_list.json

@@ -0,0 +1,1494 @@
+[
+    {
+        "type": "text",
+        "text": "SHADE: SHANNON DECAY INFORMATION-BASED REGULARIZATION FOR DEEP LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            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,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Regularization is a big issue for training deep neural networks. In this paper, we propose a new information-theory-based regularization scheme named SHADE for SHAnnon DEcay. The originality of the approach is to define a prior based on conditional entropy, which explicitly decouples the learning of invariant representations in the regularizer and the learning of correlations between inputs and labels in the data fitting term. We explain why this quantity makes our model able to achieve invariance with respect to input variations. We empirically validate the efficiency of our approach to improve classification performances compared to standard regularization schemes on several standard architectures. ",
+        "bbox": [
+            233,
+            270,
+            766,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            430,
+            336,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have shown impressive state-of-the-art results in the last years on numerous tasks and especially for image classification (Krizhevsky et al., 2012; He et al., 2016). One key element is the use of very deep models with a huge number of parameters. Accordingly, DNNs need to be trained on a lot of data (e.g. ImageNet). Regularization methods such as weight decay (Krogh & Hertz, 1992), dropout (Srivastava et al., 2014) or batch normalization (Ioffe & Szegedy, 2016) are common practice to mitigate the ratio between the numbers of training samples and model parameters. Despite constant progress of DNNs performance, their generalization ability is still largely misunderstood and theoretical tools such as PAC-based analysis seem limited to explain it. Meanwhile, the question of DNN regularization remains open as demonstrated by Zhang et al. (2017). ",
+        "bbox": [
+            174,
+            465,
+            825,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Information Bottleneck (IB) is an interesting framework to address regularization (Tishby et al., 1999). It suggests that it is possible to compare the generalization ability of different models by studying the compression rate of their representations: a model that is able to remove more information from the input while providing enough information about the label is more likely to generalize well. Considering an input variable $X$ , label $C$ and its deep representation $Y = h { \\dot { ( } } X )$ , IB regularizes the training by minimizing the mutual information $I ( X , Y )$ at constant mutual information $I ( C , Y )$ . Along with IB also come some theoretical investigations, with the definition of generalization bounds in Shamir et al. (2010). ",
+        "bbox": [
+            174,
+            597,
+            825,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A challenge for applying IB principles to DNNs is the definition of information-based regularizers that are differentiable and easily computable in order to be efficiently trained using back-propagation (LeCun et al., 1998). There are recent attempts in this direction. For example, Alemi et al. (2017) proposes a DNN that predicts the parameters of the distribution of the random representation variables conditionally to the input and use it to compute IB measures with variational bounds. Achille $\\&$ Soatto (2016) model the information about the data in the learned weights and propose to minimize it. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new regularization loss minimizing $H ( Y \\mid C )$ , the entropy of the representation variable conditionally to the label variable, instead of the mutual information ${ \\dot { I } } ( X , Y )$ For a deterministic model, meaning that the entropy $H ( Y \\mid X )$ is null, we have $I ( X , Y ) =$ $I ( C , Y ) + H ( Y \\mid C ) ^ { 1 }$ . By minimizing directly $H ( Y \\mid C )$ we explicitly decouple the data fitting term $I ( C , Y )$ , which attempts at finding correlations between inputs and labels, and a term which represents the compression rate of the representation $H ( Y \\mid C )$ . ",
+        "bbox": [
+            174,
+            806,
+            825,
+            890
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are three-fold. First, we derive in Section 2 a new regularization scheme, called SHADE for SHAnnon DEcay, to tackle the difficulty of getting an accurate, differentiable and scalable estimate of $H ( Y \\mid C )$ . It is based on a latent code $Z$ representing the activation state of a neuron $Y$ , allowing us to express a complete tractable loss with few additional computation. Second, we discuss the interest of our regularization framework based on conditional entropy in Section 3. In particular, we argue that this measure $H ( Y \\mid C )$ is well designed to compare representations in terms of invariance while still taking the target task into account. Finally, we extensively experiment our SHADE regularizer on different deep learning models and several challenging datasets (CIFAR-10, ImageNet, MNIST-M) in Section 4. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 SHADE: A NEW REGULARIZATION METHOD BASED ON $H ( Y \\mid C )$ ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            251,
+            759,
+            268
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notations and definitions. $X$ is the input from input space $\\mathcal { X }$ with high dimensionality and $C$ is the class label from finite class space $\\mathcal { C } = \\{ 1 , 2 , . . , | \\mathcal { C } | \\}$ . A hypothesis space is designed with a family of parametric (continuous) functions $\\mathcal { H } = \\{ h ( w , . ) : \\mathcal { X } \\to \\mathcal { Y }$ ; $w \\in \\mathcal { W } = \\mathbb { R } ^ { m } \\bar  \\}$ . A model $h \\in \\mathcal H$ outputs a representation of the input from which a class is predicted. In many tasks like image classification, the representation $Y = h ( X )$ of an input $X$ usually defines a distribution, noted $q _ { Y \\mid X }$ , on the class space (e.g. obtained by applying a softmax function). The training in supervised learning consists in finding the parameters $w$ of $h$ minimizing the expectancy of a loss function $\\mathcal { L } _ { \\mathrm { c l s } } ( Y , \\bar { C } )$ that quantifies the difference between the prediction and the label. It is usually the cross-entropy between the obtained distribution $q _ { Y \\mid X }$ and the one-hot distribution with unit probability for the class $C$ noted $p _ { C }$ : $\\begin{array} { r } { \\ell _ { \\mathrm { c l s } } ( Y , C ) = - \\sum _ { c \\in \\mathcal { C } } p _ { C } ( c ) \\log \\big ( q _ { Y | X } ( c ) \\big ) } \\end{array}$ . A regularization term $\\Omega ( \\cdot )$ with a coefficient $\\beta$ is often added to the classification loss, aiming at influencing the learning toward models with lower complexity2. In image classification, the most commonly used regularization criterion is the weight decay: $\\Omega ( w ) = | | w | | _ { 2 } ^ { 2 }$ . In the IB framework, the regularization term would be $\\Omega ( w ) = I \\big ( h ( w , X ) , X \\big )$ . The final loss for supervised learning is: ",
+        "bbox": [
+            173,
+            284,
+            826,
+            483
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ef33b6434bcd9ac56f35a1a123fa7aa331526c9d95beccbde9a5bf6efe7bb46.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } = \\mathbb { E } _ { ( Y , C ) } \\big ( \\ell _ { \\mathrm { c l s } } ( Y , C ) + \\beta \\Omega ( w ) \\big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            492,
+            616,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will further describe SHADE, a new regularization term based on the conditional entropy $H ( Y \\mid C )$ designed to drive the optimization toward more invariant representation. ",
+        "bbox": [
+            169,
+            526,
+            823,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ENTROPY-BASED REGULARIZATION FOR DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            574,
+            687,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Layer-wise regularization. A DNN is composed of a number $L$ of layers that transform sequentially the input. Each one can be seen as an intermediate representation variable, noted $Y _ { \\ell }$ for layer $\\ell$ , that is determined by the output of the previous layer and a set of parameters $\\mathbf { w } _ { \\ell }$ . Each layer filters out a certain part of the information from the initial input. Thus, from the data processing inequality in Cover & Thomas (1991) can be derived the following inequalities for any $\\ell$ : ",
+        "bbox": [
+            173,
+            601,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d418852afcd798a0126a4c9fb089b6a06e7079ff0929c7d148e40a893e9ea753.jpg",
+        "text": "$$\nH ( Y _ { \\ell } \\mid C ) \\leq H ( Y _ { \\ell - 1 } \\mid C ) \\leq \\ldots \\leq H ( Y _ { 1 } \\mid C ) \\leq H ( X \\mid C ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            679,
+            700,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Similarly to the recommendation of Tishby & Zaslavsky (2015), we apply regularization to all the layers, using a layer-wise criterion $H ( Y _ { \\ell } \\mid C )$ , and producing a global criterion: ",
+        "bbox": [
+            173,
+            713,
+            825,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00521d2d9758a1a2bb996200779cc4f0b85547b8f4d2a8027323ba8fd4a4bc63.jpg",
+        "text": "$$\n\\Omega _ { \\mathrm { l a y e r s } } = \\sum _ { \\ell = 1 } ^ { L } H ( Y _ { \\ell } \\mid C ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            751,
+            584,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unit-wise regularization. Examining one layer $\\ell$ , its representation variable is a random vector of coordinates $Y _ { \\ell , i }$ and of dimension $D _ { \\ell }$ : $Y _ { \\ell } \\doteq ( Y _ { \\ell , 1 } , . . . , { \\bar { Y } } _ { \\ell , D _ { \\ell } } )$ . The upper bound3 $H ( Y _ { \\ell } \\mid C ) \\le$ $\\textstyle \\sum _ { i = 1 } ^ { D _ { \\ell } } H ( Y _ { \\ell , i } \\mid C )$ \\` enables to define a unit-wise criterion that SHADE seeks to minimize. For each ",
+        "bbox": [
+            173,
+            810,
+            825,
+            857
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "unit $i$ of every layer $\\ell$ we design a loss $\\omega _ { \\mathrm { u n i t } } ( Y _ { \\ell , i } \\mid C ) = H ( Y _ { \\ell , i } \\mid C )$ that will be part of the global regularization loss: ",
+        "bbox": [
+            174,
+            102,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d2d0233c57b285e2db0f0134611e10ec6f2c8bbc6035f839207a5207d854d40.jpg",
+        "text": "$$\n\\Omega _ { \\mathrm { l a y e r s } } \\leq \\Omega _ { \\mathrm { u n i t s } } = \\sum _ { l = 1 } ^ { L } \\sum _ { i = 1 } ^ { D _ { \\ell } } \\underbrace { H ( Y _ { \\ell , i } \\mid C ) } _ { \\omega _ { \\mathrm { u n i t } } ( Y _ { \\ell , i } \\mid C ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            132,
+            635,
+            185
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Later in the paper, we use the notation $Y$ instead of $Y _ { \\ell , i }$ for simplicity since the coordinates are all considered independently to define $\\omega _ { \\mathrm { u n i t } } ( Y _ { \\ell , i } \\mid C )$ . ",
+        "bbox": [
+            173,
+            193,
+            823,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ESTIMATING ENTROPY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            374,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe how to define a loss based on the measure $H ( Y \\mid C )$ with $Y$ being one coordinate variable of one layer. Defining this loss is not obvious as the gradient of $H ( Y \\mid C )$ with respect to the layer’s parameters may be computationally intractable. $Y$ has an unknown distribution and without modeling it properly it is not possible to compute $H ( Y \\mid C )$ precisely for the following reasons. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since $\\begin{array} { r } { H ( Y \\mid C ) = \\sum _ { c \\in { \\mathcal { C } } } p ( c ) H ( Y \\mid c ) } \\end{array}$ it is necessary to compute $| { \\mathcal { C } } |$ different entropies $H ( Y \\mid c )$ This means that, given a batch, the number of samples used to estimate one of these entropies is divided by $| { \\mathcal { C } } |$ on average which becomes particularly problematic when dealing with a large number of classes such as the 1,000 classes of ImageNet. Furthermore, entropy estimators are extremely inaccurate considering the number of samples in a batch. For example, LME estimators of entropy in Paninski (2003) converge in ${ \\mathcal { O } } { ( ( \\log K ) ^ { 2 } { \\bar { / } } K ) }$ for $K$ samples. Finally, most estimators such as LME require discretizing the space in order to approximate the distribution via a histogram. This raises issues on the bins definition considering that the variable distribution is unknown and varies during the training in addition to the fact that having a histogram for each neuron is computationally and memory consuming. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To tackle these drawbacks we investigate the two following tricks: the introduction of a latent variable that enables to use more examples to estimate the entropy; and a bound on the entropy of the variable by an increasing function of its variance to avoid the issue of entropy estimation with a histogram and make the computation tractable and scalable. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Latent code. First, inspecting a neuron $Y$ (before ReLU), the ReLU activation makes it act as a detector, returning a signal when a certain pattern is present on the input. If the pattern is absent the signal is zero, otherwise, it quantifies the resemblance with it. We therefore propose to associate a binomial variable $Z$ with each unit variable $Y$ (before ReLU). This variable $Z$ indicates if a particular pattern is present on the input ( $Z = 1$ when $Y \\gg 0$ ) or not $Z = 0$ when $Y \\ll 0$ ). It acts like a latent code in variational models (e.g. Kingma & Welling, 2014) or in generative models (e.g. Chen et al., 2016). In our implementation, we chose a binomial distribution $p ( Z = 1 \\mid Y ) = \\operatorname { s i g m o i d } ( Y )$ that matches this intuition, as detailed in Sec. 2.3. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Furtherfore, it is very likely that most intermediate features of a DNN can take similar values for inputs of different classes – this is especially true for low-level features. The semantic information provided by a feature is thus more about a particular pattern than about the class itself. Only the association of features allows determining the class. So $Z$ represents a semantically meaningful factor about the class $C$ and from which the input $X$ is generated. The feature value $Y$ is then a quantification of the possibility for this semantic attribute $Z$ to be present in the input or not. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Then, we assume the Markov chain $C  Z  X  Y$ . Indeed, during the training, the distribution of $Y$ varies in order to get as close as possible to a sufficient statistic of $X$ for $C$ (see definition in Cover & Thomas, 1991). Therefore, we expect $Z$ to be such that $Y$ draws near a sufficient statistic of $Z$ for $C$ as well. By assuming the sufficient statistic relation $I ( Y , C ) = I ( Y , Z )$ we get the equivalent equality $H ( Y \\mid C ) = H ( Y \\mid Z )$ , and finally obtain: ",
+        "bbox": [
+            173,
+            765,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85fe1fc89bf51e10e5235005fc2dc1fe589d6cc6e1de7026ac5091955d555611.jpg",
+        "text": "$$\n\\omega _ { \\mathrm { u n i t } } ( Y \\mid C ) = H ( Y \\mid C ) = H ( Y \\mid Z ) = \\sum _ { z \\in \\{ 0 , 1 \\} } p ( z ) H ( Y \\mid Z = z ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            837,
+            732,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This modeling of $Z$ as a binomial variable (one for each unit) has the advantage of enabling good estimators of conditional entropy since we only divide the batch into two sets for the estimation $z = 0$ and 1) regardless of the number of classes. ",
+        "bbox": [
+            173,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Moving average updates: for $z \\in \\{ 0 , 1 \\} , p ^ { z }$ estimates $p ( Z = z )$ and $\\mu ^ { z }$ estimates $\\mathbb { E } ( { \\bar { Y } } \\mid Z = z )$ ",
+        "bbox": [
+            168,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/988a77d0d5c34e3c186737540a89297deb3798b22f69a3fe0029b3ac84891de7.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>2:</td><td>1: Initialize: μ°= -1,μ¹ =1,p°=p¹ = 0.5,入= 0.8 for each mini-batch {y(k),k ∈1..K} do</td></tr><tr><td>3:</td><td>for z∈{0,1}do</td></tr><tr><td>4:</td><td>p²←xp²+（1-）∑k=1p(z丨y()） &gt;Kp(z丨y(k）)</td></tr><tr><td>5:</td><td>μ²←λμ²+(1-)∑=1 y(k） p</td></tr><tr><td>6:</td><td>end for</td></tr><tr><td>7: end for</td><td></td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            179,
+            137,
+            557,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Variance bound. The previous trick allows computing fewer entropy estimates to obtain the global conditional entropy, thus increasing the sample size used for each entropy estimation. Unfortunately, it does not solve the bin definition issue. To address this, we propose to use the following bound on $H ( Y \\mid Z )$ , that does not require the definition of bins: ",
+        "bbox": [
+            173,
+            286,
+            825,
+            343
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c764bcdaf530ba41ba496bc2d4fc8e5ee17c4720f8c5c4b499691b7266908780.jpg",
+        "text": "$$\nH ( Y \\mid Z ) \\leq { \\frac { 1 } { 2 } } \\ln { \\big ( } 2 \\pi e \\mathbb { V } \\ a \\mathbf { r } ( Y \\mid Z ) { \\big ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            349,
+            622,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This bound holds for any continuous distributions $Y$ and there is equality if the distribution is Gaussian. For many other distributions such as the exponential one, the entropy is also equal to an increasing function of the variance. In addition, one main advantage is that variance estimators are much more robust than entropy estimators, converging in $\\mathcal { O } ( { 1 } / { \\bar { \\kappa } } )$ for $K$ samples instead of $\\mathcal { O } ( \\log ( K ) ^ { 2 } / K )$ . ",
+        "bbox": [
+            173,
+            391,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, the ln function being one-to-one and increasing, we only keep the simpler term $\\mathbb { V } \\mathrm { a r } ( Y \\mid Z )$ to design our final loss: ",
+        "bbox": [
+            173,
+            468,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fe5d8a37b44c8acff7eb501e5eab4f70d6ee414172cb34dc33e951ec5c7b621.jpg",
+        "text": "$$\n\\Omega _ { \\mathrm { S H A D E } } = \\sum _ { \\ell = 1 } ^ { L } \\sum _ { i = 1 } ^ { D _ { \\ell } } \\sum _ { z \\in \\{ 0 , 1 \\} } p ( Z _ { \\ell , i } = z \\mid Y ) \\mathrm { V a r } ( Y \\mid Z _ { \\ell , i } = z ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            502,
+            705,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In next section, we detail the definition of the differential loss using $\\mathbb { V } \\mathrm { a r } ( Y \\mid Z )$ as a criterion computed on a mini-batch. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 INSTANTIATING SHADE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            609,
+            388,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For one unit of one layer, the previous criterion writes: ",
+        "bbox": [
+            174,
+            635,
+            532,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf3f72ccf2755b9f382baa5bdf320733a94992d21e4a025fb356c4a959e9a527.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\operatorname { V a r } ( Y \\mid Z ) = \\int _ { \\mathcal { V } } p ( y ) \\int _ { { \\mathcal Z } } p ( z \\mid y ) \\big ( y - \\mathbb { E } ( Y \\mid z ) \\big ) ^ { 2 } \\mathrm { d } z \\mathrm { d } y } \\\\ { \\displaystyle \\approx \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } \\left[ \\int _ { { \\mathcal Z } } p ( z \\mid y ^ { ( k ) } ) \\big ( y ^ { ( k ) } - \\mathbb { E } ( Y \\mid z ) \\big ) ^ { 2 } \\mathrm { d } z \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            655,
+            710,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The quantity $\\mathbb { V } \\mathrm { a r } ( Y \\mid Z )$ can be estimated with Monte-Carlo sampling on a mini-batch of input-target pairs $\\left\\{ ( x ^ { ( k ) } , c ^ { ( k ) } ) \\right\\} _ { 1 \\leq k \\leq K }$ of intermediate representations $\\left\\{ y ^ { ( k ) } \\right\\} _ { 1 \\leq k \\leq K }$ as in Eq. (9). ",
+        "bbox": [
+            173,
+            747,
+            825,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$p ( Z \\mid y )$ interpreted as the probability of presence of attribute $Z$ on the input, it should clearly be modeled such that $p ( Z = \\bar { 1 ~ } | ~ y )$ increases with $y$ . The more similarities between the input and the pattern represented by $y$ , the higher the probability of presence for $Z$ . We suggest using: ",
+        "bbox": [
+            174,
+            787,
+            823,
+            832
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d71730c1f33fa1b2d9d35c59ea5a22930b2c52fc8d80c751bb808c2c94a7d24.jpg",
+        "text": "$$\np ( Z = 1 \\mid y ) = \\sigma ( y ) \\qquad p ( Z = 0 \\mid y ) = 1 - \\sigma ( y ) \\qquad { \\mathrm { w i t h ~ s i g m o i d ~ f u n c t i o n ~ } } \\sigma ( y ) = { \\frac { 1 } { 1 + e ^ { - y } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            838,
+            821,
+            864
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the expected values $\\mu ^ { z } = \\operatorname { \\mathbb { E } } ( Y \\mid z )$ we use a classic moving average that is updated after each batch as described in Algorithm 1. Note that the expected values are not changed by the optimization since they have no influence on the entropy $H ( Y \\mid Z )$ . ",
+        "bbox": [
+            174,
+            881,
+            823,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The concrete behavior of SHADE can be interpreted by analyzing its gradient as described in Appendix C. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For this proposed instantiation, our SHADE regularization penalty takes the form: ",
+        "bbox": [
+            183,
+            138,
+            715,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9127e72033ba159bf2168d10fd46aa24992c4c4ebc7d7855bbfcd27d12cc8c2.jpg",
+        "text": "$$\n\\Omega _ { \\mathrm { S H A D E } } = \\sum _ { \\ell = 1 } ^ { L } \\sum _ { i = 1 } ^ { D _ { \\ell } } \\sum _ { k = 1 } ^ { K } \\sum _ { z \\in \\left\\{ 0 , 1 \\right\\} } p \\left( Z _ { \\ell , i } = z \\left| y _ { \\ell , i } ^ { ( k ) } \\right. \\right) \\left( y _ { \\ell , i } ^ { ( k ) } - \\mu _ { \\ell , i } ^ { z } \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            155,
+            720,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We have presented a regularizer that is applied layer-wise and that can be integrated into the usual optimization process of a DNN. The additional computation and memory usage induced by SHADE is almost negligible (computation and storage of two moving averages per neuron). Namely, SHADE adds half as many parameters as batch normalization does. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 CONDITIONAL ENTROPY AS INVARIANCE MEASURE FOR CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            284,
+            821,
+            300
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the IB framework, we have derived a criterion that SHADE loss aims at minimizing. In this section, we further explore the relevance of our conditional entropy term for regularization. We first establish a connection between the entropy $H ( Y )$ of a representation and its invariance. Then we explain why $H ( Y \\mid C )$ seems to be a better fitting criterion for a classification task. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$H ( Y )$ to measure invariance. For an input $X$ and a deterministic mapping $f ( X ) = Y$ , we have $H ( Y \\mid X ) = 0$ and therefore: ",
+        "bbox": [
+            173,
+            383,
+            825,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71b1ac762b7e02fdf37a271a4db6ed6797db6cb9b04678653372400bf9b7e429.jpg",
+        "text": "$$\nH ( Y ) = I ( X , Y ) + H ( Y \\mid X ) = I ( X , Y ) = H ( X ) - H ( X \\mid Y ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            414,
+            722,
+            431
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$H ( X )$ being fixed, $H ( Y )$ is inversely related to $H ( X \\mid Y )$ . Besides, we assume that $H ( X \\mid Y )$ is a good measure to quantify how invariant a representation is. Indeed, if a representation is invariant to many transformations, many inputs have the same representation. Consequently, given a representation sample, it is difficult to guess from which input it has been computed. These properties are perfectly captured by $H ( X \\mid Y )$ , representing the uncertainty in $X$ knowing $Y$ . The bigger the uncertainty, the harder it is to predict $X$ precisely. Concretely, when trying to guess $X$ knowing $Y$ , we can lower bound the error made in the best case, with an increasing function of the conditional entropy as developed in Appendix A. Therefore, it seems that $H ( Y )$ is a good measure of the invariance of the model. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the particular case of deep learning, He et al. (2016) explain that the stacking of multiple layers is responsible for improving the generalization of DNN. This fact can be explained by the data processing inequality (Cover & Thomas, 1991). In the case of finite input space, each layer is responsible for filtering a certain amount of information. As clearly illustrated in Tishby & Zaslavsky (2015), for each stage, the representation has a lower entropy than the representation of the preceding layer. Increasing the depth increases the capacity of the network to reduce the overall entropy of the DNN representation thus increasing their invariance. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$H ( Y )$ as a regularizer. From this intuition, one can use a variance bound similar to Eq. (6): $H ( \\dot { Y } ) \\stackrel { \\cdot } { \\leq } 1 / 2 \\ln ( \\bar { 2 } \\pi e \\mathbb { V } \\mathrm { a r } ( Y ) )$ to derive a loss in order to minimize the representations’ entropy $H ( Y )$ . For instance, we can show that the weight decay reduces this variance under some approximations. In fact when $Y = \\mathbf { w } ^ { \\top } X + \\mathbf { b }$ , by estimating $\\Lambda = \\mathbb { C } \\mathrm { o v } ( X )$ , the variance takes the immediate form $\\mathbb { V } \\mathrm { a r } ( Y ) = \\mathbf { w } ^ { \\top } \\Lambda \\mathbf { w }$ . If $\\Lambda = I d$ , meaning that the input coordinates are considered independent with unit variance, then $\\mathbb { V } \\mathrm { a r } ( Y ) = | | \\mathbf { w } | | _ { 2 } ^ { 2 }$ . It corresponds to the weight decay regularization or $L _ { 2 }$ penalty. Even if within a DNN layer, the batch normalization tends to enforce this unit variance hypothesis and the depth of DNN tends to ensure the independence hypothesis the weight decay remains poor at improving generalization as illustrated in Zhang et al. (2017). Considering fewer assumptions, it is possible to reduce the variance of an output coordinate by penalizing its empirical variance on a batch during the training. We introduce an alternative loss on the variance called VarEntropy, constructed the same way SHADE has been derived, but avoiding the introduction of a latent variable $Z$ : ",
+        "bbox": [
+            173,
+            683,
+            826,
+            851
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72042d1bbb4e2f0819c66586da4edd48ecf6ddda4d997c74d0b64edc13b17a62.jpg",
+        "text": "$$\n\\Omega _ { \\mathrm { V a r E n t r o p y } } = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } \\left( y ^ { ( k ) } - \\mathbb { E } ( Y ) \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            852,
+            632,
+            895
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Even if experimentally, VarEntropy regularization seems to behave better than simple weight decay, it is not as efficient as SHADE and we try to explain why below. ",
+        "bbox": [
+            174,
+            896,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Importance of conditional entropy. We have seen that lowering the entropy of the representation enables to make it more invariant. However, another fact reported by He et al. (2016) is that stacking layers increases the difficulty to train the network. Indeed, when reducing too much the entropy, there is a risk that the information about the label is filtered as well. The representation is so invariant that it is no longer possible to distinguish between the classes. In He et al. (2016), they solve this issue by forcing the transmission of additional information through skip-connections while IB prescribes to maximize the compression rate at constant information about the label. All this highlights the fact that having invariant representations is interesting if it is intra-class invariant. Since we do not want two inputs from different classes to have the same representation, we prefer to focus on a criterion quantifying the intra-class compression rate in order to maximize intra-class invariance: $H ( Y \\mid C )$ . ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in the introduction, $H ( Y \\mid C )$ thus differs from standard IB frameworks based on $I ( X , Y )$ (Achille & Soatto, 2016; Alemi et al., 2017). Contrarily to the mutual information $I ( X , Y ) = H ( Y \\mid C ) + I ( C , Y )$ , our regularizer applied to $H ( Y \\mid { \\dot { C } } )$ ignores $I ( C , Y )$ . When minimizing $I ( X , Y )$ , there is no control on how both terms $H ( Y \\mid { \\dot { C } } )$ and $I ( C , Y )$ are modified. Our regularizer is therefore beneficial in the sense that minimizing $H ( Y \\mid C )$ does not conflict with the mutual information $I ( C , Y )$ between the representation and the label, information that is therefore for classification and should not be penalized. ",
+        "bbox": [
+            173,
+            248,
+            825,
+            347
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            326,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMAGE CLASSIFICATION WITH VARIOUS ARCHITECTURES ON CIFAR-10 ",
+        "bbox": [
+            173,
+            401,
+            720,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0d932a5584af4fdbbcfc418d7348a37a49140a71d1501856ab07422a25d92dad.jpg",
+        "table_caption": [
+            "Table 1: Classification accuracy $( \\% )$ on CIFAR-10 test set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>MLP</td><td>AlexNet</td><td>ResNet</td><td>Inception</td></tr><tr><td>No regul.</td><td>62.38</td><td>83.25</td><td>89.84</td><td>90.97</td></tr><tr><td>Weight decay</td><td>62.69</td><td>83.54</td><td>91.71</td><td>91.87</td></tr><tr><td>Dropout</td><td>65.37</td><td>85.95</td><td>89.94</td><td>91.11</td></tr><tr><td>VarEntropy</td><td>63.70</td><td>83.61</td><td>91.72</td><td>91.83</td></tr><tr><td>SHADE</td><td>66.05</td><td>85.45</td><td>92.15</td><td>93.28</td></tr><tr><td>SHADE+D</td><td>66.12</td><td>86.71</td><td>92.03</td><td>92.51</td></tr></table>",
+        "bbox": [
+            303,
+            458,
+            694,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We perform image classification on the CIFAR-10 dataset, which contains $5 0 \\mathrm { k }$ training images and $1 0 \\mathrm { k }$ test images of $3 2 \\times 3 2$ RGB pixels, fairly distributed within 10 classes (see Krizhevsky, 2009, for details). Following the architectures used in Zhang et al. (2017), we use a small Inception model, a three-layer MLP, and an AlexNet-like model with 3 convolutional and 2 fully connected layers. We also use a ResNet architecture from Zagoruyko & Komodakis (2016). Those architectures represent a large family of DNN and some have been well studied in Zhang et al. (2017) within the generalization scope. For training, we use randomly cropped images of size $2 8 \\times 2 8$ with random horizontal flips. For testing, we simply center-crop $2 8 \\times 2 8$ images. We use momentum SGD for optimization (same protocol as Zhang et al., 2017). ",
+        "bbox": [
+            173,
+            594,
+            825,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare SHADE with three regularization methods, namely weight decay, dropout and VarEntropy presented in Eq. (12). For all architectures, the regularization parameters have been crossvalidated to find the best ones for each method and the obtained accuracies on the test set are reported in Table 1. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We obtain the same trends as Zhang et al. (2017), which get a small improvement of $0 . 3 1 \\%$ with weight decay on AlexNet. The improvement with weight decay is slightly more important with ResNet and Inception $0 . 8 7 \\%$ and $0 . 9 0 \\%$ ) probably thanks to the use of batch normalization. In our experiments dropout improves generalization performances only for AlexNet and MLP. It is known that the use of batch normalization lowers the benefit of dropout, which is in fact not used in He et al. (2016). ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first notice that for all kind of architectures the use of SHADE significantly improves the generalization performance. It demonstrates the ability of SHADE to regularize the training of deep architectures. Moreover, SHADE systematically outperforms other regularizations of the same type (c) Examples of MNIST-M images misclassified by the baseline and correctly classified using SHADE, both trained with 250 samples. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/49ccdbc583baf44e56977412cf65af2ec0ff5a197c1316558d668390f3c30309.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            97,
+            823,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            222,
+            330,
+            776,
+            356
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: Results when training with a limited number of samples in the training set for MNIST-M and CIFAR-10 with and without SHADE. ",
+        "bbox": [
+            174,
+            367,
+            823,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "such as weight decay or VarEntropy, illustrating the advantage of minimizing the conditional entropy instead of the entropy directly. ",
+        "bbox": [
+            173,
+            425,
+            823,
+            454
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, SHADE shows better performances than dropout on all architecture except on AlexNet, for which they seem to be complementary, probably because of the very large number of parameters in the fully-connected layers, with best performances obtained with SHADE coupled with dropout (named SHADE $+ \\mathbf { D }$ ). This association is also beneficial for MLP. On Inception and ResNet, even if dropout and SHADE independently improve generalization performances, their association is not as good as SHADE alone, probably because it enforces too much regularization. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 LARGE SCALE CLASSIFICATION ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            542,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to experiment SHADE regularization on very large scale dataset, we train on ImageNet (Russakovsky et al., 2015) a WELDON network from Durand et al. (2016) adapted from ResNet-101. This architecture changes the forward and pooling strategy by using the network in a fully-convolutional way and adding a max+min pooling, thus improving the performance of the baseline network. We used the pre-trained weights of ResNet-101 (from the torchvision package of PyTorch) giving performances on the test set of $7 7 . 5 6 \\%$ for top-1 accuracy and $9 3 . 8 9 \\%$ for top-5 accuracy. Provided with the pre-trained weights, the WELDON architecture obtains $78 . 5 1 \\%$ for top-1 accuracy and $9 4 . 6 5 \\%$ for top-5 accuracy. After fine tuning the network using SHADE for regularization we finally obtained $8 0 . 1 4 \\%$ for top-1 accuracy and $9 5 . 3 5 \\%$ for top-5 accuracy for a concrete improvement. This demonstrates the ability to apply SHADE on very large scale image classification successfully. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 TRAINING WITH A LIMITED NUMBER OF SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            566,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When datasets are small, DNNs tend to overfit quickly and regularization becomes essential. Because it tends to filter out information and make the network more invariant, SHADE seems to be well fitted for this task. To investigate this, we propose to train DNNs with and without SHADE on CIFAR-10 and MNIST-M with different numbers of samples in the training set. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we tested this approach on the digits dataset MNIST-M (Ganin & Lempitsky, 2015). This dataset consists of the MNIST digits where the background and digit have been replaced by colored and textured information (see Fig. 1c for examples). The interest of this dataset is that it contains lots of unnecessary information that should be filtered out, and is therefore well adapted to measure the effect of SHADE. A simple convolutional network has been trained with different numbers of samples of MNIST-M and the optimal regularization weight for SHADE have been determined on the validation set (see training details in Appendix D). The results can be seen on Figure 1a. We can see that especially for small numbers of training samples $( < 1 0 0 0 )$ , SHADE provides an important gain of 10 to $15 \\%$ points over the baseline. This shows that SHADE helped the model in finding invariant and discriminative patterns using less data samples. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/568825dcc9f49bca296cae21f75540c5e8b3f250d3cc74c8ef1b04787d5ed891.jpg",
+        "image_caption": [
+            "Figure 2: Evolution of the accuracy of a pre-trained Inception model on CIFAR-10 when only applying regularization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            361,
+            101,
+            635,
+            256
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            327,
+            825,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Additionally, Figure 1c shows samples that are misclassified by the baseline model but correctly classified when using SHADE. These images contain a large amount of intra-class variance (color, texture, etc.) that is not useful for the classification tasks, explaining why adding SHADE, that encourages the model to discard information, allows important performance gains on this dataset and especially when only few training samples are given. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            459
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, to confirm this behavior, we also applied the same procedure in a more conventional setting by training an Inception model on CIFAR-10. Figure 1b shows the results in that case. We can see that once again SHADE helps the model gain in performance and that this behavior is more noticeable when the number of samples is limited, allowing a gain of $6 \\%$ when using 4000 samples. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 CLASS-INFORMATION PRESERVATION BY CONDITIONAL ENTROPY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            674,
+            559
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The main difference between SHADE and VarEntropy is the introduction of the latent variable $Z$ , supposed to contain the information about the label $C$ . The motivation of this extension is that minimizing $H ( Y \\mid C )$ instead of $H ( Y )$ enables to save the class information during the optimization of the regularization loss, as explained in Section 3. To illustrate this benefit, we compare the impact of the two regularization losses on the classification performances of a pre-trained model. To do so, we fine tune a pre-trained Inception model only with a regularization loss, either based on $\\mathbb { V } \\mathrm { a r } ( Y )$ or $\\mathbb { V } \\mathrm { a r } ( Y \\mid Z )$ ; without any label data or classification loss. The network performance obviously declines for both regularizers as we can see on Figure 2. However, this decline is slower with SHADE than VarEntropy. This confirms the intuition that $Z$ contains class-information and that SHADE produces less class-information filtering. This is explained by the optimization of the metric $\\operatorname { V a r } ( Y \\mid { \\overline { { Z } } } )$ that uses implicitly-learned information encoded in the network. ",
+        "bbox": [
+            174,
+            571,
+            826,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            318,
+            766
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced a new regularization method for DNNs training, SHADE, which focuses on minimizing the entropy of the representation conditionally to the labels. This regularization aims at increasing the intra-class invariance of the model while keeping class information. SHADE is tractable, adding only a small computational overhead when included into an efficient SGD training. We show that our SHADE regularization method significantly outperforms standard approaches such as weight decay or dropout with various DNN architectures on CIFAR-10. We also validate the scalability of SHADE by applying it on ImageNet. The invariance potential brought out by SHADE is further illustrated by its ability to ignore irrelevant visual information (texture, color) on MNIST-M. Finally, we also highlight the increasing benefit of our regularizer when the number of training examples becomes small. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nA. Achille and S. Soatto. Information dropout: learning optimal representations through noisy computation. ArXiv, 2016.   \nA. A. Alemi, I. Fischer, J. V Dillon, and K. Murphy. Deep variational information bottleneck. In ICLR, 2017.   \nXi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In NIPS, Jun 2016.   \nT. Cover and J. Thomas. Elements of information theory. Wiley New York, 1991.   \nThibaut Durand, Nicolas Thome, and Matthieu Cord. WELDON: Weakly Supervised Learning of Deep Convolutional Neural Networks. In CVPR, 2016.   \nYaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In ICML, pp. 1180–1189, 2015.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \nSergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. JMLR, 2016.   \nDiederik P. Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014.   \nA. Krizhevsky. Learning multiple layers of features from tiny images. PhD thesis, Computer Science Department University of Toronto, 2009.   \nAlex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.), NIPS, 2012.   \nAnders Krogh and John A. Hertz. A simple weight decay can improve generalization. In NIPS, 1992.   \nY. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient based learning applied to document recognition. Proceedings of the IEEE, 1998.   \nLiam Paninski. Estimation of entropy and mutual information. Neural Computation, 2003.   \nOlga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual recognition challeng. ICJV, 2015.   \nO. Shamir, S. Sabato, and N. Tishby. Learning and generalization with the information bottleneck. Theoretical Computer Science, 2010.   \nNitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014.   \nN. Tishby, F. C. Pereira, and W. Bialek. The information bottleneck method. Annual Allerton Conference on Communication, Control and Computing, 1999.   \nNaftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. In Information Theory Workshop (ITW). IEEE, 2015.   \nDavid A. van Dyk and Xiao-Li Meng. The art of data augmentation. Journal of Computational and Graphical Statistics, 2001.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. In arXiv, 2016.   \nChiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. ICLR, 2017. ",
+        "bbox": [
+            171,
+            92,
+            828,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A ENTROPY BOUNDING THE RECONSTRUCTION ERROR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            643,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In section 3 we highlight a link between the entropy $H ( X \\mid Y )$ and the difficulty to recover the input $X$ from its representation $Y$ . Here we exhibit a concrete relation between the reconstruction error, that quantifies the error made by a strategy that predicts $X$ from $Y$ , and the conditional entropy. This relation takes the form of an inequality, bounding the error measure in the best case (with the reconstruction strategy that minimizes the error) by an increasing function of the entropy. We note ${ \\hat { x } } ( Y ) \\in { \\mathcal { X } }$ the reconstruction model that tries to guess $X$ from $Y$ . ",
+        "bbox": [
+            173,
+            136,
+            825,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The discrete case In case the input space is discrete, we consider the zero-one reconstruction error for one representation point $Y$ $\\ ' \\colon \\varepsilon ( { \\bar { Y } } ) = E _ { X } [ \\mathbb { 1 } ( { \\hat { x } } ( Y ) \\neq X ) ]$ . This is the probability of error when predicting ${ \\hat { x } } ( Y )$ from $Y$ . The function that minimizes the expected error $\\mathcal { E } = \\mathbb { E } _ { Y } ( \\varepsilon ( Y ) )$ is ${ \\hat { x } } ( Y ) = \\arg \\operatorname* { m a x } _ { x \\in { \\mathcal { X } } } p ( x \\mid Y )$ as shown in Proof 1. We derive the following inequality: ",
+        "bbox": [
+            173,
+            242,
+            825,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4771025f17c71559a75d4482a68756fa8684934004fc1965c93e386d325d2dd5.jpg",
+        "text": "$$\n{ \\frac { H ( X \\mid Y ) - 1 } { \\log | { \\mathcal { X } } | } } \\leq { \\mathcal { E } } \\leq 1 - 2 ^ { - H ( X \\mid Y ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            310,
+            629,
+            345
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The left side of the inequality uses Fano’s inequality in Cover & Thomas (1991), the right one is developed in proof 2. This first bound shows how the reconstruction error and the entropy are related. For very invariant representations, it is hard to recover the input from $Y$ and the entropy of $H ( X \\mid Y )$ is high. ",
+        "bbox": [
+            173,
+            364,
+            826,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Besides, there can be an underlying continuity in the input space and it could be unfair to penalize predictions close to the input as much as predictions far from it. We expose another case below that takes this proximity into account. ",
+        "bbox": [
+            174,
+            428,
+            823,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The continuous case In the case of convex input space and input variable with continuous density, we consider the 2-norm distance as reconstruction error: $\\varepsilon ( Y ) = \\mathbb { E } _ { X \\mid Y } \\left[ | | X - \\hat { X } ( Y ) | | _ { 2 } ^ { 2 } \\right]$ . This error penalizes the average distance of the input and its reconstruction from $Y$ . The function that minimizes the expected error $\\mathcal { E } = \\mathbb { E } _ { Y } [ \\varepsilon ( Y ) ]$ is the conditional expected value: ${ \\hat { x } } ( y ) = \\operatorname { \\mathbb { E } } [ X \\mid Y = y ]$ . Then ${ \\mathcal { E } } = { \\bar { \\mathbb { V } } } \\mathrm { a r } ( X \\mid Y )$ . Helped by the well-known inequality $H ( X \\mid Y ) \\leq { \\textstyle { \\frac { 1 } { 2 } } } \\ln ( 2 { \\bar { \\pi } } e \\mathbb { V } \\mathrm { a r } ( X \\mid Y ) )$ we obtain: ",
+        "bbox": [
+            173,
+            491,
+            825,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50c31eb377a4c5765cc22391eb7f85537ff2bd875ac8f2aaa59c6fe18225262f.jpg",
+        "text": "$$\n{ \\frac { e ^ { 2 H ( X \\mid Y ) } } { 2 \\pi e } } \\leq { \\mathcal { E } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            587,
+            552,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Here again, notice that a high entropy $H ( X \\mid Y )$ implies a high reconstruction error in the best case. ",
+        "bbox": [
+            171,
+            631,
+            825,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.1 PROOF 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            670,
+            277,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have ",
+        "bbox": [
+            173,
+            698,
+            232,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/06dcbfe3dd08a9c43ce434888fddc3c126e8a2bb943f603f1d5e93b7497f0172.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\mathcal E = \\int _ { \\mathscr y } p ( \\boldsymbol y ) \\boldsymbol \\varepsilon ( \\boldsymbol y ) \\mathrm d \\boldsymbol y } } \\\\ & { = \\int _ { \\mathscr y } p ( \\boldsymbol y ) p ( \\boldsymbol X \\neq \\hat { \\boldsymbol x } ( \\boldsymbol y ) \\mid \\boldsymbol y ) \\mathrm d \\boldsymbol y } \\\\ & { = \\int _ { \\mathscr y } p ( \\boldsymbol y ) ( 1 - p ( \\hat { \\boldsymbol x } ( \\boldsymbol y ) \\mid \\boldsymbol y ) ) \\mathrm d \\boldsymbol y . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            722,
+            612,
+            827
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Since ",
+        "bbox": [
+            173,
+            837,
+            214,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb23cc6eda6d4d915e17f3f1c82eae1ce66fa7add710373ede4579c1a4a36d1a.jpg",
+        "text": "$$\np ( \\hat { x } ( y ) \\mid y ) \\le p ( \\operatorname * { a r g m a x } _ { x \\in X } p ( x \\mid y ) \\mid y ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            857,
+            627,
+            883
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "the reconstruction that minimizes the error is ${ \\hat { x } } ( y ) = \\arg \\operatorname* { m a x } _ { x \\in X } p ( x \\mid y )$ . However, this is theoretical because in most cases $p ( x \\mid Y )$ is unknown. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.2 PROOF 2 ",
+        "bbox": [
+            176,
+            103,
+            281,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We have: ",
+        "bbox": [
+            173,
+            130,
+            235,
+            143
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22145264c9bec41ef75849daca05d3d874c153174cb628929e7a6f90cb1ac306.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\log ( 1 - \\mathcal { E } ) = \\log \\left( \\displaystyle \\int _ { y } p ( y ) ( 1 - \\varepsilon ( y ) ) \\mathrm { d } y \\right) } \\\\ & { \\qquad = \\log \\left( \\displaystyle \\int _ { y } p ( y ) p ( \\hat { x } ( y ) \\mid y ) \\right) \\mathrm { d } y } \\\\ & { \\qquad \\ge \\displaystyle \\int _ { y } p ( y ) \\log \\bigl ( p ( \\hat { x } ( y ) \\mid y ) \\bigr ) \\mathrm { d } y } \\\\ & { \\qquad = \\displaystyle \\int _ { y } p ( y ) \\int _ { x } p ( x \\mid y ) \\log \\bigl ( p ( \\hat { x } ( y ) \\mid y ) \\bigr ) \\mathrm { d } x \\mathrm { d } y } \\\\ & { \\qquad \\ge \\displaystyle \\int _ { y } p ( y ) \\int _ { x } p ( x \\mid y ) \\log \\bigl ( p ( x \\mid y ) \\bigr ) \\mathrm { d } x \\mathrm { d } y } \\\\ & { \\qquad = - H ( X \\mid Y ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            142,
+            689,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The Eq. (21) is obtained using Jensen inequality and Eq. (23) is obtained using the result of Proof 1. Thus, ",
+        "bbox": [
+            169,
+            335,
+            825,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            357,
+            212,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b0e576af84ef29c74ea6245d220997f7d0af194d0c7e29e281d5a9d5e86ffa5d.jpg",
+        "text": "$$\n\\mathcal { E } \\leq 1 - 2 ^ { - H ( X | Y ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            367,
+            566,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B DEVELOPMENT OF SHADE LOSS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            404,
+            488,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Below is the detail of the development of Equation (8). ",
+        "bbox": [
+            174,
+            434,
+            534,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/677c84c7987bb3f6bccb6083be56361364cf2ec4b7fd37ea8dde566c3fcfb4fa.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\operatorname { V a r } ( Y \\mid Z ) = \\int _ { \\mathcal { Z } } p ( z ) \\operatorname { V a r } ( Y \\mid z ) \\mathrm { d } z } } \\\\ & { = \\int _ { \\mathcal { Z } } p ( z ) \\int _ { \\mathcal { Y } } p ( y \\mid z ) ( y - \\operatorname { E } ( Y \\mid z ) ) ^ { 2 } \\mathrm { d } y \\mathrm { d } z } \\\\ & { = \\int _ { \\mathcal { Y } } \\int _ { \\mathcal { Z } } p ( z ) p ( y \\mid z ) ( y - \\operatorname { E } ( Y \\mid z ) ) ^ { 2 } \\mathrm { d } y \\mathrm { d } z } \\\\ & { = \\int _ { \\mathcal { Y } } \\int _ { \\mathcal { Z } } p ( y ) p ( z \\mid y ) ( y - \\operatorname { \\mathbb { F } } ( Y \\mid z ) ) ^ { 2 } \\mathrm { d } y \\mathrm { d } z } \\\\ & { = \\int _ { \\mathcal { Y } } p ( y ) \\int _ { \\mathcal { Z } } p ( z \\mid y ) ( y - \\operatorname { \\mathbb { F } } ( Y \\mid z ) ) ^ { 2 } \\mathrm { d } y \\mathrm { d } z } \\\\ & { = \\int _ { \\mathcal { Y } } p ( y ) \\int _ { \\mathcal { Z } } p ( z \\mid y ) ( y - \\operatorname { \\mathbb { E } } ( Y \\mid z ) ) ^ { 2 } \\mathrm { d } y \\mathrm { d } z . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            452,
+            691,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C SHADE GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            636,
+            385,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Here is studied the influence of SHADE on a gradient descent step for a single neuron $Y$ of a single layer and for one training sample $X$ . The considered case of a linear layer, we have: $Y = \\mathbf { w } ^ { \\top } X + b$ . ",
+        "bbox": [
+            171,
+            666,
+            825,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The gradient of $\\Omega _ { \\mathrm { S H A D E } }$ with respect to w is: ",
+        "bbox": [
+            174,
+            702,
+            477,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36d4480bc8f8b87dc27a2ddc76d2c9951929a61bd82e146e60f6b06f2c4d6f2d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { \\mathbf { w } } \\Omega _ { \\mathrm { S H A D E } } = ( \\delta _ { 1 } + \\delta _ { 2 } ) \\mathbf { x } } \\\\ & { \\qquad \\mathrm { w i t h } \\ \\delta _ { 1 } = \\sigma ( y ) ( 1 - \\sigma ( y ) ) \\big ( ( y - \\mu ^ { 1 } ) ^ { 2 } - ( y - \\mu ^ { 0 } ) ^ { 2 } \\big ) } \\\\ & { \\qquad \\mathrm { a n d } \\ \\delta _ { 2 } = 2 \\sigma ( y ) ( y - \\mu ^ { 1 } ) + 2 ( 1 - \\sigma ( y ) ) ( y - \\mu ^ { 0 } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            718,
+            686,
+            777
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We can interpret the direction of this gradient by analyzing the two terms $\\delta _ { 1 }$ and $\\delta _ { 2 }$ as follows: ",
+        "bbox": [
+            176,
+            784,
+            790,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• $\\delta _ { 1 }$ : If $( y - \\mu ^ { 0 } ) ^ { 2 }$ is bigger than $( y - \\mu ^ { 1 } ) ^ { 2 }$ that means that $y$ is closer to $\\mu ^ { 1 }$ than it is to $\\mu ^ { 0 }$ . Then $\\delta _ { 1 }$ is positive and it contributes to increasing $y$ meaning that it increases the probability of $Z$ being from mode 1. In a way it increases the average margin between positive and negative detections. Note that if there is no ambiguity about the mode of $Z$ meaning that $\\sigma ( \\bar { y } )$ or $1 - \\sigma ( y )$ is very small then this term has negligible effect. ",
+        "bbox": [
+            215,
+            806,
+            825,
+            878
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• $\\delta _ { 2 }$ : This term moves $y$ toward the $\\mu ^ { z }$ of the mode that presents the bigger probability. This has the effect of concentrating the outputs around their expectancy depending on their mode to get sparser activation. ",
+        "bbox": [
+            215,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D EXPERIMENTS DETAILS ON MNIST-M ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            531,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dataset splits and creation. To create MNIST-M, we kept the provided splits of MNIST, so we have 55,000 training samples, 5,000 validation samples, and 10,000 test samples. Each digit of MNIST is processed to add color and texture by taking a crop in images from BST dataset. This procedure is explained in Ganin & Lempitsky (2015). ",
+        "bbox": [
+            174,
+            133,
+            825,
+            189
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Subsets of limited size. To create the training sets of limited size $N$ , we keep $N / 1 0$ (since there are 10 classes) randomly picked samples from each class. When increasing $N$ we keep the previously picked samples so the training samples for $N = 1 0 0$ are a subset of the ones for $N = 2 5 0$ . The samples chosen for a given value of $N$ are the same across all models trained using this number of samples. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            275
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Image preprocessing. The only preprocessing applied to the input images is that their values are rescaled from [0, 1] to $[ - 1 , 1 ]$ . ",
+        "bbox": [
+            176,
+            290,
+            823,
+            319
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Optimization. For the training, we use mini-batch of size 50 and use Adam optimizer with the recommended parameters, i.e. λr = 0.001, β1 = 0.9, β2 = 0.999, \u000f = 10−8. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter tuning. For weight decay and SHADE, the optimal regularization weight of each model (for each value of $N$ ) has been chosen to maximize the accuracy on the validation sets. We tried the values $\\{ 1 0 ^ { - i } , i = 1 . . 7 \\}$ . ",
+        "bbox": [
+            176,
+            377,
+            825,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Model architecture. The model have the following architecture: ",
+        "bbox": [
+            173,
+            434,
+            609,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• 2D convolution $6 4 \\times 5 \\times 5$ kernel, padding 2, stride 1) $^ +$ ReLU   \n• MaxPooling $2 \\times 2$   \n• 2D convolution $6 4 \\times 3 \\times 3$ kernel, padding 1, stride 1) $^ +$ ReLU   \n• MaxPooling $2 \\times 2$   \n• 2D convolution $( 6 4 \\times 3 \\times 3$ kernel, padding 1, stride 1) $^ +$ ReLU   \n• MaxPooling $2 \\times 2$   \n• Fully connected (1024 inputs, 10 outputs) $^ +$ SoftMax ",
+        "bbox": [
+            215,
+            462,
+            656,
+            592
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "E EXPERIMENTS DETAILS ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            529,
+            627
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The fine tuning in the experiment section 4.2 has been done with momentum-SGD with a learning rate of $1 0 ^ { - 5 }$ and a momentum of 0.9 and a batch size of 16 images. It took 8 epochs to converge. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            671
+        ],
+        "page_idx": 11
+    }
+]

parse/train/r1GbfhRqF7/r1GbfhRqF7.md

@@ -0,0 +1,390 @@
+# KERNEL CHANGE-POINT DETECTION WITH AUXILIARY DEEP GENERATIVE MODELS
+
+Wei-Cheng Chang, Chun-Liang Li, Yiming Yang & Barnabás Póczos
+
+Carnegie Mellon University   
+Pittsburgh, PA 15213, USA   
+{wchang2,chunlial,yiming,bapoczos}@cs.cmu.edu
+
+# ABSTRACT
+
+Detecting the emergence of abrupt property changes in time series is a challenging problem. Kernel two-sample test has been studied for this task which makes fewer assumptions on the distributions than traditional parametric approaches. However, selecting kernels is non-trivial in practice. Although kernel selection for two-sample test has been studied, the insufficient samples in change point detection problem hinders the success of those developed kernel selection algorithms. In this paper, we propose KL-CPD, a novel kernel learning framework for time series CPD that optimizes a lower bound of test power via an auxiliary generative model. With deep kernel parameterization, KL-CPD endows kernel twosample test with the data-driven kernel to detect different types of change-points in real-world applications. The proposed approach significantly outperformed other state-of-the-art methods in our comparative evaluation of benchmark datasets and simulation studies.
+
+# 1 INTRODUCTION
+
+Detecting changes in the temporal evolution of a system (biological, physical, mechanical, etc.) in time series analysis has attracted considerable attention in machine learning and data mining for decades (Basseville et al., 1993; Brodsky & Darkhovsky, 2013). This task, commonly referred to as change-point detection (CPD) or anomaly detection in the literature, aims to predict significant changing points in a temporal sequence of observations. CPD has a broad range of real-world applications such as medical diagnostics (Gardner et al., 2006), industrial quality control (Basu & Meckesheimer, 2007), financial market analysis (Pepelyshev & Polunchenko, 2015), video anomaly detection (Liu et al., 2018) and more.
+
+As shown in Fig. 1, we focus on the retrospective CPD (Takeuchi & Yamanishi, 2006; Li et al., 2015a), which allows a flexible time window to react on the change-points. Retrospective CPD not only enjoys more robust detection (Chandola et al., 2009) but embraces many applications such as climate change detection (Reeves et al., 2007), genetic sequence analysis (Wang et al., 2011), networks intrusion detection (Yamanishi et al., 2004), to name just a few. Various methods have been developed (Gustafsson & Gustafsson, 2000), and many of them are parametric with strong assumptions on the distributions (Basseville et al., 1993; Gustafsson, 1996), including auto-regressive models (Yamanishi & Takeuchi, 2002) and state-space models (Kawahara et al., 2007) for tracking changes in the mean, the variance, and the spectrum.
+
+![](images/9e80732598fe60a5443e149f21658e12f2dfdf295c236ee59584dd756efb31b1.jpg)  
+Figure 1: A sliding window over the time series input with two intervals: the past and the current, where $w _ { l } , w _ { r }$ are the size of the past and current interval, respectively. $X ^ { ( l ) } , \bar { X } ^ { ( r ) }$ consists of the data in the past and current interval, respectively.
+
+Ideally, the detection algorithm should be free of distributional assumptions to have robust performance as neither true data distributions nor anomaly types are known a priori. Thus the parametric assumptions in many works are unavoidably a limiting factor in practice. As an alternative, nonparametric and kernel approaches are free of distributional assumptions and hence enjoy the advantage to produce more robust performance over a broader class of data distributions.
+
+Kernel two-sample test has been applied to time series CPD with some success. For example, Harchaoui et al. (2009) presented a test statistic based upon the maximum kernel fisher discriminant ratio for hypothesis testing and Li et al. (2015a) proposed a computational efficient test statistic based on maximum mean discrepancy with block sampling techniques. The performance of kernel methods, nevertheless, relies heavily on the choice of kernels. Gretton et al. (2007; 2012a) conducted kernel selection for RBF kernel bandwidths via median heuristic. While this is certainly straightforward, it has no guarantees of optimality regarding to the statistical test power of hypothesis testing. Gretton et al. (2012b) show explicitly optimizing the test power leads to better kernel choice for hypothesis testing under mild conditions. Kernel selection by optimizing the test power, however, is not directly applicable for time series CPD due to insufficient samples, as we discuss in Section 3.
+
+In this paper, we propose KL-CPD, a kernel learning framework for time series CPD. Our main contributions are three folds.
+
+• In Section 3, we first observe the inaptness of existing kernel learning approaches in a simulated example. We then propose to optimize a lower bound of the test power via an auxiliary generative model, which aims at serving as a surrogate of the abnormal events. • In Section 4, we present a deep kernel parametrization of our framework, which endows a data-driven kernel for the kernel two-sample test. KL-CPD induces composition kernels by combining RNNs and RBF kernels that are suitable for the time series applications. • In Section 5, we conduct extensive benchmark evaluation showing the outstanding performance of KL-CPD in real-world CPD applications. With simulation-based analysis in Section 6, in addition, we can see the proposed method not only boosts the kernel power but also evades the performance degradation as data dimensionality of time series increases.
+
+Finally, our experiment code and datasets are available at https://github.com/ OctoberChang/klcpd_code.
+
+# 2 PRELIMINARY
+
+Given a sequence of $d$ -dimensional observations $\{ x _ { 1 } , \ldots , x _ { t } , \ldots \} , x _ { i } \in \mathbb { R } ^ { d }$ , our goal is to detect the existence of a change-point1 such that before the change-point, samples are i.i.d from a distribution $\mathbb { P }$ , while after the change-point, samples are i.i.d from a different distribution $\mathbb { Q }$ . Suppose at current time $t$ and the window size $w$ , denote the past window segment $X ^ { ( l ) } = \{ x _ { t - w } , \ldots , x _ { t - 1 } \}$ and the current window segment $X ^ { ( r ) } = \{ x _ { t } , \dots , x _ { t + w - 1 } \}$ , We compute the maximum mean discrepancy (MMD) between $X ^ { ( l ) }$ and $X ^ { ( r ) }$ , and use it as the plausibility of change-points: The higher the distribution discrepancy, the more likely the point is a change-point.
+
+Notice that there are multiple settings for change point detection (CPD) where samples could be piecewise iid, non-iid autoregressive, and more. It is truly difficult to come up with a generic framework to tackle all these different settings. In this paper, following the previous CPD works (Harchaoui et al., 2009; Kawahara et al., 2007; Matteson & James, 2014; Li et al., 2015a), we stay with the piecewise iid assumption of the time series samples. Extending the current model to other settings is interesting and we leave it for future work.
+
+# 2.1 MMD AND TEST POWER
+
+We review maximum mean discrepancy (MMD) and its use to two-sample test, which are two cornerstones in this work. Let $k$ be the kernel of a reproducing kernel Hilbert space (RKHS) $\mathcal { H } _ { k }$ of functions on a set $\mathcal { X }$ . We assume that $k$ is measurable and bounded, $\textstyle \operatorname* { s u p } _ { x \in { \mathcal { X } } } k ( x , x ) < \infty$ . MMD
+
+is a nonparametric probabilistic distance commonly used in two-sample-test (Gretton et al., 2007; 2012a). Given a kernel $k$ , the MMD distance between two distributions $\mathbb { P }$ and $\mathbb { Q }$ is defined as
+
+$$
+M _ { k } ( \mathbb { P } , \mathbb { Q } ) : = \| \mu _ { \mathbb { P } } - \mu _ { \mathbb { Q } } \| _ { \mathcal { H } _ { k } } ^ { 2 } = \mathbb { E } _ { \mathbb { P } } [ k ( x , x ^ { \prime } ) ] - 2 \mathbb { E } _ { \mathbb { P } , \mathbb { Q } } [ k ( x , y ) ] + \mathbb { E } _ { \mathbb { Q } } [ k ( y , y ^ { \prime } ) ] ,
+$$
+
+where $\mu _ { \mathbb { P } } = \mathbb { E } _ { x \sim \mathbb { P } } [ k ( x , \cdot ) ) ] , \mu _ { \mathbb { Q } } = \mathbb { E } _ { y \sim \mathbb { Q } } [ k ( y , \cdot ) ) ]$ are the kernel mean embedding for $\mathbb { P }$ and $\mathbb { Q }$ , respectively. In practice we use finite samples from distributions to estimate MMD distance. Given $X \bar { = } \{ x _ { 1 } , \ldots , \bar { x _ { m } } \} \sim \mathbb { P }$ and $Y = \{ y _ { 1 } , \dots , y _ { m } \} \sim \mathbb { Q }$ , one unbiased estimator of $M _ { k } ( \mathbb { P } , \mathbb { Q } )$ is
+
+$$
+\hat { M } _ { k } ( X , Y ) : = \frac { 1 } { { \binom { m } { 2 } } } \sum _ { i \neq i ^ { \prime } } k ( x _ { i } , x _ { i ^ { \prime } } ) - \frac { 2 } { m ^ { 2 } } \sum _ { i , j } k ( x _ { i } , y _ { j } ) + \frac { 1 } { { \binom { m } { 2 } } } \sum _ { j \neq j ^ { \prime } } k ( y _ { j } , y _ { j ^ { \prime } } ) .
+$$
+
+which has nearly minimal variance among unbiased estimators (Gretton et al., 2012a, Lemma 6).
+
+For any characteristic kernel $k$ , $M _ { k } ( \mathbb { P } , \mathbb { Q } )$ is non-negative and in particular $M _ { k } ( \mathbb { P } , \mathbb { Q } ) = 0$ iff $\mathbb { P } = \mathbb { Q }$ . However, the estimator $\hat { M } _ { k } ( X , X ^ { \prime } )$ may not be 0 even though $X , X ^ { \prime } \sim \mathbb { P }$ due to finite sample size. Hypothesis test instead offers thorough statistical guarantees of whether two finite sample sets are the same distribution. Following Gretton et al. (2012a), the hypothesis test is defined by the null hypothesis $H _ { 0 } : \mathbb { P } = \mathbb { Q }$ and alternative $H _ { 1 } : \mathbb { P } \neq \mathbb { Q }$ , using test statistic $m \hat { M } _ { k } ( X , Y )$ . For a given allowable false rejection probability $\alpha$ (i.e., false positive rate or Type I error), we choose a test threshold $c _ { \alpha }$ and reject $H _ { 0 }$ if $m \hat { M } _ { k } ( X , Y ) > c _ { \alpha }$ .
+
+We now describe the objective to choose the kernel $k$ for maximizing the test power (Gretton et al., 2012b; Sutherland et al., 2017). First, note that, under the alternative $H _ { 1 } : \mathbb { P } \neq \mathbb { Q }$ , $\hat { M } _ { k }$ is asymptotically normal,
+
+$$
+\frac { \hat { M } _ { k } ( X , Y ) - M _ { k } ( \mathbb { P } , \mathbb { Q } ) } { \sqrt { V _ { m } ( \mathbb { P } , \mathbb { Q } ) } } \overset { \mathcal { D } } { \longrightarrow } { \mathcal { N } } ( 0 , 1 ) ,
+$$
+
+where $V _ { m } ( \mathbb { P } , \mathbb { Q } )$ denotes the asymptotic variance of the $\hat { M } _ { k }$ estimator. The test power is then
+
+$$
+\operatorname* { P r } \Big ( m \hat { M } _ { k } ( X , Y ) > c _ { \alpha } \Big ) \longrightarrow \Phi \Big ( \frac { M _ { k } ( { \mathbb { P } } , \mathbb { Q } ) } { \sqrt { V _ { m } ( { \mathbb { P } } , \mathbb { Q } ) } } - \frac { c _ { \alpha } } { m \sqrt { V _ { m } ( { \mathbb { P } } , \mathbb { Q } ) } } \Big )
+$$
+
+where $\Phi$ is the CDF of the standard normal distribution. Given a set of kernels $\kappa$ , We aim to choose a kernel $k \in \mathcal { K }$ to maximize the test power, which is equivalent to maximizing the argument of $\Phi$ .
+
+# 3 OPTIMIZING TEST POWER FOR CHANGE-POINT DETECTION
+
+In time series CPD, we denote $\mathbb { P }$ as the distribution of usual events and $\mathbb { Q }$ as the distribution for the event when change-points happen. The difficulty of choosing kernels via optimizing test power in Eq. (2) is that we have very limited samples from the abnormal distribution $\mathbb { Q }$ . Kernel learning in this case may easily overfit, leading to sub-optimal performance in time series CPD.
+
+# 3.1 DIFFICULTIES OF OPTIMIZING KERNELS FOR CPD
+
+To demonstrate how limited samples of $\mathbb { Q }$ would affect optimizing test power, we consider kernel selection for Gaussian RBF kernels on the Blobs dataset (Gretton et al., 2012b; Sutherland et al., 2017), which is considered hard for kernel two-sample test. $\mathbb { P }$ is a $5 \times 5$ grid of two-dimensional standard normals, with spacing 15 between the centers. $\mathbb { Q }$ is laid out identically, but with covariance $\frac { \epsilon _ { q } - 1 } { \epsilon _ { q } + 1 }$ between the coordinates (so the ratio of eigenvalues in the variance is $\epsilon _ { q }$ ). Left panel of Fig. 2 shows $X \sim \mathbb { P }$ (red samples), $Y \sim \mathbb { Q }$ (blue dense samples), $\tilde { Y } \sim \mathbb { Q }$ (blue sparse samples) with $\epsilon _ { q } = 6$ . Note that when $\epsilon _ { q } = 1 , \mathbb { P } = \mathbb { Q }$ .
+
+For $\epsilon _ { q } ~ \in ~ \{ 4 , 6 , 8 , 1 0 , 1 2 , 1 4 \}$ , we take 10000 samples for $X , Y$ and 200 samples for $\tilde { Y }$ . We consider two objectives for choosing kernels: 1) median heuristic; 2) max-ratio $\eta _ { k ^ { * } } ( X , Y ) \ =$ $\operatorname { a r g m a x } _ { k } \hat { M } _ { k } ( X , Y ) / \sqrt { V _ { m } ( X , Y ) }$ ; among 20 kernel bandwidths. We repeat this process 1000 times and report the test power under false rejection rate $\alpha = 0 . 0 5$ . As shown in the right panel of Fig. 2, optimizing kernels using limited samples $\tilde { Y }$ significantly decreases the test power compared to $Y$ (blue curve down to the cyan curve). This result not only verifies our claim on the inaptness of existing kernel learning objectives for CPD task, but also stimulates us with the following question, How to optimize kernels with very limited samples from $\mathbb { Q }$ , even none in an extreme?
+
+![](images/642018921dbe598a0a3d2e9eede864af5e9b1457c6d5df005beb9b3be0b25f80.jpg)  
+Figure 2: Left: $5 \times 5$ Gaussian grid, samples from $\mathbb { P }$ , $\mathbb { Q }$ and $\mathbb { G }$ . We discuss two cases of $\mathbb { Q }$ , one of sufficient samples, the other of insufficient samples. Right: Test power of kernel selection versus $\epsilon _ { q }$ . Choosing kernels by $\gamma _ { k ^ { * } } ( X , Z )$ using a surrogate distribution $\mathbb { G }$ is advantageous when we do not have sufficient samples from $\mathbb { Q }$ , which is typically the case in time series CPD task.
+
+# 3.2 A PRACTICAL LOWER BOUND ON OPTIMIZING TEST POWER
+
+We first assume there exist a surrogate distribution $\mathbb { G }$ that we can easily draw samples from $( Z \sim \mathbb { G }$ $| Z | \gg | \tilde { Y } | )$ , and also satisfies the following property:
+
+$$
+M _ { k } ( \mathbb { P } , \mathbb { P } ) < M _ { k } ( \mathbb { P } , \mathbb { G } ) < M _ { k } ( \mathbb { P } , \mathbb { Q } ) , \forall k \in \mathcal { K } ,
+$$
+
+Besides, we assume dealing with non trivial case of $\mathbb { P }$ and $\mathbb { Q }$ where a lower bound $\begin{array} { r } { \frac { 1 } { m } v _ { l } \ \leq } \end{array}$ $V _ { m , k } ( \mathbb { P } , \mathbb { Q } ) , \forall k$ exists. Since $M _ { k } ( \mathbb { P } , \mathbb { Q } )$ is bounded, there exists an upper bound $v _ { u }$ . With bounded variance $\begin{array} { r } { \frac { v _ { i } } { m } \leq V _ { m , k } ( \mathbb { P } , \mathbb { Q } ) \leq \frac { v _ { u } } { m } } \end{array}$ condition, we derive an lower bound $\gamma _ { k * } ( \mathbb { P } , \mathbb { G } )$ of the test power
+
+$$
+\operatorname* { m a x } _ { \in \mathbb { K } } \frac { M _ { k } ( \mathbb { P } , \mathbb { Q } ) } { \sqrt { V _ { m } ( \mathbb { P } , \mathbb { Q } ) } } - \frac { c _ { \alpha } / m } { \sqrt { V _ { m } ( \mathbb { P } , \mathbb { Q } ) } } \geq \operatorname* { m a x } _ { k \in \mathbb { K } } \frac { M _ { k } ( \mathbb { P } , \mathbb { Q } ) } { \sqrt { v _ { u } / m } } - \frac { c _ { \alpha } } { \sqrt { m v _ { l } } } \geq \operatorname* { m a x } _ { k \in \mathbb { K } } \frac { M _ { k } ( \mathbb { P } , \mathbb { G } ) } { \sqrt { v _ { u } / m } } - \frac { c _ { \alpha } } { \sqrt { m v _ { l } } } = \gamma _ { k * } ( \mathbb { P } , \mathbb { Q } )
+$$
+
+Just for now in the blob toy experiment, we artifact this distribution $\mathbb { G }$ by mimicking $\mathbb { Q }$ with the covariance $\epsilon _ { g } = \epsilon _ { q } - 2$ . We defer the discussion on how to find $\mathbb { G }$ in the later subsection 3.3. Choosing kernels via $\gamma _ { k ^ { * } } ( X , Z )$ using surrogate samples $Z \sim \mathbb { G }$ , as represented by the green curve in Fig. 2, substantially boosts the test power compared to $\eta _ { k * } ( X , { \tilde { Y } } )$ with sparse samples $\tilde { Y } \sim \mathbb { Q }$ . This toy example not only suggesets that optimizing kernel with surrogate distribution $\mathbb { G }$ leads to better test power when samples from $\mathbb { Q }$ are insufficient, but also demonstrates that the effectiveness of our kernel selection objective holds without introducing any autoregressive/RNN modeling to control the Type-I error.
+
+Test Threshold Approximation Under $H _ { 0 } : \mathbb { P } = \mathbb { Q }$ , $m \hat { M } _ { k } ( X , Y )$ converges asymptotically to a distribution that depends on the unknown data distribution $\mathbb { P }$ (Gretton et al., 2012a, Theorem 12); we thus cannot evaluate the test threshold $c _ { \alpha }$ in closed form. Common ways of estimating threshold includes the permutation test and a estimated null distribution based on approximating the eigenspectrum of the kernel. Nonetheless, both are still computational demanding in practice. Even with the estimated threshold, it is difficult to optimize $c _ { \alpha }$ because it is a function of $k$ and $\mathbb { P }$ .
+
+For $X , X ^ { \prime } \sim \mathbb { P }$ , we know that $c _ { \alpha }$ is a function of the empirical estimator $\hat { M } _ { k } ( X , X ^ { \prime } )$ that controls the Type I error. Bounding $\hat { M } _ { k } ( X , X ^ { \prime } )$ could be an approximation of bounding $c _ { \alpha }$ . Therefore, we propose the following objective that maximizing a lower bound of test power
+
+$$
+\operatorname * { a r g m a x } _ { k \in \mathcal { K } } M _ { k } ( \mathbb { P } , \mathbb { G } ) - \lambda \hat { M } _ { k } ( X , X ^ { \prime } ) ,
+$$
+
+where $\lambda$ is a hyper-parameter to control the trade-off between Type-I and Type-II errors, as well as absorbing the constants $m , v _ { l } , v _ { u }$ in variance approximation. Note that in experiment, the optimization of Eq. (5) is solved using the unbiased estimator of $M _ { k } ( \mathbb { P } , \mathbb { G } )$ with empirical samples.
+
+# 3.3 SURROGATE DISTRIBUTIONS USING GENERATIVE MODELS
+
+The remaining question is how to construct the surrogate distribution $\mathbb { G }$ without any sample from $\mathbb { Q }$ . Injecting random noise to $\mathbb { P }$ is a simple way to construct $\mathbb { G }$ . While straightforward, it may result in a sub-optimal $\mathbb { G }$ because of sensitivity to the level of injected random noise. As no prior knowledge of $\mathbb { Q }$ , to ensure (3) hold for any possible $\mathbb { Q }$ (e.g. $\mathbb { Q } \neq \mathbb { P }$ but $\mathbb { Q } \approx \mathbb { P }$ ), intuitively, we have to make $\mathbb { G }$ as closed to $\mathbb { P }$ as possible. We propose to learn an auxiliary generative model $\mathbb { G } _ { \theta }$ parameterized by $\theta$ such that
+
+$$
+\hat { M } _ { k } ( X , X ^ { \prime } ) < \operatorname* { m i n } _ { \theta } M _ { k } ( \mathbb { P } , \mathbb { G } _ { \theta } ) < M _ { k } ( \mathbb { P } , \mathbb { Q } ) , \forall k \in \mathcal { K } .
+$$
+
+To ensure the first inequality hold, we set early stopping criterion when solving $\mathbb { G } _ { \theta }$ in practice. Also, if $\mathbb { P }$ is sophisticate, which is common in time series cases, limited capacity of parametrization of $\mathbb { G } _ { \theta }$ with finite size model (e.g. neural networks) (Arora et al., 2017) and finite samples of $\mathbb { P }$ also hinder us to fully recover $\mathbb { P }$ . Therefore, we result in a min-max formulation to consider all possible $k \in \mathcal { K }$ when we learn $\mathbb { G }$ ,
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { k \in \mathcal { K } } \quad M _ { k } ( \mathbb { P } , \mathbb { G } _ { \theta } ) - \lambda \hat { M } _ { k } ( X , X ^ { \prime } ) ,
+$$
+
+and solve the kernel for the hypothesis test in the mean time. In experiment, we use simple alternative (stochastic) gradient descent to solve each other.
+
+Lastly, we remark that although the resulted objective (6) is similar to Li et al. (2017), the motivation and explanation are different. One major difference is we aim to find $k$ with highest test power while their goal is finding $\mathbb { G } _ { \theta }$ to approximate $\mathbb { P }$ . A more detailed discussion can be found in Appendix A.
+
+# 4 KLCPD: REALIZATION FOR TIME SERIES APPLICATIONS
+
+In this section, we present a realization of the kernel learning framework for time series CPD.
+
+Compositional Kernels To have a more expressive kernel for complex time series, we consider compositional kernels $\tilde { k } = k \circ f$ that combines RBF kernels $k$ with injective functions $f _ { \phi }$ :
+
+$$
+K = \left\{ \tilde { k } | \tilde { k } ( x , x ^ { \prime } ) = \exp ( - \| f _ { \phi } ( x ) - f _ { \phi } ( x ) ^ { \prime } \| ^ { 2 } ) \right\} .
+$$
+
+The resulted kernel $\tilde { k }$ is still characteristic if $f$ is an injective function and $k$ is characteristic (Gretton et al., 2012a). This ensures the MMD endowed by $\tilde { k }$ is still a valid probabilistic distance. One example function class is $\{ f _ { \phi } | f _ { \phi } ( x ) = \phi x , \phi > 0 \}$ , equivalent to the kernel bandwidth tuning. Inspired by the recent success of combining deep neural networks into kernels (Wilson et al., 2016; Al-Shedivat et al., 2017; Li et al., 2017), we parameterize the injective functions $f _ { \phi }$ by recurrent neural networks (RNNs) to capture the temporal dynamics of time series.
+
+For an injective function $f$ , there exists a function $F$ such that $F ( f ( x ) ) = x , \forall x \in \mathcal { X }$ , which can be approximated by an auto-encoder via sequence-to-sequence architecture for time series. One practical realization of $f$ would be a RNN encoder parametrized by $\phi$ while the function $F$ is a RNN decoder parametrized by $\psi$ trained to minimize the reconstruction loss. Thus, our final objective is
+
+$$
+\begin{array} { r l } { \underset { \theta } { \mathop { \operatorname* { m i n } } } \underset { \phi } { \mathop { \operatorname* { m a x } } } } & { M _ { f _ { \phi } } \big ( \mathbb { P } , \mathbb { G } _ { \theta } \big ) - \lambda \cdot \hat { M } _ { f _ { \phi } } \big ( X , X ^ { \prime } \big ) - \beta \cdot \mathbb { E } _ { \nu \in \mathbb { P } \cup \mathbb { G } _ { \theta } } \| \nu - F _ { \psi } \big ( f _ { \phi } ( \nu ) \big ) \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Practical Implementation In practice, we consider two consecutive windows in mini-batch to estimate $\hat { M } _ { f _ { \phi } } \left( X , X ^ { \prime } \right)$ in an online fashion for the sake of efficiency. Specifically, the sample $X \sim \mathbb { P }$ is divided into the left window segment $X ^ { ( l ) } = \{ x _ { t - w } , \ldots , x _ { t - 1 } \}$ and the right window segment $X ^ { ( r ) } = \{ x _ { t } , \ldots , x _ { t + w - 1 } \}$ such that $X = \{ X ^ { ( l ) } , X ^ { ( r ) } \}$ . We now reveal implementation details of the auxiliary generative model and the deep kernel.
+
+Generator $g _ { \boldsymbol { \theta } }$ Instead of modeling the explicit density $\mathbb { G } _ { \theta }$ , we model a generator $g _ { \theta }$ where we can draw samples from. The goal of $g _ { \theta }$ is to generate plausibly counterfeit but natural samples based on historical $X \sim \mathbb { P }$ , which is similar to the conditional GANs (Mirza & Osindero, 2014; Isola et al., 2017). We use sequence-to-sequence (Seq2Seq) architectures (Sutskever et al., 2014) where $g _ { \theta _ { e } }$ encodes time series into hidden states, and $g _ { \theta _ { d } }$ decodes it with the distributional autoregressive process to approximate the surrogate sample $Z$ :
+
+$$
+H = g _ { \theta _ { e } } \left( X ^ { ( l ) } , \mathbf { 0 } \right) , \quad \tilde { h } = h _ { t - 1 } + \omega , \quad Z = g _ { \theta _ { d } } \big ( X _ { \gg 1 } ^ { ( r ) } , \tilde { h } \big ) .
+$$
+
+where $\omega \sim \mathbb { P } ( W )$ is a $d _ { h }$ -dimensional random noise sampled from a base distribution $\mathbb { P } ( W )$ (e.g., uniform, Gaussian). $H = [ h _ { t - w } , \dots , h _ { t - 1 } ] \in \mathbb { R } ^ { d _ { h } \times w }$ is a sequence of hidden states of the generator’s encoder. $X _ { \gg 1 } ^ { ( r ) } = \{ \mathbf { 0 } , x _ { t } , x _ { t + 1 } , \ldots , x _ { t + w - 2 } \}$ denotes right shift one unit operator over $X ^ { ( r ) }$ .
+
+Deep Kernel Parametrization We aim to maximize a lower bound of test power via backpropagation on $\phi$ using the deep kernel form $\tilde { k } = k \circ f _ { \phi }$ . On the other hand, we can also view the deep kernel parametrization as an embedding learning on the injective function $f _ { \phi } ( x )$ that can be distinguished by MMD. Similar to the design of generator, the deep kernel is a Seq2Seq framework with one GRU layer of the follow form:
+
+$$
+H _ { \nu } = f _ { \phi } ( \nu ) , \hat { \nu } = F _ { \psi } \big ( H _ { \nu } \big ) .
+$$
+
+where $\nu \sim \mathbb { P } \cup \mathbb { G } _ { \theta }$ are from either the time series data $X$ or the generated sample $Z \sim g _ { \theta } ( \omega | X )$
+
+We present an realization of KL-CPD in Algorithm 1 with the weight-clipping technique. The stopping condition is based on a maximum number of epochs or the detecting power of kernel MMD $\bar { M } _ { f _ { \phi } } ( \mathbb { P } , \mathbb { G } _ { \theta } ) \leq \epsilon$ . This ensure the surrogate $\mathbb { G } _ { \theta }$ is not too close to $\mathbb { P }$ , as motivated in Sec. 3.2.
+
+# Algorithm 1: KL-CPD, our proposed algorithm.
+
+input : $\alpha$ the learning rate, $c$ the clipping parameter, $w$ the window size, $n _ { c }$ the number of iterations of deep kernels training per generator update.   
+while $M _ { k \circ f _ { \phi } } ( \mathbb { P } , \mathbb { G } _ { \theta } ) > \bar { \epsilon }$ do for $t = 1 , \ldots , n _ { c }$ do Sample a minibatch $X _ { t } \sim \mathbb { P }$ , denote $X _ { t } = \{ X _ { t } ^ { ( l ) } , X _ { t } ^ { ( r ) } \}$ , and $\omega \sim \mathbb { P } ( \Omega )$ gradien $\begin{array} { r } { \cdot ( \phi )  \nabla _ { \phi } M _ { k \circ f _ { \phi } } \big ( \mathbb { P } , \mathbb { G } _ { \theta } \big ) - \lambda \hat { M } _ { k \circ f _ { \phi } } \big ( X _ { t } ^ { ( l ) } , X _ { t } ^ { ( r ) } \big ) - \beta \mathbb { E } _ { \nu \sim \mathbb { P } \cup \mathbb { G } _ { \theta } } \| \nu - F _ { \psi } \big ( f _ { \phi } ( \nu ) \big ) \| _ { 2 } ^ { 2 } } \end{array}$ $\phi  \phi + \alpha \cdot \mathrm { R M S P r o p } ( \phi , \mathrm { g r }$ adient $\left( \phi \right)$ ) $\phi  \mathrm { c l i p } ( \phi , - c , c )$ Sample a minibatch $X _ { t ^ { \prime } } \sim \mathbb { P }$ , denote $X _ { t ^ { \prime } } = \{ X _ { t ^ { \prime } } ^ { ( l ) } , X _ { t ^ { \prime } } ^ { ( r ) } \}$ , and $\omega \sim \mathbb { P } ( \Omega )$ gradien $\mathopen : \mathclose \bgroup ( \theta \aftergroup \egroup )  \nabla _ { \theta } M _ { k \circ f _ { \phi } } \mathopen { } \mathclose \bgroup ( \mathbb { P } , \mathbb { G } _ { \theta } \aftergroup \egroup )$ $\theta  \theta - \alpha \cdot \mathrm { A d a m } ( \theta$ , gradient(θ))
+
+# 5 EVALUATION ON REAL-WORLD DATA
+
+The section presents a comparative evaluation of the proposed KL-CPD and seven representative baselines on benchmark datasets from real-world applications of CPD, including the domains of biology, environmental science, human activity sensing, and network traffic loads. The data statistics are summarized in Table 1. We pre-process all dataset by normalizing each dimension in the range of [0, 1]. Detailed descriptions are available in Appendix B.1.
+
+Following Lai et al. (2018); Saatçi et al. (2010); Liu et al. (2013), the datasets are split into the training set $( 6 0 \% )$ , validation set $( 2 0 \% )$ and test set $( 2 0 \% )$ in chronological order. Note that training is fully unsupervised for all methods while labels in the validation set are used for hyperparameters tuning.
+
+For quantitative evaluation, we consider receiver operating characteristic (ROC) curves of
+
+<table><tr><td>Dataset</td><td>T</td><td>#sequences</td><td>domain</td><td>#labels</td></tr><tr><td>Bee-Dance</td><td>826.66</td><td>6</td><td>R3</td><td>19.5</td></tr><tr><td>Fishkiller</td><td>45175</td><td>1</td><td>R+</td><td>899</td></tr><tr><td>HASC</td><td>39397</td><td>1</td><td>R3</td><td>65</td></tr><tr><td>Yahoo</td><td>1432.13</td><td>15</td><td>R+</td><td>36.06</td></tr></table>
+
+Table 1: Dataset. $T$ is length of time series, #labels is average number of labeled change points.
+
+We compare KL-CPD with real-time CPD methods (ARMA, ARGP, RNN,LSTNet) and retrospective CPD methods (ARGP-BOCPD, RDR-KCPD, Mstats-KCPD). Details are in Appendix B.3. Note that OPT-MMD is a deep kernel learning baseline which optimizes MMD by treating past samples as $\mathbb { P }$ and the current window as $\mathbb { Q }$ (insufficient samples).
+
+<table><tr><td>Method</td><td>Bee-Dance</td><td>Fishkiller</td><td>HASC</td><td>Yahoo</td></tr><tr><td>ARMA (Box, 2013)</td><td>0.5368</td><td>0.8794</td><td>0.5863</td><td>0.8615</td></tr><tr><td>ARGP (Candela et al., 2003)</td><td>0.5833</td><td>0.8813</td><td>0.6448</td><td>0.9318</td></tr><tr><td>RNN (Cho et al., 2014)</td><td>0.5827</td><td>0.8872</td><td>0.6128</td><td>0.8508</td></tr><tr><td>LSTNet (Lai et al., 2018)</td><td>0.6168</td><td>0.9127</td><td>0.5077</td><td>0.8863</td></tr><tr><td>ARGP-BOCPD (Saatci et al., 2010)</td><td>0.5089</td><td>0.8333</td><td>0.6421</td><td>0.9130</td></tr><tr><td>RDR-KCPD (Liu et al., 2013)</td><td>0.5197</td><td>0.4942</td><td>0.4217</td><td>0.6029</td></tr><tr><td>Mstats-KCPD (Li et al., 2015a)</td><td>0.5616</td><td>0.6392</td><td>0.5199</td><td>0.6961</td></tr><tr><td>OPT-MMD</td><td>0.5262</td><td>0.7517</td><td>0.6176</td><td>0.8193</td></tr><tr><td>KL-CPD (Proposed method)</td><td>0.6767</td><td>0.9596</td><td>0.6490</td><td>0.9146</td></tr></table>
+
+Table 2: AUC on four real-world datasets. KL-CPD has the best AUC on three out of four datasets.
+
+# 5.1 MAIN RESULTS
+
+In Table 2, the first four rows present the real-time CPD methods, followed by three retrospectiveCPD models, and the last is our proposed method. KL-CPD shows significant improvement over the other methods on all the datasets, except being in a second place on the Yahoo dataset, with $2 \%$ lower AUC compared to the leading ARGP. This confirms the importance of data-driven kernel selection and effectiveness of our kernel learning framework. Notice that OPT-MMD performs not so good compared to KL-CPD, which again verifies our simulated example in Sec. 3 that directly applying existing kernel learning approaches with insufficient samples may not be suitable for realworld CPD task.
+
+Distribution matching approaches like RDR-KCPD and Mstats-KCPD are not as competitive as KL-CPD, and often inferior to real-time CPD methods. One explanation is both RDR-KCPD and Mstats-KCPD measure the distribution distance in the original data space with simple kernel selection using the median heuristic. The change-points may be hard to detect without the latent embedding learned by neural networks. KL-CPD, instead, leverages RNN to extract useful contexts and encodes time series in a discriminative embedding (latent space) on which kernel two-sample test is used to detection changing points. This also explains the inferior performance of MstatsKCPD which uses kernel MMD with a fix RBF kernel. That is, using a fixed kernel to detect versatile types of change points is likely to fail.
+
+Finally, the non-iid temporal structure in real-world applications may raise readers concern that the improvement coming from adopting RNN and controlling type-I error for model selection (kernel selection). Indeed, using RNN parameterized kernels (trained by minimizing reconstruction loss) buys us some gain compared to directly conduct kernel two-sample test on the original time series samples (Figure 3 cyan bar rises to blue bar). Nevertheless, we still have to do model selection to decide the parameters of RNN. In Table 2, we studied a kernel learning baseline, OPT-MMD, that optimizing an RNN parameterized kernel by controlling type-I error without the surrogate distribution. OPT-MMD is inferior to the KL-CPD that introduce the surrogate distribution with an auxiliary generator. On the other hand, from Table 2, we can also observe KL-CPD is better than other RNN alternatives, such as LSTNet. Those performance gaps between KL-CPD, OPT-MMD (regularizing type-I only) and other RNN works indicate the proposed maximizing testing power framework via an auxiliary distribution serves as a good surrogate for kernel (model) selection.
+
+# 5.2 ABLATION TEST ON LEARNING KERNELS WITH DIFFERENT ENCODERS
+
+We further examine how different encoders $f _ { \phi }$ affects KL-CPD. For MMD-dataspace, $f _ { \phi }$ is an identity map, equivalent to kernel selection with median heuristic in data space. For MMDcodespace, $\{ f _ { \phi } , F _ { \psi } \}$ is a Seq2Seq autoencoder minimizing reconstruction loss without optimizing test power. For MMD-negsample, the same objective as KL-CPD except for replacing the auxiliary generator with injecting Gaussian noise to $\mathbb { P }$ .
+
+![](images/ad86845f6eb1bb68bfaa6fd744b51767a466f1171365913288e0cf318d9af55f.jpg)  
+Figure 3: Ablation test of KL-CPD.
+
+![](images/2838262534c71cc0dbfdda64a7ecac8fa56bc1e5cfccb64c4f714206b80b9e7e.jpg)  
+Figure 4: AUC vs. different window size $w _ { r }$ on Bee-Dance.
+
+The results are shown in Figure 3. We first notice the mild improvement of MMD-codespace over MMD-dataspace, showing that using MMD on the induced latent space is effective for discovering beneficial kernels for time series CPD. Next, we see MMD-negsample outperforms MMDcodespace, showing the advantages of injecting a random perturbation to the current interval to approximate $g _ { \theta } \big ( z | X ^ { ( l ) } \big )$ . This also justify the validity of the proposed lower bound approach by optimizing $M _ { k } ( \mathbb { P } , \mathbb { G } )$ , which is effective even if we adopt simple perturbed $\mathbb { P }$ as $\mathbb { G }$ . Finally, KL-CPD models the $\mathbb { G }$ with an auxiliary generator $g _ { \theta }$ to obtain conditional samples that are more complex and subtle than the perturbed samples in MMD-negsample, resulting in even better performance.
+
+In Figure 4, we also demonstrate how the tolerance of delay $w _ { r }$ influences the performance. Due to space limit, results other than Bee-Dance dataset are omitted, given they share similar trends. KL-CPD shows competitive AUC mostly, only slightly decreases when $w _ { r } = 5$ . MMD-dataspace and MMD-codespace, in contrast, AUC degradation is much severe under low tolerance of delay $( w _ { r } = \{ 5 , 1 0 \} )$ ). The conditional generated samples from KL-CPD can be found in Appendix B.5.
+
+# 6 IN-DEPTH ANALYSIS ON SIMULATED DATA
+
+To further explore the performance of KL-CPD with controlled experiments, we follow other time series CPD papers (Takeuchi & Yamanishi, 2006; Liu et al., 2013; Matteson & James, 2014) to create three simulated datasets each with a representative change-point characteristic: jumping mean, scaling variance, and alternating between two mixtures of Gaussian (Gaussian-Mixtures). More description of the generated process see Appendix B.2.
+
+Table 3: AUC on three artificial datasets. Mean and standard deviation under 10 random seeds.   
+
+<table><tr><td>Method</td><td> Jumping-Mean</td><td> Scaling-Variance</td><td>Gaussian-Mixtures</td></tr><tr><td>ARMA</td><td>0.7731 (0.06)</td><td>0.4801 (0.07)</td><td>0.5035 (0.08)</td></tr><tr><td>ARGP</td><td>0.4770 (0.03)</td><td>0.4910 (0.07)</td><td>0.5027 (0.08)</td></tr><tr><td>RNN</td><td>0.5053 (0.03)</td><td>0.5177 (0.08)</td><td>0.5053 (0.08)</td></tr><tr><td>LSTNet</td><td>0.7694 (0.09)</td><td>0.4906 ( 5(0.07)</td><td>0.4985 (0.07)</td></tr><tr><td>ARGP-BOCPD</td><td>0.7983 (0.06)</td><td>0.4767 7(0.08)</td><td>0.5027 (0.08)</td></tr><tr><td>RDR-KCPD</td><td>0.6484 (0.11)</td><td>0.7574 (0.06)</td><td>0.6022 (0.11)</td></tr><tr><td>Mstats-KCPD</td><td>0.7309 (0.05)</td><td>0.7534 (0.04)</td><td>0.6026 (0.08)</td></tr><tr><td>KL-CPD</td><td>0.9454 (0.02)</td><td>0.8823 (0.03)</td><td>0.6782 (0.05)</td></tr></table>
+
+# 6.1 MAIN RESULTS ON SIMULATED DATA
+
+The results are summarized in Table 3. KL-CPD achieves the best in all cases. Interestingly, retrospective-CPD (ARGP-BOCPD, RDR-KCPD, Mstats-KCPD) have better results compared to real-time CPD (ARMA, ARGP, RNN,LSTNet), which is not the case in real-world datasets. This suggests low reconstruction error does not necessarily lead to good CPD accuracies.
+
+As for why Mstats-KCPD does not have comparable performance as KL-CPD, given that both of them use MMD as distribution distance? Notice that Mstats-KCPD assumes the reference time series (training data) follows the same distribution as the current interval. However, if the reference time series is highly non-stationary, it is more accurate to compute the distribution distance between the latest past window and the current window, which is the essence of KL-CPD.
+
+# 6.2 MMD VERSUS DIMENSIONALITY OF DATA
+
+We study how different encoders $f _ { \phi }$ would affect the power of MMD versus the dimensionality of data. We generate an simulated time series dataset by sampling between two multivariate Gaussian $\mathcal { N } ( 0 , \sigma _ { 1 } ^ { 2 } \bar { I _ { d } } )$ and $\mathcal { N } ( 0 , \sigma _ { 2 } ^ { 2 } I _ { d } )$ where the dimension $d \overset { \cdot } { = } \{ 2 , \overset { \cdot } { 4 } , 6 , \overset { - } { \dots } , 2 0 \}$ and $\sigma _ { 1 } = 0 . 7 5$ , $\sigma _ { 2 } = 1 . 2 5$ .
+
+Figure 5 plots the one-dimension data and AUC results. We see that all methods remain equally strong in low dimensions $( d \leq 1 0 )$ ), while MMD-dataspace decreases significantly as data dimensionality increases $( d \geq 1 2 )$ ). An explanation is non-parametric statistical models require the sample size to grow exponentially with the dimensionality of data, which limits the performance of MMDdataspace because of the fixed sample size. On the other hand, MMD-codespace and KL-CPD are conducting kernel two-sample test on a learned low dimension codespace, which moderately alleviates this issue. Also, KL-CPD finds a better kernel (embedding) than MMD-codespace by optimizing the lower bound of the test power.
+
+![](images/7a50de6b16ccba8e151bc990513ef05be35f912cc92dac14fc0770d29be377d8.jpg)  
+Figure 5: MMD with different encoder $f _ { \phi _ { e } }$ versus data dimension, under 10 random seeds.
+
+# 7 CONCLUSION
+
+We propose KL-CPD, a new kernel learning framework for two-sample test by optimizing a lower bound of test power with a auxiliary generator, to resolve the issue of insufficient samples in changepoints detection. The deep kernel parametrization of KL-CPD combines the latent space of RNNs with RBF kernels that effectively detect a variety of change-points from different real-world applications. Extensive evaluation of our new approach along with strong baseline methods on benchmark datasets shows the outstanding performance of the proposed method in retrospective CPD. With simulation analysis in addition we can see that the new method not only boosts the kernel power but also evades the performance degradation as data dimensionality increases.
+
+# 8 ACKOWLEDGEMENT
+
+We thank the reviewers for their helpful comments. This work is supported in part by the National Science Foundation (NSF) under grant IIS-1546329, and by the United States Department of Energy via the Brookhaven National Laboratory under Contract No. 322174.
+
+# REFERENCES
+
+Maruan Al-Shedivat, Andrew Gordon Wilson, Yunus Saatchi, Zhiting Hu, and Eric P Xing. Learning scalable deep kernels with recurrent structure. JMLR, 2017.
+
+Michael Arbel, Dougal J Sutherland, Mikołaj Binkowski, and Arthur Gretton. On gradient regular- ´ izers for mmd gans. In NIPS, 2018.
+
+Sanjeev Arora, Rong Ge, Yingyu Liang, Tengyu Ma, and Yi Zhang. Generalization and equilibrium in generative adversarial nets (gans). In ICML, 2017.
+
+Michèle Basseville, Igor V Nikiforov, et al. Detection of abrupt changes: theory and application. Prentice Hall Englewood Cliffs, 1993.
+
+Sabyasachi Basu and Martin Meckesheimer. Automatic outlier detection for time series: an application to sensor data. Knowledge and Information Systems, 2007.
+
+Mikołaj Binkowski, Dougal J Sutherland, Michael Arbel, and Arthur Gretton. Demystifying mmd ´ gans. In ICLR, 2018.
+
+George Box. Box and jenkins: time series analysis, forecasting and control. A Very British Affair, ser. Palgrave Advanced Texts in Econometrics. Palgrave Macmillan UK, 2013.
+
+E Brodsky and Boris S Darkhovsky. Nonparametric methods in change point problems. Springer Science & Business Media, 2013.
+
+Joaquin Quinonero Candela, Agathe Girard, Jan Larsen, and Carl Edward Rasmussen. Propagation of uncertainty in bayesian kernel models-application to multiple-step ahead forecasting. In ICASSP, 2003.
+
+Varun Chandola, Arindam Banerjee, and Vipin Kumar. Anomaly detection: A survey. ACM computing surveys (CSUR), 2009.
+
+Kyunghyun Cho, Bart van Merrienboer, Çaglar Gülçehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. In EMNLP, 2014.
+
+Gintare Karolina Dziugaite, Daniel M Roy, and Zoubin Ghahramani. Training generative neural networks via maximum mean discrepancy optimization. In UAI, 2015.
+
+Andrew B Gardner, Abba M Krieger, George Vachtsevanos, and Brian Litt. One-class novelty detection for seizure analysis from intracranial eeg. JMLR, 2006.
+
+Arthur Gretton, Karsten M Borgwardt, Malte Rasch, Bernhard Schölkopf, and Alex J Smola. A kernel method for the two-sample-problem. In NIPS, 2007.
+
+Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. JMLR, 2012a.
+
+Arthur Gretton, Dino Sejdinovic, Heiko Strathmann, Sivaraman Balakrishnan, Massimiliano Pontil, Kenji Fukumizu, and Bharath K Sriperumbudur. Optimal kernel choice for large-scale two-sample tests. In NIPS, 2012b.
+
+Fredrik Gustafsson. The marginalized likelihood ratio test for detecting abrupt changes. IEEE Transactions on automatic control, 1996.
+
+Fredrik Gustafsson and Fredrik Gustafsson. Adaptive filtering and change detection. Citeseer, 2000.
+
+Zaid Harchaoui, Eric Moulines, and Francis R Bach. Kernel change-point analysis. In NIPS, 2009.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, 2017.
+
+Yoshinobu Kawahara, Takehisa Yairi, and Kazuo Machida. Change-point detection in time-series data based on subspace identification. In ICDM. IEEE, 2007.
+
+Guokun Lai, Wei-Cheng Chang, Yiming Yang, and Hanxiao Liu. Modeling long-and short-term temporal patterns with deep neural networks. In SIGIR, 2018.
+
+Chun-Liang Li, Wei-Cheng Chang, Yu Cheng, Yiming Yang, and Barnabás Póczos. Mmd gan: Towards deeper understanding of moment matching network. In NIPS, 2017.
+
+Shuang Li, Yao Xie, Hanjun Dai, and Le Song. M-statistic for kernel change-point detection. In NIPS, 2015a.
+
+Yujia Li, Kevin Swersky, and Rich Zemel. Generative moment matching networks. In ICML, 2015b.
+
+Song Liu, Makoto Yamada, Nigel Collier, and Masashi Sugiyama. Change-point detection in timeseries data by relative density-ratio estimation. Neural Networks, 2013.
+
+Yusha Liu, Chun-Liang Li, and Barnabás Póczos. Classifier two-sample test for video anomaly detections. In BMVC, 2018.
+
+David S Matteson and Nicholas A James. A nonparametric approach for multiple change point analysis of multivariate data. Journal of the American Statistical Association, 2014.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.
+
+Youssef Mroueh, Chun-Liang Li, Tom Sercu, Anant Raj, and Yu Cheng. Sobolev gan. In ICLR, 2018.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Andrey Pepelyshev and Aleksey S Polunchenko. Real-time financial surveillance via quickest change-point detection methods. arXiv preprint arXiv:1509.01570, 2015.
+
+Jaxk Reeves, Jien Chen, Xiaolan L Wang, Robert Lund, and Qi Qi Lu. A review and comparison of changepoint detection techniques for climate data. Journal of Applied Meteorology and Climatology, 2007.
+
+Yunus Saatçi, Ryan Turner, and Carl Edward Rasmussen. Gaussian process change point models. In ICML, June 2010.
+
+Dougal J Sutherland, Hsiao-Yu Tung, Heiko Strathmann, Soumyajit De, Aaditya Ramdas, Alex Smola, and Arthur Gretton. Generative models and model criticism via optimized maximum mean discrepancy. In ICLR, 2017.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In NIPS, 2014.
+
+Jun-ichi Takeuchi and Kenji Yamanishi. A unifying framework for detecting outliers and change points from time series. IEEE transactions on Knowledge and Data Engineering, 2006.
+
+Yao Wang, Chunguo Wu, Zhaohua Ji, Binghong Wang, and Yanchun Liang. Non-parametric change-point method for differential gene expression detection. PloS one, 2011.
+
+Andrew Gordon Wilson, Zhiting Hu, Ruslan Salakhutdinov, and Eric P Xing. Deep kernel learning. In AISTATS, 2016.
+
+Zhao Xu, Kristian Kersting, and Lorenzo von Ritter. Stochastic online anomaly analysis for streaming time series. In IJCAI, 2017.
+
+Kenji Yamanishi and Jun-ichi Takeuchi. A unifying framework for detecting outliers and change points from non-stationary time series data. In SIGKDD. ACM, 2002.
+
+Kenji Yamanishi, Jun-Ichi Takeuchi, Graham Williams, and Peter Milne. On-line unsupervised outlier detection using finite mixtures with discounting learning algorithms. Data Mining and Knowledge Discovery, 2004.
+
+# A CONNECTION TO MMD GAN
+
+Although our proposed method KL-CPD has a similar objective function as appeared in MMD GAN (Li et al., 2017), we would like to point out the underlying interpretation and motivations are radically different, as summarized below.
+
+The first difference is the interpretation of inner maximization problem $\operatorname* { m a x } _ { k } M _ { k } ( \mathbb { P } , \mathbb { G } )$ . MMD GANs (Li et al., 2017; Binkowski et al. ´ , 2018) treat whole maximization problem ma $\mathrm { x } _ { k } M _ { k } ( \mathbb { P } , \mathbb { G } )$ as a new probabilistic distance, which can also be viewed as an extension of integral probability metric (IPM). The properties of the distance is also studied in Li et al. (2017); Arbel et al. (2018). A follow-up work (Arbel et al., 2018) by combining Mroueh et al. (2018) push maxk $M _ { k } ( \mathbb { P } , \mathbb { G } )$ further to be a scaled distance with gradient norm. However, the maximization problem (4) of this paper defines the lower bound of the test power, which also takes the variance of the empirical estimate into account, instead of the distance.
+
+Regarding the goals, MMD GAN aims to learn a generative model that approximates the underlying data distribution $\mathbb { P }$ of interests. All the works (Dziugaite et al., 2015; Li et al., 2015b; Sutherland et al., 2017; Li et al., 2017; Binkowski et al. ´ , 2018; Arbel et al., 2018) use MMD or $\mathrm { m a x } _ { k }$ $M _ { k } ( \mathbb { P } , \mathbb { G } )$ to define distance, then try to optimize $\mathbb { G }$ to be as closed to $\mathbb { P }$ as possible. However, that is not the goal of this paper, where $\mathbb { G }$ is just an auxiliary generative model which needs to satisfies Eq. (3). Instead, we aim to find the most powerful $k$ for conducting hypothesis test. In practice, we still optimize $\mathbb { G }$ toward $\mathbb { P }$ because we usually have no prior knowledge (sufficient samples) about $\mathbb { Q }$ , and we want to ensure the lower bound still hold for many possible $\mathbb { Q }$ (e.g. $\mathbb { Q }$ can be also similar to $\mathbb { P }$ ). However, even with this reason, we still adopt early stopping to prevent the auxiliary $\mathbb { G }$ from being exactly the same as $\mathbb { P }$ .
+
+# B DETAILED EXPERIMENT SETTINGS
+
+# B.1 BENCHMARK DATASETS
+
+• Bee-Dance2 records the pixel locations in x and y dimensions and angle differences of bee movements. Ethologists are interested in the three-stages bee waggle dance and aim at identifying the change point from one stage to another, where different stages serve as the communication with other honey bees about the location of pollen and water.
+
+• Fishkiller3 records water level from a dam in Canada. When the dam not functions normally, the water level oscillates quickly in a particular pattern, causing trouble for the fish. The beginning and end of every water oscillation (fish kills) are treated as change points.
+
+• $\mathbf { H A S C ^ { 4 } }$ is a subset of the Human Activity Sensing Consortium (HASC) challenge 2011 dataset, which provides human activity information collected by portable three-axis accelerometers. The task of change point detection is to segment the time series data according to the 6 behaviors: stay, walk, jog, skip, stair up, and stair down.
+
+• Yahoo5 contains time series representing the metrics of various Yahoo services (e.g. CPU utilization, memory, network traffic, etc) with manually labeled anomalies. We select 15 out of 68 representative time series sequences after removing some sequences with duplicate patterns in anomalies.
+
+# B.2 SYNTHETIC DATASETS
+
+• Jumping-Mean: Consider the 1-dimensional auto-regressive model to generate 5000 samples $\bar { y } ( t ) ^ { \top } = 0 . 6 y ( t - 1 ) - 0 . 5 y ( t - 2 ) + \epsilon _ { t }$ , where $\bar { y ( 1 ) } = y ( 2 ) = 0$ , $\bar { \epsilon } _ { t } \sim \mathcal { N } ( \mu , 1 . 5 )$ is a Gaussian noise with mean $\mu$ and standard deviation 1.5. A change point is inserted at every
+
+$1 0 0 + \tau$ time stamps by setting the noise mean $\mu$ at time $t$ as
+
+$$
+\begin{array} { r } { \mu _ { n } = \left\{ \begin{array} { l l } { 0 } & { n = 1 , } \\ { \mu _ { n - 1 } + \frac { n } { 1 6 } } & { n = 2 , . . . , 4 9 , } \end{array} \right. } \end{array}
+$$
+
+where $\tau \sim \mathcal { N } ( 0 , 1 0 )$ and $n$ is a natural number such that $1 0 0 ( n - 1 ) + 1 \leq t \leq 1 0 0 n$
+
+• Scaling-Variance: Same auto-regressive generative model as Jumping-Mean, but a change point is inserted at every $1 0 0 + \tau$ time stamps by setting the noise standard deviation of $\epsilon _ { t }$ at time $t$ as
+
+$$
+\sigma _ { n } = \left\{ \begin{array} { l l } { 1 } & { n = 1 , 3 , \ldots , 4 9 , } \\ { \ln ( e + \frac { n } { 4 } ) } & { n = 2 , 4 , \ldots , 4 8 , } \end{array} \right.
+$$
+
+where $\tau \sim \mathcal { N } ( 0 , 1 0 )$ and $n$ is a natural number such that $1 0 0 ( n - 1 ) + 1 \leq t \leq 1 0 0 n$
+
+• Gaussian-Mixtures: Time series data are sampled alternatively between two mixtures of Gaussian $0 . 5 \mathcal { N } ( - 1 , 0 . 5 ^ { 2 } ) + 0 . 5 \mathcal { N } ( 1 , 0 . 5 ^ { 2 } )$ and $0 . 8 \mathcal { N } ( - 1 , 1 . 0 ^ { 2 } ) + 0 . 2 \mathcal { N } ( 1 , 0 . 1 ^ { 2 } )$ for every 100 time stamps, which is defined as the change points.
+
+# B.3 COMPARING BASELINES
+
+We include the following representative baselines in the literature of time series forecasting and change-point detection for evaluations:
+
+• Autoregressive Moving Average (ARMA) (Box, 2013) is the classic statistical model that predicts the future time series based on an Autoregressive (AR) and a moving average (MA), where AR involves linear regression, while MA models the error term as a linear combination of errors in the past.   
+• Autoregressive Gaussian Process (ARGP) (Candela et al., 2003) is a Gaussian Process for time series forecasting. In an ARGP of order $p$ , $x _ { t - p : t - 1 }$ are taken as the GP input while the output is $x _ { t }$ . ARGP can be viewed as a non-linear version of AR model.   
+• Recurrent Neural Networks (RNN) (Cho et al., 2014) are powerful neural networks for learning non-linear temporal dynamical systems. We consider gated recurrent units (GRU) in our implementation.   
+LSTNet (Lai et al., 2018) is a recent state-of-the-art deep neural network fore time series forecasting. LSTNet combines different architectures including CNN, RNN, residual networks, and highway networks. ARGP-BOCPD (Saatçi et al., 2010) is an extension of the Bayesian online change point detection (BOCPD) which uses ARGP instead of AR in underlying predictive models of BOCPD framework. RDR-KCPD (Liu et al., 2013) considers f-divergence as the dissimilarity measure. The f-divergence is estimated by relative density ratio technique, which involves solving an unconstrained least-squares importance fitting problem.   
+• Mstats-KCPD (Li et al., 2015a) consider kernel maximum mean discrepancy (MMD) on data space as dissimilarity measure. Specifically, It samples $B$ block of segments from the past time series, and computes $B$ times MMD distance between the past block with the current segment and takes the average as the dissimilarity measure.
+
+# B.4 HYPERPARAMETER SETTINGS
+
+For hyper-parameter tuning in ARMA, the time lag $p , q$ are chosen from $\{ 1 , 2 , 3 , 4 , 5 \}$ . For ARGP and ARGP-BOCPD the time lag order $p$ is set to the same as ARMA and the hyperparameter of kernel is learned by maximizing the marginalized likelihood. For RDR-KCPD, the window size $w$ are chosen from $\{ 2 5 , 5 0 \}$ , sub-dim $k = 5$ , $\alpha = \{ 0 . 0 1 , 0 . 1 , 1 \}$ . For Mstats-KCPD and KL-CPD, the window size $w = 2 5$ , and we use RBF kernel with median heuristic setting the kernel bandwidth. The hidden dimension of GRU is $d _ { h } = 1 0$ for MMD-codespace, MMD-negsample and KL-CPD. For KL-CPD, $\lambda$ is chosen from $\{ 0 . 1 , 1 , 1 0 \}$ and $\beta$ is chosen from $\{ 1 0 ^ { - 3 } , 1 \bar { 0 } ^ { - 1 } , \bar { 1 , } 1 0 \}$ .
+
+Our algorithms are implemented in Python (PyTorch Paszke et al. (2017)), and running on Nvidia GeForce GTX 1080 Ti GPUs. Datasets and experiment code are publicly available. For all the baseline methods we used the released source code, include MATLAB code6 for ARMA, ARGP and ARGP-BOCPD, Pytorch code7 for RNN and LSTNet, MATLAB code8 for RDR-KCPD, and MATLAB code 9 for Mstats-KCPD.
+
+# B.5 CONDITIONAL SAMPLES OF KL-CPD
+
+![](images/5713ef65aa28f83a9384f9d298644fa92bee22f83843d02597e84e0f368a99f5.jpg)  
+Figure 6: Conditionally generated samples by KL-CPD and system-predicted CPD scores on BeeDance (Left) and HASC (Right) datasets. In the first three subplots are ground truth signals (blue line), 10 conditional generated samples (green lines) and change points (red vertical line). The last subplot is MMD scores, which peaks around ground truth change points mostly.

parse/train/r1GbfhRqF7/r1GbfhRqF7_content_list.json

@@ -0,0 +1,2001 @@
+[
+    {
+        "type": "text",
+        "text": "KERNEL CHANGE-POINT DETECTION WITH AUXILIARY DEEP GENERATIVE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wei-Cheng Chang, Chun-Liang Li, Yiming Yang & Barnabás Póczos ",
+        "bbox": [
+            186,
+            169,
+            665,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Carnegie Mellon University   \nPittsburgh, PA 15213, USA   \n{wchang2,chunlial,yiming,bapoczos}@cs.cmu.edu ",
+        "bbox": [
+            186,
+            185,
+            629,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Detecting the emergence of abrupt property changes in time series is a challenging problem. Kernel two-sample test has been studied for this task which makes fewer assumptions on the distributions than traditional parametric approaches. However, selecting kernels is non-trivial in practice. Although kernel selection for two-sample test has been studied, the insufficient samples in change point detection problem hinders the success of those developed kernel selection algorithms. In this paper, we propose KL-CPD, a novel kernel learning framework for time series CPD that optimizes a lower bound of test power via an auxiliary generative model. With deep kernel parameterization, KL-CPD endows kernel twosample test with the data-driven kernel to detect different types of change-points in real-world applications. The proposed approach significantly outperformed other state-of-the-art methods in our comparative evaluation of benchmark datasets and simulation studies. ",
+        "bbox": [
+            233,
+            295,
+            764,
+            473
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            336,
+            521
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Detecting changes in the temporal evolution of a system (biological, physical, mechanical, etc.) in time series analysis has attracted considerable attention in machine learning and data mining for decades (Basseville et al., 1993; Brodsky & Darkhovsky, 2013). This task, commonly referred to as change-point detection (CPD) or anomaly detection in the literature, aims to predict significant changing points in a temporal sequence of observations. CPD has a broad range of real-world applications such as medical diagnostics (Gardner et al., 2006), industrial quality control (Basu & Meckesheimer, 2007), financial market analysis (Pepelyshev & Polunchenko, 2015), video anomaly detection (Liu et al., 2018) and more. ",
+        "bbox": [
+            173,
+            537,
+            825,
+            648
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As shown in Fig. 1, we focus on the retrospective CPD (Takeuchi & Yamanishi, 2006; Li et al., 2015a), which allows a flexible time window to react on the change-points. Retrospective CPD not only enjoys more robust detection (Chandola et al., 2009) but embraces many applications such as climate change detection (Reeves et al., 2007), genetic sequence analysis (Wang et al., 2011), networks intrusion detection (Yamanishi et al., 2004), to name just a few. Various methods have been developed (Gustafsson & Gustafsson, 2000), and many of them are parametric with strong assumptions on the distributions (Basseville et al., 1993; Gustafsson, 1996), including auto-regressive models (Yamanishi & Takeuchi, 2002) and state-space models (Kawahara et al., 2007) for tracking changes in the mean, the variance, and the spectrum. ",
+        "bbox": [
+            174,
+            656,
+            516,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e80732598fe60a5443e149f21658e12f2dfdf295c236ee59584dd756efb31b1.jpg",
+        "image_caption": [
+            "Figure 1: A sliding window over the time series input with two intervals: the past and the current, where $w _ { l } , w _ { r }$ are the size of the past and current interval, respectively. $X ^ { ( l ) } , \\bar { X } ^ { ( r ) }$ consists of the data in the past and current interval, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            684,
+            833,
+            782
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ideally, the detection algorithm should be free of distributional assumptions to have robust performance as neither true data distributions nor anomaly types are known a priori. Thus the parametric assumptions in many works are unavoidably a limiting factor in practice. As an alternative, nonparametric and kernel approaches are free of distributional assumptions and hence enjoy the advantage to produce more robust performance over a broader class of data distributions. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Kernel two-sample test has been applied to time series CPD with some success. For example, Harchaoui et al. (2009) presented a test statistic based upon the maximum kernel fisher discriminant ratio for hypothesis testing and Li et al. (2015a) proposed a computational efficient test statistic based on maximum mean discrepancy with block sampling techniques. The performance of kernel methods, nevertheless, relies heavily on the choice of kernels. Gretton et al. (2007; 2012a) conducted kernel selection for RBF kernel bandwidths via median heuristic. While this is certainly straightforward, it has no guarantees of optimality regarding to the statistical test power of hypothesis testing. Gretton et al. (2012b) show explicitly optimizing the test power leads to better kernel choice for hypothesis testing under mild conditions. Kernel selection by optimizing the test power, however, is not directly applicable for time series CPD due to insufficient samples, as we discuss in Section 3. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            290
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose KL-CPD, a kernel learning framework for time series CPD. Our main contributions are three folds. ",
+        "bbox": [
+            174,
+            296,
+            823,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• In Section 3, we first observe the inaptness of existing kernel learning approaches in a simulated example. We then propose to optimize a lower bound of the test power via an auxiliary generative model, which aims at serving as a surrogate of the abnormal events. • In Section 4, we present a deep kernel parametrization of our framework, which endows a data-driven kernel for the kernel two-sample test. KL-CPD induces composition kernels by combining RNNs and RBF kernels that are suitable for the time series applications. • In Section 5, we conduct extensive benchmark evaluation showing the outstanding performance of KL-CPD in real-world CPD applications. With simulation-based analysis in Section 6, in addition, we can see the proposed method not only boosts the kernel power but also evades the performance degradation as data dimensionality of time series increases. ",
+        "bbox": [
+            215,
+            337,
+            825,
+            487
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, our experiment code and datasets are available at https://github.com/ OctoberChang/klcpd_code. ",
+        "bbox": [
+            174,
+            500,
+            821,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            549,
+            323,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a sequence of $d$ -dimensional observations $\\{ x _ { 1 } , \\ldots , x _ { t } , \\ldots \\} , x _ { i } \\in \\mathbb { R } ^ { d }$ , our goal is to detect the existence of a change-point1 such that before the change-point, samples are i.i.d from a distribution $\\mathbb { P }$ , while after the change-point, samples are i.i.d from a different distribution $\\mathbb { Q }$ . Suppose at current time $t$ and the window size $w$ , denote the past window segment $X ^ { ( l ) } = \\{ x _ { t - w } , \\ldots , x _ { t - 1 } \\}$ and the current window segment $X ^ { ( r ) } = \\{ x _ { t } , \\dots , x _ { t + w - 1 } \\}$ , We compute the maximum mean discrepancy (MMD) between $X ^ { ( l ) }$ and $X ^ { ( r ) }$ , and use it as the plausibility of change-points: The higher the distribution discrepancy, the more likely the point is a change-point. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notice that there are multiple settings for change point detection (CPD) where samples could be piecewise iid, non-iid autoregressive, and more. It is truly difficult to come up with a generic framework to tackle all these different settings. In this paper, following the previous CPD works (Harchaoui et al., 2009; Kawahara et al., 2007; Matteson & James, 2014; Li et al., 2015a), we stay with the piecewise iid assumption of the time series samples. Extending the current model to other settings is interesting and we leave it for future work. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MMD AND TEST POWER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            388,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We review maximum mean discrepancy (MMD) and its use to two-sample test, which are two cornerstones in this work. Let $k$ be the kernel of a reproducing kernel Hilbert space (RKHS) $\\mathcal { H } _ { k }$ of functions on a set $\\mathcal { X }$ . We assume that $k$ is measurable and bounded, $\\textstyle \\operatorname* { s u p } _ { x \\in { \\mathcal { X } } } k ( x , x ) < \\infty$ . MMD ",
+        "bbox": [
+            176,
+            818,
+            823,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "is a nonparametric probabilistic distance commonly used in two-sample-test (Gretton et al., 2007; 2012a). Given a kernel $k$ , the MMD distance between two distributions $\\mathbb { P }$ and $\\mathbb { Q }$ is defined as ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af1937009631788a67ea09af151286a442786e8f33d0eac0a74ead0c8259fc3a.jpg",
+        "text": "$$\nM _ { k } ( \\mathbb { P } , \\mathbb { Q } ) : = \\| \\mu _ { \\mathbb { P } } - \\mu _ { \\mathbb { Q } } \\| _ { \\mathcal { H } _ { k } } ^ { 2 } = \\mathbb { E } _ { \\mathbb { P } } [ k ( x , x ^ { \\prime } ) ] - 2 \\mathbb { E } _ { \\mathbb { P } , \\mathbb { Q } } [ k ( x , y ) ] + \\mathbb { E } _ { \\mathbb { Q } } [ k ( y , y ^ { \\prime } ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            133,
+            751,
+            154
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mu _ { \\mathbb { P } } = \\mathbb { E } _ { x \\sim \\mathbb { P } } [ k ( x , \\cdot ) ) ] , \\mu _ { \\mathbb { Q } } = \\mathbb { E } _ { y \\sim \\mathbb { Q } } [ k ( y , \\cdot ) ) ]$ are the kernel mean embedding for $\\mathbb { P }$ and $\\mathbb { Q }$ , respectively. In practice we use finite samples from distributions to estimate MMD distance. Given $X \\bar { = } \\{ x _ { 1 } , \\ldots , \\bar { x _ { m } } \\} \\sim \\mathbb { P }$ and $Y = \\{ y _ { 1 } , \\dots , y _ { m } \\} \\sim \\mathbb { Q }$ , one unbiased estimator of $M _ { k } ( \\mathbb { P } , \\mathbb { Q } )$ is ",
+        "bbox": [
+            173,
+            156,
+            825,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5e433c2cb203830ed6104087186a8972bb31827df45ebb9a64c36760a451755.jpg",
+        "text": "$$\n\\hat { M } _ { k } ( X , Y ) : = \\frac { 1 } { { \\binom { m } { 2 } } } \\sum _ { i \\neq i ^ { \\prime } } k ( x _ { i } , x _ { i ^ { \\prime } } ) - \\frac { 2 } { m ^ { 2 } } \\sum _ { i , j } k ( x _ { i } , y _ { j } ) + \\frac { 1 } { { \\binom { m } { 2 } } } \\sum _ { j \\neq j ^ { \\prime } } k ( y _ { j } , y _ { j ^ { \\prime } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            203,
+            750,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which has nearly minimal variance among unbiased estimators (Gretton et al., 2012a, Lemma 6). ",
+        "bbox": [
+            174,
+            244,
+            805,
+            260
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For any characteristic kernel $k$ , $M _ { k } ( \\mathbb { P } , \\mathbb { Q } )$ is non-negative and in particular $M _ { k } ( \\mathbb { P } , \\mathbb { Q } ) = 0$ iff $\\mathbb { P } = \\mathbb { Q }$ . However, the estimator $\\hat { M } _ { k } ( X , X ^ { \\prime } )$ may not be 0 even though $X , X ^ { \\prime } \\sim \\mathbb { P }$ due to finite sample size. Hypothesis test instead offers thorough statistical guarantees of whether two finite sample sets are the same distribution. Following Gretton et al. (2012a), the hypothesis test is defined by the null hypothesis $H _ { 0 } : \\mathbb { P } = \\mathbb { Q }$ and alternative $H _ { 1 } : \\mathbb { P } \\neq \\mathbb { Q }$ , using test statistic $m \\hat { M } _ { k } ( X , Y )$ . For a given allowable false rejection probability $\\alpha$ (i.e., false positive rate or Type I error), we choose a test threshold $c _ { \\alpha }$ and reject $H _ { 0 }$ if $m \\hat { M } _ { k } ( X , Y ) > c _ { \\alpha }$ . ",
+        "bbox": [
+            173,
+            265,
+            825,
+            371
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now describe the objective to choose the kernel $k$ for maximizing the test power (Gretton et al., 2012b; Sutherland et al., 2017). First, note that, under the alternative $H _ { 1 } : \\mathbb { P } \\neq \\mathbb { Q }$ , $\\hat { M } _ { k }$ is asymptotically normal, ",
+        "bbox": [
+            173,
+            376,
+            825,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2bcd7d3c4bb2ec7633425222f50070da2c767b222243000c0121a18718c84c4b.jpg",
+        "text": "$$\n\\frac { \\hat { M } _ { k } ( X , Y ) - M _ { k } ( \\mathbb { P } , \\mathbb { Q } ) } { \\sqrt { V _ { m } ( \\mathbb { P } , \\mathbb { Q } ) } } \\overset { \\mathcal { D } } { \\longrightarrow } { \\mathcal { N } } ( 0 , 1 ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            417,
+            624,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $V _ { m } ( \\mathbb { P } , \\mathbb { Q } )$ denotes the asymptotic variance of the $\\hat { M } _ { k }$ estimator. The test power is then ",
+        "bbox": [
+            169,
+            460,
+            782,
+            476
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f341c8ad3f12a832f0c1cefd66bf912b0d797f619489359c17489d2282d8a6b.jpg",
+        "text": "$$\n\\operatorname* { P r } \\Big ( m \\hat { M } _ { k } ( X , Y ) > c _ { \\alpha } \\Big ) \\longrightarrow \\Phi \\Big ( \\frac { M _ { k } ( { \\mathbb { P } } , \\mathbb { Q } ) } { \\sqrt { V _ { m } ( { \\mathbb { P } } , \\mathbb { Q } ) } } - \\frac { c _ { \\alpha } } { m \\sqrt { V _ { m } ( { \\mathbb { P } } , \\mathbb { Q } ) } } \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            478,
+            717,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\Phi$ is the CDF of the standard normal distribution. Given a set of kernels $\\kappa$ , We aim to choose a kernel $k \\in \\mathcal { K }$ to maximize the test power, which is equivalent to maximizing the argument of $\\Phi$ . ",
+        "bbox": [
+            173,
+            518,
+            825,
+            547
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 OPTIMIZING TEST POWER FOR CHANGE-POINT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            565,
+            705,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In time series CPD, we denote $\\mathbb { P }$ as the distribution of usual events and $\\mathbb { Q }$ as the distribution for the event when change-points happen. The difficulty of choosing kernels via optimizing test power in Eq. (2) is that we have very limited samples from the abnormal distribution $\\mathbb { Q }$ . Kernel learning in this case may easily overfit, leading to sub-optimal performance in time series CPD. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DIFFICULTIES OF OPTIMIZING KERNELS FOR CPD ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            667,
+            563,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate how limited samples of $\\mathbb { Q }$ would affect optimizing test power, we consider kernel selection for Gaussian RBF kernels on the Blobs dataset (Gretton et al., 2012b; Sutherland et al., 2017), which is considered hard for kernel two-sample test. $\\mathbb { P }$ is a $5 \\times 5$ grid of two-dimensional standard normals, with spacing 15 between the centers. $\\mathbb { Q }$ is laid out identically, but with covariance $\\frac { \\epsilon _ { q } - 1 } { \\epsilon _ { q } + 1 }$ between the coordinates (so the ratio of eigenvalues in the variance is $\\epsilon _ { q }$ ). Left panel of Fig. 2 shows $X \\sim \\mathbb { P }$ (red samples), $Y \\sim \\mathbb { Q }$ (blue dense samples), $\\tilde { Y } \\sim \\mathbb { Q }$ (blue sparse samples) with $\\epsilon _ { q } = 6$ . Note that when $\\epsilon _ { q } = 1 , \\mathbb { P } = \\mathbb { Q }$ . ",
+        "bbox": [
+            173,
+            694,
+            825,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For $\\epsilon _ { q } ~ \\in ~ \\{ 4 , 6 , 8 , 1 0 , 1 2 , 1 4 \\}$ , we take 10000 samples for $X , Y$ and 200 samples for $\\tilde { Y }$ . We consider two objectives for choosing kernels: 1) median heuristic; 2) max-ratio $\\eta _ { k ^ { * } } ( X , Y ) \\ =$ $\\operatorname { a r g m a x } _ { k } \\hat { M } _ { k } ( X , Y ) / \\sqrt { V _ { m } ( X , Y ) }$ ; among 20 kernel bandwidths. We repeat this process 1000 times and report the test power under false rejection rate $\\alpha = 0 . 0 5$ . As shown in the right panel of Fig. 2, optimizing kernels using limited samples $\\tilde { Y }$ significantly decreases the test power compared to $Y$ (blue curve down to the cyan curve). This result not only verifies our claim on the inaptness of existing kernel learning objectives for CPD task, but also stimulates us with the following question, How to optimize kernels with very limited samples from $\\mathbb { Q }$ , even none in an extreme? ",
+        "bbox": [
+            173,
+            808,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/642018921dbe598a0a3d2e9eede864af5e9b1457c6d5df005beb9b3be0b25f80.jpg",
+        "image_caption": [
+            "Figure 2: Left: $5 \\times 5$ Gaussian grid, samples from $\\mathbb { P }$ , $\\mathbb { Q }$ and $\\mathbb { G }$ . We discuss two cases of $\\mathbb { Q }$ , one of sufficient samples, the other of insufficient samples. Right: Test power of kernel selection versus $\\epsilon _ { q }$ . Choosing kernels by $\\gamma _ { k ^ { * } } ( X , Z )$ using a surrogate distribution $\\mathbb { G }$ is advantageous when we do not have sufficient samples from $\\mathbb { Q }$ , which is typically the case in time series CPD task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            823,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 A PRACTICAL LOWER BOUND ON OPTIMIZING TEST POWER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            385,
+            635,
+            400
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first assume there exist a surrogate distribution $\\mathbb { G }$ that we can easily draw samples from $( Z \\sim \\mathbb { G }$ $| Z | \\gg | \\tilde { Y } | )$ , and also satisfies the following property: ",
+        "bbox": [
+            176,
+            410,
+            823,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0abca8284d095a425d1b9bc004885bf5d4217cc4f51ceb443ffd357b7866c184.jpg",
+        "text": "$$\nM _ { k } ( \\mathbb { P } , \\mathbb { P } ) < M _ { k } ( \\mathbb { P } , \\mathbb { G } ) < M _ { k } ( \\mathbb { P } , \\mathbb { Q } ) , \\forall k \\in \\mathcal { K } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            445,
+            650,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Besides, we assume dealing with non trivial case of $\\mathbb { P }$ and $\\mathbb { Q }$ where a lower bound $\\begin{array} { r } { \\frac { 1 } { m } v _ { l } \\ \\leq } \\end{array}$ $V _ { m , k } ( \\mathbb { P } , \\mathbb { Q } ) , \\forall k$ exists. Since $M _ { k } ( \\mathbb { P } , \\mathbb { Q } )$ is bounded, there exists an upper bound $v _ { u }$ . With bounded variance $\\begin{array} { r } { \\frac { v _ { i } } { m } \\leq V _ { m , k } ( \\mathbb { P } , \\mathbb { Q } ) \\leq \\frac { v _ { u } } { m } } \\end{array}$ condition, we derive an lower bound $\\gamma _ { k * } ( \\mathbb { P } , \\mathbb { G } )$ of the test power ",
+        "bbox": [
+            173,
+            467,
+            826,
+            512
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b79a11fcb7a818adf1d76e2c56f46d743c8e43eb2f950393eb15d8d86e25ccc6.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\in \\mathbb { K } } \\frac { M _ { k } ( \\mathbb { P } , \\mathbb { Q } ) } { \\sqrt { V _ { m } ( \\mathbb { P } , \\mathbb { Q } ) } } - \\frac { c _ { \\alpha } / m } { \\sqrt { V _ { m } ( \\mathbb { P } , \\mathbb { Q } ) } } \\geq \\operatorname* { m a x } _ { k \\in \\mathbb { K } } \\frac { M _ { k } ( \\mathbb { P } , \\mathbb { Q } ) } { \\sqrt { v _ { u } / m } } - \\frac { c _ { \\alpha } } { \\sqrt { m v _ { l } } } \\geq \\operatorname* { m a x } _ { k \\in \\mathbb { K } } \\frac { M _ { k } ( \\mathbb { P } , \\mathbb { G } ) } { \\sqrt { v _ { u } / m } } - \\frac { c _ { \\alpha } } { \\sqrt { m v _ { l } } } = \\gamma _ { k * } ( \\mathbb { P } , \\mathbb { Q } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            516,
+            839,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Just for now in the blob toy experiment, we artifact this distribution $\\mathbb { G }$ by mimicking $\\mathbb { Q }$ with the covariance $\\epsilon _ { g } = \\epsilon _ { q } - 2$ . We defer the discussion on how to find $\\mathbb { G }$ in the later subsection 3.3. Choosing kernels via $\\gamma _ { k ^ { * } } ( X , Z )$ using surrogate samples $Z \\sim \\mathbb { G }$ , as represented by the green curve in Fig. 2, substantially boosts the test power compared to $\\eta _ { k * } ( X , { \\tilde { Y } } )$ with sparse samples $\\tilde { Y } \\sim \\mathbb { Q }$ . This toy example not only suggesets that optimizing kernel with surrogate distribution $\\mathbb { G }$ leads to better test power when samples from $\\mathbb { Q }$ are insufficient, but also demonstrates that the effectiveness of our kernel selection objective holds without introducing any autoregressive/RNN modeling to control the Type-I error. ",
+        "bbox": [
+            173,
+            578,
+            826,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Test Threshold Approximation Under $H _ { 0 } : \\mathbb { P } = \\mathbb { Q }$ , $m \\hat { M } _ { k } ( X , Y )$ converges asymptotically to a distribution that depends on the unknown data distribution $\\mathbb { P }$ (Gretton et al., 2012a, Theorem 12); we thus cannot evaluate the test threshold $c _ { \\alpha }$ in closed form. Common ways of estimating threshold includes the permutation test and a estimated null distribution based on approximating the eigenspectrum of the kernel. Nonetheless, both are still computational demanding in practice. Even with the estimated threshold, it is difficult to optimize $c _ { \\alpha }$ because it is a function of $k$ and $\\mathbb { P }$ . ",
+        "bbox": [
+            173,
+            707,
+            825,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For $X , X ^ { \\prime } \\sim \\mathbb { P }$ , we know that $c _ { \\alpha }$ is a function of the empirical estimator $\\hat { M } _ { k } ( X , X ^ { \\prime } )$ that controls the Type I error. Bounding $\\hat { M } _ { k } ( X , X ^ { \\prime } )$ could be an approximation of bounding $c _ { \\alpha }$ . Therefore, we propose the following objective that maximizing a lower bound of test power ",
+        "bbox": [
+            173,
+            799,
+            825,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b728462ff372804de9df1cbdc1870be1f4c24d188274e5c8eb6900e7fdb7ce6.jpg",
+        "text": "$$\n\\operatorname * { a r g m a x } _ { k \\in \\mathcal { K } } M _ { k } ( \\mathbb { P } , \\mathbb { G } ) - \\lambda \\hat { M } _ { k } ( X , X ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            849,
+            617,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a hyper-parameter to control the trade-off between Type-I and Type-II errors, as well as absorbing the constants $m , v _ { l } , v _ { u }$ in variance approximation. Note that in experiment, the optimization of Eq. (5) is solved using the unbiased estimator of $M _ { k } ( \\mathbb { P } , \\mathbb { G } )$ with empirical samples. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 SURROGATE DISTRIBUTIONS USING GENERATIVE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            625,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The remaining question is how to construct the surrogate distribution $\\mathbb { G }$ without any sample from $\\mathbb { Q }$ . Injecting random noise to $\\mathbb { P }$ is a simple way to construct $\\mathbb { G }$ . While straightforward, it may result in a sub-optimal $\\mathbb { G }$ because of sensitivity to the level of injected random noise. As no prior knowledge of $\\mathbb { Q }$ , to ensure (3) hold for any possible $\\mathbb { Q }$ (e.g. $\\mathbb { Q } \\neq \\mathbb { P }$ but $\\mathbb { Q } \\approx \\mathbb { P }$ ), intuitively, we have to make $\\mathbb { G }$ as closed to $\\mathbb { P }$ as possible. We propose to learn an auxiliary generative model $\\mathbb { G } _ { \\theta }$ parameterized by $\\theta$ such that ",
+        "bbox": [
+            173,
+            128,
+            825,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aec89c4d3bd024f30e6062a8e9bd6a14f2fdf7ff931fc4f719754401c74a250d.jpg",
+        "text": "$$\n\\hat { M } _ { k } ( X , X ^ { \\prime } ) < \\operatorname* { m i n } _ { \\theta } M _ { k } ( \\mathbb { P } , \\mathbb { G } _ { \\theta } ) < M _ { k } ( \\mathbb { P } , \\mathbb { Q } ) , \\forall k \\in \\mathcal { K } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            210,
+            676,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To ensure the first inequality hold, we set early stopping criterion when solving $\\mathbb { G } _ { \\theta }$ in practice. Also, if $\\mathbb { P }$ is sophisticate, which is common in time series cases, limited capacity of parametrization of $\\mathbb { G } _ { \\theta }$ with finite size model (e.g. neural networks) (Arora et al., 2017) and finite samples of $\\mathbb { P }$ also hinder us to fully recover $\\mathbb { P }$ . Therefore, we result in a min-max formulation to consider all possible $k \\in \\mathcal { K }$ when we learn $\\mathbb { G }$ , ",
+        "bbox": [
+            173,
+            239,
+            825,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9306c2914f5eefb9275dd4e44dfa91cf70e744a8f451819ec4ce4116cb30d989.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\operatorname* { m a x } _ { k \\in \\mathcal { K } } \\quad M _ { k } ( \\mathbb { P } , \\mathbb { G } _ { \\theta } ) - \\lambda \\hat { M } _ { k } ( X , X ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            309,
+            633,
+            334
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and solve the kernel for the hypothesis test in the mean time. In experiment, we use simple alternative (stochastic) gradient descent to solve each other. ",
+        "bbox": [
+            168,
+            339,
+            823,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we remark that although the resulted objective (6) is similar to Li et al. (2017), the motivation and explanation are different. One major difference is we aim to find $k$ with highest test power while their goal is finding $\\mathbb { G } _ { \\theta }$ to approximate $\\mathbb { P }$ . A more detailed discussion can be found in Appendix A. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 KLCPD: REALIZATION FOR TIME SERIES APPLICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            684,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present a realization of the kernel learning framework for time series CPD. ",
+        "bbox": [
+            173,
+            469,
+            784,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Compositional Kernels To have a more expressive kernel for complex time series, we consider compositional kernels $\\tilde { k } = k \\circ f$ that combines RBF kernels $k$ with injective functions $f _ { \\phi }$ : ",
+        "bbox": [
+            174,
+            500,
+            828,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da0792c0619b383d6e8b73cc9acb552e4f8cee1ce47cffa5ec829fbfb741b4b6.jpg",
+        "text": "$$\nK = \\left\\{ \\tilde { k } | \\tilde { k } ( x , x ^ { \\prime } ) = \\exp ( - \\| f _ { \\phi } ( x ) - f _ { \\phi } ( x ) ^ { \\prime } \\| ^ { 2 } ) \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            540,
+            669,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The resulted kernel $\\tilde { k }$ is still characteristic if $f$ is an injective function and $k$ is characteristic (Gretton et al., 2012a). This ensures the MMD endowed by $\\tilde { k }$ is still a valid probabilistic distance. One example function class is $\\{ f _ { \\phi } | f _ { \\phi } ( x ) = \\phi x , \\phi > 0 \\}$ , equivalent to the kernel bandwidth tuning. Inspired by the recent success of combining deep neural networks into kernels (Wilson et al., 2016; Al-Shedivat et al., 2017; Li et al., 2017), we parameterize the injective functions $f _ { \\phi }$ by recurrent neural networks (RNNs) to capture the temporal dynamics of time series. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For an injective function $f$ , there exists a function $F$ such that $F ( f ( x ) ) = x , \\forall x \\in \\mathcal { X }$ , which can be approximated by an auto-encoder via sequence-to-sequence architecture for time series. One practical realization of $f$ would be a RNN encoder parametrized by $\\phi$ while the function $F$ is a RNN decoder parametrized by $\\psi$ trained to minimize the reconstruction loss. Thus, our final objective is ",
+        "bbox": [
+            173,
+            669,
+            823,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c57ed5259d80e98010d31ee3ba1abf5be0f360145f605daa1d570f12edf7c86.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\theta } { \\mathop { \\operatorname* { m i n } } } \\underset { \\phi } { \\mathop { \\operatorname* { m a x } } } } & { M _ { f _ { \\phi } } \\big ( \\mathbb { P } , \\mathbb { G } _ { \\theta } \\big ) - \\lambda \\cdot \\hat { M } _ { f _ { \\phi } } \\big ( X , X ^ { \\prime } \\big ) - \\beta \\cdot \\mathbb { E } _ { \\nu \\in \\mathbb { P } \\cup \\mathbb { G } _ { \\theta } } \\| \\nu - F _ { \\psi } \\big ( f _ { \\phi } ( \\nu ) \\big ) \\| _ { 2 } ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            732,
+            761,
+            760
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Practical Implementation In practice, we consider two consecutive windows in mini-batch to estimate $\\hat { M } _ { f _ { \\phi } } \\left( X , X ^ { \\prime } \\right)$ in an online fashion for the sake of efficiency. Specifically, the sample $X \\sim \\mathbb { P }$ is divided into the left window segment $X ^ { ( l ) } = \\{ x _ { t - w } , \\ldots , x _ { t - 1 } \\}$ and the right window segment $X ^ { ( r ) } = \\{ x _ { t } , \\ldots , x _ { t + w - 1 } \\}$ such that $X = \\{ X ^ { ( l ) } , X ^ { ( r ) } \\}$ . We now reveal implementation details of the auxiliary generative model and the deep kernel. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Generator $g _ { \\boldsymbol { \\theta } }$ Instead of modeling the explicit density $\\mathbb { G } _ { \\theta }$ , we model a generator $g _ { \\theta }$ where we can draw samples from. The goal of $g _ { \\theta }$ is to generate plausibly counterfeit but natural samples based on historical $X \\sim \\mathbb { P }$ , which is similar to the conditional GANs (Mirza & Osindero, 2014; Isola et al., 2017). We use sequence-to-sequence (Seq2Seq) architectures (Sutskever et al., 2014) where $g _ { \\theta _ { e } }$ encodes time series into hidden states, and $g _ { \\theta _ { d } }$ decodes it with the distributional autoregressive process to approximate the surrogate sample $Z$ : ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/10d626a3d3b46e32e84b51dd04079adcc88cfdc62a97c708cf2afbef36f05d67.jpg",
+        "text": "$$\nH = g _ { \\theta _ { e } } \\left( X ^ { ( l ) } , \\mathbf { 0 } \\right) , \\quad \\tilde { h } = h _ { t - 1 } + \\omega , \\quad Z = g _ { \\theta _ { d } } \\big ( X _ { \\gg 1 } ^ { ( r ) } , \\tilde { h } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            140,
+            692,
+            161
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\omega \\sim \\mathbb { P } ( W )$ is a $d _ { h }$ -dimensional random noise sampled from a base distribution $\\mathbb { P } ( W )$ (e.g., uniform, Gaussian). $H = [ h _ { t - w } , \\dots , h _ { t - 1 } ] \\in \\mathbb { R } ^ { d _ { h } \\times w }$ is a sequence of hidden states of the generator’s encoder. $X _ { \\gg 1 } ^ { ( r ) } = \\{ \\mathbf { 0 } , x _ { t } , x _ { t + 1 } , \\ldots , x _ { t + w - 2 } \\}$ denotes right shift one unit operator over $X ^ { ( r ) }$ . ",
+        "bbox": [
+            174,
+            170,
+            825,
+            219
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Deep Kernel Parametrization We aim to maximize a lower bound of test power via backpropagation on $\\phi$ using the deep kernel form $\\tilde { k } = k \\circ f _ { \\phi }$ . On the other hand, we can also view the deep kernel parametrization as an embedding learning on the injective function $f _ { \\phi } ( x )$ that can be distinguished by MMD. Similar to the design of generator, the deep kernel is a Seq2Seq framework with one GRU layer of the follow form: ",
+        "bbox": [
+            173,
+            233,
+            825,
+            305
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3375869eb497f72a6ecd977c5eb77c9c8aed854f166cf10801b48160a44c7f89.jpg",
+        "text": "$$\nH _ { \\nu } = f _ { \\phi } ( \\nu ) , \\hat { \\nu } = F _ { \\psi } \\big ( H _ { \\nu } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            311,
+            596,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\nu \\sim \\mathbb { P } \\cup \\mathbb { G } _ { \\theta }$ are from either the time series data $X$ or the generated sample $Z \\sim g _ { \\theta } ( \\omega | X )$ ",
+        "bbox": [
+            174,
+            339,
+            805,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We present an realization of KL-CPD in Algorithm 1 with the weight-clipping technique. The stopping condition is based on a maximum number of epochs or the detecting power of kernel MMD $\\bar { M } _ { f _ { \\phi } } ( \\mathbb { P } , \\mathbb { G } _ { \\theta } ) \\leq \\epsilon$ . This ensure the surrogate $\\mathbb { G } _ { \\theta }$ is not too close to $\\mathbb { P }$ , as motivated in Sec. 3.2. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: KL-CPD, our proposed algorithm. ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            425,
+            496,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "input : $\\alpha$ the learning rate, $c$ the clipping parameter, $w$ the window size, $n _ { c }$ the number of iterations of deep kernels training per generator update.   \nwhile $M _ { k \\circ f _ { \\phi } } ( \\mathbb { P } , \\mathbb { G } _ { \\theta } ) > \\bar { \\epsilon }$ do for $t = 1 , \\ldots , n _ { c }$ do Sample a minibatch $X _ { t } \\sim \\mathbb { P }$ , denote $X _ { t } = \\{ X _ { t } ^ { ( l ) } , X _ { t } ^ { ( r ) } \\}$ , and $\\omega \\sim \\mathbb { P } ( \\Omega )$ gradien $\\begin{array} { r } { \\cdot ( \\phi )  \\nabla _ { \\phi } M _ { k \\circ f _ { \\phi } } \\big ( \\mathbb { P } , \\mathbb { G } _ { \\theta } \\big ) - \\lambda \\hat { M } _ { k \\circ f _ { \\phi } } \\big ( X _ { t } ^ { ( l ) } , X _ { t } ^ { ( r ) } \\big ) - \\beta \\mathbb { E } _ { \\nu \\sim \\mathbb { P } \\cup \\mathbb { G } _ { \\theta } } \\| \\nu - F _ { \\psi } \\big ( f _ { \\phi } ( \\nu ) \\big ) \\| _ { 2 } ^ { 2 } } \\end{array}$ $\\phi  \\phi + \\alpha \\cdot \\mathrm { R M S P r o p } ( \\phi , \\mathrm { g r }$ adient $\\left( \\phi \\right)$ ) $\\phi  \\mathrm { c l i p } ( \\phi , - c , c )$ Sample a minibatch $X _ { t ^ { \\prime } } \\sim \\mathbb { P }$ , denote $X _ { t ^ { \\prime } } = \\{ X _ { t ^ { \\prime } } ^ { ( l ) } , X _ { t ^ { \\prime } } ^ { ( r ) } \\}$ , and $\\omega \\sim \\mathbb { P } ( \\Omega )$ gradien $\\mathopen : \\mathclose \\bgroup ( \\theta \\aftergroup \\egroup )  \\nabla _ { \\theta } M _ { k \\circ f _ { \\phi } } \\mathopen { } \\mathclose \\bgroup ( \\mathbb { P } , \\mathbb { G } _ { \\theta } \\aftergroup \\egroup )$ $\\theta  \\theta - \\alpha \\cdot \\mathrm { A d a m } ( \\theta$ , gradient(θ)) ",
+        "bbox": [
+            174,
+            443,
+            825,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EVALUATION ON REAL-WORLD DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            517,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The section presents a comparative evaluation of the proposed KL-CPD and seven representative baselines on benchmark datasets from real-world applications of CPD, including the domains of biology, environmental science, human activity sensing, and network traffic loads. The data statistics are summarized in Table 1. We pre-process all dataset by normalizing each dimension in the range of [0, 1]. Detailed descriptions are available in Appendix B.1. ",
+        "bbox": [
+            173,
+            688,
+            825,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following Lai et al. (2018); Saatçi et al. (2010); Liu et al. (2013), the datasets are split into the training set $( 6 0 \\% )$ , validation set $( 2 0 \\% )$ and test set $( 2 0 \\% )$ in chronological order. Note that training is fully unsupervised for all methods while labels in the validation set are used for hyperparameters tuning. ",
+        "bbox": [
+            174,
+            765,
+            483,
+            862
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For quantitative evaluation, we consider receiver operating characteristic (ROC) curves of ",
+        "bbox": [
+            173,
+            868,
+            485,
+            896
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/fdad07b64537002346fe8a7b0e89aaea3e2fa923d93ebc8b3b02b7b355645f4f.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Dataset. $T$ is length of time series, #labels is average number of labeled change points. "
+        ],
+        "table_body": "<table><tr><td>Dataset</td><td>T</td><td>#sequences</td><td>domain</td><td>#labels</td></tr><tr><td>Bee-Dance</td><td>826.66</td><td>6</td><td>R3</td><td>19.5</td></tr><tr><td>Fishkiller</td><td>45175</td><td>1</td><td>R+</td><td>899</td></tr><tr><td>HASC</td><td>39397</td><td>1</td><td>R3</td><td>65</td></tr><tr><td>Yahoo</td><td>1432.13</td><td>15</td><td>R+</td><td>36.06</td></tr></table>",
+        "bbox": [
+            496,
+            781,
+            821,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare KL-CPD with real-time CPD methods (ARMA, ARGP, RNN,LSTNet) and retrospective CPD methods (ARGP-BOCPD, RDR-KCPD, Mstats-KCPD). Details are in Appendix B.3. Note that OPT-MMD is a deep kernel learning baseline which optimizes MMD by treating past samples as $\\mathbb { P }$ and the current window as $\\mathbb { Q }$ (insufficient samples). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/60e580b39ff796af3134e7958c776217ca7d4a86c335c345cbd831f0bad84bab.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: AUC on four real-world datasets. KL-CPD has the best AUC on three out of four datasets. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>Bee-Dance</td><td>Fishkiller</td><td>HASC</td><td>Yahoo</td></tr><tr><td>ARMA (Box, 2013)</td><td>0.5368</td><td>0.8794</td><td>0.5863</td><td>0.8615</td></tr><tr><td>ARGP (Candela et al., 2003)</td><td>0.5833</td><td>0.8813</td><td>0.6448</td><td>0.9318</td></tr><tr><td>RNN (Cho et al., 2014)</td><td>0.5827</td><td>0.8872</td><td>0.6128</td><td>0.8508</td></tr><tr><td>LSTNet (Lai et al., 2018)</td><td>0.6168</td><td>0.9127</td><td>0.5077</td><td>0.8863</td></tr><tr><td>ARGP-BOCPD (Saatci et al., 2010)</td><td>0.5089</td><td>0.8333</td><td>0.6421</td><td>0.9130</td></tr><tr><td>RDR-KCPD (Liu et al., 2013)</td><td>0.5197</td><td>0.4942</td><td>0.4217</td><td>0.6029</td></tr><tr><td>Mstats-KCPD (Li et al., 2015a)</td><td>0.5616</td><td>0.6392</td><td>0.5199</td><td>0.6961</td></tr><tr><td>OPT-MMD</td><td>0.5262</td><td>0.7517</td><td>0.6176</td><td>0.8193</td></tr><tr><td>KL-CPD (Proposed method)</td><td>0.6767</td><td>0.9596</td><td>0.6490</td><td>0.9146</td></tr></table>",
+        "bbox": [
+            204,
+            172,
+            790,
+            338
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 MAIN RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            323,
+            386
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Table 2, the first four rows present the real-time CPD methods, followed by three retrospectiveCPD models, and the last is our proposed method. KL-CPD shows significant improvement over the other methods on all the datasets, except being in a second place on the Yahoo dataset, with $2 \\%$ lower AUC compared to the leading ARGP. This confirms the importance of data-driven kernel selection and effectiveness of our kernel learning framework. Notice that OPT-MMD performs not so good compared to KL-CPD, which again verifies our simulated example in Sec. 3 that directly applying existing kernel learning approaches with insufficient samples may not be suitable for realworld CPD task. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Distribution matching approaches like RDR-KCPD and Mstats-KCPD are not as competitive as KL-CPD, and often inferior to real-time CPD methods. One explanation is both RDR-KCPD and Mstats-KCPD measure the distribution distance in the original data space with simple kernel selection using the median heuristic. The change-points may be hard to detect without the latent embedding learned by neural networks. KL-CPD, instead, leverages RNN to extract useful contexts and encodes time series in a discriminative embedding (latent space) on which kernel two-sample test is used to detection changing points. This also explains the inferior performance of MstatsKCPD which uses kernel MMD with a fix RBF kernel. That is, using a fixed kernel to detect versatile types of change points is likely to fail. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, the non-iid temporal structure in real-world applications may raise readers concern that the improvement coming from adopting RNN and controlling type-I error for model selection (kernel selection). Indeed, using RNN parameterized kernels (trained by minimizing reconstruction loss) buys us some gain compared to directly conduct kernel two-sample test on the original time series samples (Figure 3 cyan bar rises to blue bar). Nevertheless, we still have to do model selection to decide the parameters of RNN. In Table 2, we studied a kernel learning baseline, OPT-MMD, that optimizing an RNN parameterized kernel by controlling type-I error without the surrogate distribution. OPT-MMD is inferior to the KL-CPD that introduce the surrogate distribution with an auxiliary generator. On the other hand, from Table 2, we can also observe KL-CPD is better than other RNN alternatives, such as LSTNet. Those performance gaps between KL-CPD, OPT-MMD (regularizing type-I only) and other RNN works indicate the proposed maximizing testing power framework via an auxiliary distribution serves as a good surrogate for kernel (model) selection. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ABLATION TEST ON LEARNING KERNELS WITH DIFFERENT ENCODERS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            709,
+            843
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We further examine how different encoders $f _ { \\phi }$ affects KL-CPD. For MMD-dataspace, $f _ { \\phi }$ is an identity map, equivalent to kernel selection with median heuristic in data space. For MMDcodespace, $\\{ f _ { \\phi } , F _ { \\psi } \\}$ is a Seq2Seq autoencoder minimizing reconstruction loss without optimizing test power. For MMD-negsample, the same objective as KL-CPD except for replacing the auxiliary generator with injecting Gaussian noise to $\\mathbb { P }$ . ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad86845f6eb1bb68bfaa6fd744b51767a466f1171365913288e0cf318d9af55f.jpg",
+        "image_caption": [
+            "Figure 3: Ablation test of KL-CPD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            107,
+            465,
+            252
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2838262534c71cc0dbfdda64a7ecac8fa56bc1e5cfccb64c4f714206b80b9e7e.jpg",
+        "image_caption": [
+            "Figure 4: AUC vs. different window size $w _ { r }$ on Bee-Dance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            102,
+            820,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Figure 3. We first notice the mild improvement of MMD-codespace over MMD-dataspace, showing that using MMD on the induced latent space is effective for discovering beneficial kernels for time series CPD. Next, we see MMD-negsample outperforms MMDcodespace, showing the advantages of injecting a random perturbation to the current interval to approximate $g _ { \\theta } \\big ( z | X ^ { ( l ) } \\big )$ . This also justify the validity of the proposed lower bound approach by optimizing $M _ { k } ( \\mathbb { P } , \\mathbb { G } )$ , which is effective even if we adopt simple perturbed $\\mathbb { P }$ as $\\mathbb { G }$ . Finally, KL-CPD models the $\\mathbb { G }$ with an auxiliary generator $g _ { \\theta }$ to obtain conditional samples that are more complex and subtle than the perturbed samples in MMD-negsample, resulting in even better performance. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, we also demonstrate how the tolerance of delay $w _ { r }$ influences the performance. Due to space limit, results other than Bee-Dance dataset are omitted, given they share similar trends. KL-CPD shows competitive AUC mostly, only slightly decreases when $w _ { r } = 5$ . MMD-dataspace and MMD-codespace, in contrast, AUC degradation is much severe under low tolerance of delay $( w _ { r } = \\{ 5 , 1 0 \\} )$ ). The conditional generated samples from KL-CPD can be found in Appendix B.5. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 IN-DEPTH ANALYSIS ON SIMULATED DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            563,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further explore the performance of KL-CPD with controlled experiments, we follow other time series CPD papers (Takeuchi & Yamanishi, 2006; Liu et al., 2013; Matteson & James, 2014) to create three simulated datasets each with a representative change-point characteristic: jumping mean, scaling variance, and alternating between two mixtures of Gaussian (Gaussian-Mixtures). More description of the generated process see Appendix B.2. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f2986f23e81cf01f74c97b51f650ef6b13c89be3866f7e303f6a4b7621751d32.jpg",
+        "table_caption": [
+            "Table 3: AUC on three artificial datasets. Mean and standard deviation under 10 random seeds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td> Jumping-Mean</td><td> Scaling-Variance</td><td>Gaussian-Mixtures</td></tr><tr><td>ARMA</td><td>0.7731 (0.06)</td><td>0.4801 (0.07)</td><td>0.5035 (0.08)</td></tr><tr><td>ARGP</td><td>0.4770 (0.03)</td><td>0.4910 (0.07)</td><td>0.5027 (0.08)</td></tr><tr><td>RNN</td><td>0.5053 (0.03)</td><td>0.5177 (0.08)</td><td>0.5053 (0.08)</td></tr><tr><td>LSTNet</td><td>0.7694 (0.09)</td><td>0.4906 ( 5(0.07)</td><td>0.4985 (0.07)</td></tr><tr><td>ARGP-BOCPD</td><td>0.7983 (0.06)</td><td>0.4767 7(0.08)</td><td>0.5027 (0.08)</td></tr><tr><td>RDR-KCPD</td><td>0.6484 (0.11)</td><td>0.7574 (0.06)</td><td>0.6022 (0.11)</td></tr><tr><td>Mstats-KCPD</td><td>0.7309 (0.05)</td><td>0.7534 (0.04)</td><td>0.6026 (0.08)</td></tr><tr><td>KL-CPD</td><td>0.9454 (0.02)</td><td>0.8823 (0.03)</td><td>0.6782 (0.05)</td></tr></table>",
+        "bbox": [
+            220,
+            637,
+            779,
+            790
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 MAIN RESULTS ON SIMULATED DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            475,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are summarized in Table 3. KL-CPD achieves the best in all cases. Interestingly, retrospective-CPD (ARGP-BOCPD, RDR-KCPD, Mstats-KCPD) have better results compared to real-time CPD (ARMA, ARGP, RNN,LSTNet), which is not the case in real-world datasets. This suggests low reconstruction error does not necessarily lead to good CPD accuracies. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As for why Mstats-KCPD does not have comparable performance as KL-CPD, given that both of them use MMD as distribution distance? Notice that Mstats-KCPD assumes the reference time series (training data) follows the same distribution as the current interval. However, if the reference time series is highly non-stationary, it is more accurate to compute the distribution distance between the latest past window and the current window, which is the essence of KL-CPD. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 MMD VERSUS DIMENSIONALITY OF DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            189,
+            511,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We study how different encoders $f _ { \\phi }$ would affect the power of MMD versus the dimensionality of data. We generate an simulated time series dataset by sampling between two multivariate Gaussian $\\mathcal { N } ( 0 , \\sigma _ { 1 } ^ { 2 } \\bar { I _ { d } } )$ and $\\mathcal { N } ( 0 , \\sigma _ { 2 } ^ { 2 } I _ { d } )$ where the dimension $d \\overset { \\cdot } { = } \\{ 2 , \\overset { \\cdot } { 4 } , 6 , \\overset { - } { \\dots } , 2 0 \\}$ and $\\sigma _ { 1 } = 0 . 7 5$ , $\\sigma _ { 2 } = 1 . 2 5$ . ",
+        "bbox": [
+            176,
+            215,
+            825,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 plots the one-dimension data and AUC results. We see that all methods remain equally strong in low dimensions $( d \\leq 1 0 )$ ), while MMD-dataspace decreases significantly as data dimensionality increases $( d \\geq 1 2 )$ ). An explanation is non-parametric statistical models require the sample size to grow exponentially with the dimensionality of data, which limits the performance of MMDdataspace because of the fixed sample size. On the other hand, MMD-codespace and KL-CPD are conducting kernel two-sample test on a learned low dimension codespace, which moderately alleviates this issue. Also, KL-CPD finds a better kernel (embedding) than MMD-codespace by optimizing the lower bound of the test power. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a50de6b16ccba8e151bc990513ef05be35f912cc92dac14fc0770d29be377d8.jpg",
+        "image_caption": [
+            "Figure 5: MMD with different encoder $f _ { \\phi _ { e } }$ versus data dimension, under 10 random seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            386,
+            808,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            318,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose KL-CPD, a new kernel learning framework for two-sample test by optimizing a lower bound of test power with a auxiliary generator, to resolve the issue of insufficient samples in changepoints detection. The deep kernel parametrization of KL-CPD combines the latent space of RNNs with RBF kernels that effectively detect a variety of change-points from different real-world applications. Extensive evaluation of our new approach along with strong baseline methods on benchmark datasets shows the outstanding performance of the proposed method in retrospective CPD. With simulation analysis in addition we can see that the new method not only boosts the kernel power but also evades the performance degradation as data dimensionality increases. ",
+        "bbox": [
+            173,
+            578,
+            825,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 ACKOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            375,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank the reviewers for their helpful comments. This work is supported in part by the National Science Foundation (NSF) under grant IIS-1546329, and by the United States Department of Energy via the Brookhaven National Laboratory under Contract No. 322174. ",
+        "bbox": [
+            174,
+            739,
+            823,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            287,
+            816
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Maruan Al-Shedivat, Andrew Gordon Wilson, Yunus Saatchi, Zhiting Hu, and Eric P Xing. Learning scalable deep kernels with recurrent structure. JMLR, 2017. ",
+        "bbox": [
+            173,
+            824,
+            825,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Arbel, Dougal J Sutherland, Mikołaj Binkowski, and Arthur Gretton. On gradient regular- ´ izers for mmd gans. In NIPS, 2018. ",
+        "bbox": [
+            173,
+            859,
+            821,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Rong Ge, Yingyu Liang, Tengyu Ma, and Yi Zhang. Generalization and equilibrium in generative adversarial nets (gans). In ICML, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michèle Basseville, Igor V Nikiforov, et al. Detection of abrupt changes: theory and application. Prentice Hall Englewood Cliffs, 1993. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sabyasachi Basu and Martin Meckesheimer. Automatic outlier detection for time series: an application to sensor data. Knowledge and Information Systems, 2007. ",
+        "bbox": [
+            171,
+            141,
+            821,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mikołaj Binkowski, Dougal J Sutherland, Michael Arbel, and Arthur Gretton. Demystifying mmd ´ gans. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Box. Box and jenkins: time series analysis, forecasting and control. A Very British Affair, ser. Palgrave Advanced Texts in Econometrics. Palgrave Macmillan UK, 2013. ",
+        "bbox": [
+            173,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "E Brodsky and Boris S Darkhovsky. Nonparametric methods in change point problems. Springer Science & Business Media, 2013. ",
+        "bbox": [
+            174,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joaquin Quinonero Candela, Agathe Girard, Jan Larsen, and Carl Edward Rasmussen. Propagation of uncertainty in bayesian kernel models-application to multiple-step ahead forecasting. In ICASSP, 2003. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            334
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Varun Chandola, Arindam Banerjee, and Vipin Kumar. Anomaly detection: A survey. ACM computing surveys (CSUR), 2009. ",
+        "bbox": [
+            171,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart van Merrienboer, Çaglar Gülçehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. In EMNLP, 2014. ",
+        "bbox": [
+            174,
+            381,
+            823,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gintare Karolina Dziugaite, Daniel M Roy, and Zoubin Ghahramani. Training generative neural networks via maximum mean discrepancy optimization. In UAI, 2015. ",
+        "bbox": [
+            173,
+            431,
+            821,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew B Gardner, Abba M Krieger, George Vachtsevanos, and Brian Litt. One-class novelty detection for seizure analysis from intracranial eeg. JMLR, 2006. ",
+        "bbox": [
+            171,
+            469,
+            821,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arthur Gretton, Karsten M Borgwardt, Malte Rasch, Bernhard Schölkopf, and Alex J Smola. A kernel method for the two-sample-problem. In NIPS, 2007. ",
+        "bbox": [
+            173,
+            507,
+            821,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. JMLR, 2012a. ",
+        "bbox": [
+            174,
+            545,
+            821,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arthur Gretton, Dino Sejdinovic, Heiko Strathmann, Sivaraman Balakrishnan, Massimiliano Pontil, Kenji Fukumizu, and Bharath K Sriperumbudur. Optimal kernel choice for large-scale two-sample tests. In NIPS, 2012b. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fredrik Gustafsson. The marginalized likelihood ratio test for detecting abrupt changes. IEEE Transactions on automatic control, 1996. ",
+        "bbox": [
+            174,
+            633,
+            821,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fredrik Gustafsson and Fredrik Gustafsson. Adaptive filtering and change detection. Citeseer, 2000. ",
+        "bbox": [
+            171,
+            671,
+            821,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zaid Harchaoui, Eric Moulines, and Francis R Bach. Kernel change-point analysis. In NIPS, 2009. ",
+        "bbox": [
+            173,
+            695,
+            820,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            719,
+            823,
+            750
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshinobu Kawahara, Takehisa Yairi, and Kazuo Machida. Change-point detection in time-series data based on subspace identification. In ICDM. IEEE, 2007. ",
+        "bbox": [
+            174,
+            757,
+            823,
+            787
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guokun Lai, Wei-Cheng Chang, Yiming Yang, and Hanxiao Liu. Modeling long-and short-term temporal patterns with deep neural networks. In SIGIR, 2018. ",
+        "bbox": [
+            174,
+            796,
+            823,
+            825
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chun-Liang Li, Wei-Cheng Chang, Yu Cheng, Yiming Yang, and Barnabás Póczos. Mmd gan: Towards deeper understanding of moment matching network. In NIPS, 2017. ",
+        "bbox": [
+            174,
+            833,
+            821,
+            863
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuang Li, Yao Xie, Hanjun Dai, and Le Song. M-statistic for kernel change-point detection. In NIPS, 2015a. ",
+        "bbox": [
+            174,
+            871,
+            821,
+            900
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Kevin Swersky, and Rich Zemel. Generative moment matching networks. In ICML, 2015b. ",
+        "bbox": [
+            174,
+            909,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Liu, Makoto Yamada, Nigel Collier, and Masashi Sugiyama. Change-point detection in timeseries data by relative density-ratio estimation. Neural Networks, 2013. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yusha Liu, Chun-Liang Li, and Barnabás Póczos. Classifier two-sample test for video anomaly detections. In BMVC, 2018. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David S Matteson and Nicholas A James. A nonparametric approach for multiple change point analysis of multivariate data. Journal of the American Statistical Association, 2014. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014. ",
+        "bbox": [
+            173,
+            215,
+            823,
+            244
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Youssef Mroueh, Chun-Liang Li, Tom Sercu, Anant Raj, and Yu Cheng. Sobolev gan. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            252,
+            825,
+            282
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017. ",
+        "bbox": [
+            174,
+            290,
+            823,
+            333
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrey Pepelyshev and Aleksey S Polunchenko. Real-time financial surveillance via quickest change-point detection methods. arXiv preprint arXiv:1509.01570, 2015. ",
+        "bbox": [
+            171,
+            342,
+            823,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jaxk Reeves, Jien Chen, Xiaolan L Wang, Robert Lund, and Qi Qi Lu. A review and comparison of changepoint detection techniques for climate data. Journal of Applied Meteorology and Climatology, 2007. ",
+        "bbox": [
+            174,
+            378,
+            821,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunus Saatçi, Ryan Turner, and Carl Edward Rasmussen. Gaussian process change point models. In ICML, June 2010. ",
+        "bbox": [
+            171,
+            430,
+            823,
+            459
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dougal J Sutherland, Hsiao-Yu Tung, Heiko Strathmann, Soumyajit De, Aaditya Ramdas, Alex Smola, and Arthur Gretton. Generative models and model criticism via optimized maximum mean discrepancy. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            467,
+            821,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In NIPS, 2014. ",
+        "bbox": [
+            174,
+            518,
+            820,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun-ichi Takeuchi and Kenji Yamanishi. A unifying framework for detecting outliers and change points from time series. IEEE transactions on Knowledge and Data Engineering, 2006. ",
+        "bbox": [
+            173,
+            556,
+            820,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yao Wang, Chunguo Wu, Zhaohua Ji, Binghong Wang, and Yanchun Liang. Non-parametric change-point method for differential gene expression detection. PloS one, 2011. ",
+        "bbox": [
+            174,
+            593,
+            820,
+            623
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Gordon Wilson, Zhiting Hu, Ruslan Salakhutdinov, and Eric P Xing. Deep kernel learning. In AISTATS, 2016. ",
+        "bbox": [
+            173,
+            631,
+            821,
+            660
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhao Xu, Kristian Kersting, and Lorenzo von Ritter. Stochastic online anomaly analysis for streaming time series. In IJCAI, 2017. ",
+        "bbox": [
+            171,
+            667,
+            823,
+            698
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenji Yamanishi and Jun-ichi Takeuchi. A unifying framework for detecting outliers and change points from non-stationary time series data. In SIGKDD. ACM, 2002. ",
+        "bbox": [
+            171,
+            707,
+            823,
+            736
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenji Yamanishi, Jun-Ichi Takeuchi, Graham Williams, and Peter Milne. On-line unsupervised outlier detection using finite mixtures with discounting learning algorithms. Data Mining and Knowledge Discovery, 2004. ",
+        "bbox": [
+            174,
+            743,
+            826,
+            786
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A CONNECTION TO MMD GAN ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            457,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Although our proposed method KL-CPD has a similar objective function as appeared in MMD GAN (Li et al., 2017), we would like to point out the underlying interpretation and motivations are radically different, as summarized below. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            178
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The first difference is the interpretation of inner maximization problem $\\operatorname* { m a x } _ { k } M _ { k } ( \\mathbb { P } , \\mathbb { G } )$ . MMD GANs (Li et al., 2017; Binkowski et al. ´ , 2018) treat whole maximization problem ma $\\mathrm { x } _ { k } M _ { k } ( \\mathbb { P } , \\mathbb { G } )$ as a new probabilistic distance, which can also be viewed as an extension of integral probability metric (IPM). The properties of the distance is also studied in Li et al. (2017); Arbel et al. (2018). A follow-up work (Arbel et al., 2018) by combining Mroueh et al. (2018) push maxk $M _ { k } ( \\mathbb { P } , \\mathbb { G } )$ further to be a scaled distance with gradient norm. However, the maximization problem (4) of this paper defines the lower bound of the test power, which also takes the variance of the empirical estimate into account, instead of the distance. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Regarding the goals, MMD GAN aims to learn a generative model that approximates the underlying data distribution $\\mathbb { P }$ of interests. All the works (Dziugaite et al., 2015; Li et al., 2015b; Sutherland et al., 2017; Li et al., 2017; Binkowski et al. ´ , 2018; Arbel et al., 2018) use MMD or $\\mathrm { m a x } _ { k }$ $M _ { k } ( \\mathbb { P } , \\mathbb { G } )$ to define distance, then try to optimize $\\mathbb { G }$ to be as closed to $\\mathbb { P }$ as possible. However, that is not the goal of this paper, where $\\mathbb { G }$ is just an auxiliary generative model which needs to satisfies Eq. (3). Instead, we aim to find the most powerful $k$ for conducting hypothesis test. In practice, we still optimize $\\mathbb { G }$ toward $\\mathbb { P }$ because we usually have no prior knowledge (sufficient samples) about $\\mathbb { Q }$ , and we want to ensure the lower bound still hold for many possible $\\mathbb { Q }$ (e.g. $\\mathbb { Q }$ can be also similar to $\\mathbb { P }$ ). However, even with this reason, we still adopt early stopping to prevent the auxiliary $\\mathbb { G }$ from being exactly the same as $\\mathbb { P }$ . ",
+        "bbox": [
+            174,
+            301,
+            825,
+            439
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B DETAILED EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            500,
+            479
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 BENCHMARK DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            498,
+            387,
+            512
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Bee-Dance2 records the pixel locations in x and y dimensions and angle differences of bee movements. Ethologists are interested in the three-stages bee waggle dance and aim at identifying the change point from one stage to another, where different stages serve as the communication with other honey bees about the location of pollen and water. ",
+        "bbox": [
+            217,
+            526,
+            823,
+            582
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Fishkiller3 records water level from a dam in Canada. When the dam not functions normally, the water level oscillates quickly in a particular pattern, causing trouble for the fish. The beginning and end of every water oscillation (fish kills) are treated as change points. ",
+        "bbox": [
+            217,
+            590,
+            821,
+            631
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• $\\mathbf { H A S C ^ { 4 } }$ is a subset of the Human Activity Sensing Consortium (HASC) challenge 2011 dataset, which provides human activity information collected by portable three-axis accelerometers. The task of change point detection is to segment the time series data according to the 6 behaviors: stay, walk, jog, skip, stair up, and stair down. ",
+        "bbox": [
+            217,
+            640,
+            823,
+            695
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Yahoo5 contains time series representing the metrics of various Yahoo services (e.g. CPU utilization, memory, network traffic, etc) with manually labeled anomalies. We select 15 out of 68 representative time series sequences after removing some sequences with duplicate patterns in anomalies. ",
+        "bbox": [
+            217,
+            704,
+            823,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 SYNTHETIC DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            375,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Jumping-Mean: Consider the 1-dimensional auto-regressive model to generate 5000 samples $\\bar { y } ( t ) ^ { \\top } = 0 . 6 y ( t - 1 ) - 0 . 5 y ( t - 2 ) + \\epsilon _ { t }$ , where $\\bar { y ( 1 ) } = y ( 2 ) = 0$ , $\\bar { \\epsilon } _ { t } \\sim \\mathcal { N } ( \\mu , 1 . 5 )$ is a Gaussian noise with mean $\\mu$ and standard deviation 1.5. A change point is inserted at every ",
+        "bbox": [
+            215,
+            809,
+            821,
+            851
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$1 0 0 + \\tau$ time stamps by setting the noise mean $\\mu$ at time $t$ as ",
+        "bbox": [
+            232,
+            103,
+            632,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/783905d475ac2ab66f353cc0f44071b771b6e867570155e805945bb2b9c4a404.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mu _ { n } = \\left\\{ \\begin{array} { l l } { 0 } & { n = 1 , } \\\\ { \\mu _ { n - 1 } + \\frac { n } { 1 6 } } & { n = 2 , . . . , 4 9 , } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            126,
+            648,
+            162
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau \\sim \\mathcal { N } ( 0 , 1 0 )$ and $n$ is a natural number such that $1 0 0 ( n - 1 ) + 1 \\leq t \\leq 1 0 0 n$ ",
+        "bbox": [
+            225,
+            170,
+            795,
+            186
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Scaling-Variance: Same auto-regressive generative model as Jumping-Mean, but a change point is inserted at every $1 0 0 + \\tau$ time stamps by setting the noise standard deviation of $\\epsilon _ { t }$ at time $t$ as ",
+        "bbox": [
+            217,
+            190,
+            823,
+            233
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bcf5d04f027b654b99ce6b9a96770a6087b7c0d3a3e1f9c7b2c0b8a09d0b510.jpg",
+        "text": "$$\n\\sigma _ { n } = \\left\\{ \\begin{array} { l l } { 1 } & { n = 1 , 3 , \\ldots , 4 9 , } \\\\ { \\ln ( e + \\frac { n } { 4 } ) } & { n = 2 , 4 , \\ldots , 4 8 , } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            241,
+            651,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau \\sim \\mathcal { N } ( 0 , 1 0 )$ and $n$ is a natural number such that $1 0 0 ( n - 1 ) + 1 \\leq t \\leq 1 0 0 n$ ",
+        "bbox": [
+            225,
+            284,
+            795,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Gaussian-Mixtures: Time series data are sampled alternatively between two mixtures of Gaussian $0 . 5 \\mathcal { N } ( - 1 , 0 . 5 ^ { 2 } ) + 0 . 5 \\mathcal { N } ( 1 , 0 . 5 ^ { 2 } )$ and $0 . 8 \\mathcal { N } ( - 1 , 1 . 0 ^ { 2 } ) + 0 . 2 \\mathcal { N } ( 1 , 0 . 1 ^ { 2 } )$ for every 100 time stamps, which is defined as the change points. ",
+        "bbox": [
+            222,
+            304,
+            823,
+            347
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.3 COMPARING BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            363,
+            388,
+            378
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We include the following representative baselines in the literature of time series forecasting and change-point detection for evaluations: ",
+        "bbox": [
+            174,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Autoregressive Moving Average (ARMA) (Box, 2013) is the classic statistical model that predicts the future time series based on an Autoregressive (AR) and a moving average (MA), where AR involves linear regression, while MA models the error term as a linear combination of errors in the past.   \n• Autoregressive Gaussian Process (ARGP) (Candela et al., 2003) is a Gaussian Process for time series forecasting. In an ARGP of order $p$ , $x _ { t - p : t - 1 }$ are taken as the GP input while the output is $x _ { t }$ . ARGP can be viewed as a non-linear version of AR model.   \n• Recurrent Neural Networks (RNN) (Cho et al., 2014) are powerful neural networks for learning non-linear temporal dynamical systems. We consider gated recurrent units (GRU) in our implementation.   \nLSTNet (Lai et al., 2018) is a recent state-of-the-art deep neural network fore time series forecasting. LSTNet combines different architectures including CNN, RNN, residual networks, and highway networks. ARGP-BOCPD (Saatçi et al., 2010) is an extension of the Bayesian online change point detection (BOCPD) which uses ARGP instead of AR in underlying predictive models of BOCPD framework. RDR-KCPD (Liu et al., 2013) considers f-divergence as the dissimilarity measure. The f-divergence is estimated by relative density ratio technique, which involves solving an unconstrained least-squares importance fitting problem.   \n• Mstats-KCPD (Li et al., 2015a) consider kernel maximum mean discrepancy (MMD) on data space as dissimilarity measure. Specifically, It samples $B$ block of segments from the past time series, and computes $B$ times MMD distance between the past block with the current segment and takes the average as the dissimilarity measure. ",
+        "bbox": [
+            214,
+            431,
+            825,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.4 HYPERPARAMETER SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            424,
+            815
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For hyper-parameter tuning in ARMA, the time lag $p , q$ are chosen from $\\{ 1 , 2 , 3 , 4 , 5 \\}$ . For ARGP and ARGP-BOCPD the time lag order $p$ is set to the same as ARMA and the hyperparameter of kernel is learned by maximizing the marginalized likelihood. For RDR-KCPD, the window size $w$ are chosen from $\\{ 2 5 , 5 0 \\}$ , sub-dim $k = 5$ , $\\alpha = \\{ 0 . 0 1 , 0 . 1 , 1 \\}$ . For Mstats-KCPD and KL-CPD, the window size $w = 2 5$ , and we use RBF kernel with median heuristic setting the kernel bandwidth. The hidden dimension of GRU is $d _ { h } = 1 0$ for MMD-codespace, MMD-negsample and KL-CPD. For KL-CPD, $\\lambda$ is chosen from $\\{ 0 . 1 , 1 , 1 0 \\}$ and $\\beta$ is chosen from $\\{ 1 0 ^ { - 3 } , 1 \\bar { 0 } ^ { - 1 } , \\bar { 1 , } 1 0 \\}$ . ",
+        "bbox": [
+            173,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our algorithms are implemented in Python (PyTorch Paszke et al. (2017)), and running on Nvidia GeForce GTX 1080 Ti GPUs. Datasets and experiment code are publicly available. For all the baseline methods we used the released source code, include MATLAB code6 for ARMA, ARGP and ARGP-BOCPD, Pytorch code7 for RNN and LSTNet, MATLAB code8 for RDR-KCPD, and MATLAB code 9 for Mstats-KCPD. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.5 CONDITIONAL SAMPLES OF KL-CPD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            190,
+            482,
+            204
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/5713ef65aa28f83a9384f9d298644fa92bee22f83843d02597e84e0f368a99f5.jpg",
+        "image_caption": [
+            "Figure 6: Conditionally generated samples by KL-CPD and system-predicted CPD scores on BeeDance (Left) and HASC (Right) datasets. In the first three subplots are ground truth signals (blue line), 10 conditional generated samples (green lines) and change points (red vertical line). The last subplot is MMD scores, which peaks around ground truth change points mostly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            222,
+            821,
+            353
+        ],
+        "page_idx": 13
+    }
+]

parse/train/r1fYuytex/r1fYuytex.md

@@ -0,0 +1,283 @@
+# SPARSELY-CONNECTED NEURAL NETWORKS: TOWARDS EFFICIENT VLSI IMPLEMENTATION OF DEEP NEURAL NETWORKS
+
+Arash Ardakani, Carlo Condo and Warren J. Gross   
+Department of Electrical and Computer Engineering   
+McGill University, Montreal, Qu ´ ebec, Canada ´   
+Email: arash.ardakani $@$ mail.mcgill.ca, carlo.condo $@$ mail.mcgill.ca, warren.gross@mcgill.ca
+
+# ABSTRACT
+
+Recently deep neural networks have received considerable attention due to their ability to extract and represent high-level abstractions in data sets. Deep neural networks such as fully-connected and convolutional neural networks have shown excellent performance on a wide range of recognition and classification tasks. However, their hardware implementations currently suffer from large silicon area and high power consumption due to the their high degree of complexity. The power/energy consumption of neural networks is dominated by memory accesses, the majority of which occur in fully-connected networks. In fact, they contain most of the deep neural network parameters. In this paper, we propose sparsely-connected networks, by showing that the number of connections in fullyconnected networks can be reduced by up to $90 \%$ while improving the accuracy performance on three popular datasets (MNIST, CIFAR10 and SVHN). We then propose an efficient hardware architecture based on linear-feedback shift registers to reduce the memory requirements of the proposed sparsely-connected networks. The proposed architecture can save up to $90 \%$ of memory compared to the conventional implementations of fully-connected neural networks. Moreover, implementation results show up to $84 \%$ reduction in the energy consumption of a single neuron of the proposed sparsely-connected networks compared to a single neuron of fully-connected neural networks.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have shown remarkable performance in extracting and representing high-level abstractions in complex data (Lecun et al. (2015)). DNNs rely on multiple layers of interconnected neurons and parameters to solve complex tasks, such as image recognition and classification (Krizhevsky et al. (2012)). While they have been proven very effective in said tasks, their hardware implementations still suffer from high memory and power consumption, due to the complexity and size of their models. Therefore, research efforts have been conducted towards more efficient implementations of DNNs (Han et al. (2016)). In the past few years, the parallel nature of DNNs has led to the use of graphical processing units (GPUs) to execute neural networks tasks (Han et al. (2015)). However, their large latency and power consumption have pushed researchers towards application-specific integrated circuits (ASICs) for hardware implementations (Cavigelli et al. (2015)). For instance, in (Han et al. (2016)), it was shown that a DNN implemented with customized hardware can accelerate the classification task by $1 8 9 \times$ and $1 3 \times$ , while saving $2 4 { , } 0 0 0 \times$ and $3 { , } 4 0 0 \times$ energy compared to CPU (Intel i7-5930k) and GPU (GeForce TITAN X), respectively.
+
+Convolutional layers in DNNs are used to extract high level abstractions and features of data. In such layers, the connectivity between neurons follows a pattern inspired by the organization of the animal visual cortex. It was shown that the computation in the visual cortex can mathematically be described by a convolution operation (LeCun et al. (1989)). Therefore, each neuron is only connected to a few neurons based on a pattern and a set of weights is shared among all neurons. In contrast, in a fully-connected layer, each neuron is connected to every neuron in the previous and next layers and each connection is associated with a weight. These layers are usually used to learn non-linear combinations of given data. Fig. 1 shows a two-layer fully-connected network. The main computation kernel performs numerous vector-matrix multiplications followed by non-linear functions in each layer. In (Courbariaux & Bengio (2016); Horowitz (2014); Han et al. (2016)), it was shown that the power/energy consumption of DNNs is dominated by memory accesses. Fully-connected layers, which are widely used in recurrent neural networks (RNNs) and adopted in many state-of-the-art neural network architectures (Krizhevsky et al. (2012); Simonyan & Zisserman (2014); Zeiler & Fergus (2013); Szegedy et al. (2015); Lecun et al. (1998)), independently or as a part of convolutional neural networks, contain most of the weights of a DNN. For instance, the first fully-connected layer of VGGNet (Simonyan & Zisserman (2014)), which is composed of 13 convolution layers and three fully-connected layers, contains 100M weights out of a total of 140M. Such large storage requirements in fully-connected networks result in copious power/energy consumption.
+
+![](images/f5f2daf53646f0ef888a30fbd10c363676904b9eaf437dc3dc8f9c532bf0e3fa.jpg)  
+Figure 1: A two-layer fully-connected neural network
+
+To overcome the aforementioned issue, a pruning technique was first introduced in (Han et al. (2015)) to reduce the memory required by DNN architectures for mobile applications. However, it makes use of an additional training stage, while information addresses identifying the pruned connections still need to be stored in a memory. More recently, several works have focused on the binarization and ternarization of the weights of DNNs (Courbariaux & Bengio (2016); Courbariaux et al. (2015); Lin et al. (2015); Kim & Smaragdis (2016)). While these approaches reduce weight quantization and thus the memory width, the number of weights is unchanged.
+
+In (Shafiee et al. (2016b)), an alternative deep network connectivity named StochasticNet and inspired from the brain synaptic connection between neurons was explored on low-power CPUs. StochasticNet is formed by randomly removing up to $61 \%$ connections in both fully-connected and convolution layers of DNNs, speeding up the classification task.
+
+In (Wen et al. (2016)), a method named structured sparsity learning (SSL) was introduced to regularize the convolutional layers’ structures of DNNs. SSL can learn a structured sparsity of DNNs to efficiently speed up the convolutional computations both on CPU and GPU platforms.
+
+In this paper, we propose sparsely-connected networks by randomly removing some of the connections in fully-connected networks. Random connection masks are generated by linear-feedback shift registers (LFSRs), which are also used in the VLSI implementation to disable the connections. Experimental results on three commonly used datasets show that the proposed networks can improve network accuracy while removing up to $90 \%$ of the connections. Additionally, we apply the proposed algorithm on top of the binarizing/ternarizing technique achieving a better misclassification rate than the best binarized/ternarized networks reported in literature. Finally, an efficient very large scale integration (VLSI) hardware architecture of a DNN based on sparsely-connected network is proposed, which saves up to $90 \%$ memory and $84 \%$ energy with respect to the traditional architectures.
+
+The rest of the paper is organized as follows. Section 2 briefly introduces DNNs and their hardware implementation challenges, while Section 3 describes the proposed sparsely-connected network and their training algorithm. In Section 4 the experimental results over three datasets are presented and compared to the state of the art. Section 5 portrays the proposed VLSI architecture for the sparselyconnected network, and conclusions are drawn in Section 6.
+
+# 2 PRELIMINARIES
+
+# 2.1 DEEP NEURAL NETWORKS
+
+DNNs are constructed using multiple layers of neurons between the input and output layers. These are usually referred to as hidden layers. They are used in many current image and speech applications to perform complex tasks as recognition or classification. DNNs are trained through an initial phase, called the learning stage, that uses data to prepare the DNN for the task that will follow in the inference stage. Two subcategories of DNNs which are widely used in detection and recognition tasks are convolutional neural networks (CNNs) and RNNs (Han et al. (2016)). Due to parameter reuse in convolutional layers, they are well-studied and can be efficiently implemented with customized hardware platforms (Chen et al. (2016); Shafiee et al. (2016a); Chen et al. (2016)). On the other hand, fully-connected layers, which are widely used in RNNs like long short-term memories and as a part of CNNs, require a large number of parameters to be stored in memories.
+
+DNNs are mostly trained by the backpropagation algorithm in conjunction with stochastic gradient descent (SGD) optimization method (Rumelhart et al. (1986)). This algorithm computes the gradient of a cost function $C$ with respect to all the weights in all the layers. A common choice for the cost function is using the modified hinge loss introduced in (Tang (2013)). The obtained errors are then backward propagated through the layers to update the weights in an attempt to minimize the cost function. Instead of using a whole dataset to update parameters, data are first divided in mini-batches and parameters are updated using each mini-batch several times to speed up the convergence of the training algorithm. The weight updating speed is controlled by a learning rate $\eta$ . Batch normalization is also commonly used to regularize each mini-batch of data (Ioffe & Szegedy (2015)): it speeds up the training process by allowing the use of a bigger $\eta$ .
+
+# 2.2 TOWARDS HARDWARE IMPLEMENTATION OF DNNS
+
+DNNs have shown excellent performance in applications such as computer vision and speech recognition: since the number of neurons has a linear relationship with the ability of a DNN to perform tasks, high-performance DNNs are extremely complex in hardware. AlexNet (Krizhevsky et al. (2012)) and VGGNet (Simonyan & Zisserman (2014)) are two models comprising convolutional layers followed by some fully-connected layers, which are widely used in classification algorithms. Despite their very good classification performance, they require large amounts of memory to store the numerous parameters. Most of these parameters (more than $9 6 \%$ ) lie in fully-connected layers. In (Han et al. (2016)), it was shown that the total energy of DNNs is dominated by the required memory accesses. Therefore, the majority of power in a DNN is dissipated through fully-connected layers of DNNs. Moreover, the huge memory requirements make possible only for very small DNNs to be fitted in on-chip RAMs in ASIC/FPGA platforms.
+
+Recently, many works tried to reduce the computational complexity of DNNs. In (Akopyan et al. (2015)), the spiking neural network based on stochastic computing (Smithson et al. (2016)) was introduced, where 1-bit calculations are performed throughout the whole architecture. In (Ardakani et al. (2015)), integral stochastic computing was used to reduce the computation latency, showing that stochastic computing can consume less energy than conventional binary radix implementations. However, both works do not manage to reduce the DNN memory requirements.
+
+Network pruning, compression and weight sharing have been proposed in (Han et al. (2016)), together with weight matrix sparsification and compression. However, additional indexes denoting the pruned connections are required to be stored along with the compressed weight matrices. In (Han et al. (2015)), it was shown that the number of indexes are almost the same as the number of non-zero elements of weight matrices, thus increasing the word length of the required memories. Moreover, the encoding and compression techniques require inverse computations to obtain decoded and decompressed weights, and introduce additional hardware complexity for hardware implementation compared to the conventional computational architectures. Other pruning techniques presented in literature such as (Anwar et al. (2015)) try to reduce the memory required to store the pruned locations by introducing a structured sparsity in DNNs. However, the resulting network yields up to $3 1 . 8 1 \%$ misclassification rate on the CIFAR-10 dataset.
+
+Algorithm 1: Training algorithm for the proposed sparsely-connected network
+
+Data: Fully-connected network with parameters $W$ , $b$ and $M$ for each layer. Input data $x$ , its   
+corresponding targets $t$ , and learning rate of $\eta$ .   
+Result: $W$ and $b$   
+1 1. Forward computations   
+2 for each layer $i$ in range( $^ { \cdot } l , N )$ do   
+3 $W _ { s } \gets W _ { i } \cdot M _ { i }$   
+4 Compute layer output $y _ { i }$ according to (3) and its previous layer output $y _ { i - 1 }$ , $W _ { s }$ and $b _ { i }$ .   
+5 end   
+6 2. Backward Computations   
+7 Initialize output layers activation gradient $\frac { \partial C } { \partial y _ { N } }$   
+8 for each layer $j$ in range(2,N-1) do   
+9 Compute $\frac { \partial C } { \partial y _ { j } }$   
+10 end   
+11 for each layer $j$ in range(1,N-1) do   
+12 Compute $\frac { \partial C } { \partial W _ { s } }$ knowing $\frac { \partial C } { \partial y _ { j } }$ and yj−1   
+13 Compute $\frac { \partial C } { \partial b _ { j } }$   
+14 Update $W _ { j } : W _ { j }  W _ { j } - \eta \frac { \partial C } { \partial W _ { s } }$   
+15 Update bj : bj ← bj − η ∂bj   
+16 end
+
+# 3 SPARSELY-CONNECTED NEURAL NETWORKS
+
+Considering a fully-connected neural network layer with $n$ input and $m$ output nodes, the forward computations are performed as follow
+
+$$
+y = a c t ( W x + b ) ,
+$$
+
+where $W$ represents the weights and $b$ the biases, while $a c t ( )$ is the non-linear activation function in which $\mathrm { R e L U } ( x ) = m a x ( 0 , x )$ is used in most cases (Nair $\&$ Hinton (2010)). The network’s inputs and outputs are denoted by $x$ and $y$ , respectively.
+
+Let us introduce the sparse weight matrix $W _ { s }$ as the element-wise multiplication
+
+$$
+W _ { s } = W \cdot M ,
+$$
+
+where $W _ { s }$ and $M$ are sparser than $W$ . The Mask binary matrix $M$ can be defined as
+
+$$
+M _ { n \times m } = \left[ \begin{array} { c c c c } { M _ { 1 1 } } & { M _ { 1 2 } } & { \ldots } & { M _ { 1 m } } \\ { M _ { 2 1 } } & { M _ { 2 2 } } & { \ldots } & { M _ { 2 m } } \\ { \vdots } & { \vdots } & { \ddots } & { \vdots } \\ { M _ { n 1 } } & { M _ { n 2 } } & { \ldots } & { M _ { n m } } \end{array} \right] ,
+$$
+
+where each element of Mask $M _ { i j } \in \{ 0 , 1 \}$ , $i \in \{ 1 , \ldots , n \}$ and $j \in \{ 1 , \dots , m \}$ . Note that the dimensions of $M$ are the same as the weight matrix $W$ . Similarly to a fully-connected network (1), the forward computation of the sparsely-connected network can be expressed as
+
+$$
+y = a c t ( W _ { s } x + b ) .
+$$
+
+We propose the use of LFSRs to form each column of $M$ , similar to the approach used in stochastic computing to generate a binary stream (Gaines (1969)). In general, an $n b$ -bit LFSR serially generates $2 ^ { n b } - 1$ numbers $S _ { i } \in ( 0 , 1 ) , \stackrel { . } { i } \in \{ 1 , 2 , . . . 2 ^ { n b } - 1 \}$ . A random binary stream with expected value of $p \in [ 0 1 ]$ can be obtained by comparing $S _ { i }$ with a constant value of $p$ . This unit is hereafter referred to as stochastic number generator (SNG). Therefore, a random binary stream element $X _ { i } \in \{ 0 , 1 \}$ is 1 when $S _ { i } ~ \geq ~ p$ , and 0 otherwise. Fig. 2 shows the formation of a small sparsely-connected network using binary streams generated by LFSR units. Fig. 2(a) shows a 3-bit LFSR unit with its 7 different values and a random binary stream with expected value of $p = 0 . 5 7$ . A total of $m$ LFSRs of $\log _ { 2 } ( n )$ -bit length with different seed values are required to form $M$ . By tuning the value of $p$ it is possible to change the sparsity degree of $M$ , and thus of the sparsely-connected network. Fig. 2(b) and Fig. 2(c) show the fully-connected network based on $W$ and the sparsely-connected version based on $W _ { s }$ .
+
+![](images/b42c7cb35555f81c004363f73ded985fcb06d8726f2d47ae2c87782bf808a995.jpg)  
+Figure 2: (a) shows the formation of a Mask matrix $M$ using a 3-bit LFSR for $p = 0 . 5 7$ . (b) shows a fully-connected layer. (c) shows a sparsely-connected layer formed based on $M$ .
+
+Algorithm 1 summarizes the training algorithm for the proposed sparsely-connected network. The algorithm itself is very similar to what would be used with a fully-connected network, but considers each network layer to have a mask that disables some of the connections. The forward propagation (line 1-5) follows (3), while derivatives in the backward computations (line 6-16) are computed with respect to $W _ { s }$ . It is worth mentioning that most CNNs use fully-connected layers and the proposed training algorithm can still be used for those layers in CNNs.
+
+# 4 EXPERIMENTAL RESULTS
+
+We have validated the effectiveness of the proposed sparsely-connected network and its training algorithm on three datasets: MNIST (LeCun & Cortes (2010)), CIFAR10 (Krizhevsky (2009)) and SVHN (Netzer et al. (2011)) using the Theano library (Team (2016)) in Python.
+
+Table 1: Misclassification rate for Different Network Sizes on MNIST   
+
+<table><tr><td rowspan="2">Case</td><td rowspan="2">Method</td><td>Network</td><td>Misclassification</td><td>Number of</td></tr><tr><td>Configuration</td><td>Rate (%)</td><td>Parameters</td></tr><tr><td rowspan="2">1</td><td>Fully-Connected</td><td>784-512-512-10</td><td>1.18</td><td>669706</td></tr><tr><td>Sparsely-Connected 50%</td><td>784-512-512-10</td><td>1.19</td><td>335370</td></tr><tr><td rowspan="3">2</td><td>Fully-Connected</td><td>784-256-256-10</td><td>1.35</td><td>269322</td></tr><tr><td>Sparsely-Connected 60%</td><td>784-512-512-10</td><td>1.20</td><td>268503</td></tr><tr><td>Sparsely-Connected 70%</td><td>784-512-512-10</td><td>1.31</td><td>201636</td></tr><tr><td rowspan="2">3</td><td>Fully-Connected</td><td>784-145-145-10</td><td>1.41</td><td>136455</td></tr><tr><td>Sparsely-Connected 80%</td><td>784-512-512-10</td><td>1.28</td><td>134768</td></tr><tr><td rowspan="2">4</td><td>Fully-Connected</td><td>784-77-77-10</td><td>1.75</td><td>67231</td></tr><tr><td>Sparsely-Connected 90%</td><td>784-512-512-10</td><td>1.75</td><td>67901</td></tr><tr><td rowspan="2">5</td><td>Fully-Connected</td><td>784-12-12-10</td><td>4.68</td><td>9706</td></tr><tr><td>Sparsely-Connected 90%</td><td>784-100-100-10</td><td>3.16</td><td>8961</td></tr></table>
+
+# 4.1 EXPERIMENTAL RESULTS ON MNIST
+
+The MNIST dataset contains 60000 gray-scale $2 8 \times 2 8$ images (50000 for training and 10000 for testing), falling into 10 classes. A deep fully-connected neural network is used for evaluation and the hinge loss is considered as the cost function. The training set is divided into two separate parts. The first 40000 images are used as the training set and the rest for the validation and test sets. All models are trained using SGD without momentum, a batch size of 100, 500 epochs and the batch normalization method.
+
+Table 1 summarizes the misclassification rate of sparsely-connected neural networks compared to fully-connected neural networks for different network configurations, using single-precision floating-point format. We adopted a fully-connected network with 784-512-512-10 network configuration as a reference network, in which each number represent the number of inputs to each fully-connected layer. From this, we formed sparse weight matrices $W _ { s }$ with different sparsity degrees. For instance, sparsely-connected $9 0 \%$ denotes sparse weight matrices containing $9 0 \%$ zero elements. Case 1 shows that a sparsely-connected neural network with $5 0 \%$ fewer connections achieves approximately the same accuracy as the fully-connected network using the same network configuration. In Cases 2 and 3, the sparsely-connected networks with $6 0 \%$ and $8 0 \%$ fewer connections achieve a better misclassification rate than the fully-connected network while having approximately the same number of parameters. Case 4 shows no gain in performance and number of parameters for a sparsely-connected $9 0 \%$ and network configuration of 784-512-512-10 compared to the fully-connected at the same number of parameters. However, we can still reduce the connections up to $9 0 \%$ using a smaller network, as shown in Case 5.
+
+Recently, BinaryConnect and TernaryConnect neural networks have outperformed the state-of-theart on different datasets (Courbariaux et al. (2015); Lin et al. (2015)). In BinaryConnect, weights are represented with either $^ { - 1 }$ or 1, whereas they can be -1, 0 or 1 in TernaryConnect. These networks have emerged to facilitate hardware implementations of neural networks by reducing the memory requirements and removing multiplications. We applied our training method to BinaryConnect and TernaryConnect training algorithms: the obtained results are provided in Table 2. The source Python codes used for comparison are the same used in (Courbariaux et al. (2015); Lin et al. (2015)), available online (Lin et al. (2015)). The simulation results show that up to $7 0 \%$ and $8 0 \%$ of connections can be dropped by the proposed method from BinaryConnect and TernaryConnect networks without any compromise in performance without using data augmentation, respectively. Moreover, the binarized and ternarized sparsely-connected $5 0 \%$ improve the accuracy compared to the conventional binarized and ternarized fully-connected networks. Considering data augmentation (affine transformation), our method can drop up to $5 0 \%$ and $7 0 \%$ of connections from BinaryConnect and TernaryConnect networks without any compromise in performance, respectively. However, using data augmentation results in a better misclassification rate when it is used on networks trained with single-precision floating-point weights as shown in Table 2. In this case, our method still can drop up to $90 \%$ of connections without any performance degradation. It is worth specifying that we only used the binarized/ternarized algorithm during the learning phase, and we used single-precision floating-point weights during the test run in Section 4, similar to the approach used in (Lin et al. (2015)).
+
+Table 2: Misclassification rate for a 784-1024-1024-1024-10 neural network on MNIST   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">Misclassification Rate (%)</td><td rowspan="2"># of Parameters</td></tr><tr><td>Without Data Augmentation</td><td>With</td></tr><tr><td>Single-Precision Floating-Point (SPFP)</td><td>1.33</td><td>Data Augmentation</td><td>2913290</td></tr><tr><td>Sparsely-Connected 50% +SPFP</td><td>1.17</td><td>0.67 0.64</td><td>1458186</td></tr><tr><td>Sparsely-Connected 90% + SPFP</td><td>1.33</td><td>0.66</td><td>294103</td></tr><tr><td>BinaryConnecta(Courbariaux et al. (2015))</td><td>1.23</td><td>0.76</td><td>2913290</td></tr><tr><td>TernaryConnectb(Lin et al. (2015))</td><td>1.15</td><td>0.74</td><td>2913290</td></tr><tr><td>Sparsely-Connected 5O% +BinaryConnecta</td><td>0.99</td><td>0.75</td><td>1458186</td></tr><tr><td>Sparsely-Connected 6O% +BinaryConnecta</td><td>1.03</td><td>0.81</td><td>1167165</td></tr><tr><td>Sparsely-Connected 7O% + BinaryConnecta</td><td>1.16</td><td>0.85</td><td>876144</td></tr><tr><td>Sparsely-Connected 8O% +BinaryConnecta</td><td>1.32</td><td>1.06</td><td>585124</td></tr><tr><td>Sparsely-Connected 9O% +BinaryConnecta</td><td>1.33</td><td>1.36</td><td>294103</td></tr><tr><td>Sparsely-Connected 5O% + TernaryConnectb</td><td>0.95</td><td></td><td>1458186</td></tr><tr><td>Sparsely-Connected 6O% + TernaryConnectb</td><td>1.05</td><td>0.63 0.64</td><td>1167165</td></tr><tr><td>Sparsely-Connected 7O% + TernaryConnectb</td><td>1.01</td><td>0.73</td><td>876144</td></tr><tr><td>Sparsely-Connected 8O% + TernaryConnectb</td><td>1.11</td><td>0.85</td><td>585124</td></tr><tr><td>Sparsely-Connected 9o% + TernaryConnectb</td><td>1.41</td><td>1.05</td><td>294103</td></tr></table>
+
+a Binarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the test run. b Ternarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the test run.
+
+# 4.2 EXPERIMENTAL RESULTS ON CIFAR10
+
+The CIFAR10 dataset consists of a total number of $6 0 , 0 0 0 3 2 \times 3 2$ RGB images. Similar to MNIST, we split the images into 40, 000, 10, 000 and 10, 000 training, validation and test datasets, respectively. As our model, we adopt a convolutional network comprising $\{ 1 2 8 - 1 2 8 - 2 5 6 - 2 5 6 - 5 1 2 - 5 1 2 \}$ channels for six convolution/pooling layers and two 1024-node fully-connected layers followed by a classification layer. This architecture is inspired by VGGNet (Simonyan & Zisserman (2014)) and was also used in (Courbariaux et al. (2015)). Hinge loss is used for training with batch normalization and a batch size of 50.
+
+In order to show the performance of the proposed technique, we use sparsely-connected networks instead of fully-connected networks in the convolutional network. Again, we compare our results with the binarized and ternarized models since they are the most hardware-friendly models reported to-date. As summarized in Table 3, simulation results show significant improvement in accuracy compared to the ordinary network while having significantly fewer parameters.
+
+# 4.3 EXPERIMENTAL RESULTS ON SVHN
+
+SVHN dataset contains $3 2 \times 3 2$ RGB images (600, 000 images for training and roughly 26, 000 images for testing) of street house numbers. Also, $6 , 0 0 0$ images are separated from the training part for validation. Similar to the CIFAR10 case, we use a convolutional network comprising {128-128- $2 5 6 - 2 5 6 - 5 1 2 - 5 1 2 \}$ channels for six convolution/pooling layers and two 1024 fully-connected layers followed by a classification layer. Hinge loss is used as the cost function with batch normalization and batch size of 50.
+
+Table 4 summarizes the accuracy performance of using the proposed sparsely-connected network in the convolutional network model, compared to the hardware-friendly binarized and ternarized models. Despite the fewer parameters that the proposed sparsely-connected network provides, it also yields state-of-the-art results in terms of accuracy performance.
+
+Table 3: Misclassification rate for a Convolutional Network on CIFAR10   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">Misclassification Rate (%)</td><td rowspan="2"># of Parameters</td></tr><tr><td>Without</td><td>With</td></tr><tr><td>Single-Precision Floating-Point (SPFP)</td><td>Data Augmentation</td><td>Data Augmentation</td><td></td></tr><tr><td>Sparsely-Connected 90% + SPFP</td><td>12.45</td><td>9.77</td><td>14025866 5523184</td></tr><tr><td>BinaryConnect a(Courbariaux etal. (2015))</td><td>12.05</td><td>9.30</td><td></td></tr><tr><td>TernaryConnect b(Lin et al. (2015))</td><td>9.91 9.32</td><td>8.01</td><td>14025866</td></tr><tr><td>Sparsely-Connected 5O% +BinaryConnect a</td><td></td><td>7.83</td><td>14025866</td></tr><tr><td>Sparsely-Connected 9O% +BinaryConnect a</td><td>8.95</td><td>7.27</td><td>9302154</td></tr><tr><td>Sparsely-Connected 5O% + TernaryConnect b</td><td>8.05</td><td>6.92</td><td>5523184</td></tr><tr><td>Sparsely-Connected 90% + TernaryConnect b</td><td>8.45</td><td>7.13</td><td>9302154</td></tr><tr><td></td><td>7.88</td><td>6.99</td><td>5523184</td></tr></table>
+
+a Binarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the b Ternarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the test run.
+
+Table 4: Misclassification rate for a Convolutional Network on SVHN   
+
+<table><tr><td>Method</td><td>Misclassification Rate (%)</td><td>Number of Parameters</td></tr><tr><td>Single-Precision Floating-Point</td><td>4.734615</td><td>14025866</td></tr><tr><td>BinaryConnect a(Courbariaux et al. (2015)</td><td>2.134615</td><td>14025866</td></tr><tr><td>TernaryConnect b(Lin et al. (2015))</td><td>2.9</td><td>14025866</td></tr><tr><td>Sparsely-Connected 90% + BinaryConnect a</td><td>2.003846</td><td>5523184</td></tr><tr><td>Sparsely-Connected 90% + TernaryConnect b</td><td>1.957692</td><td>5523184</td></tr></table>
+
+a Binarizing algorithm was only used in the learning phase and single-precision floatingpoint weights were used during the test run. b Ternarizing algorithm was only used in the learning phase and single-precision floatingpoint weights were used during the test run.
+
+# 4.4 COMPARISON WITH THE STATE OF THE ART
+
+The proposed sparsely-connected network has been compared to other networks in literature in terms of misclassification rate in Table 5. In Section 4.1 to 4.3, we used the binarization/ternarization algorithm to train our models in the learning phase while using single-precision floating-point weights during the test run (i.e. inference phase). The first part of Table 5 applies the same technique, while in the second part we use binarized/ternarized weights also during the test run. We thus exploit a deterministic method introduced in (Courbariaux et al. (2015)) to perform the test run using binarized/ternarized weights. The weights are obtained as follows:
+
+$$
+W _ { b } = \left\{ \begin{array} { c l } { { 1 } } & { { \mathrm { i f } W \geq 0 } } \\ { { { - 1 } } } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. ,
+$$
+
+$$
+W _ { t } = \left\{ \begin{array} { l l } { { 1 } } & { { \mathrm { ~ i f ~ } W \geq \frac { 1 } { 3 } } } \\ { { 0 } } & { { \mathrm { ~ o t h e r w i s e } } } \\ { { - 1 } } & { { \mathrm { ~ i f ~ } W \leq - \frac { 1 } { 3 } } } \end{array} \right. ,
+$$
+
+where $W _ { b }$ and $W _ { t }$ denote binarized and ternarized weights, respectively.
+
+From the results presented in Table 5, we can see that our proposed work outperforms the state-ofthe-art models with binarized/ternarized weights during the test run while achieving performance close to the state-of-the-art result of the model with no binarization/ternarization in the test run. The former are the most suitable and hardware-friendly models for hardware implementation of DNNs: our model shows a better performance in terms of both accuracy/misclassification rate and memory requirements. The obtained results suggest that the proposed network acts as a regularizer to prevent models from overfitting. Similar conclusions were also obtained in (Courbariaux et al. (2015)). It is worth noting that no data augmentation was used in our simulations throughout this paper except for the results reported in Table 2 and Table 3.
+
+Table 5: Misclassification rate comparison. Sparsity degree for the proposed network is $5 0 \%$ in MNIST, and $9 0 \%$ in SVHN and CIFAR10.   
+
+<table><tr><td colspan="2"></td><td colspan="2">Datasets</td></tr><tr><td>Method</td><td>MNIST Binarized/Ternarized Weights During Test Run</td><td>SVHN</td><td>CIFAR10</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>BNN(Torch7)(Courbariaux &amp; Bengio (2016)) BNN (Theano)(Courbariaux &amp; Bengio (2016))</td><td>1.40%</td><td>2.53%</td><td>10.15%</td></tr><tr><td>(Baldassi et al. (2015))</td><td>0.96% 1.35%</td><td>2.80%</td><td>11.40%</td></tr><tr><td>BinaryConnect (Courbariaux et al.(2015))</td><td>1.29%</td><td>1</td><td>1</td></tr><tr><td>EBP (Cheng et al. (2015))</td><td>2.2%</td><td>2.30%</td><td>9.90%</td></tr><tr><td>Bitwise DNNs (Kim &amp; Smaragdis (2016))</td><td>1.33%</td><td>1</td><td>1</td></tr><tr><td>(Hwang&amp; Sung (2014))</td><td>1.45%</td><td>1</td><td>1</td></tr><tr><td></td><td>1.08%</td><td>1</td><td>1</td></tr><tr><td>Sparsely-Connected+BinaryConnect</td><td>0.98%</td><td>2.053846% 1.992308%</td><td>8.66%</td></tr><tr><td>Sparsely-Connected+ TernaryConnect</td><td></td><td></td><td>8.24%</td></tr><tr><td>Method</td><td>Single-Precision Floating-Point Weights During Test Run</td><td></td><td></td></tr><tr><td>TernaryConnect (Lin et al. (2015))</td><td>1.15%</td><td>2.42%</td><td>12.01%</td></tr><tr><td>Maxout Networks (Goodfellow et al.(2013))</td><td>0.94%</td><td>2.47%</td><td>11.68%</td></tr><tr><td>Network in Network (Lin et al.(2013))</td><td></td><td>2.35%</td><td>10.41%</td></tr><tr><td>Gated pooling (Lee et al. (2015))</td><td>1</td><td>1.69%</td><td>7.62%</td></tr><tr><td>Sparsely-Connected+BinaryConnect</td><td>0.99%</td><td>2.003846%</td><td>8.05%</td></tr><tr><td>Sparsely-Connected+ TernaryConnect</td><td>0.95%</td><td>1.957692%</td><td>7.88%</td></tr></table>
+
+# 5 VLSI IMPLEMENTATION OF SPARSELY-CONNECTED NEURAL NETWORKS
+
+In this Section, we propose an efficient hardware architecture for the proposed sparsely-connected network. In fully-connected networks, the main computational core is the matrix-vector multiplication that computes (1). This computation is usually implemented in parallel on GPUs. However, parallel implementation of this unit requires parallel access to memories and causes routing congestion, leading to large silicon area and power/energy consumption in customized hardware. Thus, VLSI architectures usually opt for semi-parallel implementations of such networks. In this approach, each neuron performs its computations serially, and a certain number of neurons are instantiated in parallel (Moreno et al. (2008)). Every neuron is implemented using multiply-and-accumulate (MAC) units as shown in Fig. 3(a). The number of inputs of each neuron determines the latency of this architecture. For example, considering a hidden layer with 1024 inputs and 1024 outputs, 1024 MACs are required in parallel and each MAC requires 1024 clock cycles to perform computations of this layer. In general, a counter is required to count from 0 to $N - 1$ where $N$ is the number of inputs of each neuron. It provides the addresses for the memory in which a column of the weight matrix $W$ is stored. In this way, each input and its corresponding weight are fed to the multiplier every clock cycle (see Fig. 3(a)). For binarized/ternarized networks, the multiplier in 3(a) is substituted with a multiplexer.
+
+In Section 3, we described the formation of the Mask matrix $M$ using an SNG unit (see Fig. 2(a)). The value of $p$ , through which it is possible to tune the sparsity degree of networks, also corresponds to the occurrence of 1 in a binary stream generated by SNG. Therefore, we can save up to $9 \hat { 0 } \%$ of memory by storing only the weights corresponding to the 1s in the SNG stream. For instance, considering a Mask matrix $M$ in Fig. 2(a), $W _ { s }$ is formed as
+
+![](images/ba40bac7f6042434ce819f57c15eb7b93d15a82be0d1abbb4ce296f2f28ad5c3.jpg)  
+Figure 3: (a) shows the conventional architecture of a single neuron of a fully-connected network. (b) shows the proposed architecture of a single neuron of a sparsely-connected network.
+
+$$
+W _ { s } = \left[ \begin{array} { c c } { 0 } & { 0 } \\ { W _ { 2 1 } } & { W _ { 2 2 } } \\ { W _ { 3 1 } } & { 0 } \\ { W _ { 4 1 } } & { 0 } \\ { 0 } & { W _ { 5 2 } } \\ { W _ { 6 1 } } & { W _ { 6 2 } } \\ { 0 } & { W _ { 7 2 } } \end{array} \right] ,
+$$
+
+Table 6: ASIC Implementation Results for a Single Neuron of Sparsely-Connected Network $@$ 400 MHz in TSMC 65 nm CMOS Technology.   
+
+<table><tr><td rowspan="2"></td><td colspan="5">Sparsity Degree</td></tr><tr><td>p=0 Fully-Connected (FC)</td><td>p=0.5</td><td>p=0.75 Sparsely-Connected</td><td>p= 0.875 Sparsely-Connected</td><td>p= 0.9375 Sparsely-Connected</td></tr><tr><td>Memory Size [bits]</td><td>1024</td><td>Sparsely-Connected 512</td><td>256</td><td>128</td><td>64</td></tr><tr><td>Area [μm²](improvement W.r.t.FC)</td><td>26265</td><td>13859 (47%↓)</td><td>7316 (72% ↓)</td><td>4221(84% ↓)</td><td>2662 (90%↓)</td></tr><tr><td>Power [μW]</td><td>278</td><td>155</td><td>86</td><td>60</td><td>43</td></tr><tr><td>Energy [pJ](improvement w.r.t.FC)</td><td>712</td><td>397(44%↓)</td><td>220(69%↓)</td><td>154(78%↓)</td><td>110 (84%↓)</td></tr><tr><td>Latency [μs]</td><td>2.56</td><td>2.56</td><td>2.56</td><td>2.56</td><td>2.56</td></tr></table>
+
+and the compressed matrix $W _ { c }$ stored in on-chip memories is
+
+$$
+W _ { c } = \left[ \begin{array} { l l } { W _ { 2 1 } } & { W _ { 2 2 } } \\ { W _ { 3 1 } } & { W _ { 5 2 } } \\ { W _ { 4 1 } } & { W _ { 6 2 } } \\ { W _ { 6 1 } } & { W _ { 7 2 } } \end{array} \right] .
+$$
+
+The smaller memory can significantly reduce the silicon area and the power consumption of DNNs architectures. Depending on the value of $p$ , the size of the memory varies. In general, the depth of the weight memory in each neuron is $( 1 - p ) \times N$ .
+
+Fig. 3(b) depicts the architecture of a single neuron of the proposed sparsely-connected network. Decompression is performed using an SNG generating the enable signal of the counter and accumulator. Inputs are fed into each neuron sequentially in each clock cycle. If the output of the SNG is 1, the counter counts upward and provides an address for the memory. Then, the multiplication of an input and its corresponding weight is computed, the result stored in the internal register of the accumulator. If instead the output of the SNG is 0, the counter holds its previous value, while the internal register of the accumulator is not enabled, and does not load a new value. The latency of the proposed architecture is the same as that of the conventional architecture.
+
+Table 6 shows the ASIC implementation results of the neuron in Fig. 3(b) supposing 1024 inputs. The proposed architectures were described in VHDL and synthesized in TSMC 65 nm CMOS technology with Cadence RTL compiler, for different sparsity degrees $p$ . For the provided syntheses we used a binarized network. Implementation results show up to $\bar { 8 } 4 \%$ decrement in energy consumption and up to $9 0 \%$ less area compared to the conventional fully-connected architecture.
+
+# 6 CONCLUSION
+
+DNNs are capable of solving complex tasks: their ability to do so depends on the number of neurons and their connections. Fully-connected layers in DNNs contain more than $9 6 \%$ of the total neural network parameters, pushing the designers to use off-chip memories which are band-width limited and consume large amounts of energy. In this paper, we proposed sparsely-connected networks and their training algorithm to substantially reduce the memory requirements of DNNs. The sparsity degree of the proposed network can be tuned by an SNG, which is implemented using an LFSR unit and a comparator. We used the proposed sparsely-connected network instead of fully-connected networks in a VGG-like network on three commonly used datasets: we achieved better accuracy results with up to $9 0 \%$ fewer connections than the state of the art. Moreover, our simulation results confirm that the proposed network can be used as a regularizer to prevent models from overfitting. Finally, we implemented a single neuron of the sparsely-connected network in in $6 5 \ \mathrm { n m } \mathrm { C M O S }$ technology for different sparsity degrees. The implementation results show that the proposed architecture can save up to $8 4 \%$ energy and $9 0 \%$ silicon area compared to the conventional fully-connected network while having a lower misclassification rate.
+
+# REFERENCES
+
+F. Akopyan, J. Sawada, A. Cassidy, R. Alvarez-Icaza, J. Arthur, P. Merolla, N. Imam, Y. Nakamura, P. Datta, G. J. Nam, B. Taba, M. Beakes, B. Brezzo, J. B. Kuang, R. Manohar, W. P. Risk, B. Jackson, and D. S. Modha. TrueNorth: design and tool flow of a $6 5 ~ \mathrm { m W }$ 1 million neuron programmable neurosynaptic chip. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 34(10):1537–1557, Oct 2015. ISSN 0278-0070. doi: 10.1109/TCAD.2015. 2474396.
+
+Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. CoRR, abs/1512.08571, 2015. URL http://arxiv.org/abs/1512.08571.
+
+Arash Ardakani, Franc¸ois Leduc-Primeau, Naoya Onizawa, Takahiro Hanyu, and Warren J. Gross. VLSI implementation of deep neural network using integral stochastic computing. CoRR, abs/1509.08972, 2015. URL http://arxiv.org/abs/1509.08972.
+
+Carlo Baldassi, Alessandro Ingrosso, Carlo Lucibello, Luca Saglietti, and Riccardo Zecchina. Subdominant dense clusters allow for simple learning and high computational performance in neural networks with discrete synapses. Phys. Rev. Lett., 115:128101, Sep 2015.
+
+Lukas Cavigelli, David Gschwend, Christoph Mayer, Samuel Willi, Beat Muheim, and Luca Benini. Origami: a convolutional network accelerator. CoRR, abs/1512.04295, 2015. URL http:// arxiv.org/abs/1512.04295.
+
+Yu-Hsin Chen, Joel Emer, and Vivienne Sze. Eyeriss: a spatial architecture for energy-efficient dataflow for convolutional neural networks. In Proceedings of the 43rd International Symposium on Computer Architecture, ISCA ’16, pp. 367–379, Piscataway, NJ, USA, 2016. IEEE Press. ISBN 978-1-4673-8947-1. doi: 10.1109/ISCA.2016.40. URL http://dx.doi.org/10. 1109/ISCA.2016.40.
+
+Yu-Hsin Chen, Tushar Krishna, Joel Emer, and Vivienne Sze. Eyeriss: An Energy-Efficient Reconfigurable Accelerator for Deep Convolutional Neural Networks. In IEEE International Solid-State Circuits Conference, ISSCC 2016, Digest of Technical Papers, pp. 262–263, 2016.
+
+Zhiyong Cheng, Daniel Soudry, Zexi Mao, and Zhen-zhong Lan. Training binary multilayer neural networks for image classification using expectation backpropagation. CoRR, abs/1503.03562, 2015.
+
+Matthieu Courbariaux and Yoshua Bengio. BinaryNet: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. CoRR, abs/1602.02830, 2016.
+
+Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. BinaryConnect: Training deep neural networks with binary weights during propagations. CoRR, abs/1511.00363, 2015.
+
+B. R. Gaines. Stochastic Computing Systems, pp. 37–172. Springer US, Boston, MA, 1969. ISBN 978-1-4899-5841-9.
+
+Ian J. Goodfellow, David Warde-farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. In In ICML, 2013.
+
+S. Han, X. Liu, H. Mao, J. Pu, A. Pedram, M. A. Horowitz, and W. J. Dally. EIE: Efficient inference engine on compressed deep neural network. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pp. 243–254, June 2016. doi: 10.1109/ISCA.2016.30.
+
+Song Han, Huizi Mao, and William J. Dally. Deep compression: compressing deep neural network with pruning, trained quantization and huffman coding. CoRR, abs/1510.00149, 2015.
+
+Mark Horowitz. 1.1 computing’s energy problem (and what we can do about it). In 2014 IEEE International Solid-State Circuits Conference Digest of Technical Papers (ISSCC), pp. 10–14, Feb 2014. doi: 10.1109/ISSCC.2014.6757323.
+
+K. Hwang and W. Sung. Fixed-point feedforward deep neural network design using weights -1, 0, and 1. In 2014 IEEE Workshop on Signal Processing Systems (SiPS), pp. 1–6, Oct 2014.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: accelerating deep network training by reducing internal covariate shift. CoRR, abs/1502.03167, 2015. URL http://arxiv.org/ abs/1502.03167.
+
+Minje Kim and Paris Smaragdis. Bitwise neural networks. CoRR, abs/1601.06071, 2016.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 25, pp. 1097–1105. Curran Associates, Inc., 2012.
+
+Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural Comput., 1(4):541–551, December 1989. ISSN 0899-7667. doi: 10.1162/neco.1989.1.4.541. URL http://dx.doi. org/10.1162/neco.1989.1.4.541.
+
+Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/.
+
+Yann Lecun, Lon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. In Proceedings of the IEEE, pp. 2278–2324, 1998.
+
+Yann Lecun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 5 2015. ISSN 0028-0836. doi: 10.1038/nature14539.
+
+Chen-Yu Lee, Patrick W. Gallagher, and Zhuowen Tu. Generalizing pooling functions in convolutional neural networks: mixed, gated, and tree. CoRR, abs/1509.08985, 2015.
+
+Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. CoRR, abs/1312.4400, 2013.
+
+Zhouhan Lin, Matthieu Courbariaux, Roland Memisevic, and Yoshua Bengio. Neural networks with few multiplications. CoRR, abs/1510.03009, 2015.
+
+F. Moreno, J. Alarcon, R. Salvador, and T. Riesgo. Fpga implementation of an image recognition system based on tiny neural networks and on-line reconfiguration. In Industrial Electronics, 2008. IECON 2008. 34th Annual Conference of IEEE, pp. 2445–2452, Nov 2008. doi: 10.1109/IECON. 2008.4758340.
+
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In Johannes Frnkranz and Thorsten Joachims (eds.), Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 807–814. Omnipress, 2010. URL http://www.icml2010.org/papers/432.pdf.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford.edu/ housenumbers/nips2011_housenumbers.pdf.
+
+D. E. Rumelhart, G. E. Hinton, and R. J. Williams. Parallel distributed processing: Explorations in the microstructure of cognition, vol. 1. chapter Learning Internal Representations by Error Propagation, pp. 318–362. MIT Press, Cambridge, MA, USA, 1986. ISBN 0-262-68053-X. URL http://dl.acm.org/citation.cfm?id $\mathbf { \Phi } = \mathbf { \dot { \Phi } }$ 104279.104293.
+
+A. Shafiee, A. Nag, N. Muralimanohar, R. Balasubramonian, J. P. Strachan, M. Hu, R. S. Williams, and V. Srikumar. ISAAC: a convolutional neural network accelerator with in-situ analog arithmetic in crossbars. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pp. 14–26, June 2016a. doi: 10.1109/ISCA.2016.12.
+
+M. J. Shafiee, P. Siva, and A. Wong. StochasticNet: forming deep neural networks via stochastic connectivity. IEEE Access, 4:1915–1924, 2016b. ISSN 2169-3536.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014.
+
+Sean C. Smithson, Kaushik Boga, Arash Ardakani, Brett H. Meyer, and Warren J. Gross. Stochastic computing can improve upon digital spiking neural networks. In 2016 IEEE Workshop on Signal Processing Systems (SiPS), pp. 309–314, Oct 2016.
+
+C. Szegedy, Wei Liu, Yangqing Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, June 2015. doi: 10.1109/CVPR.2015.7298594.
+
+Yichuan Tang. Deep learning using support vector machines. CoRR, abs/1306.0239, 2013. URL http://arxiv.org/abs/1306.0239.
+
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. CoRR, abs/1608.03665, 2016. URL http://arxiv.org/abs/ 1608.03665.
+
+Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. CoRR, abs/1311.2901, 2013. URL http://arxiv.org/abs/1311.2901.

parse/train/r1fYuytex/r1fYuytex_content_list.json

@@ -0,0 +1,1401 @@
+[
+    {
+        "type": "text",
+        "text": "SPARSELY-CONNECTED NEURAL NETWORKS: TOWARDS EFFICIENT VLSI IMPLEMENTATION OF DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Arash Ardakani, Carlo Condo and Warren J. Gross   \nDepartment of Electrical and Computer Engineering   \nMcGill University, Montreal, Qu ´ ebec, Canada ´   \nEmail: arash.ardakani $@$ mail.mcgill.ca, carlo.condo $@$ mail.mcgill.ca, warren.gross@mcgill.ca ",
+        "bbox": [
+            184,
+            195,
+            799,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            287,
+            544,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently deep neural networks have received considerable attention due to their ability to extract and represent high-level abstractions in data sets. Deep neural networks such as fully-connected and convolutional neural networks have shown excellent performance on a wide range of recognition and classification tasks. However, their hardware implementations currently suffer from large silicon area and high power consumption due to the their high degree of complexity. The power/energy consumption of neural networks is dominated by memory accesses, the majority of which occur in fully-connected networks. In fact, they contain most of the deep neural network parameters. In this paper, we propose sparsely-connected networks, by showing that the number of connections in fullyconnected networks can be reduced by up to $90 \\%$ while improving the accuracy performance on three popular datasets (MNIST, CIFAR10 and SVHN). We then propose an efficient hardware architecture based on linear-feedback shift registers to reduce the memory requirements of the proposed sparsely-connected networks. The proposed architecture can save up to $90 \\%$ of memory compared to the conventional implementations of fully-connected neural networks. Moreover, implementation results show up to $84 \\%$ reduction in the energy consumption of a single neuron of the proposed sparsely-connected networks compared to a single neuron of fully-connected neural networks. ",
+        "bbox": [
+            233,
+            318,
+            764,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            608,
+            336,
+            623
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have shown remarkable performance in extracting and representing high-level abstractions in complex data (Lecun et al. (2015)). DNNs rely on multiple layers of interconnected neurons and parameters to solve complex tasks, such as image recognition and classification (Krizhevsky et al. (2012)). While they have been proven very effective in said tasks, their hardware implementations still suffer from high memory and power consumption, due to the complexity and size of their models. Therefore, research efforts have been conducted towards more efficient implementations of DNNs (Han et al. (2016)). In the past few years, the parallel nature of DNNs has led to the use of graphical processing units (GPUs) to execute neural networks tasks (Han et al. (2015)). However, their large latency and power consumption have pushed researchers towards application-specific integrated circuits (ASICs) for hardware implementations (Cavigelli et al. (2015)). For instance, in (Han et al. (2016)), it was shown that a DNN implemented with customized hardware can accelerate the classification task by $1 8 9 \\times$ and $1 3 \\times$ , while saving $2 4 { , } 0 0 0 \\times$ and $3 { , } 4 0 0 \\times$ energy compared to CPU (Intel i7-5930k) and GPU (GeForce TITAN X), respectively. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional layers in DNNs are used to extract high level abstractions and features of data. In such layers, the connectivity between neurons follows a pattern inspired by the organization of the animal visual cortex. It was shown that the computation in the visual cortex can mathematically be described by a convolution operation (LeCun et al. (1989)). Therefore, each neuron is only connected to a few neurons based on a pattern and a set of weights is shared among all neurons. In contrast, in a fully-connected layer, each neuron is connected to every neuron in the previous and next layers and each connection is associated with a weight. These layers are usually used to learn non-linear combinations of given data. Fig. 1 shows a two-layer fully-connected network. The main computation kernel performs numerous vector-matrix multiplications followed by non-linear functions in each layer. In (Courbariaux & Bengio (2016); Horowitz (2014); Han et al. (2016)), it was shown that the power/energy consumption of DNNs is dominated by memory accesses. Fully-connected layers, which are widely used in recurrent neural networks (RNNs) and adopted in many state-of-the-art neural network architectures (Krizhevsky et al. (2012); Simonyan & Zisserman (2014); Zeiler & Fergus (2013); Szegedy et al. (2015); Lecun et al. (1998)), independently or as a part of convolutional neural networks, contain most of the weights of a DNN. For instance, the first fully-connected layer of VGGNet (Simonyan & Zisserman (2014)), which is composed of 13 convolution layers and three fully-connected layers, contains 100M weights out of a total of 140M. Such large storage requirements in fully-connected networks result in copious power/energy consumption. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f5f2daf53646f0ef888a30fbd10c363676904b9eaf437dc3dc8f9c532bf0e3fa.jpg",
+        "image_caption": [
+            "Figure 1: A two-layer fully-connected neural network "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            85,
+            648,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            332,
+            825,
+            484
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To overcome the aforementioned issue, a pruning technique was first introduced in (Han et al. (2015)) to reduce the memory required by DNN architectures for mobile applications. However, it makes use of an additional training stage, while information addresses identifying the pruned connections still need to be stored in a memory. More recently, several works have focused on the binarization and ternarization of the weights of DNNs (Courbariaux & Bengio (2016); Courbariaux et al. (2015); Lin et al. (2015); Kim & Smaragdis (2016)). While these approaches reduce weight quantization and thus the memory width, the number of weights is unchanged. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In (Shafiee et al. (2016b)), an alternative deep network connectivity named StochasticNet and inspired from the brain synaptic connection between neurons was explored on low-power CPUs. StochasticNet is formed by randomly removing up to $61 \\%$ connections in both fully-connected and convolution layers of DNNs, speeding up the classification task. ",
+        "bbox": [
+            174,
+            595,
+            823,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In (Wen et al. (2016)), a method named structured sparsity learning (SSL) was introduced to regularize the convolutional layers’ structures of DNNs. SSL can learn a structured sparsity of DNNs to efficiently speed up the convolutional computations both on CPU and GPU platforms. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose sparsely-connected networks by randomly removing some of the connections in fully-connected networks. Random connection masks are generated by linear-feedback shift registers (LFSRs), which are also used in the VLSI implementation to disable the connections. Experimental results on three commonly used datasets show that the proposed networks can improve network accuracy while removing up to $90 \\%$ of the connections. Additionally, we apply the proposed algorithm on top of the binarizing/ternarizing technique achieving a better misclassification rate than the best binarized/ternarized networks reported in literature. Finally, an efficient very large scale integration (VLSI) hardware architecture of a DNN based on sparsely-connected network is proposed, which saves up to $90 \\%$ memory and $84 \\%$ energy with respect to the traditional architectures. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows. Section 2 briefly introduces DNNs and their hardware implementation challenges, while Section 3 describes the proposed sparsely-connected network and their training algorithm. In Section 4 the experimental results over three datasets are presented and compared to the state of the art. Section 5 portrays the proposed VLSI architecture for the sparselyconnected network, and conclusions are drawn in Section 6. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            338,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            147,
+            401,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DNNs are constructed using multiple layers of neurons between the input and output layers. These are usually referred to as hidden layers. They are used in many current image and speech applications to perform complex tasks as recognition or classification. DNNs are trained through an initial phase, called the learning stage, that uses data to prepare the DNN for the task that will follow in the inference stage. Two subcategories of DNNs which are widely used in detection and recognition tasks are convolutional neural networks (CNNs) and RNNs (Han et al. (2016)). Due to parameter reuse in convolutional layers, they are well-studied and can be efficiently implemented with customized hardware platforms (Chen et al. (2016); Shafiee et al. (2016a); Chen et al. (2016)). On the other hand, fully-connected layers, which are widely used in RNNs like long short-term memories and as a part of CNNs, require a large number of parameters to be stored in memories. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DNNs are mostly trained by the backpropagation algorithm in conjunction with stochastic gradient descent (SGD) optimization method (Rumelhart et al. (1986)). This algorithm computes the gradient of a cost function $C$ with respect to all the weights in all the layers. A common choice for the cost function is using the modified hinge loss introduced in (Tang (2013)). The obtained errors are then backward propagated through the layers to update the weights in an attempt to minimize the cost function. Instead of using a whole dataset to update parameters, data are first divided in mini-batches and parameters are updated using each mini-batch several times to speed up the convergence of the training algorithm. The weight updating speed is controlled by a learning rate $\\eta$ . Batch normalization is also commonly used to regularize each mini-batch of data (Ioffe & Szegedy (2015)): it speeds up the training process by allowing the use of a bigger $\\eta$ . ",
+        "bbox": [
+            174,
+            329,
+            825,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 TOWARDS HARDWARE IMPLEMENTATION OF DNNS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            570,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DNNs have shown excellent performance in applications such as computer vision and speech recognition: since the number of neurons has a linear relationship with the ability of a DNN to perform tasks, high-performance DNNs are extremely complex in hardware. AlexNet (Krizhevsky et al. (2012)) and VGGNet (Simonyan & Zisserman (2014)) are two models comprising convolutional layers followed by some fully-connected layers, which are widely used in classification algorithms. Despite their very good classification performance, they require large amounts of memory to store the numerous parameters. Most of these parameters (more than $9 6 \\%$ ) lie in fully-connected layers. In (Han et al. (2016)), it was shown that the total energy of DNNs is dominated by the required memory accesses. Therefore, the majority of power in a DNN is dissipated through fully-connected layers of DNNs. Moreover, the huge memory requirements make possible only for very small DNNs to be fitted in on-chip RAMs in ASIC/FPGA platforms. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, many works tried to reduce the computational complexity of DNNs. In (Akopyan et al. (2015)), the spiking neural network based on stochastic computing (Smithson et al. (2016)) was introduced, where 1-bit calculations are performed throughout the whole architecture. In (Ardakani et al. (2015)), integral stochastic computing was used to reduce the computation latency, showing that stochastic computing can consume less energy than conventional binary radix implementations. However, both works do not manage to reduce the DNN memory requirements. ",
+        "bbox": [
+            174,
+            705,
+            823,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Network pruning, compression and weight sharing have been proposed in (Han et al. (2016)), together with weight matrix sparsification and compression. However, additional indexes denoting the pruned connections are required to be stored along with the compressed weight matrices. In (Han et al. (2015)), it was shown that the number of indexes are almost the same as the number of non-zero elements of weight matrices, thus increasing the word length of the required memories. Moreover, the encoding and compression techniques require inverse computations to obtain decoded and decompressed weights, and introduce additional hardware complexity for hardware implementation compared to the conventional computational architectures. Other pruning techniques presented in literature such as (Anwar et al. (2015)) try to reduce the memory required to store the pruned locations by introducing a structured sparsity in DNNs. However, the resulting network yields up to $3 1 . 8 1 \\%$ misclassification rate on the CIFAR-10 dataset. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            946
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Training algorithm for the proposed sparsely-connected network ",
+        "bbox": [
+            173,
+            107,
+            694,
+            122
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Data: Fully-connected network with parameters $W$ , $b$ and $M$ for each layer. Input data $x$ , its   \ncorresponding targets $t$ , and learning rate of $\\eta$ .   \nResult: $W$ and $b$   \n1 1. Forward computations   \n2 for each layer $i$ in range( $^ { \\cdot } l , N )$ do   \n3 $W _ { s } \\gets W _ { i } \\cdot M _ { i }$   \n4 Compute layer output $y _ { i }$ according to (3) and its previous layer output $y _ { i - 1 }$ , $W _ { s }$ and $b _ { i }$ .   \n5 end   \n6 2. Backward Computations   \n7 Initialize output layers activation gradient $\\frac { \\partial C } { \\partial y _ { N } }$   \n8 for each layer $j$ in range(2,N-1) do   \n9 Compute $\\frac { \\partial C } { \\partial y _ { j } }$   \n10 end   \n11 for each layer $j$ in range(1,N-1) do   \n12 Compute $\\frac { \\partial C } { \\partial W _ { s } }$ knowing $\\frac { \\partial C } { \\partial y _ { j } }$ and yj−1   \n13 Compute $\\frac { \\partial C } { \\partial b _ { j } }$   \n14 Update $W _ { j } : W _ { j }  W _ { j } - \\eta \\frac { \\partial C } { \\partial W _ { s } }$   \n15 Update bj : bj ← bj − η ∂bj   \n16 end ",
+        "bbox": [
+            151,
+            118,
+            812,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 SPARSELY-CONNECTED NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            521,
+            581,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Considering a fully-connected neural network layer with $n$ input and $m$ output nodes, the forward computations are performed as follow ",
+        "bbox": [
+            173,
+            551,
+            825,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/94039cb76f8d5e4e302e29429a49af31b1a49995da5b1d8964acdfab3ca945da.jpg",
+        "text": "$$\ny = a c t ( W x + b ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            587,
+            560,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W$ represents the weights and $b$ the biases, while $a c t ( )$ is the non-linear activation function in which $\\mathrm { R e L U } ( x ) = m a x ( 0 , x )$ is used in most cases (Nair $\\&$ Hinton (2010)). The network’s inputs and outputs are denoted by $x$ and $y$ , respectively. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us introduce the sparse weight matrix $W _ { s }$ as the element-wise multiplication ",
+        "bbox": [
+            173,
+            659,
+            700,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a35b29420a297d618922d13d5ec642c6c6eff99339ee03a417fc018647b5802.jpg",
+        "text": "$$\nW _ { s } = W \\cdot M ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            679,
+            547,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { s }$ and $M$ are sparser than $W$ . The Mask binary matrix $M$ can be defined as ",
+        "bbox": [
+            176,
+            702,
+            725,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc41fbeb87d463134b6fcad3f26cfc04b04d13042eca4e9c0fa574d912b3775c.jpg",
+        "text": "$$\nM _ { n \\times m } = \\left[ \\begin{array} { c c c c } { M _ { 1 1 } } & { M _ { 1 2 } } & { \\ldots } & { M _ { 1 m } } \\\\ { M _ { 2 1 } } & { M _ { 2 2 } } & { \\ldots } & { M _ { 2 m } } \\\\ { \\vdots } & { \\vdots } & { \\ddots } & { \\vdots } \\\\ { M _ { n 1 } } & { M _ { n 2 } } & { \\ldots } & { M _ { n m } } \\end{array} \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            722,
+            630,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where each element of Mask $M _ { i j } \\in \\{ 0 , 1 \\}$ , $i \\in \\{ 1 , \\ldots , n \\}$ and $j \\in \\{ 1 , \\dots , m \\}$ . Note that the dimensions of $M$ are the same as the weight matrix $W$ . Similarly to a fully-connected network (1), the forward computation of the sparsely-connected network can be expressed as ",
+        "bbox": [
+            173,
+            796,
+            825,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c828b4efba2720168c2df7c5fff427b9017032eeddff023cf4948d7cb1d2499.jpg",
+        "text": "$$\ny = a c t ( W _ { s } x + b ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            844,
+            565,
+            862
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose the use of LFSRs to form each column of $M$ , similar to the approach used in stochastic computing to generate a binary stream (Gaines (1969)). In general, an $n b$ -bit LFSR serially generates $2 ^ { n b } - 1$ numbers $S _ { i } \\in ( 0 , 1 ) , \\stackrel { . } { i } \\in \\{ 1 , 2 , . . . 2 ^ { n b } - 1 \\}$ . A random binary stream with expected value of $p \\in [ 0 1 ]$ can be obtained by comparing $S _ { i }$ with a constant value of $p$ . This unit is hereafter referred to as stochastic number generator (SNG). Therefore, a random binary stream element $X _ { i } \\in \\{ 0 , 1 \\}$ is 1 when $S _ { i } ~ \\geq ~ p$ , and 0 otherwise. Fig. 2 shows the formation of a small sparsely-connected network using binary streams generated by LFSR units. Fig. 2(a) shows a 3-bit LFSR unit with its 7 different values and a random binary stream with expected value of $p = 0 . 5 7$ . A total of $m$ LFSRs of $\\log _ { 2 } ( n )$ -bit length with different seed values are required to form $M$ . By tuning the value of $p$ it is possible to change the sparsity degree of $M$ , and thus of the sparsely-connected network. Fig. 2(b) and Fig. 2(c) show the fully-connected network based on $W$ and the sparsely-connected version based on $W _ { s }$ . ",
+        "bbox": [
+            173,
+            867,
+            825,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b42c7cb35555f81c004363f73ded985fcb06d8726f2d47ae2c87782bf808a995.jpg",
+        "image_caption": [
+            "Figure 2: (a) shows the formation of a Mask matrix $M$ using a 3-bit LFSR for $p = 0 . 5 7$ . (b) shows a fully-connected layer. (c) shows a sparsely-connected layer formed based on $M$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            99,
+            787,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            627,
+            825,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 summarizes the training algorithm for the proposed sparsely-connected network. The algorithm itself is very similar to what would be used with a fully-connected network, but considers each network layer to have a mask that disables some of the connections. The forward propagation (line 1-5) follows (3), while derivatives in the backward computations (line 6-16) are computed with respect to $W _ { s }$ . It is worth mentioning that most CNNs use fully-connected layers and the proposed training algorithm can still be used for those layers in CNNs. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            851,
+            418,
+            866
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We have validated the effectiveness of the proposed sparsely-connected network and its training algorithm on three datasets: MNIST (LeCun & Cortes (2010)), CIFAR10 (Krizhevsky (2009)) and SVHN (Netzer et al. (2011)) using the Theano library (Team (2016)) in Python. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f99aca61f9c5136c172ec157e88bdfe8e74def3373461d054f4108ae7c249786.jpg",
+        "table_caption": [
+            "Table 1: Misclassification rate for Different Network Sizes on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Case</td><td rowspan=\"2\">Method</td><td>Network</td><td>Misclassification</td><td>Number of</td></tr><tr><td>Configuration</td><td>Rate (%)</td><td>Parameters</td></tr><tr><td rowspan=\"2\">1</td><td>Fully-Connected</td><td>784-512-512-10</td><td>1.18</td><td>669706</td></tr><tr><td>Sparsely-Connected 50%</td><td>784-512-512-10</td><td>1.19</td><td>335370</td></tr><tr><td rowspan=\"3\">2</td><td>Fully-Connected</td><td>784-256-256-10</td><td>1.35</td><td>269322</td></tr><tr><td>Sparsely-Connected 60%</td><td>784-512-512-10</td><td>1.20</td><td>268503</td></tr><tr><td>Sparsely-Connected 70%</td><td>784-512-512-10</td><td>1.31</td><td>201636</td></tr><tr><td rowspan=\"2\">3</td><td>Fully-Connected</td><td>784-145-145-10</td><td>1.41</td><td>136455</td></tr><tr><td>Sparsely-Connected 80%</td><td>784-512-512-10</td><td>1.28</td><td>134768</td></tr><tr><td rowspan=\"2\">4</td><td>Fully-Connected</td><td>784-77-77-10</td><td>1.75</td><td>67231</td></tr><tr><td>Sparsely-Connected 90%</td><td>784-512-512-10</td><td>1.75</td><td>67901</td></tr><tr><td rowspan=\"2\">5</td><td>Fully-Connected</td><td>784-12-12-10</td><td>4.68</td><td>9706</td></tr><tr><td>Sparsely-Connected 90%</td><td>784-100-100-10</td><td>3.16</td><td>8961</td></tr></table>",
+        "bbox": [
+            246,
+            127,
+            746,
+            335
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL RESULTS ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            475,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The MNIST dataset contains 60000 gray-scale $2 8 \\times 2 8$ images (50000 for training and 10000 for testing), falling into 10 classes. A deep fully-connected neural network is used for evaluation and the hinge loss is considered as the cost function. The training set is divided into two separate parts. The first 40000 images are used as the training set and the rest for the validation and test sets. All models are trained using SGD without momentum, a batch size of 100, 500 epochs and the batch normalization method. ",
+        "bbox": [
+            173,
+            395,
+            825,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 summarizes the misclassification rate of sparsely-connected neural networks compared to fully-connected neural networks for different network configurations, using single-precision floating-point format. We adopted a fully-connected network with 784-512-512-10 network configuration as a reference network, in which each number represent the number of inputs to each fully-connected layer. From this, we formed sparse weight matrices $W _ { s }$ with different sparsity degrees. For instance, sparsely-connected $9 0 \\%$ denotes sparse weight matrices containing $9 0 \\%$ zero elements. Case 1 shows that a sparsely-connected neural network with $5 0 \\%$ fewer connections achieves approximately the same accuracy as the fully-connected network using the same network configuration. In Cases 2 and 3, the sparsely-connected networks with $6 0 \\%$ and $8 0 \\%$ fewer connections achieve a better misclassification rate than the fully-connected network while having approximately the same number of parameters. Case 4 shows no gain in performance and number of parameters for a sparsely-connected $9 0 \\%$ and network configuration of 784-512-512-10 compared to the fully-connected at the same number of parameters. However, we can still reduce the connections up to $9 0 \\%$ using a smaller network, as shown in Case 5. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            680
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Recently, BinaryConnect and TernaryConnect neural networks have outperformed the state-of-theart on different datasets (Courbariaux et al. (2015); Lin et al. (2015)). In BinaryConnect, weights are represented with either $^ { - 1 }$ or 1, whereas they can be -1, 0 or 1 in TernaryConnect. These networks have emerged to facilitate hardware implementations of neural networks by reducing the memory requirements and removing multiplications. We applied our training method to BinaryConnect and TernaryConnect training algorithms: the obtained results are provided in Table 2. The source Python codes used for comparison are the same used in (Courbariaux et al. (2015); Lin et al. (2015)), available online (Lin et al. (2015)). The simulation results show that up to $7 0 \\%$ and $8 0 \\%$ of connections can be dropped by the proposed method from BinaryConnect and TernaryConnect networks without any compromise in performance without using data augmentation, respectively. Moreover, the binarized and ternarized sparsely-connected $5 0 \\%$ improve the accuracy compared to the conventional binarized and ternarized fully-connected networks. Considering data augmentation (affine transformation), our method can drop up to $5 0 \\%$ and $7 0 \\%$ of connections from BinaryConnect and TernaryConnect networks without any compromise in performance, respectively. However, using data augmentation results in a better misclassification rate when it is used on networks trained with single-precision floating-point weights as shown in Table 2. In this case, our method still can drop up to $90 \\%$ of connections without any performance degradation. It is worth specifying that we only used the binarized/ternarized algorithm during the learning phase, and we used single-precision floating-point weights during the test run in Section 4, similar to the approach used in (Lin et al. (2015)). ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7f464bbc3dd492008aac3e019967c782c85ead3f3a58f0c261a24d5cde58737c.jpg",
+        "table_caption": [
+            "Table 2: Misclassification rate for a 784-1024-1024-1024-10 neural network on MNIST "
+        ],
+        "table_footnote": [
+            "a Binarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the test run. b Ternarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the test run. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">Misclassification Rate (%)</td><td rowspan=\"2\"># of Parameters</td></tr><tr><td>Without Data Augmentation</td><td>With</td></tr><tr><td>Single-Precision Floating-Point (SPFP)</td><td>1.33</td><td>Data Augmentation</td><td>2913290</td></tr><tr><td>Sparsely-Connected 50% +SPFP</td><td>1.17</td><td>0.67 0.64</td><td>1458186</td></tr><tr><td>Sparsely-Connected 90% + SPFP</td><td>1.33</td><td>0.66</td><td>294103</td></tr><tr><td>BinaryConnecta(Courbariaux et al. (2015))</td><td>1.23</td><td>0.76</td><td>2913290</td></tr><tr><td>TernaryConnectb(Lin et al. (2015))</td><td>1.15</td><td>0.74</td><td>2913290</td></tr><tr><td>Sparsely-Connected 5O% +BinaryConnecta</td><td>0.99</td><td>0.75</td><td>1458186</td></tr><tr><td>Sparsely-Connected 6O% +BinaryConnecta</td><td>1.03</td><td>0.81</td><td>1167165</td></tr><tr><td>Sparsely-Connected 7O% + BinaryConnecta</td><td>1.16</td><td>0.85</td><td>876144</td></tr><tr><td>Sparsely-Connected 8O% +BinaryConnecta</td><td>1.32</td><td>1.06</td><td>585124</td></tr><tr><td>Sparsely-Connected 9O% +BinaryConnecta</td><td>1.33</td><td>1.36</td><td>294103</td></tr><tr><td>Sparsely-Connected 5O% + TernaryConnectb</td><td>0.95</td><td></td><td>1458186</td></tr><tr><td>Sparsely-Connected 6O% + TernaryConnectb</td><td>1.05</td><td>0.63 0.64</td><td>1167165</td></tr><tr><td>Sparsely-Connected 7O% + TernaryConnectb</td><td>1.01</td><td>0.73</td><td>876144</td></tr><tr><td>Sparsely-Connected 8O% + TernaryConnectb</td><td>1.11</td><td>0.85</td><td>585124</td></tr><tr><td>Sparsely-Connected 9o% + TernaryConnectb</td><td>1.41</td><td>1.05</td><td>294103</td></tr></table>",
+        "bbox": [
+            176,
+            127,
+            831,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            500,
+            826,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTAL RESULTS ON CIFAR10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            559,
+            490,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The CIFAR10 dataset consists of a total number of $6 0 , 0 0 0 3 2 \\times 3 2$ RGB images. Similar to MNIST, we split the images into 40, 000, 10, 000 and 10, 000 training, validation and test datasets, respectively. As our model, we adopt a convolutional network comprising $\\{ 1 2 8 - 1 2 8 - 2 5 6 - 2 5 6 - 5 1 2 - 5 1 2 \\}$ channels for six convolution/pooling layers and two 1024-node fully-connected layers followed by a classification layer. This architecture is inspired by VGGNet (Simonyan & Zisserman (2014)) and was also used in (Courbariaux et al. (2015)). Hinge loss is used for training with batch normalization and a batch size of 50. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            683
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to show the performance of the proposed technique, we use sparsely-connected networks instead of fully-connected networks in the convolutional network. Again, we compare our results with the binarized and ternarized models since they are the most hardware-friendly models reported to-date. As summarized in Table 3, simulation results show significant improvement in accuracy compared to the ordinary network while having significantly fewer parameters. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 EXPERIMENTAL RESULTS ON SVHN ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            779,
+            467,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "SVHN dataset contains $3 2 \\times 3 2$ RGB images (600, 000 images for training and roughly 26, 000 images for testing) of street house numbers. Also, $6 , 0 0 0$ images are separated from the training part for validation. Similar to the CIFAR10 case, we use a convolutional network comprising {128-128- $2 5 6 - 2 5 6 - 5 1 2 - 5 1 2 \\}$ channels for six convolution/pooling layers and two 1024 fully-connected layers followed by a classification layer. Hinge loss is used as the cost function with batch normalization and batch size of 50. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4 summarizes the accuracy performance of using the proposed sparsely-connected network in the convolutional network model, compared to the hardware-friendly binarized and ternarized models. Despite the fewer parameters that the proposed sparsely-connected network provides, it also yields state-of-the-art results in terms of accuracy performance. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e1c61f02203ce4bd56d4697bb41ad8322d36e0a3e6164f2500a546129d883cee.jpg",
+        "table_caption": [
+            "Table 3: Misclassification rate for a Convolutional Network on CIFAR10 "
+        ],
+        "table_footnote": [
+            "a Binarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the b Ternarizing algorithm was only used in the learning phase and single-precision floating-point weights were used during the test run. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">Misclassification Rate (%)</td><td rowspan=\"2\"># of Parameters</td></tr><tr><td>Without</td><td>With</td></tr><tr><td>Single-Precision Floating-Point (SPFP)</td><td>Data Augmentation</td><td>Data Augmentation</td><td></td></tr><tr><td>Sparsely-Connected 90% + SPFP</td><td>12.45</td><td>9.77</td><td>14025866 5523184</td></tr><tr><td>BinaryConnect a(Courbariaux etal. (2015))</td><td>12.05</td><td>9.30</td><td></td></tr><tr><td>TernaryConnect b(Lin et al. (2015))</td><td>9.91 9.32</td><td>8.01</td><td>14025866</td></tr><tr><td>Sparsely-Connected 5O% +BinaryConnect a</td><td></td><td>7.83</td><td>14025866</td></tr><tr><td>Sparsely-Connected 9O% +BinaryConnect a</td><td>8.95</td><td>7.27</td><td>9302154</td></tr><tr><td>Sparsely-Connected 5O% + TernaryConnect b</td><td>8.05</td><td>6.92</td><td>5523184</td></tr><tr><td>Sparsely-Connected 90% + TernaryConnect b</td><td>8.45</td><td>7.13</td><td>9302154</td></tr><tr><td></td><td>7.88</td><td>6.99</td><td>5523184</td></tr></table>",
+        "bbox": [
+            176,
+            127,
+            836,
+            313
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b4012fe37239016ddd09ffc2129f3206998c0285af7f0d1c865d325e4b08cceb.jpg",
+        "table_caption": [
+            "Table 4: Misclassification rate for a Convolutional Network on SVHN "
+        ],
+        "table_footnote": [
+            "a Binarizing algorithm was only used in the learning phase and single-precision floatingpoint weights were used during the test run. b Ternarizing algorithm was only used in the learning phase and single-precision floatingpoint weights were used during the test run. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>Misclassification Rate (%)</td><td>Number of Parameters</td></tr><tr><td>Single-Precision Floating-Point</td><td>4.734615</td><td>14025866</td></tr><tr><td>BinaryConnect a(Courbariaux et al. (2015)</td><td>2.134615</td><td>14025866</td></tr><tr><td>TernaryConnect b(Lin et al. (2015))</td><td>2.9</td><td>14025866</td></tr><tr><td>Sparsely-Connected 90% + BinaryConnect a</td><td>2.003846</td><td>5523184</td></tr><tr><td>Sparsely-Connected 90% + TernaryConnect b</td><td>1.957692</td><td>5523184</td></tr></table>",
+        "bbox": [
+            256,
+            397,
+            740,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            589,
+            823,
+            618
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 COMPARISON WITH THE STATE OF THE ART ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            633,
+            519,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The proposed sparsely-connected network has been compared to other networks in literature in terms of misclassification rate in Table 5. In Section 4.1 to 4.3, we used the binarization/ternarization algorithm to train our models in the learning phase while using single-precision floating-point weights during the test run (i.e. inference phase). The first part of Table 5 applies the same technique, while in the second part we use binarized/ternarized weights also during the test run. We thus exploit a deterministic method introduced in (Courbariaux et al. (2015)) to perform the test run using binarized/ternarized weights. The weights are obtained as follows: ",
+        "bbox": [
+            173,
+            660,
+            826,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b0c668467fc96cf332e6aa44bb03b2768f0f0a683f949752a7edec34240732c.jpg",
+        "text": "$$\nW _ { b } = \\left\\{ \\begin{array} { c l } { { 1 } } & { { \\mathrm { i f } W \\geq 0 } } \\\\ { { { - 1 } } } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            760,
+            584,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7cc5c839a9f4b23cdbf86abe9d9367a44a48f171aed82cd06182866e61f0139.jpg",
+        "text": "$$\nW _ { t } = \\left\\{ \\begin{array} { l l } { { 1 } } & { { \\mathrm { ~ i f ~ } W \\geq \\frac { 1 } { 3 } } } \\\\ { { 0 } } & { { \\mathrm { ~ o t h e r w i s e } } } \\\\ { { - 1 } } & { { \\mathrm { ~ i f ~ } W \\leq - \\frac { 1 } { 3 } } } \\end{array} \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            805,
+            589,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { b }$ and $W _ { t }$ denote binarized and ternarized weights, respectively. ",
+        "bbox": [
+            173,
+            875,
+            648,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From the results presented in Table 5, we can see that our proposed work outperforms the state-ofthe-art models with binarized/ternarized weights during the test run while achieving performance close to the state-of-the-art result of the model with no binarization/ternarization in the test run. The former are the most suitable and hardware-friendly models for hardware implementation of DNNs: our model shows a better performance in terms of both accuracy/misclassification rate and memory requirements. The obtained results suggest that the proposed network acts as a regularizer to prevent models from overfitting. Similar conclusions were also obtained in (Courbariaux et al. (2015)). It is worth noting that no data augmentation was used in our simulations throughout this paper except for the results reported in Table 2 and Table 3. ",
+        "bbox": [
+            173,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/dec35d730664ace09a7c72ebd0b8ec6c4e3b6aa5c5c9c1a2d4292c77f1d59d50.jpg",
+        "table_caption": [
+            "Table 5: Misclassification rate comparison. Sparsity degree for the proposed network is $5 0 \\%$ in MNIST, and $9 0 \\%$ in SVHN and CIFAR10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"2\">Datasets</td></tr><tr><td>Method</td><td>MNIST Binarized/Ternarized Weights During Test Run</td><td>SVHN</td><td>CIFAR10</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>BNN(Torch7)(Courbariaux &amp; Bengio (2016)) BNN (Theano)(Courbariaux &amp; Bengio (2016))</td><td>1.40%</td><td>2.53%</td><td>10.15%</td></tr><tr><td>(Baldassi et al. (2015))</td><td>0.96% 1.35%</td><td>2.80%</td><td>11.40%</td></tr><tr><td>BinaryConnect (Courbariaux et al.(2015))</td><td>1.29%</td><td>1</td><td>1</td></tr><tr><td>EBP (Cheng et al. (2015))</td><td>2.2%</td><td>2.30%</td><td>9.90%</td></tr><tr><td>Bitwise DNNs (Kim &amp; Smaragdis (2016))</td><td>1.33%</td><td>1</td><td>1</td></tr><tr><td>(Hwang&amp; Sung (2014))</td><td>1.45%</td><td>1</td><td>1</td></tr><tr><td></td><td>1.08%</td><td>1</td><td>1</td></tr><tr><td>Sparsely-Connected+BinaryConnect</td><td>0.98%</td><td>2.053846% 1.992308%</td><td>8.66%</td></tr><tr><td>Sparsely-Connected+ TernaryConnect</td><td></td><td></td><td>8.24%</td></tr><tr><td>Method</td><td>Single-Precision Floating-Point Weights During Test Run</td><td></td><td></td></tr><tr><td>TernaryConnect (Lin et al. (2015))</td><td>1.15%</td><td>2.42%</td><td>12.01%</td></tr><tr><td>Maxout Networks (Goodfellow et al.(2013))</td><td>0.94%</td><td>2.47%</td><td>11.68%</td></tr><tr><td>Network in Network (Lin et al.(2013))</td><td></td><td>2.35%</td><td>10.41%</td></tr><tr><td>Gated pooling (Lee et al. (2015))</td><td>1</td><td>1.69%</td><td>7.62%</td></tr><tr><td>Sparsely-Connected+BinaryConnect</td><td>0.99%</td><td>2.003846%</td><td>8.05%</td></tr><tr><td>Sparsely-Connected+ TernaryConnect</td><td>0.95%</td><td>1.957692%</td><td>7.88%</td></tr></table>",
+        "bbox": [
+            223,
+            140,
+            772,
+            417
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            459,
+            825,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 VLSI IMPLEMENTATION OF SPARSELY-CONNECTED NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            595,
+            816,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this Section, we propose an efficient hardware architecture for the proposed sparsely-connected network. In fully-connected networks, the main computational core is the matrix-vector multiplication that computes (1). This computation is usually implemented in parallel on GPUs. However, parallel implementation of this unit requires parallel access to memories and causes routing congestion, leading to large silicon area and power/energy consumption in customized hardware. Thus, VLSI architectures usually opt for semi-parallel implementations of such networks. In this approach, each neuron performs its computations serially, and a certain number of neurons are instantiated in parallel (Moreno et al. (2008)). Every neuron is implemented using multiply-and-accumulate (MAC) units as shown in Fig. 3(a). The number of inputs of each neuron determines the latency of this architecture. For example, considering a hidden layer with 1024 inputs and 1024 outputs, 1024 MACs are required in parallel and each MAC requires 1024 clock cycles to perform computations of this layer. In general, a counter is required to count from 0 to $N - 1$ where $N$ is the number of inputs of each neuron. It provides the addresses for the memory in which a column of the weight matrix $W$ is stored. In this way, each input and its corresponding weight are fed to the multiplier every clock cycle (see Fig. 3(a)). For binarized/ternarized networks, the multiplier in 3(a) is substituted with a multiplexer. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Section 3, we described the formation of the Mask matrix $M$ using an SNG unit (see Fig. 2(a)). The value of $p$ , through which it is possible to tune the sparsity degree of networks, also corresponds to the occurrence of 1 in a binary stream generated by SNG. Therefore, we can save up to $9 \\hat { 0 } \\%$ of memory by storing only the weights corresponding to the 1s in the SNG stream. For instance, considering a Mask matrix $M$ in Fig. 2(a), $W _ { s }$ is formed as ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba40bac7f6042434ce819f57c15eb7b93d15a82be0d1abbb4ce296f2f28ad5c3.jpg",
+        "image_caption": [
+            "Figure 3: (a) shows the conventional architecture of a single neuron of a fully-connected network. (b) shows the proposed architecture of a single neuron of a sparsely-connected network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            97,
+            794,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            785,
+            565,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18dddf2f238cdccaeaa872973501952bc0ca31023bf56d5a9eee1fe0085ee536.jpg",
+        "text": "$$\nW _ { s } = \\left[ \\begin{array} { c c } { 0 } & { 0 } \\\\ { W _ { 2 1 } } & { W _ { 2 2 } } \\\\ { W _ { 3 1 } } & { 0 } \\\\ { W _ { 4 1 } } & { 0 } \\\\ { 0 } & { W _ { 5 2 } } \\\\ { W _ { 6 1 } } & { W _ { 6 2 } } \\\\ { 0 } & { W _ { 7 2 } } \\end{array} \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            828,
+            573,
+            926
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/62a245d3d6659219ea60e2043290ca95a7800f10636eaa68ca2e6f1294ecd233.jpg",
+        "table_caption": [
+            "Table 6: ASIC Implementation Results for a Single Neuron of Sparsely-Connected Network $@$ 400 MHz in TSMC 65 nm CMOS Technology. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"5\">Sparsity Degree</td></tr><tr><td>p=0 Fully-Connected (FC)</td><td>p=0.5</td><td>p=0.75 Sparsely-Connected</td><td>p= 0.875 Sparsely-Connected</td><td>p= 0.9375 Sparsely-Connected</td></tr><tr><td>Memory Size [bits]</td><td>1024</td><td>Sparsely-Connected 512</td><td>256</td><td>128</td><td>64</td></tr><tr><td>Area [μm²](improvement W.r.t.FC)</td><td>26265</td><td>13859 (47%↓)</td><td>7316 (72% ↓)</td><td>4221(84% ↓)</td><td>2662 (90%↓)</td></tr><tr><td>Power [μW]</td><td>278</td><td>155</td><td>86</td><td>60</td><td>43</td></tr><tr><td>Energy [pJ](improvement w.r.t.FC)</td><td>712</td><td>397(44%↓)</td><td>220(69%↓)</td><td>154(78%↓)</td><td>110 (84%↓)</td></tr><tr><td>Latency [μs]</td><td>2.56</td><td>2.56</td><td>2.56</td><td>2.56</td><td>2.56</td></tr></table>",
+        "bbox": [
+            176,
+            142,
+            820,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "and the compressed matrix $W _ { c }$ stored in on-chip memories is ",
+        "bbox": [
+            173,
+            265,
+            575,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ac317f3c557025e09f238a086242addf8faba0341cdf9cbf6ab517d05769a2b.jpg",
+        "text": "$$\nW _ { c } = \\left[ \\begin{array} { l l } { W _ { 2 1 } } & { W _ { 2 2 } } \\\\ { W _ { 3 1 } } & { W _ { 5 2 } } \\\\ { W _ { 4 1 } } & { W _ { 6 2 } } \\\\ { W _ { 6 1 } } & { W _ { 7 2 } } \\end{array} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            287,
+            575,
+            347
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The smaller memory can significantly reduce the silicon area and the power consumption of DNNs architectures. Depending on the value of $p$ , the size of the memory varies. In general, the depth of the weight memory in each neuron is $( 1 - p ) \\times N$ . ",
+        "bbox": [
+            174,
+            353,
+            823,
+            396
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3(b) depicts the architecture of a single neuron of the proposed sparsely-connected network. Decompression is performed using an SNG generating the enable signal of the counter and accumulator. Inputs are fed into each neuron sequentially in each clock cycle. If the output of the SNG is 1, the counter counts upward and provides an address for the memory. Then, the multiplication of an input and its corresponding weight is computed, the result stored in the internal register of the accumulator. If instead the output of the SNG is 0, the counter holds its previous value, while the internal register of the accumulator is not enabled, and does not load a new value. The latency of the proposed architecture is the same as that of the conventional architecture. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 6 shows the ASIC implementation results of the neuron in Fig. 3(b) supposing 1024 inputs. The proposed architectures were described in VHDL and synthesized in TSMC 65 nm CMOS technology with Cadence RTL compiler, for different sparsity degrees $p$ . For the provided syntheses we used a binarized network. Implementation results show up to $\\bar { 8 } 4 \\%$ decrement in energy consumption and up to $9 0 \\%$ less area compared to the conventional fully-connected architecture. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            318,
+            626
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "DNNs are capable of solving complex tasks: their ability to do so depends on the number of neurons and their connections. Fully-connected layers in DNNs contain more than $9 6 \\%$ of the total neural network parameters, pushing the designers to use off-chip memories which are band-width limited and consume large amounts of energy. In this paper, we proposed sparsely-connected networks and their training algorithm to substantially reduce the memory requirements of DNNs. The sparsity degree of the proposed network can be tuned by an SNG, which is implemented using an LFSR unit and a comparator. We used the proposed sparsely-connected network instead of fully-connected networks in a VGG-like network on three commonly used datasets: we achieved better accuracy results with up to $9 0 \\%$ fewer connections than the state of the art. Moreover, our simulation results confirm that the proposed network can be used as a regularizer to prevent models from overfitting. Finally, we implemented a single neuron of the sparsely-connected network in in $6 5 \\ \\mathrm { n m } \\mathrm { C M O S }$ technology for different sparsity degrees. The implementation results show that the proposed architecture can save up to $8 4 \\%$ energy and $9 0 \\%$ silicon area compared to the conventional fully-connected network while having a lower misclassification rate. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            837
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            285,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "F. Akopyan, J. Sawada, A. Cassidy, R. Alvarez-Icaza, J. Arthur, P. Merolla, N. Imam, Y. Nakamura, P. Datta, G. J. Nam, B. Taba, M. Beakes, B. Brezzo, J. B. Kuang, R. Manohar, W. P. Risk, B. Jackson, and D. S. Modha. TrueNorth: design and tool flow of a $6 5 ~ \\mathrm { m W }$ 1 million neuron programmable neurosynaptic chip. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 34(10):1537–1557, Oct 2015. ISSN 0278-0070. doi: 10.1109/TCAD.2015. 2474396. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            187,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. CoRR, abs/1512.08571, 2015. URL http://arxiv.org/abs/1512.08571. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arash Ardakani, Franc¸ois Leduc-Primeau, Naoya Onizawa, Takahiro Hanyu, and Warren J. Gross. VLSI implementation of deep neural network using integral stochastic computing. CoRR, abs/1509.08972, 2015. URL http://arxiv.org/abs/1509.08972. ",
+        "bbox": [
+            176,
+            191,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Carlo Baldassi, Alessandro Ingrosso, Carlo Lucibello, Luca Saglietti, and Riccardo Zecchina. Subdominant dense clusters allow for simple learning and high computational performance in neural networks with discrete synapses. Phys. Rev. Lett., 115:128101, Sep 2015. ",
+        "bbox": [
+            174,
+            243,
+            823,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lukas Cavigelli, David Gschwend, Christoph Mayer, Samuel Willi, Beat Muheim, and Luca Benini. Origami: a convolutional network accelerator. CoRR, abs/1512.04295, 2015. URL http:// arxiv.org/abs/1512.04295. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu-Hsin Chen, Joel Emer, and Vivienne Sze. Eyeriss: a spatial architecture for energy-efficient dataflow for convolutional neural networks. In Proceedings of the 43rd International Symposium on Computer Architecture, ISCA ’16, pp. 367–379, Piscataway, NJ, USA, 2016. IEEE Press. ISBN 978-1-4673-8947-1. doi: 10.1109/ISCA.2016.40. URL http://dx.doi.org/10. 1109/ISCA.2016.40. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu-Hsin Chen, Tushar Krishna, Joel Emer, and Vivienne Sze. Eyeriss: An Energy-Efficient Reconfigurable Accelerator for Deep Convolutional Neural Networks. In IEEE International Solid-State Circuits Conference, ISSCC 2016, Digest of Technical Papers, pp. 262–263, 2016. ",
+        "bbox": [
+            176,
+            425,
+            821,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhiyong Cheng, Daniel Soudry, Zexi Mao, and Zhen-zhong Lan. Training binary multilayer neural networks for image classification using expectation backpropagation. CoRR, abs/1503.03562, 2015. ",
+        "bbox": [
+            173,
+            477,
+            821,
+            520
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux and Yoshua Bengio. BinaryNet: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. CoRR, abs/1602.02830, 2016. ",
+        "bbox": [
+            169,
+            529,
+            823,
+            559
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. BinaryConnect: Training deep neural networks with binary weights during propagations. CoRR, abs/1511.00363, 2015. ",
+        "bbox": [
+            171,
+            565,
+            823,
+            595
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B. R. Gaines. Stochastic Computing Systems, pp. 37–172. Springer US, Boston, MA, 1969. ISBN 978-1-4899-5841-9. ",
+        "bbox": [
+            171,
+            603,
+            823,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ian J. Goodfellow, David Warde-farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. In In ICML, 2013. ",
+        "bbox": [
+            171,
+            641,
+            825,
+            671
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "S. Han, X. Liu, H. Mao, J. Pu, A. Pedram, M. A. Horowitz, and W. J. Dally. EIE: Efficient inference engine on compressed deep neural network. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pp. 243–254, June 2016. doi: 10.1109/ISCA.2016.30. ",
+        "bbox": [
+            176,
+            679,
+            823,
+            723
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J. Dally. Deep compression: compressing deep neural network with pruning, trained quantization and huffman coding. CoRR, abs/1510.00149, 2015. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            760
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mark Horowitz. 1.1 computing’s energy problem (and what we can do about it). In 2014 IEEE International Solid-State Circuits Conference Digest of Technical Papers (ISSCC), pp. 10–14, Feb 2014. doi: 10.1109/ISSCC.2014.6757323. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            811
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "K. Hwang and W. Sung. Fixed-point feedforward deep neural network design using weights -1, 0, and 1. In 2014 IEEE Workshop on Signal Processing Systems (SiPS), pp. 1–6, Oct 2014. ",
+        "bbox": [
+            173,
+            819,
+            823,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: accelerating deep network training by reducing internal covariate shift. CoRR, abs/1502.03167, 2015. URL http://arxiv.org/ abs/1502.03167. ",
+        "bbox": [
+            173,
+            857,
+            826,
+            900
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Minje Kim and Paris Smaragdis. Bitwise neural networks. CoRR, abs/1601.06071, 2016. ",
+        "bbox": [
+            168,
+            909,
+            759,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            169,
+            103,
+            805,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 25, pp. 1097–1105. Curran Associates, Inc., 2012. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural Comput., 1(4):541–551, December 1989. ISSN 0899-7667. doi: 10.1162/neco.1989.1.4.541. URL http://dx.doi. org/10.1162/neco.1989.1.4.541. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/. ",
+        "bbox": [
+            176,
+            260,
+            820,
+            289
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yann Lecun, Lon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. In Proceedings of the IEEE, pp. 2278–2324, 1998. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yann Lecun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 5 2015. ISSN 0028-0836. doi: 10.1038/nature14539. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            364
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chen-Yu Lee, Patrick W. Gallagher, and Zhuowen Tu. Generalizing pooling functions in convolutional neural networks: mixed, gated, and tree. CoRR, abs/1509.08985, 2015. ",
+        "bbox": [
+            173,
+            375,
+            821,
+            404
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. CoRR, abs/1312.4400, 2013. ",
+        "bbox": [
+            173,
+            412,
+            789,
+            428
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhouhan Lin, Matthieu Courbariaux, Roland Memisevic, and Yoshua Bengio. Neural networks with few multiplications. CoRR, abs/1510.03009, 2015. ",
+        "bbox": [
+            171,
+            436,
+            821,
+            465
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "F. Moreno, J. Alarcon, R. Salvador, and T. Riesgo. Fpga implementation of an image recognition system based on tiny neural networks and on-line reconfiguration. In Industrial Electronics, 2008. IECON 2008. 34th Annual Conference of IEEE, pp. 2445–2452, Nov 2008. doi: 10.1109/IECON. 2008.4758340. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            531
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In Johannes Frnkranz and Thorsten Joachims (eds.), Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 807–814. Omnipress, 2010. URL http://www.icml2010.org/papers/432.pdf. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            598
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford.edu/ housenumbers/nips2011_housenumbers.pdf. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            664
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D. E. Rumelhart, G. E. Hinton, and R. J. Williams. Parallel distributed processing: Explorations in the microstructure of cognition, vol. 1. chapter Learning Internal Representations by Error Propagation, pp. 318–362. MIT Press, Cambridge, MA, USA, 1986. ISBN 0-262-68053-X. URL http://dl.acm.org/citation.cfm?id $\\mathbf { \\Phi } = \\mathbf { \\dot { \\Phi } }$ 104279.104293. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            729
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A. Shafiee, A. Nag, N. Muralimanohar, R. Balasubramonian, J. P. Strachan, M. Hu, R. S. Williams, and V. Srikumar. ISAAC: a convolutional neural network accelerator with in-situ analog arithmetic in crossbars. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pp. 14–26, June 2016a. doi: 10.1109/ISCA.2016.12. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            795
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "M. J. Shafiee, P. Siva, and A. Wong. StochasticNet: forming deep neural networks via stochastic connectivity. IEEE Access, 4:1915–1924, 2016b. ISSN 2169-3536. ",
+        "bbox": [
+            166,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. ",
+        "bbox": [
+            168,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sean C. Smithson, Kaushik Boga, Arash Ardakani, Brett H. Meyer, and Warren J. Gross. Stochastic computing can improve upon digital spiking neural networks. In 2016 IEEE Workshop on Signal Processing Systems (SiPS), pp. 309–314, Oct 2016. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C. Szegedy, Wei Liu, Yangqing Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, June 2015. doi: 10.1109/CVPR.2015.7298594. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yichuan Tang. Deep learning using support vector machines. CoRR, abs/1306.0239, 2013. URL http://arxiv.org/abs/1306.0239. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. ",
+        "bbox": [
+            171,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. CoRR, abs/1608.03665, 2016. URL http://arxiv.org/abs/ 1608.03665. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. CoRR, abs/1311.2901, 2013. URL http://arxiv.org/abs/1311.2901. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 13
+    }
+]