Add files using upload-large-folder tool

parse/train/6rEnMF1okeiBO/6rEnMF1okeiBO.md

@@ -0,0 +1,209 @@
+# Low-Rank Approximations for Conditional Feedforward Computation in Deep Neural Networks
+
+Andrew S. Davis Department of Electrical Engineering and Computer Science University of Tennessee andrew.davis@utk.edu
+
+Itamar Arel Department of Electrical Engineering and Computer Science University of Tennessee itamar@ieee.org
+
+# Abstract
+
+Scalability properties of deep neural networks raise key research questions, particularly as the problems considered become larger and more challenging. This paper expands on the idea of conditional computation introduced in [2], where the nodes of a deep network are augmented by a set of gating units that determine when a node should be calculated. By factorizing the weight matrix into a low-rank approximation, an estimation of the sign of the pre-nonlinearity activation can be efficiently obtained. For networks using rectified-linear hidden units, this implies that the computation of a hidden unit with an estimated negative pre-nonlinearity can be omitted altogether, as its value will become zero when nonlinearity is applied. For sparse neural networks, this can result in considerable speed gains. Experimental results using the MNIST and SVHN data sets with a fully-connected deep neural network demonstrate the performance robustness of the proposed scheme with respect to the error introduced by the conditional computation process.
+
+# 1 Introduction
+
+In recent years, deep neural networks have redefined state-of-the-art in many application domains, notably in computer vision [11] and speech processing [14]. In order to scale to more challenging problems, however, neural networks must become larger, which implies an increase in computational resources. Shifting computation to highly parallel platforms such as GPUs has enabled the training of massive neural networks that would otherwise train too slowly on conventional CPUs. While the extremely high computational power used for the experiment performed in [12] (16,000 cores training for many days) was greatly reduced in [4] (3 servers training for many days), specialized high-performance platforms still require several machines and several days of processing time. However, there may exist more fundamental changes to the algorithms involved which can greatly assist in scaling neural networks.
+
+Many of these state-of-the-art networks have several common properties: the use of rectified-linear activation functions in the hidden neurons, and a high level of sparsity induced by dropout regularization or a sparsity-inducing penalty term on the loss function. Given that many of the activations are effectively zero, due to the combination of sparsity and the hard thresholding of rectified linear units, a large amount of computation is wasted on calculating values that are eventually truncated to zero and provide no contribution to the network outputs or error components. Here we focus on this key observation in devising a scheme that can predict the zero-valued activations in a computationally cost-efficient manner.
+
+![](images/330c633a35bf86691190ce2c9e23656faa49e05ba728a5e0d3579d3dd77aadaa.jpg)  
+Figure 1: An illustration of an activation estimator. $U$ and $V$ represent the factorization of the lowrank matrix and $W$ denotes the full-rank matrix. In this case, the activation estimator recommends that only the $2 ^ { n d }$ and the $n ^ { t h }$ neuron be computed for layer $l + 1$ .
+
+# 2 Conditional Computation in Deep Neural Networks
+
+# 2.1 Exploiting Redundancy in Deep Architectures
+
+In [5], the authors made the observation that deep models tend to have a high degree of redundancy in their weight parameterization. The authors exploit this redundancy in order to train as few as $5 \%$ of the weights in a neural network while estimating the other $9 5 \%$ with the use of carefully constructed low-rank decompositions of the weight matrices. Such a reduction in the number of active training parameters can render optimization easier by reducing the number of variables to optimize over. Moreover, it can help address the problem of scalability by greatly reducing the communication overhead in a distributed system.
+
+Assuming there is a considerable amount of redundancy in the weight parameterization, a similar level of redundancy is likely found in the activation patterns of individual neurons. Therefore, given an input sample, the set of redundant activations in the network may be approximated. If a sufficiently accurate approximation can be obtained using low computational resources, activations for a subset of neurons in the network’s hidden layers need not be calculated.
+
+In [2] and [3], the authors propose the idea of conditional computation in neural networks, where the network is augmented by a gating model that turns activations on or off depending on the state of the network. If this gating model is able to reliably estimate which neurons need to be calculated for a particular input, great improvements in computational efficiency may be obtainable if the network is sufficiently sparse. Figure 1 illustrates a conditional computation unit augmenting a layer of a neural net by using some function $f \left( U , V , a _ { l } \right)$ to determine which hidden unit activations $a _ { l + 1 }$ should be computed given the activations $a _ { l }$ of layer $l$ .
+
+# 2.2 Sparse Representations, Activation Functions, and Prediction
+
+In some situations, sparse representations may be superior to dense representations, particularly in the context of deep architectures [7]. However, sparse representations learned by neural networks with sigmoidal activations are not truly “sparse”, as activations only approach zero in the limit towards negative infinity. A conditional computation model estimating the sparsity of a sigmoidal network would thus have to impose some threshold, beyond which the neuron is considered inactive. So-called “hard-threshold” activation functions such as rectified-linear units, on the other hand, produce true zeros which can be used by conditional computation models without imposing additional hyperparameters.
+
+![](images/bb9a58a228619740cc5b690dffa4597c00b0675e72d7f0d8c1f1ae3f6187ad37.jpg)  
+Figure 2: The low-rank approximation $U V$ can be substituted in for $W$ , and can approximate the matrix $W$ with a relatively low rank. However, if we use the output of the activation estimator $S$ , as defined in Eq. (5), with the full-rank feedforward, $\sigma \left( a W \right) \cdot S$ , a lower-rank approximation can be utilized. The activations and weights are from the first layer of a neural network trained on MNIST, and the factorization $U V$ is obtained via SVD.
+
+# 3 Problem Formulation
+
+# 3.1 Estimating Activation Sign via Low-Rank Approximation
+
+Given the activation $a _ { l }$ of layer $l$ of a neural network, the activation $a _ { l + 1 }$ of layer $l + 1$ is given by:
+
+$$
+a _ { l + 1 } = \sigma ( a _ { l } W _ { l } )
+$$
+
+where $\sigma ( \cdot )$ denotes the function defining the neuron’s non-linearity, $a _ { l } \in \mathbb { R } ^ { n \times h _ { 1 } }$ , $a _ { l + 1 } \in \mathbb { R } ^ { n \times h _ { 2 } }$ , $W _ { l } \in \mathbb { R } ^ { \dot { h _ { 1 } } \times h _ { 2 } }$ . If the weight matrix is highly redundant, as in [5], it can be well-approximated using a low-rank representation and we may rewrite (1) as
+
+$$
+a _ { l + 1 } = \sigma ( a _ { l } U _ { l } V _ { l } )
+$$
+
+where $U _ { l } V _ { l }$ is the low-rank approximation of $W _ { l }$ , $U _ { l } \in \mathbb { R } ^ { h _ { 1 } \times k }$ , $V _ { l } \in \mathbb { R } ^ { k \times h _ { 2 } }$ , $k \ll \operatorname* { m i n } ( h _ { 1 } , h _ { 2 } )$ . So long as $\begin{array} { r } { k < \frac { h _ { 1 } h _ { 2 } } { h _ { 1 } + h _ { 2 } } } \end{array}$ , the low-rank multiplication $a _ { l } U _ { l } V _ { l }$ requires fewer arithmetic operations than the full-rank multiplication $a _ { l } W _ { l }$ , assuming the multiplication $a _ { l } U _ { l }$ occurs first. When $\sigma ( \cdot )$ is the rectified-linear function,
+
+$$
+\sigma ( x ) = \operatorname* { m a x } ( 0 , x )
+$$
+
+such that all negative elements of the linear transform $a _ { l } W _ { l }$ become zero, one only needs to estimate the sign of the elements of the linear transform in order to predict the zero-valued elements. Assuming the weights in a deep neural network can be well-approximated using a low-rank estimation, the small error in the low-rank estimation is of marginal relevance in the context of recovering the sign of the operation.
+
+Given a low-rank approximation $W _ { l } \approx U _ { l } V _ { l } = { \hat { W } } _ { l }$ , the estimated sign of $a _ { l + 1 }$ is given by
+
+$$
+s g n ( a _ { l + 1 } ) \approx s g n ( a _ { l } \hat { W } _ { l } )
+$$
+
+Each element $( a _ { l + 1 } ) _ { i , j }$ is given by a dot product between the row vector $a _ { l } ^ { ( i ) }$ and the column vector $W _ { l } ^ { ( j ) }$ . If $s g n ( a _ { l } \hat { W } _ { l } ^ { ( j ) } ) = - 1$ , then the true activation $( a _ { l + 1 } ) _ { i , j }$ is likely negative, and will likely become zero after the rectified-linear function is applied. Considerable speed gains are possible if we skip those dot products based on the prediction; such gains are especially substantial when the network is very sparse. The overall activation for a hidden layer $l$ augmented by the activation estimator is given by $\sigma \left( a _ { l } W _ { l } \right) \cdot S _ { l }$ , where $\cdot$ denotes the element-wise product and $S _ { l }$ denotes a matrix of zeros and ones, where
+
+$$
+\left( S _ { l } \right) _ { i , j = } \left\{ 0 , \quad s g n \left( \left( a _ { l } U _ { l } V _ { l } \right) _ { i , j } \right) = - 1 \right. \nonumber
+$$
+
+Figure 2 illustrates the error profile of a neural network using the low-rank estimation $U V$ in place of $W$ compared with a neural network augmented with an activation sign estimator as the rank is varied from one to full-rank. One can see that the error of the activation sign estimator diminishes far more quickly than the error of the low-rank activation, implying that the sign estimator can do well with a relatively low-rank approximation of $W$ .
+
+# 3.2 SVD as a Low-Rank Approximation
+
+The Singular Value Decomposition (SVD) is a common matrix decomposition technique that factorizes a matrix $A \in \mathbb { R } ^ { m \times n }$ into $A = U \Sigma V ^ { T }$ , $U \in \mathbb { R } ^ { m \times m } , \Sigma \in \mathbb { R } ^ { m \times n } , V \in \mathbb { R } ^ { n \times n }$ . By [6], the matrix $A$ can be approximated using a low rank matrix $\hat { A } _ { r }$ corresponding to the solution of the constrained optimization of
+
+$$
+\operatorname* { m i n } _ { \hat { A } _ { r } } \| A - \hat { A } _ { r } \| _ { F }
+$$
+
+where $\| \cdot \| _ { F }$ is the Frobenius norm, and $\hat { A } _ { r }$ is constrained to be of rank $r \ < \ r a n k ( A )$ . The minimizer $\hat { A } _ { r }$ is given by taking the first $r$ columns of $U$ , the first $r$ diagonal entries of $\Sigma$ , and the first $r$ columns of $V$ . The resulting matrices $U _ { r }$ , $\Sigma _ { r }$ , and $V _ { r }$ are multiplied, yielding $\hat { A } _ { r } = U _ { r } \Sigma _ { r } V _ { r } ^ { T }$ . The low-rank approximation $\hat { W } = U V$ is then defined such that $\hat { W } = U _ { r } ( \Sigma _ { r } V _ { r } ^ { T } )$ , where $U = U _ { r }$ and $\begin{array} { r } { V = \Sigma _ { r } V _ { r } ^ { \bar { T } } } \end{array}$ .
+
+Unfortunately, calculating the SVD is an expensive operation, on the order of $O ( m n ^ { 2 } )$ , so recalculating the SVD upon the completion of every minibatch adds significant overhead to the training procedure. Given that we are uniquely interested in estimating in the sign of $a _ { l + 1 } = a _ { l } W _ { l }$ , we can opt to calculate the SVD less frequently than once per minibatch, assuming that the weights $W _ { l }$ do not change significantly over the course of a single epoch so as to corrupt the sign estimation.
+
+# 3.3 Encouraging Neural Network Sparsity
+
+To overcome the additional overhead imposed by the conditional computation architecture, the neural network must have sparse activations. Without encouragement to settle on weights that result in sparse activations, such as penalties on the loss function, a neural network will not necessarily become sparse enough to be useful in the context of conditional computation. Therefore, an $\ell _ { 1 }$ penalty for the activation vector of each layer is applied to the overall loss function, such that
+
+$$
+J ( W , \lambda ) = L ( W ) + \lambda \sum _ { l = 1 } ^ { L } \| a _ { l } \| _ { 1 }
+$$
+
+Such a penalty is commonly used in sparse dictionary learning algorithms and tends to push elements of $a _ { l }$ towards zero [13].
+
+Dropout regularization [9] is another technique known to sparsify the hidden activations in a neural network. Dropout first sets the hidden activations $a _ { l }$ to zero with probability $p$ . During training, the number of active neurons is likely less than $p$ for each minibatch. When the regularized network is running in the inference mode, dropout has been observed to have a sparsifying effect on the hidden activations [17]. The adaptive dropout method [1] can further decrease the number of active neurons without degrading the performance of the network.
+
+# 3.4 Theoretical Speed Gain
+
+For every input example, a standard neural network computes $\sigma \left( a W \right)$ , where $a ~ \in ~ \mathbb { R } ^ { N \times d }$ and $W \in \mathbb { R } ^ { \mathsf { \bar { d } } \times h }$ , where $N = 1$ for a fully-connected network, or $N$ is the number of convolutions for a convolutional network. Assuming additions and multiplications are constant-time operations, the matrix multiplication requires $N \left( 2 d - 1 \right) h$ floating point operations (we need to compute $N h$ dot products, where each dot product consists of $d$ multiplications and $d - 1$ additions), and the activation function requires $N h$ floating point operations, yielding $N \left( 2 d - 1 \right) h + N h$ operations. The activation estimator $\sigma \left( a U V \right)$ , $U \in \mathbb { R } ^ { d \times k }$ , $V \in \mathbb { R } ^ { k \times \tilde { h } }$ requires $N \left( 2 d - 1 \right) k + N \left( 2 k - 1 \right) h$ floating point operations for the low-rank multiplication followed by $N h$ operations for the sgn (·) activation function, yielding $N \left( 2 d - 1 \right) k + \bar { N ( 2 k - 1 ) } h + N h$ . However, given a sparsity coefficient $\alpha \in [ 0 , 1 ]$ (where $\alpha = 0$ implies no activations are active, and $\alpha = 1$ implies all activations are active), a conditional matrix multiplication would require $\alpha N \left( 2 d - 1 \right) h + \alpha N h$ operations. The SVD calculation to obtain the activation estimation weights is $\beta O \left( n d \operatorname* { m i n } \left( n , d \right) \right)$ , where $\beta$ is the ratio of feed-forwards to SVD updates (eg., with a minibatch size of 250, a training set size of 50,000, and once-per-epoch SVD updates, $\begin{array} { r } { \dot { \beta } = \frac { 2 5 0 } { 5 0 0 0 0 } = 0 . 0 0 5 ) } \end{array}$ .
+
+Altogether, the number of floating point operations for calculating the feed-forward in a layer in a standard neural network is
+
+$$
+F _ { n n } = N \left( 2 d - 1 \right) h + N h
+$$
+
+and the number of floating point operations for the activation estimation network with conditional computation is
+
+$$
+F _ { a e } = N \left( 2 d - 1 \right) k + N \left( 2 k - 1 \right) h + N h + \alpha h \left( N \left( 2 d - 1 \right) h + N h \right) + \beta O \left( n d \operatorname* { m i n } \left( n , d \right) \right) .
+$$
+
+The relative reduction of floating point operations for a layer can be represented as $\scriptstyle { \frac { F _ { n n } } { F _ { a e } } }$ , and is simplified as
+
+$$
+\frac { 2 d h } { k \left( 2 d + 2 h - 1 \right) + 2 \alpha d h + \beta O \left( n d \operatorname* { m i n } \left( n , d \right) \right) }
+$$
+
+For a neural network with many layers, the relative speedup is given by
+
+$$
+\begin{array} { l } { { \displaystyle \sum _ { i = 1 } ^ { L } F _ { n n } ^ { ( l ) } } } \\ { { \displaystyle \sum _ { i = 1 } ^ { L } F _ { a e } ^ { ( l ) } } } \end{array}
+$$
+
+where $F _ { n n } ^ { ( l ) }$ is the number of floating point operations for theth ${ { l } ^ { t h } }$ layer of the full network, and $F _ { a e } ^ { ( l ) }$ is the number of floating point operations for the layer of the network augmented by the activation estimation network. The overall speedup is greatly dependent on the sparsity of the network and the overhead of the activation estimator.
+
+# 3.5 Implementation Details
+
+The neural network is built using Rasmus Berg Palm’s Deep Learning Toolbox [16]. All hidden units are rectified-linear, and the output units are softmax trained with a negative log-likelihood loss function. The weights, $w$ , are initialized as $w \sim \mathcal { N } \left( 0 , \sigma ^ { 2 } \right)$ and biases $b$ are set to 1 in order to encourage the neurons to operate in their non-saturated region once training begins, as suggested in [11]. In all experiments, the dropout probability $p$ is fixed to 0.5 for the hidden layers.
+
+The learning rate $\gamma$ is scheduled such that $\gamma _ { n } ~ = ~ \gamma _ { 0 } \lambda ^ { n }$ where $\gamma _ { n }$ is the learning rate for the $n ^ { t h }$ epoch, $\gamma _ { 0 }$ is the initial learning rate, and $\lambda$ is a decay term slightly less than 1, eg., 0.995. The momentum term $\nu$ is scheduled such that $\nu _ { n } = \operatorname* { m a x } \left( \nu _ { m a x } , \nu _ { 0 } \beta ^ { n } \right)$ where $\nu _ { n }$ is the momentum for the $n ^ { t h }$ epoch, $\nu _ { m a x }$ is the maximum allowed momentum, $\nu _ { 0 }$ is the initial momentum, and $\beta$ is an incremental term slightly greater than 1, eg., 1.05.
+
+To simplify prototyping, the feed-forward is calculated for a layer, and the activation estimator is immediately applied before the next layer activations are used. This is equivalent to bypassing the calculations for activations that are likely to produce zeros. In practice, re-calculating the SVD once per epoch for the activation estimator seems to be a decent tradeoff between activation estimation accuracy and computational efficiency, but this may not necessarily be true for other datasets.
+
+Table 1: Hyperparameters for SVHN and MNIST experiments.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>SVHN</td><td rowspan=1 colspan=1>MNIST</td></tr><tr><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>1024-1500-700-400-200-10</td><td rowspan=1 colspan=1>784-1000-600-400-10</td></tr><tr><td rowspan=1 colspan=1>Weight Init</td><td rowspan=1 colspan=1>w ~N (0,0.01);b= 1</td><td rowspan=1 colspan=1>w ~N (0,0.05);b=1</td></tr><tr><td rowspan=1 colspan=1>InitLearningRate</td><td rowspan=1 colspan=1>0.15</td><td rowspan=1 colspan=1>0.25</td></tr><tr><td rowspan=1 colspan=1>LearningRateScaling</td><td rowspan=1 colspan=1>0.99</td><td rowspan=1 colspan=1>0.99</td></tr><tr><td rowspan=1 colspan=1>MaximumMomentum</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>0.8</td></tr><tr><td rowspan=1 colspan=1>MomentumIncrement</td><td rowspan=1 colspan=1>1.01</td><td rowspan=1 colspan=1>1.05</td></tr><tr><td rowspan=1 colspan=1>MaximumNorm</td><td rowspan=1 colspan=1>25</td><td rowspan=1 colspan=1>25</td></tr><tr><td rowspan=1 colspan=1>l1 Activation Penalty</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1×10-5</td></tr><tr><td rowspan=1 colspan=1>l2Weight Penalty</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>5×10-5</td></tr></table>
+
+![](images/0a8e79cdd733ed2d87a5767f2b4e2eadb0058f84435899642e7ff1ff63d5c876.jpg)  
+Figure 3: Classification error of the validation set for SVHN on seven configurations of the activation estimator for each hidden layer. The ’control’ network has no activation estimator and is used as a baseline of comparison for the other networks.
+
+# 4 Experimental Results
+
+# 4.1 SVHN
+
+Street View House Numbers (SVHN) [15] is a large image dataset containing over 600,000 labeled examples of digits taken from street signs. Each example is an RGB $3 2 \times 3 2$ (3072-dimensional) image. To pre-process the dataset, each image is transformed into the YUV colorspace. Next, local contrast normalization [10] followed by a histogram equalization is applied to the Y channel. The U and V channels are discarded, resulting in a 1024-dimensional vector per example. The dataset is then normalized for the neural network by subtracting out the mean and dividing by the square root of the variance for each variable. To select the hyperparameters, the training data was split into 590,000 samples for the training set and 14,388 samples for the validation set. The architecture was held fixed while the other hyperparameters were chosen randomly over 30 runs using a network with no activation estimation. The hyperparameters of the neural network with the lowest resulting validation error were then used for all experiments.
+
+To evaluate the sensitivity of the activation estimator, several parameterizations for the activation estimator are evaluated. Each network is trained with the hyperparameters in Table 1, and the results of seven parameterizations are shown in Figure 3. Each parameterization is described by the rank of each approximation, eg., ‘75-50-40-30’ describes a network with an activation estimator using a 75-rank approximation for $W _ { 1 }$ , a 50-rank approximation for $W _ { 2 }$ , a 40-rank approximation for $W _ { 3 }$ , and a 30-rank approximation for $W _ { 4 }$ . Note that a low-rank approximation is not necessary for $W _ { 5 }$ (the weights connecting the last hidden layer to the output layer), as we do not want to approximate the activations for the output layer.
+
+Some runs, specifically 25-25-25-25 and 50-35-25-25 in Figure 3 exhibit an initial decrease in classification error, followed by a gradual increase in classification error as training progresses. In the initial epochs, the hidden layer activations are mostly positive because the weights are relatively small and the biases are very large. As a consequence, the activation estimation is a much simpler task for the initial epochs. However, as the pattern of the activation signs diversifies as the network continues to train, the lower-rank approximations begin to fail, as illustrated in Figure 4.
+
+![](images/f6b504d82bee33be549ba3ff3e2a25bf4b7bed420563eb806114dcca81b981b2.jpg)  
+Figure 4: A comparison of a low-rank activation estimator and a higher-rank activation estimator. In this instance, a 25-25-25-25 activation estimator is too coarse to adequately capture the structure of the weight matrices.
+
+Table 2: SVHN test set error for seven networks.   
+
+<table><tr><td rowspan=1 colspan=1>Network</td><td rowspan=1 colspan=1>Error</td></tr><tr><td rowspan=1 colspan=1>Control</td><td rowspan=1 colspan=1>9.31%</td></tr><tr><td rowspan=1 colspan=1>200-100-75-15</td><td rowspan=1 colspan=1>9.67%</td></tr><tr><td rowspan=1 colspan=1>100-75-50-25</td><td rowspan=1 colspan=1>9.96%</td></tr><tr><td rowspan=1 colspan=1>100-75-50-15</td><td rowspan=1 colspan=1>10.01%</td></tr><tr><td rowspan=1 colspan=1>75-50-40-30</td><td rowspan=1 colspan=1>10.72%</td></tr><tr><td rowspan=1 colspan=1>50-40-40-35</td><td rowspan=1 colspan=1>12.16%</td></tr><tr><td rowspan=1 colspan=1>25-25-15-15</td><td rowspan=1 colspan=1>19.40%</td></tr></table>
+
+Table 2 summarizes the test set error for the control and activation estimation networks. $W _ { 1 }$ appears to be most sensitive, quickly reducing the test set error from $1 0 . 7 2 \%$ to $1 2 . 1 6 \%$ when the rank of $\hat { W } _ { 1 }$ is lowered from 75 to 50. The rank of $\hat { W } _ { 4 }$ appears to be the least sensitive, reducing the test set error from $9 . 9 6 \%$ to $1 0 . 0 1 \%$ as the rank is lowered from 25 to 15.
+
+# 4.2 MNIST
+
+MNIST is a well-known dataset of hand-written digits containing $7 0 , 0 0 0 \ 2 8 \times 2 8$ labeled images, and is generally split into 60,000 training and 10,000 testing examples. Very little pre-processing is required to achieve good results - each feature is transformed by $\begin{array} { r } { x _ { t } = \frac { x } { \sqrt { \sigma _ { m a x } ^ { 2 } } } - 0 . 5 } \end{array}$ , where $x$ is the input feature, $\sigma _ { m a x } ^ { 2 }$ is the maximum variance of all features, and 0.5 is a constant term to roughly center each feature. To select the hyperparameters, the training data was split into 50,000 samples for the training set and 10,000 samples for the validation set. The architecture was held fixed while the other hyperparameters were chosen randomly over 30 runs using a network with no activation estimation. The hyperparameters of the neural network with the lowest resulting validation error were then used for all experiments. Several parameterizations for the activation estimator are evaluated for a neural network trained with the hyperparameters listed in Table 1 using the same approach as the SVHN experiment above. The results for the validation set plotted against the epoch number are shown in Figure 5, and the final test set accuracy is reported in Table 3.
+
+A neural network with a very low-rank weight matrix in the activation estimation can train surprisingly well on MNIST. Lowering the rank from 784-600-400 to 50-35-25 impacts performance negligibly. Ranks as low as 25-25-25 does not lessen performance too greatly, and ranks as low as 10-10-5 yield a classifier capable of $2 . 2 8 \%$ error.
+
+![](images/11558a5ea2d37ebe91065c45e763c77ec3d8d21d94ebc2b0c090822029259d0a.jpg)  
+Figure 5: Classification error of the validation set for MNIST on five configurations of the activation estimator for each hidden layer.
+
+Table 3: MNIST test set error for five networks.   
+
+<table><tr><td rowspan=1 colspan=1>Network</td><td rowspan=1 colspan=1>Error</td></tr><tr><td rowspan=1 colspan=1>Control</td><td rowspan=1 colspan=1>1.40%</td></tr><tr><td rowspan=1 colspan=1>50-35-25</td><td rowspan=1 colspan=1>1.43%</td></tr><tr><td rowspan=1 colspan=1>25-25-25</td><td rowspan=1 colspan=1>1.60%</td></tr><tr><td rowspan=1 colspan=1>15-10-5</td><td rowspan=1 colspan=1>1.85%</td></tr><tr><td rowspan=1 colspan=1>10-10-5</td><td rowspan=1 colspan=1>2.28%</td></tr></table>
+
+# 5 Discussion and Further Work
+
+Low-rank estimations of weight matrices of a neural network obtained via once-per-epoch SVD work very well as efficient estimators of the sign of the activation for the next hidden layer. In the context of rectified-linear hidden units, computation time can be reduced greatly if this estimation is reliable and the hidden activations are sufficiently sparse. This approach is applicable to any hardthresholding activation function, such as the functions investigated in [8], and can be easily extended to be used with convolutional neural networks.
+
+While the activation estimation error does not tend to deviate too greatly inbetween minibatches over an epoch, as illustrated in Figure 6, this is not guaranteed. An online approach to the low-rank approximation would therefore be preferable to a once-per-epoch calculation. In addition, while the low-rank approximation given by SVD minimizes the objective function $\| A - { \hat { A } } _ { r } \| _ { F }$ , this is not necessarily the best objective function for an activation estimator, where we seek to minimize $\left\| \sigma \left( a W \right) - \sigma \left( a W \cdot S \right) \right\|$ , which is a much more difficult and non-convex objective function. Also, setting the hyperparameters for the activation estimator can be a tedious process involving expensive cross-validation when an adaptive algorithm could instead choose the rank based on the spectrum of the singular values. Therefore, developing a more suitable low-rank approximation algorithm could provide a promising future direction of research.
+
+![](images/6823918133299ef531225ca3d5ccbbe5d6a2cad03005d49d4dc4f9f3ac1334f3.jpg)  
+Figure 6: Because the SVD is calculated at the beginning of each epoch, each subsequent gradient update in each minibatch moves the weight matrix further from low-rank factorization, resulting in an increasing error until the SVD is recalculated at the beginning of the next epoch. Different layers are negatively impacted in differing degrees.
+
+In [1], the authors propose a method called “adaptive dropout” by which the dropout probabilities are chosen by a function optimized by gradient descent instead of fixed to some value. This approach bears some resemblance to this paper, but with the key difference that the approach in [1] is motivated by improved regularization and this paper’s method is motivated by computational efficiency. However, the authors introduce a biasing term that allows for greater sparsity that could be introduced into this paper’s methodology. By modifying the conditional computation unit to compute $s g n \left( a U V - b \right)$ , where $b$ is some bias, we can introduce a parameter that can tune the sparsity of the network, allowing for a more powerful trade-off between accuracy and computational efficiency.
+
+# Acknowledgments
+
+This work was partially supported by the Defense Advanced Research Projects Agency (DARPA) under contract number HR0011-13-2-0016.
+
+# References
+
+[1] Jimmy Ba and Brendan Frey. Adaptive dropout for training deep neural networks. In Advances in Neural Information Processing Systems, pages 3084–3092, 2013. 3.3, 5   
+[2] Yoshua Bengio. Deep learning of representations: Looking forward. In Adrian-Horia Dediu, Carlos Martin-Vide, Ruslan Mitkov, and Bianca Truthe, editors, Statistical Language and Speech Processing, volume 7978 of Lecture Notes in Computer Science, pages 1–37. Springer Berlin Heidelberg, 2013. (document), 2.1   
+[3] Yoshua Bengio, Nicholas Léonard, and Aaron C. Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. CoRR, abs/1308.3432, 2013. 2.1   
+[4] Adam Coates, Brody Huval, Tao Wang, David Wu, Bryan Catanzaro, and $\mathrm { N g }$ Andrew. Deep learning with cots hpc systems. In Proceedings of the 30th International Conference on Machine Learning (ICML-13), pages 1337–1345, 2013. 1   
+[5] Misha Denil, Babak Shakibi, Laurent Dinh, Marc’Aurelio Ranzato, and Nando de Freitas. Predicting parameters in deep learning. arXiv preprint arXiv:1306.0543, 2013. 2.1, 3.1   
+[6] Carl Eckart and Gale Young. The approximation of one matrix by another of lower rank. Psychometrika, 1(3):211–218, 1936. 3.2   
+[7] Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier networks. In Proceedings of the 14th International Conference on Artificial Intelligence and Statistics. JMLR W&CP Volume, volume 15, pages 315–323, 2011. 2.2   
+[8] Rostislav Goroshin and Yann LeCun. Saturating auto-encoder. arXiv preprint arXiv:1301.3577, 2013. 5   
+[9] Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012. 3.3   
+[10] Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multi-stage architecture for object recognition? In Computer Vision, 2009 IEEE 12th International Conference on, pages 2146–2153. IEEE, 2009. 4.1   
+[11] Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pages 1106–1114, 2012. 1, 3.5   
+[12] Quoc Le, Marc’Aurelio Ranzato, Rajat Monga, Matthieu Devin, Kai Chen, Greg Corrado, Jeff Dean, and Andrew Ng. Building high-level features using large scale unsupervised learning. In International Conference in Machine Learning, 2012. 1   
+[13] Honglak Lee, Alexis Battle, Rajat Raina, and Andrew Ng. Efficient sparse coding algorithms. In Advances in neural information processing systems, pages 801–808, 2006. 3.3   
+[14] A Mohamed, Tara N Sainath, George Dahl, Bhuvana Ramabhadran, Geoffrey E Hinton, and Michael A Picheny. Deep belief networks using discriminative features for phone recognition. In Acoustics, Speech and Signal Processing (ICASSP), 2011 IEEE International Conference on, pages 5060–5063. IEEE, 2011. 1   
+[15] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 4.1   
+[16] R. B. Palm. Prediction as a candidate for learning deep hierarchical models of data, 2012. 3.5   
+[17] Nitish Srivastava. Improving neural networks with dropout. PhD thesis, University of Toronto, 2013. 3.3

parse/train/6rEnMF1okeiBO/6rEnMF1okeiBO_content_list.json

@@ -0,0 +1,1027 @@
+[
+    {
+        "type": "text",
+        "text": "Low-Rank Approximations for Conditional Feedforward Computation in Deep Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            135,
+            818,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Andrew S. Davis Department of Electrical Engineering and Computer Science University of Tennessee andrew.davis@utk.edu ",
+        "bbox": [
+            299,
+            238,
+            699,
+            294
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Itamar Arel Department of Electrical Engineering and Computer Science University of Tennessee itamar@ieee.org ",
+        "bbox": [
+            299,
+            315,
+            699,
+            371
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            406,
+            535,
+            424
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Scalability properties of deep neural networks raise key research questions, particularly as the problems considered become larger and more challenging. This paper expands on the idea of conditional computation introduced in [2], where the nodes of a deep network are augmented by a set of gating units that determine when a node should be calculated. By factorizing the weight matrix into a low-rank approximation, an estimation of the sign of the pre-nonlinearity activation can be efficiently obtained. For networks using rectified-linear hidden units, this implies that the computation of a hidden unit with an estimated negative pre-nonlinearity can be omitted altogether, as its value will become zero when nonlinearity is applied. For sparse neural networks, this can result in considerable speed gains. Experimental results using the MNIST and SVHN data sets with a fully-connected deep neural network demonstrate the performance robustness of the proposed scheme with respect to the error introduced by the conditional computation process. ",
+        "bbox": [
+            233,
+            440,
+            764,
+            633
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            310,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, deep neural networks have redefined state-of-the-art in many application domains, notably in computer vision [11] and speech processing [14]. In order to scale to more challenging problems, however, neural networks must become larger, which implies an increase in computational resources. Shifting computation to highly parallel platforms such as GPUs has enabled the training of massive neural networks that would otherwise train too slowly on conventional CPUs. While the extremely high computational power used for the experiment performed in [12] (16,000 cores training for many days) was greatly reduced in [4] (3 servers training for many days), specialized high-performance platforms still require several machines and several days of processing time. However, there may exist more fundamental changes to the algorithms involved which can greatly assist in scaling neural networks. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many of these state-of-the-art networks have several common properties: the use of rectified-linear activation functions in the hidden neurons, and a high level of sparsity induced by dropout regularization or a sparsity-inducing penalty term on the loss function. Given that many of the activations are effectively zero, due to the combination of sparsity and the hard thresholding of rectified linear units, a large amount of computation is wasted on calculating values that are eventually truncated to zero and provide no contribution to the network outputs or error components. Here we focus on this key observation in devising a scheme that can predict the zero-valued activations in a computationally cost-efficient manner. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/330c633a35bf86691190ce2c9e23656faa49e05ba728a5e0d3579d3dd77aadaa.jpg",
+        "image_caption": [
+            "Figure 1: An illustration of an activation estimator. $U$ and $V$ represent the factorization of the lowrank matrix and $W$ denotes the full-rank matrix. In this case, the activation estimator recommends that only the $2 ^ { n d }$ and the $n ^ { t h }$ neuron be computed for layer $l + 1$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            99,
+            730,
+            233
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            328,
+            823,
+            357
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Conditional Computation in Deep Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            392,
+            635,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Exploiting Redundancy in Deep Architectures ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            532,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In [5], the authors made the observation that deep models tend to have a high degree of redundancy in their weight parameterization. The authors exploit this redundancy in order to train as few as $5 \\%$ of the weights in a neural network while estimating the other $9 5 \\%$ with the use of carefully constructed low-rank decompositions of the weight matrices. Such a reduction in the number of active training parameters can render optimization easier by reducing the number of variables to optimize over. Moreover, it can help address the problem of scalability by greatly reducing the communication overhead in a distributed system. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Assuming there is a considerable amount of redundancy in the weight parameterization, a similar level of redundancy is likely found in the activation patterns of individual neurons. Therefore, given an input sample, the set of redundant activations in the network may be approximated. If a sufficiently accurate approximation can be obtained using low computational resources, activations for a subset of neurons in the network’s hidden layers need not be calculated. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            641
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In [2] and [3], the authors propose the idea of conditional computation in neural networks, where the network is augmented by a gating model that turns activations on or off depending on the state of the network. If this gating model is able to reliably estimate which neurons need to be calculated for a particular input, great improvements in computational efficiency may be obtainable if the network is sufficiently sparse. Figure 1 illustrates a conditional computation unit augmenting a layer of a neural net by using some function $f \\left( U , V , a _ { l } \\right)$ to determine which hidden unit activations $a _ { l + 1 }$ should be computed given the activations $a _ { l }$ of layer $l$ . ",
+        "bbox": [
+            174,
+            648,
+            825,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Sparse Representations, Activation Functions, and Prediction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            640,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In some situations, sparse representations may be superior to dense representations, particularly in the context of deep architectures [7]. However, sparse representations learned by neural networks with sigmoidal activations are not truly “sparse”, as activations only approach zero in the limit towards negative infinity. A conditional computation model estimating the sparsity of a sigmoidal network would thus have to impose some threshold, beyond which the neuron is considered inactive. So-called “hard-threshold” activation functions such as rectified-linear units, on the other hand, produce true zeros which can be used by conditional computation models without imposing additional hyperparameters. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb9a58a228619740cc5b690dffa4597c00b0675e72d7f0d8c1f1ae3f6187ad37.jpg",
+        "image_caption": [
+            "Figure 2: The low-rank approximation $U V$ can be substituted in for $W$ , and can approximate the matrix $W$ with a relatively low rank. However, if we use the output of the activation estimator $S$ , as defined in Eq. (5), with the full-rank feedforward, $\\sigma \\left( a W \\right) \\cdot S$ , a lower-rank approximation can be utilized. The activations and weights are from the first layer of a neural network trained on MNIST, and the factorization $U V$ is obtained via SVD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            264,
+            103,
+            723,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Problem Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            392,
+            387,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Estimating Activation Sign via Low-Rank Approximation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            422,
+            614,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given the activation $a _ { l }$ of layer $l$ of a neural network, the activation $a _ { l + 1 }$ of layer $l + 1$ is given by: ",
+        "bbox": [
+            171,
+            450,
+            820,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c848f6722e2da70b28f251860af8abd54559584ea49dacdc62bf0c40ab1847c6.jpg",
+        "text": "$$\na _ { l + 1 } = \\sigma ( a _ { l } W _ { l } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            486,
+            555,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma ( \\cdot )$ denotes the function defining the neuron’s non-linearity, $a _ { l } \\in \\mathbb { R } ^ { n \\times h _ { 1 } }$ , $a _ { l + 1 } \\in \\mathbb { R } ^ { n \\times h _ { 2 } }$ , $W _ { l } \\in \\mathbb { R } ^ { \\dot { h _ { 1 } } \\times h _ { 2 } }$ . If the weight matrix is highly redundant, as in [5], it can be well-approximated using a low-rank representation and we may rewrite (1) as ",
+        "bbox": [
+            173,
+            513,
+            825,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/782286b5f76342fc2f666ea8b6ec3e5b835205f2032bcc4d8520b21fdeaa71fa.jpg",
+        "text": "$$\na _ { l + 1 } = \\sigma ( a _ { l } U _ { l } V _ { l } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            577,
+            560,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $U _ { l } V _ { l }$ is the low-rank approximation of $W _ { l }$ , $U _ { l } \\in \\mathbb { R } ^ { h _ { 1 } \\times k }$ , $V _ { l } \\in \\mathbb { R } ^ { k \\times h _ { 2 } }$ , $k \\ll \\operatorname* { m i n } ( h _ { 1 } , h _ { 2 } )$ . So long as $\\begin{array} { r } { k < \\frac { h _ { 1 } h _ { 2 } } { h _ { 1 } + h _ { 2 } } } \\end{array}$ , the low-rank multiplication $a _ { l } U _ { l } V _ { l }$ requires fewer arithmetic operations than the full-rank multiplication $a _ { l } W _ { l }$ , assuming the multiplication $a _ { l } U _ { l }$ occurs first. When $\\sigma ( \\cdot )$ is the rectified-linear function, ",
+        "bbox": [
+            173,
+            603,
+            825,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/34b7ae3c7308023dd97198cb93e5d56c0b053210ec58600e58fccd1e14a60129.jpg",
+        "text": "$$\n\\sigma ( x ) = \\operatorname* { m a x } ( 0 , x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            686,
+            562,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "such that all negative elements of the linear transform $a _ { l } W _ { l }$ become zero, one only needs to estimate the sign of the elements of the linear transform in order to predict the zero-valued elements. Assuming the weights in a deep neural network can be well-approximated using a low-rank estimation, the small error in the low-rank estimation is of marginal relevance in the context of recovering the sign of the operation. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            785
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a low-rank approximation $W _ { l } \\approx U _ { l } V _ { l } = { \\hat { W } } _ { l }$ , the estimated sign of $a _ { l + 1 }$ is given by ",
+        "bbox": [
+            171,
+            791,
+            759,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc16f8d560ca2b75837ed4f80c54be348fd0d038a9b73e2be77db536d9ed57d0.jpg",
+        "text": "$$\ns g n ( a _ { l + 1 } ) \\approx s g n ( a _ { l } \\hat { W } _ { l } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            815,
+            583,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each element $( a _ { l + 1 } ) _ { i , j }$ is given by a dot product between the row vector $a _ { l } ^ { ( i ) }$ and the column vector $W _ { l } ^ { ( j ) }$ . If $s g n ( a _ { l } \\hat { W } _ { l } ^ { ( j ) } ) = - 1$ , then the true activation $( a _ { l + 1 } ) _ { i , j }$ is likely negative, and will likely become zero after the rectified-linear function is applied. Considerable speed gains are possible if we skip those dot products based on the prediction; such gains are especially substantial when the network is very sparse. The overall activation for a hidden layer $l$ augmented by the activation estimator is given by $\\sigma \\left( a _ { l } W _ { l } \\right) \\cdot S _ { l }$ , where $\\cdot$ denotes the element-wise product and $S _ { l }$ denotes a matrix of zeros and ones, where ",
+        "bbox": [
+            173,
+            844,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/770da6ecbe025ab88742b5f8d089375b80c6551d4c1d8826fb595ab32a47776c.jpg",
+        "text": "$$\n\\left( S _ { l } \\right) _ { i , j = } \\left\\{ 0 , \\quad s g n \\left( \\left( a _ { l } U _ { l } V _ { l } \\right) _ { i , j } \\right) = - 1 \\right. \\nonumber\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            136,
+            633,
+            186
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 illustrates the error profile of a neural network using the low-rank estimation $U V$ in place of $W$ compared with a neural network augmented with an activation sign estimator as the rank is varied from one to full-rank. One can see that the error of the activation sign estimator diminishes far more quickly than the error of the low-rank activation, implying that the sign estimator can do well with a relatively low-rank approximation of $W$ . ",
+        "bbox": [
+            173,
+            196,
+            825,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 SVD as a Low-Rank Approximation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            284,
+            465,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Singular Value Decomposition (SVD) is a common matrix decomposition technique that factorizes a matrix $A \\in \\mathbb { R } ^ { m \\times n }$ into $A = U \\Sigma V ^ { T }$ , $U \\in \\mathbb { R } ^ { m \\times m } , \\Sigma \\in \\mathbb { R } ^ { m \\times n } , V \\in \\mathbb { R } ^ { n \\times n }$ . By [6], the matrix $A$ can be approximated using a low rank matrix $\\hat { A } _ { r }$ corresponding to the solution of the constrained optimization of ",
+        "bbox": [
+            173,
+            309,
+            825,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1fefaf3261b683e03668fcdf5608edaed005bfbb71e473bd0f0f9ebaf8b35af3.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\hat { A } _ { r } } \\| A - \\hat { A } _ { r } \\| _ { F }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            366,
+            555,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\| \\cdot \\| _ { F }$ is the Frobenius norm, and $\\hat { A } _ { r }$ is constrained to be of rank $r \\ < \\ r a n k ( A )$ . The minimizer $\\hat { A } _ { r }$ is given by taking the first $r$ columns of $U$ , the first $r$ diagonal entries of $\\Sigma$ , and the first $r$ columns of $V$ . The resulting matrices $U _ { r }$ , $\\Sigma _ { r }$ , and $V _ { r }$ are multiplied, yielding $\\hat { A } _ { r } = U _ { r } \\Sigma _ { r } V _ { r } ^ { T }$ . The low-rank approximation $\\hat { W } = U V$ is then defined such that $\\hat { W } = U _ { r } ( \\Sigma _ { r } V _ { r } ^ { T } )$ , where $U = U _ { r }$ and $\\begin{array} { r } { V = \\Sigma _ { r } V _ { r } ^ { \\bar { T } } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            398,
+            825,
+            478
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, calculating the SVD is an expensive operation, on the order of $O ( m n ^ { 2 } )$ , so recalculating the SVD upon the completion of every minibatch adds significant overhead to the training procedure. Given that we are uniquely interested in estimating in the sign of $a _ { l + 1 } = a _ { l } W _ { l }$ , we can opt to calculate the SVD less frequently than once per minibatch, assuming that the weights $W _ { l }$ do not change significantly over the course of a single epoch so as to corrupt the sign estimation. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            555
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Encouraging Neural Network Sparsity ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            570,
+            480,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To overcome the additional overhead imposed by the conditional computation architecture, the neural network must have sparse activations. Without encouragement to settle on weights that result in sparse activations, such as penalties on the loss function, a neural network will not necessarily become sparse enough to be useful in the context of conditional computation. Therefore, an $\\ell _ { 1 }$ penalty for the activation vector of each layer is applied to the overall loss function, such that ",
+        "bbox": [
+            173,
+            597,
+            825,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/271322ebf6515a67ad2d6e5494b0a33124eb3e3c0ed0432dd167713d1b95068e.jpg",
+        "text": "$$\nJ ( W , \\lambda ) = L ( W ) + \\lambda \\sum _ { l = 1 } ^ { L } \\| a _ { l } \\| _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            671,
+            607,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Such a penalty is commonly used in sparse dictionary learning algorithms and tends to push elements of $a _ { l }$ towards zero [13]. ",
+        "bbox": [
+            176,
+            719,
+            820,
+            748
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dropout regularization [9] is another technique known to sparsify the hidden activations in a neural network. Dropout first sets the hidden activations $a _ { l }$ to zero with probability $p$ . During training, the number of active neurons is likely less than $p$ for each minibatch. When the regularized network is running in the inference mode, dropout has been observed to have a sparsifying effect on the hidden activations [17]. The adaptive dropout method [1] can further decrease the number of active neurons without degrading the performance of the network. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 Theoretical Speed Gain ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            377,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For every input example, a standard neural network computes $\\sigma \\left( a W \\right)$ , where $a ~ \\in ~ \\mathbb { R } ^ { N \\times d }$ and $W \\in \\mathbb { R } ^ { \\mathsf { \\bar { d } } \\times h }$ , where $N = 1$ for a fully-connected network, or $N$ is the number of convolutions for a convolutional network. Assuming additions and multiplications are constant-time operations, the matrix multiplication requires $N \\left( 2 d - 1 \\right) h$ floating point operations (we need to compute $N h$ dot products, where each dot product consists of $d$ multiplications and $d - 1$ additions), and the activation function requires $N h$ floating point operations, yielding $N \\left( 2 d - 1 \\right) h + N h$ operations. The activation estimator $\\sigma \\left( a U V \\right)$ , $U \\in \\mathbb { R } ^ { d \\times k }$ , $V \\in \\mathbb { R } ^ { k \\times \\tilde { h } }$ requires $N \\left( 2 d - 1 \\right) k + N \\left( 2 k - 1 \\right) h$ floating point operations for the low-rank multiplication followed by $N h$ operations for the sgn (·) activation function, yielding $N \\left( 2 d - 1 \\right) k + \\bar { N ( 2 k - 1 ) } h + N h$ . However, given a sparsity coefficient $\\alpha \\in [ 0 , 1 ]$ (where $\\alpha = 0$ implies no activations are active, and $\\alpha = 1$ implies all activations are active), a conditional matrix multiplication would require $\\alpha N \\left( 2 d - 1 \\right) h + \\alpha N h$ operations. The SVD calculation to obtain the activation estimation weights is $\\beta O \\left( n d \\operatorname* { m i n } \\left( n , d \\right) \\right)$ , where $\\beta$ is the ratio of feed-forwards to SVD updates (eg., with a minibatch size of 250, a training set size of 50,000, and once-per-epoch SVD updates, $\\begin{array} { r } { \\dot { \\beta } = \\frac { 2 5 0 } { 5 0 0 0 0 } = 0 . 0 0 5 ) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Altogether, the number of floating point operations for calculating the feed-forward in a layer in a standard neural network is ",
+        "bbox": [
+            174,
+            263,
+            823,
+            291
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6137c03c4f25010c1e40d6de1123f551d320acd069cc41ab9b0f6080618a54da.jpg",
+        "text": "$$\nF _ { n n } = N \\left( 2 d - 1 \\right) h + N h\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            295,
+            593,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and the number of floating point operations for the activation estimation network with conditional computation is ",
+        "bbox": [
+            174,
+            320,
+            826,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22e003bfb7ee19f503f391f6865748863b5f2980a8a63f45cd1fe80f8a228df9.jpg",
+        "text": "$$\nF _ { a e } = N \\left( 2 d - 1 \\right) k + N \\left( 2 k - 1 \\right) h + N h + \\alpha h \\left( N \\left( 2 d - 1 \\right) h + N h \\right) + \\beta O \\left( n d \\operatorname* { m i n } \\left( n , d \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            359,
+            799,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The relative reduction of floating point operations for a layer can be represented as $\\scriptstyle { \\frac { F _ { n n } } { F _ { a e } } }$ , and is simplified as ",
+        "bbox": [
+            178,
+            388,
+            825,
+            419
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e5d5a3f370f6a07b4f1a4a75dddd5c305b68d58f35e0565992443d65cca025d.jpg",
+        "text": "$$\n\\frac { 2 d h } { k \\left( 2 d + 2 h - 1 \\right) + 2 \\alpha d h + \\beta O \\left( n d \\operatorname* { m i n } \\left( n , d \\right) \\right) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            421,
+            656,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For a neural network with many layers, the relative speedup is given by ",
+        "bbox": [
+            173,
+            472,
+            642,
+            487
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65c1396f64009d89fe08eace05656fd2385a0fa30886077c724c60f3181bc936.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\sum _ { i = 1 } ^ { L } F _ { n n } ^ { ( l ) } } } \\\\ { { \\displaystyle \\sum _ { i = 1 } ^ { L } F _ { a e } ^ { ( l ) } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            467,
+            496,
+            531,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $F _ { n n } ^ { ( l ) }$ is the number of floating point operations for theth ${ { l } ^ { t h } }$ layer of the full network, and $F _ { a e } ^ { ( l ) }$ is the number of floating point operations for the layer of the network augmented by the activation estimation network. The overall speedup is greatly dependent on the sparsity of the network and the overhead of the activation estimator. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            672,
+            377,
+            688
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The neural network is built using Rasmus Berg Palm’s Deep Learning Toolbox [16]. All hidden units are rectified-linear, and the output units are softmax trained with a negative log-likelihood loss function. The weights, $w$ , are initialized as $w \\sim \\mathcal { N } \\left( 0 , \\sigma ^ { 2 } \\right)$ and biases $b$ are set to 1 in order to encourage the neurons to operate in their non-saturated region once training begins, as suggested in [11]. In all experiments, the dropout probability $p$ is fixed to 0.5 for the hidden layers. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            771
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The learning rate $\\gamma$ is scheduled such that $\\gamma _ { n } ~ = ~ \\gamma _ { 0 } \\lambda ^ { n }$ where $\\gamma _ { n }$ is the learning rate for the $n ^ { t h }$ epoch, $\\gamma _ { 0 }$ is the initial learning rate, and $\\lambda$ is a decay term slightly less than 1, eg., 0.995. The momentum term $\\nu$ is scheduled such that $\\nu _ { n } = \\operatorname* { m a x } \\left( \\nu _ { m a x } , \\nu _ { 0 } \\beta ^ { n } \\right)$ where $\\nu _ { n }$ is the momentum for the $n ^ { t h }$ epoch, $\\nu _ { m a x }$ is the maximum allowed momentum, $\\nu _ { 0 }$ is the initial momentum, and $\\beta$ is an incremental term slightly greater than 1, eg., 1.05. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To simplify prototyping, the feed-forward is calculated for a layer, and the activation estimator is immediately applied before the next layer activations are used. This is equivalent to bypassing the calculations for activations that are likely to produce zeros. In practice, re-calculating the SVD once per epoch for the activation estimator seems to be a decent tradeoff between activation estimation accuracy and computational efficiency, but this may not necessarily be true for other datasets. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1cd2b5e0df76a39e138b40fe18afae6f58867958fa926570a5ae3484d7086be.jpg",
+        "table_caption": [
+            "Table 1: Hyperparameters for SVHN and MNIST experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>SVHN</td><td rowspan=1 colspan=1>MNIST</td></tr><tr><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>1024-1500-700-400-200-10</td><td rowspan=1 colspan=1>784-1000-600-400-10</td></tr><tr><td rowspan=1 colspan=1>Weight Init</td><td rowspan=1 colspan=1>w ~N (0,0.01);b= 1</td><td rowspan=1 colspan=1>w ~N (0,0.05);b=1</td></tr><tr><td rowspan=1 colspan=1>InitLearningRate</td><td rowspan=1 colspan=1>0.15</td><td rowspan=1 colspan=1>0.25</td></tr><tr><td rowspan=1 colspan=1>LearningRateScaling</td><td rowspan=1 colspan=1>0.99</td><td rowspan=1 colspan=1>0.99</td></tr><tr><td rowspan=1 colspan=1>MaximumMomentum</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>0.8</td></tr><tr><td rowspan=1 colspan=1>MomentumIncrement</td><td rowspan=1 colspan=1>1.01</td><td rowspan=1 colspan=1>1.05</td></tr><tr><td rowspan=1 colspan=1>MaximumNorm</td><td rowspan=1 colspan=1>25</td><td rowspan=1 colspan=1>25</td></tr><tr><td rowspan=1 colspan=1>l1 Activation Penalty</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1×10-5</td></tr><tr><td rowspan=1 colspan=1>l2Weight Penalty</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>5×10-5</td></tr></table>",
+        "bbox": [
+            225,
+            101,
+            771,
+            248
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a8e79cdd733ed2d87a5767f2b4e2eadb0058f84435899642e7ff1ff63d5c876.jpg",
+        "image_caption": [
+            "Figure 3: Classification error of the validation set for SVHN on seven configurations of the activation estimator for each hidden layer. The ’control’ network has no activation estimator and is used as a baseline of comparison for the other networks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            279,
+            285,
+            694,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            531,
+            385,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SVHN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            563,
+            258,
+            578
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Street View House Numbers (SVHN) [15] is a large image dataset containing over 600,000 labeled examples of digits taken from street signs. Each example is an RGB $3 2 \\times 3 2$ (3072-dimensional) image. To pre-process the dataset, each image is transformed into the YUV colorspace. Next, local contrast normalization [10] followed by a histogram equalization is applied to the Y channel. The U and V channels are discarded, resulting in a 1024-dimensional vector per example. The dataset is then normalized for the neural network by subtracting out the mean and dividing by the square root of the variance for each variable. To select the hyperparameters, the training data was split into 590,000 samples for the training set and 14,388 samples for the validation set. The architecture was held fixed while the other hyperparameters were chosen randomly over 30 runs using a network with no activation estimation. The hyperparameters of the neural network with the lowest resulting validation error were then used for all experiments. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the sensitivity of the activation estimator, several parameterizations for the activation estimator are evaluated. Each network is trained with the hyperparameters in Table 1, and the results of seven parameterizations are shown in Figure 3. Each parameterization is described by the rank of each approximation, eg., ‘75-50-40-30’ describes a network with an activation estimator using a 75-rank approximation for $W _ { 1 }$ , a 50-rank approximation for $W _ { 2 }$ , a 40-rank approximation for $W _ { 3 }$ , and a 30-rank approximation for $W _ { 4 }$ . Note that a low-rank approximation is not necessary for $W _ { 5 }$ (the weights connecting the last hidden layer to the output layer), as we do not want to approximate the activations for the output layer. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Some runs, specifically 25-25-25-25 and 50-35-25-25 in Figure 3 exhibit an initial decrease in classification error, followed by a gradual increase in classification error as training progresses. In the initial epochs, the hidden layer activations are mostly positive because the weights are relatively small and the biases are very large. As a consequence, the activation estimation is a much simpler task for the initial epochs. However, as the pattern of the activation signs diversifies as the network continues to train, the lower-rank approximations begin to fail, as illustrated in Figure 4. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f6b504d82bee33be549ba3ff3e2a25bf4b7bed420563eb806114dcca81b981b2.jpg",
+        "image_caption": [
+            "Figure 4: A comparison of a low-rank activation estimator and a higher-rank activation estimator. In this instance, a 25-25-25-25 activation estimator is too coarse to adequately capture the structure of the weight matrices. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            103,
+            700,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ad9e973a9d28ed3be437599e807a1260e69317c66c8ed1fdfee256b9147134e.jpg",
+        "table_caption": [
+            "Table 2: SVHN test set error for seven networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Network</td><td rowspan=1 colspan=1>Error</td></tr><tr><td rowspan=1 colspan=1>Control</td><td rowspan=1 colspan=1>9.31%</td></tr><tr><td rowspan=1 colspan=1>200-100-75-15</td><td rowspan=1 colspan=1>9.67%</td></tr><tr><td rowspan=1 colspan=1>100-75-50-25</td><td rowspan=1 colspan=1>9.96%</td></tr><tr><td rowspan=1 colspan=1>100-75-50-15</td><td rowspan=1 colspan=1>10.01%</td></tr><tr><td rowspan=1 colspan=1>75-50-40-30</td><td rowspan=1 colspan=1>10.72%</td></tr><tr><td rowspan=1 colspan=1>50-40-40-35</td><td rowspan=1 colspan=1>12.16%</td></tr><tr><td rowspan=1 colspan=1>25-25-15-15</td><td rowspan=1 colspan=1>19.40%</td></tr></table>",
+        "bbox": [
+            403,
+            344,
+            593,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            525,
+            825,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 summarizes the test set error for the control and activation estimation networks. $W _ { 1 }$ appears to be most sensitive, quickly reducing the test set error from $1 0 . 7 2 \\%$ to $1 2 . 1 6 \\%$ when the rank of $\\hat { W } _ { 1 }$ is lowered from 75 to 50. The rank of $\\hat { W } _ { 4 }$ appears to be the least sensitive, reducing the test set error from $9 . 9 6 \\%$ to $1 0 . 0 1 \\%$ as the rank is lowered from 25 to 15. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            618
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 MNIST ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            652,
+            266,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MNIST is a well-known dataset of hand-written digits containing $7 0 , 0 0 0 \\ 2 8 \\times 2 8$ labeled images, and is generally split into 60,000 training and 10,000 testing examples. Very little pre-processing is required to achieve good results - each feature is transformed by $\\begin{array} { r } { x _ { t } = \\frac { x } { \\sqrt { \\sigma _ { m a x } ^ { 2 } } } - 0 . 5 } \\end{array}$ , where $x$ is the input feature, $\\sigma _ { m a x } ^ { 2 }$ is the maximum variance of all features, and 0.5 is a constant term to roughly center each feature. To select the hyperparameters, the training data was split into 50,000 samples for the training set and 10,000 samples for the validation set. The architecture was held fixed while the other hyperparameters were chosen randomly over 30 runs using a network with no activation estimation. The hyperparameters of the neural network with the lowest resulting validation error were then used for all experiments. Several parameterizations for the activation estimator are evaluated for a neural network trained with the hyperparameters listed in Table 1 using the same approach as the SVHN experiment above. The results for the validation set plotted against the epoch number are shown in Figure 5, and the final test set accuracy is reported in Table 3. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A neural network with a very low-rank weight matrix in the activation estimation can train surprisingly well on MNIST. Lowering the rank from 784-600-400 to 50-35-25 impacts performance negligibly. Ranks as low as 25-25-25 does not lessen performance too greatly, and ranks as low as 10-10-5 yield a classifier capable of $2 . 2 8 \\%$ error. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/11558a5ea2d37ebe91065c45e763c77ec3d8d21d94ebc2b0c090822029259d0a.jpg",
+        "image_caption": [
+            "Figure 5: Classification error of the validation set for MNIST on five configurations of the activation estimator for each hidden layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            101,
+            687,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/113b718afa0237ce7172232623c61b2ac67838db64cd8acabd55b21482aaabed.jpg",
+        "table_caption": [
+            "Table 3: MNIST test set error for five networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Network</td><td rowspan=1 colspan=1>Error</td></tr><tr><td rowspan=1 colspan=1>Control</td><td rowspan=1 colspan=1>1.40%</td></tr><tr><td rowspan=1 colspan=1>50-35-25</td><td rowspan=1 colspan=1>1.43%</td></tr><tr><td rowspan=1 colspan=1>25-25-25</td><td rowspan=1 colspan=1>1.60%</td></tr><tr><td rowspan=1 colspan=1>15-10-5</td><td rowspan=1 colspan=1>1.85%</td></tr><tr><td rowspan=1 colspan=1>10-10-5</td><td rowspan=1 colspan=1>2.28%</td></tr></table>",
+        "bbox": [
+            426,
+            324,
+            570,
+            414
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion and Further Work ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            462,
+            454,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Low-rank estimations of weight matrices of a neural network obtained via once-per-epoch SVD work very well as efficient estimators of the sign of the activation for the next hidden layer. In the context of rectified-linear hidden units, computation time can be reduced greatly if this estimation is reliable and the hidden activations are sufficiently sparse. This approach is applicable to any hardthresholding activation function, such as the functions investigated in [8], and can be easily extended to be used with convolutional neural networks. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            580
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the activation estimation error does not tend to deviate too greatly inbetween minibatches over an epoch, as illustrated in Figure 6, this is not guaranteed. An online approach to the low-rank approximation would therefore be preferable to a once-per-epoch calculation. In addition, while the low-rank approximation given by SVD minimizes the objective function $\\| A - { \\hat { A } } _ { r } \\| _ { F }$ , this is not necessarily the best objective function for an activation estimator, where we seek to minimize $\\left\\| \\sigma \\left( a W \\right) - \\sigma \\left( a W \\cdot S \\right) \\right\\|$ , which is a much more difficult and non-convex objective function. Also, setting the hyperparameters for the activation estimator can be a tedious process involving expensive cross-validation when an adaptive algorithm could instead choose the rank based on the spectrum of the singular values. Therefore, developing a more suitable low-rank approximation algorithm could provide a promising future direction of research. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6823918133299ef531225ca3d5ccbbe5d6a2cad03005d49d4dc4f9f3ac1334f3.jpg",
+        "image_caption": [
+            "Figure 6: Because the SVD is calculated at the beginning of each epoch, each subsequent gradient update in each minibatch moves the weight matrix further from low-rank factorization, resulting in an increasing error until the SVD is recalculated at the beginning of the next epoch. Different layers are negatively impacted in differing degrees. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            685,
+            692,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In [1], the authors propose a method called “adaptive dropout” by which the dropout probabilities are chosen by a function optimized by gradient descent instead of fixed to some value. This approach bears some resemblance to this paper, but with the key difference that the approach in [1] is motivated by improved regularization and this paper’s method is motivated by computational efficiency. However, the authors introduce a biasing term that allows for greater sparsity that could be introduced into this paper’s methodology. By modifying the conditional computation unit to compute $s g n \\left( a U V - b \\right)$ , where $b$ is some bias, we can introduce a parameter that can tune the sparsity of the network, allowing for a more powerful trade-off between accuracy and computational efficiency. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            309,
+            303,
+            324
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was partially supported by the Defense Advanced Research Projects Agency (DARPA) under contract number HR0011-13-2-0016. ",
+        "bbox": [
+            176,
+            335,
+            821,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            383,
+            266,
+            400
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "[1] Jimmy Ba and Brendan Frey. Adaptive dropout for training deep neural networks. In Advances in Neural Information Processing Systems, pages 3084–3092, 2013. 3.3, 5   \n[2] Yoshua Bengio. Deep learning of representations: Looking forward. In Adrian-Horia Dediu, Carlos Martin-Vide, Ruslan Mitkov, and Bianca Truthe, editors, Statistical Language and Speech Processing, volume 7978 of Lecture Notes in Computer Science, pages 1–37. Springer Berlin Heidelberg, 2013. (document), 2.1   \n[3] Yoshua Bengio, Nicholas Léonard, and Aaron C. Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. CoRR, abs/1308.3432, 2013. 2.1   \n[4] Adam Coates, Brody Huval, Tao Wang, David Wu, Bryan Catanzaro, and $\\mathrm { N g }$ Andrew. Deep learning with cots hpc systems. In Proceedings of the 30th International Conference on Machine Learning (ICML-13), pages 1337–1345, 2013. 1   \n[5] Misha Denil, Babak Shakibi, Laurent Dinh, Marc’Aurelio Ranzato, and Nando de Freitas. Predicting parameters in deep learning. arXiv preprint arXiv:1306.0543, 2013. 2.1, 3.1   \n[6] Carl Eckart and Gale Young. The approximation of one matrix by another of lower rank. Psychometrika, 1(3):211–218, 1936. 3.2   \n[7] Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier networks. In Proceedings of the 14th International Conference on Artificial Intelligence and Statistics. JMLR W&CP Volume, volume 15, pages 315–323, 2011. 2.2   \n[8] Rostislav Goroshin and Yann LeCun. Saturating auto-encoder. arXiv preprint arXiv:1301.3577, 2013. 5   \n[9] Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012. 3.3   \n[10] Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multi-stage architecture for object recognition? In Computer Vision, 2009 IEEE 12th International Conference on, pages 2146–2153. IEEE, 2009. 4.1   \n[11] Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pages 1106–1114, 2012. 1, 3.5   \n[12] Quoc Le, Marc’Aurelio Ranzato, Rajat Monga, Matthieu Devin, Kai Chen, Greg Corrado, Jeff Dean, and Andrew Ng. Building high-level features using large scale unsupervised learning. In International Conference in Machine Learning, 2012. 1   \n[13] Honglak Lee, Alexis Battle, Rajat Raina, and Andrew Ng. Efficient sparse coding algorithms. In Advances in neural information processing systems, pages 801–808, 2006. 3.3   \n[14] A Mohamed, Tara N Sainath, George Dahl, Bhuvana Ramabhadran, Geoffrey E Hinton, and Michael A Picheny. Deep belief networks using discriminative features for phone recognition. In Acoustics, Speech and Signal Processing (ICASSP), 2011 IEEE International Conference on, pages 5060–5063. IEEE, 2011. 1   \n[15] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 4.1   \n[16] R. B. Palm. Prediction as a candidate for learning deep hierarchical models of data, 2012. 3.5   \n[17] Nitish Srivastava. Improving neural networks with dropout. PhD thesis, University of Toronto, 2013. 3.3 ",
+        "bbox": [
+            179,
+            397,
+            826,
+            929
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            102,
+            828,
+            276
+        ],
+        "page_idx": 9
+    }
+]

parse/train/H1gDaa4YwS/H1gDaa4YwS.md

@@ -0,0 +1,370 @@
+# LEARNING GENERAL AND REUSABLE FEATURES VIA RACECAR-TRAINING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a novel training approach for improving the learning of generalizing features in neural networks. We augment the network with a reverse pass which aims for reconstructing the full sequence of internal states of the network. Despite being a surprisingly simple change, we demonstrate that this forward-backward training approach, i.e. racecar training, leads to significantly more general features to be extracted from a given data set. We demonstrate in our paper that a network obtained in this way is continually trained for the original task, it outperforms baseline models trained in a regular fashion. This improved performance is visible for a wide range of learning tasks from classification, to regression and stylization. In addition, networks trained with our approach exhibit improved performance for task transfers. We additionally analyze the mutual information of our networks to explain the improved generalizing capabilities.
+
+# 1 INTRODUCTION
+
+Humans spend surprising amounts of time assembling and disassembling objects. These deconstruction tasks serve a wide range of purposes from a hobby for motorists, to an important source of learning and exploration for children (Gopnik et al., 1999). Motivated by this behavioral trait of humans, we propose a surprisingly simple, yet powerful modification of neural network training: in addition to a regular forward pass, we add a reverse pass that is constrained to reconstruct all in-between results of the forward pass as well as the input. As we will demonstrate below, this palindromic structure yields substantial improvements for generalization of the learned features in a wide range of architectures, and in many cases even improves the baseline achieved with regular training. Our results indicate that the reversible nature of the proposed training setup, which we will subsequently refer to via the palindrome ”racecar”, encourages the formation of general and reusable features that benefit a wide range of learning tasks.
+
+With our approach we specifically target transfer learning applications. For a regular, i.e., a nontransfer task, the goal usually is to train a network that gives the optimal performance for one specific goal, as has been demonstrated in many success stories over the years (LeCun et al., 1998; Krizhevsky et al., 2012; Goodfellow et al., 2014; He et al., 2016). In such a case, the network naturally exploits any observed correlations between input and output distribution. E.g., if the color of an object in any way correlates with its type, the training of a classifier should find and use this information. In recent years, even networks trained only for a very specific task were shown to be powerful starting points for training models with different tasks (Zamir et al., 2018; Gopalakrishnan et al., 2017; Ding et al., 2017). In many cases, the original network contained features that were applicable to different data domains and beneficial for new inference tasks. An inherent difficulty in this setting is that typically no knowledge about the specifics of the new data and task domains is available at training time of the source model. While it is common practice to target broad and difficult tasks with the hope that this will yield learned features that are applicable in new domains, we instead specifically target improving the generalizing capabilities of learned features while training the source model.
+
+The core idea of our approach is to add a reverse path during training that is constrained to be as reversible as possible every step of the way. This makes the training task more difficult at first, but at the same time encourages the network to learn reversible and general features. Motivated by the disassembly and assembly processes of humans, and in contrast to previous work on invertible networks (Gomez et al., 2017; Jacobsen et al., 2018; Zhang et al., 2018), we constrain the network to represent a as-reversible-as-possible process for all intermediate layer activations, instead of only perfectly reproducing the input. Thus, even for cases where a classifier can, e.g., rely on color for inference of an object type, the model is encouraged to learn a representation that can recover the input in order to not only reconstruct the color of an object but also its shape. Hence the internal representation the network builds naturally has to encode as many aspects of the input data distribution as its representational capabilities permit, in order to recover the input. We demonstrate the benefits of our approach for a variety of architectures, from pure convolutional neural networks (CNNs) with and without batch normalization, to networks that include fully connected layers, as well as GAN architectures.
+
+# 2 RELATED WORK
+
+Transfer learning with deep neural networks has been very successful for a variety of tasks, such as image classification (Duan et al., 2012; Kulis et al., 2011; Zhu et al., 2011), multi-language text classification (Zhou et al., 2014b; Prettenhofer & Stein, 2010; Zhou et al., 2014a), and medical imaging problems (Ravishankar et al., 2016). A central question in transfer learning is whether base and target tasks are related or not. Zamir et al. (2018) proposed an approach to obtain task relationship graphs for different tasks. Another critical point is that we need the neural networks to learn general features from the data set, which are useful for both base and related tasks, rather than some specific features. But how to improve generalization of trained neural networks and reuse them for different related tasks is still a challenge.
+
+In this paper we propose a modified training approach for improving generalization via explicitly building a reverse pass network in addition to a regular forward pass. While Zhang et al. (2018) proposed reverse connected modules, they are primarily used to transfer information from deep layers to shallow layers for a given task. Recovering all input information from hidden representations of a network is generally very difficult (Dinh et al., 2016; Mahendran & Vedaldi, 2016), due to the loss of information over the course of the layer transformations. In this context, Tishby & Zaslavsky (2015) proposed the information bottleneck principle, which states that for an optimal representation, information unrelated to the current task is reduced. This highlights the common specialization of regular training approaches. Ardizzone et al. (2018), Jacobsen et al. (2018) and Gomez et al. (2017) also build reversed networks, but mainly focus on how to make a network fully invertible via introducing special structures. As a consequence, the path from input to output is actually different from the reverse path that translates output to input. In addition, the proposed structures of previous work can not be easily attached to other network architectures. In contrast, we show that it is not necessary to strive for perfect reversibility to obtain an improved performance. Our racecar training also fully preserves an architecture for the backward path, and does not require operations that are not part of the source network. As such it can easily be applied in new settings, such as for adversarial training (Goodfellow et al., 2014).
+
+Aiming for related goals, Bansal et al. (2018) introduced orthogonality regularizations to the loss function. However, the proposed constraints are relatively weak, and make it difficult to arrive at invertible networks. Besides, the orthogonality regularization still focuses on improving performance of a known, given task. This means the training process only extracts features which the network considers useful for improving the performance of the current task. Hence, unlike our method, orthogonality does not necessarily improve generalization or improved transfer performance (Torrey & Shavlik, 2010).
+
+# 3 METHOD
+
+The goal of transfer learning is to reuse a basic model trained for task A for a related new task B. The performance for B naturally depends crucially on whether the content of the basic model yields benefits for the new task. In line with previous work (Yosinski et al., 2014), we consider the generality of features learned on task A as the extent to which the features can be used for task B. This can be measured in terms of the difference between the transfer performance $p _ { A B }$ and training a model for task B from scratch yielding performance $p _ { B }$ . Our central goal is improving the transferability of the basic model w.r.t. the performance metric $p _ { A B } - p _ { B }$ , which at the same time can be seen as a measure of the generalizing capabilities of the basic model.
+
+Regular training approaches typically construct a model with a certain network structure, and train the model weights for a given task via a suitable loss function. Our approach does not modify this initial structure, but adds a second pass that reverses the initial structure while reusing all weights and biases. E.g., for a typical fully connected layer, the forward pass, the operation $L _ { 2 } = M \times L _ { 1 } + b$ is changed to $L _ { 1 } ^ { ' } = M ^ { T } \times ( L _ { 2 } - b )$ for the reverse pass, where $L _ { 1 }$ and $L _ { 2 }$ denote input and output, respectively. Here, $M$ and $b$ denote weight matrix and bias, while $L _ { 1 } ^ { ' }$ denotes the input regenerated via the reverse pass. We will show and discuss $L ^ { ' }$ for several examples below.
+
+Our goal with the reverse pass is to invert all operations of the forward pass to obtain identical intermediate activations between the layers with matching dimensionality. We can then constrain the intermediate results of each layer of the forward pass to match the results of the backward pass. Due to the symmetric structure of the two passes, we can use a simple $\mathcal { L } ^ { 2 }$ difference to drive the network towards aligning the results:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { r a c e c a r } } = \sum _ { m = 1 } ^ { n } \lambda _ { m } \left\| L _ { m } - L _ { m } ^ { ' } \right\| _ { 2 } } \end{array}
+$$
+
+Here $L _ { m }$ denotes the input of layer $m$ in the forward pass and $L _ { m } ^ { ' }$ the output of layer $m$ for the reverse pass. $\lambda _ { m }$ denotes a scaling factor for the loss of layer $m$ , which, however, is typically constant in our tests across all layers. An illustration of this process for a CNN structure is shown in Fig. 1. While the construction of the reverse is straight-forward for all standard operations, i.e., fully connected layers, convolutions, pooling etc., batch normalization (BN) and activation function require slight adjustments to map $L _ { m }$ and $L _ { m } ^ { ' }$ to the same range of values such that they can be compared in the loss. Hence, we use the BN parameters and the activation function of layer $m - 1$ from the forward pass for layer $m$ in the reverse pass, Note that with our notation, $L _ { 1 }$ and $L _ { 1 } ^ { ' }$ refer to the input $I$ , and the regenerated input $I ^ { ' }$ , respectively. In the following, we will refer to networks trained with the added reverse structure and the loss terms of equation 1 as racecar training.
+
+The constraints of equation 1 intentionally only minimize differences in an averaged manner with an $\mathcal { L } ^ { 2 }$ norm, as we don’t strive for a perfectly bijective mapping between input and output domains. Rather, our goal with the racecar training is to encourage the network to extract features that preserve as much information from the input data set as possible with the given representative capabilities of the chosen architecture. Hence, while a regular forward training allows a model to specialize its extracted features to maximize performance for a given task, our approach encourages the network to consider the full input data distribution, such that it ideally can be recovered from the latent-space representation of all layers.
+
+To differentiate variants, we will use the following naming scheme: $\mathrm { S t d _ { A / B } }$ , $\mathrm { R R } _ { \mathrm { A / B } } ^ { s }$ , $\mathrm { O r t } _ { \mathrm { A / B } }$ for trained base models. Here, $S t d$ denotes a regular training run (always shown in yellow color in graphs below), while $R R ^ { s }$ denotes models trained with our racecar training (in green below). Here, the $s$ superscript denotes how many intermediate results of layers are used, e.g., $R R ^ { 3 }$ means $n = 3$ in equation 1, which constrains the input data as well as the next two layers of the original structure.
+
+![](images/e56f2834f9a5e4a211e1e2f2c2140b703c997949808920655462b1d9deeb328c.jpg)  
+Figure 1: Left: An overview of the regular forward pass (blue) and corresponding reverse pass (yellow). The right side illustrates how parameters are reused for a convolutional layer. conv and deconv denote convolution and deconvolutional operations, and $f _ { m }$ and $B N _ { m }$ denote activation function and batch normalization of layer $m$ , respectively. Shared kernel and bias are represented by $k _ { m }$ and $b _ { m }$ , and we assume that the deconvolution internally transposes the kernel tensor.
+
+Correspondingly, a network trained with $R R ^ { 1 }$ means the network is trained to regenerate the input without any constraints for the activations inside of the network. This represents a special, and somewhat sub-optimal case of our method, as we will demonstrate below. $O r t$ additionally denotes models trained with orthogonal constraints (Bansal et al., 2018) (in blue). The subscripts $A / B$ denote the task $A / B$ the model was trained for. We will call direct training for either task phase I in the following.
+
+In phase II, we reuse a model trained in phase I for new tasks (typically B), with a regular training approach. I.e., in phase II, all models are only trained with the forward structure and original loss, and do not use the racecar loss or other modifications. We will use the naming scheme StdAA/AB, $\mathsf { R R } _ { \mathrm { A A } / \mathrm { A B } } ^ { s }$ , OrtAA/AB for trained models in phase II. Here $A A / A B$ mean the model was trained for task $A$ during phase I, and is then trained for task $A / B$ in phase II.
+
+It is worth pointing out that the additional constraints of our racecar training lead to increased requirements for memory and additional computations during phase I, e.g., it is $6 1 . 1 3 \%$ slower per epoch for the MNIST tests. And while the constraints can also lead to a slight deterioration of performance, e.g., a $0 . 1 7 \%$ lower accuracy for MNIST tests during phase I, we will demonstrate that our models outperform baselines during phase II even for the original task, and thus in practice justify introducing the racecar training.
+
+# 4 EVALUATION IN TERMS OF MUTUAL INFORMATION
+
+We now evaluate our approach in terms of the mutual information (MI) between input and output data distributions. As our approach hinges on the introduction of the reverse pass, we will show that our approach succeeds in terms of establishing mutual information between the input and the constrained intermediates inside a network. More formally, the mutual information $I ( X ; Y )$ of random variables $X$ and $Y$ measures how different the joint distribution of $X$ and $Y$ is w.r.t. the product of their marginal distributions, i.e., the Kullback-Leibler divergence: I(X; Y ) = $D _ { K L } [ P _ { ( X , Y ) } | | P _ { X } { \bf \bar { P } } _ { Y } ]$ .
+
+Tishby & Zaslavsky (2015) proposed a mutual information plane to analyze the training process, which shows $I ( X ; L )$ and $I ( L ; Y )$ for each layer $L$ over the course of the training epochs. Points in the resulting graphs are colored w.r.t. the epoch, i.e., initially black, and yellow once the training is finished. Each graph shows the 5 middle and output layers. The MI planes visualize how much information about input and output distribution is retained at each layer, and how these relationships change within the network. For regular training, the information bottleneck principle (Tishby & Zaslavsky, 2015) states that early layers contain more information about the input (high $I ( X ; L )$ and $I ( Y ; L ) )$ . Hence they are often visible at the top-right. Later layers have no relationship with the output $I ( Y ; L )$ initially, which increases over the course of a successful training. Thus, they typically move
+
+![](images/9764bd99b821b394710b35abaeb4aef6fc222f2c7ddb050e0d3d62abefc17163.jpg)  
+Figure 2: MI planes for the initial models $\mathrm { R R } _ { \mathrm { A } } ^ { 1 }$ , $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ , $\mathrm { S t d _ { A } }$ and $\mathrm { O r t } _ { \mathrm { A } }$ . End points of $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ are located in the middle of the graphs. But for $\mathrm { S t d _ { A } }$ and $\mathrm { O r t } _ { \mathrm { A } }$ , $I ( L ; Y )$ values of every layer are very high, which means more specific features about the given output data set are learned by them.
+
+to the top-left. The intuition behind MI planes is explained in more detail in Appendix A.1. We use the same numerical studies as in Shwartz-Ziv & Tishby (2017) as task $A$ , i.e. a regular feedforward neural network with 6 fully-connected layers. The inputs consist of 12 binary digits, and outputs are 2 binary digits. Models are trained using cross entropy as base loss function. Details of this architecture (and following ones) are given in the Sec. A.1. At first, we train a base model $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ with a full racecar loss. For comparison, we also show the MI planes for $\mathrm { S t d _ { A } }$ (a regularly trained model), and $\mathrm { O r t _ { A } }$ (trained with orthogonal constraints (Bansal et al., 2018)). We additionally include a version $\mathrm { R R } _ { \mathrm { A } } ^ { 1 }$ , i.e. trained with only one racecar loss term $\lambda _ { 1 } | L _ { 1 } - L _ { 1 } ^ { ' } | _ { 2 } )$ , which means that only the input is constrained to be recovered. Thus, $\mathrm { R R } _ { \mathrm { A } } ^ { 1 }$ represents a simplified version of our approach which receives no constraints that the intermediate results of forward and backward pass should match. The resulting information planes are shown in Fig. 2. We can see that the end points of $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ , i.e., the yellow clusters of points for the final state of the model, are located in the middle part of the graph. This means that all layers successfully encode information about the inputs as well as the outputs. In contrast, for $\mathrm { S t d _ { A } }$ and $\mathrm { O r t } _ { \mathrm { A } }$ , $I ( X ; L )$ values of later layers are very low (points near the top left), while $I ( L ; Y )$ is high throughout. This indicates that the outputs were successfully encoded, and that increasing amounts of information about the inputs are discarded by $\mathrm { S t d _ { A } }$ and $\mathrm { O r t } _ { \mathrm { A } }$ . Hence, both models are highly specialized for the given task. Comparing $\mathrm { R R } _ { \mathrm { A } } ^ { 1 }$ with $\mathsf { R R } _ { \mathrm { A } } ^ { 6 }$ , the yellow end points of the latter are located in a centralized region, which indicates that every layer contains similar information about $X$ and $Y$ . It also indicates that the path from input to output is similar to the path from output to input. The end points of $\mathrm { R R } _ { \mathrm { A } } ^ { 1 }$ , on the other hand, are located in a scattered region. I.e., this network has different amounts of mutual information across its layers, and potentially a very different path in each direction. $\mathrm { R R } _ { \mathrm { A } } ^ { 1 }$ is only constrained to be able to regenerate its input, while the full racecar loss for $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ ensures that the network learns features which are beneficial for both directions. This test highlights the importance of the constraints throughout the depth of a network in our racecar loss.
+
+As the discussion above focused on phase I, we now turn to analyzing phase II, i.e., follow-up training runs with models trained during phase I. Based on $\mathrm { R R } _ { \mathrm { A } } ^ { \mathrm { 1 } }$ $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ , $\mathrm { O r t } _ { \mathrm { A } }$ and $\mathrm { S t d _ { A } }$ A, we continue training the models only for the original task, i.e., $\dot { \mathsf { R R } } _ { \mathrm { A A } } ^ { 1 }$ , $\mathrm { R R } _ { \mathrm { A A } } ^ { 6 ^ { - } }$ , OrtAA and $\mathrm { S t d _ { A A } }$ . The resulting MI planes are shown in Fig. 3. While all models now focus on the output (yellow points at the top, maximizing $I ( L ; Y )$ , there are differences in the distributions of the yellow points along the
+
+![](images/476c1cf10b58a30f1a490f050b6e07a212db3a3921c351fde8b0d3f60e3b21ad.jpg)  
+Figure 3: MI plane and accuracy comparisons for continued training $( \mathrm { R R } _ { \mathrm { A A } } ^ { 1 }$ $\mathrm { R } \check { \mathrm { R } } _ { \mathrm { A A } } ^ { 6 }$ , StdAA and $\mathrm { O r t } _ { \mathrm { A A } }$ ). The $\mathrm { \dot { R } R _ { A A } ^ { 6 } }$ model slightly outperforms the other three models, indicating the positive effect of the full racecar training.
+
+$\mathbf { X }$ axis, i.e., how much MI with the input is retained. We can see that for model $\mathrm { R R } _ { \mathrm { A A } } ^ { 6 }$ , the final $I ( X ; L _ { 6 } )$ value at the end of the training is higher than for $\mathrm { S t d _ { A A } }$ , $\mathrm { O r t } _ { \mathrm { A A } }$ and $\mathrm { R R } _ { \mathrm { A A } } ^ { 1 }$ (final $I ( L _ { 6 } ; Y )$ values are shown above each graph). While the final accuracy is high throughout due to the relatively simple setup, $\mathrm { R R } _ { \mathrm { A A } } ^ { 6 }$ slightly outperforms the other variants for the original task. We will more clearly demonstrate this positive trait of our racecar training with more complex tasks below.
+
+![](images/76257d511ec3c20fbd90c35ac4f7fd263332168dc7e19ef9a645ff1107adc52b.jpg)  
+Figure 4: MI plane and accuracy comparisons for a task transfer for models $\mathrm { R R } _ { \mathrm { A B } } ^ { 1 }$ , $\mathrm { R R } _ { \mathrm { A B } } ^ { 6 }$ , $\mathrm { O r t } _ { \mathrm { A B } }$ and $\mathrm { S t d _ { A B } }$ $\mathrm { R } \breve { \mathrm { R } } _ { \mathrm { A B } } ^ { 6 }$ successfully reuses features from task $A$ for task $\mathbf { B }$ , and outperforms $\mathrm { S t d _ { B } }$ . The regular model $\mathrm { S t d } _ { \mathrm { A B } }$ yields a very low performance.
+
+We now analyze a new task, to check whether the model learned specific or general features, and reverse output labels as transwe invert it to [1,0]. Based on a, , $B$ . nd f the out, we train [, , ginaand set,for $\mathrm { R R } _ { \mathrm { A } } ^ { 1 }$ $\mathsf { R R } _ { \mathrm { A } } ^ { 6 }$ $\mathrm { O r t } _ { \mathrm { A } }$ $\mathrm { S t d _ { A } }$ $\mathrm { R R } _ { \mathrm { A B } } ^ { 1 }$ $\mathrm { R } \bar { \mathrm { R } } _ { \mathrm { A B } } ^ { 6 }$ $\mathrm { O r t } _ { \mathrm { A B } }$ $\mathrm { S t d } _ { \mathrm { A B } }$ the modified data set. For comparison, we also train a model trained $\mathrm { S t d } _ { \mathrm { B } }$ from scratch. MI planes and accuracy comparisons are shown in Fig. 4. While the range in performance is relatively small across most models, ${ \mathrm { S t d } } _ { \mathrm { A B } }$ stands out with a very low accuracy. This model from a regular training run has large difficulties to adapt to the new task. Model $\mathrm { O r t } _ { \mathrm { A B } }$ also performs worse than $\mathrm { S t d _ { B } }$ . $\mathrm { R R } _ { \mathrm { A B } } ^ { 6 }$ shows the best performance in this setting, confirming the previous MI plane visualizations, and demonstrating that our loss formulation helped to learn more general features from the input data, improving the performance for related tasks such as the inverted outputs.
+
+# 5 EXPERIMENTAL RESULTS
+
+We now turn to more complex network structures (CNNs, GANs, Auto-Encoders), with different data sets (MNIST, Cifar, smoke, ImageNet) and different tasks (such as classification and synthesis) to show that models trained with our approach succeed in learning very general features that transfer to new tasks.
+
+# 5.1 DIGIT CLASSIFICATION
+
+The MNIST data set is a commonly used data set for hand written digit classification (LeCun et al., 1998). At first, we train three models for regular MNIST data set classification as task $A$ , one with racecar loss $\mathsf { R R } _ { \mathrm { A } } ^ { 3 }$ , a regular model $\mathrm { S t d _ { A } }$ , and one with orthogonal $\mathrm { O r t } _ { \mathrm { A } }$ constraints (Bansal et al., 2018), as the latter also aims for improving CNN performance. Usually, convolutional layers take up most of the model parameters, so we correspondingly compute the racecar loss for the convolutional layers, omitting the fully connected layers that would be required for class label inference. To highlight the properties of our algorithm, we show comparisons between $I$ and the regenerated $I ^ { \prime }$ in Fig. 5. We can see that for racecar training, most of the features from the input are recovered. Trying to invert the network in the same way for a regular training run or training with orthogonal constraints largely fails, as the extracted features are extracted according to the digit classification and discard information unrelated to this task.
+
+![](images/9c72d24be2710ff2f3c6fe90174fd2b670fabdee08f7aceda1512de0e4e0ef13.jpg)  
+Figure 5: Comparisons between regenerated inputs. F.l.t.r.: $\mathrm { O r t } _ { \mathrm { A } }$ , $\mathrm { S t { \dot { d } } _ { A } }$ , $\mathrm { R R } _ { \mathrm { A } } ^ { 3 }$ , and the reference. Only $\mathrm { R R } _ { \mathrm { A } } ^ { 3 }$ recovers most of the input information successfully.
+
+Based models $\mathrm { O r t } _ { \mathrm { A } }$ $\mathrm { S t d _ { A } }$ , a $\mathrm { R R _ { A } ^ { 3 } }$ e continue training to obtain. Results are shown in Fig. 6. $\mathrm { O r t } _ { \mathrm { A A } }$ $\mathrm { S t d _ { A A } }$ $\mathrm { R R } _ { \mathrm { A A } } ^ { 3 }$   
+clusions. We can see that $\mathrm { R R } _ { \mathrm { A A } } ^ { 3 }$ outperforms $\mathrm { O r t } _ { \mathrm { A A } }$ and $\mathrm { S t d _ { A A } }$ at the end of training, which indicates that racecar training yields general features that can also improve performance for original task. Council (2000) illustrated that balanced learning of both general and specific features is more effective for human learning, and our results here are consistent with this intuition.
+
+As general features are more robust than specific features (Novak et al., 2018), we investigate a perturbed data set for the transfer task B. We apply $\mathrm { O r t _ { A } }$ , $\mathrm { S t d _ { A } }$ and $\mathsf { R R } _ { \mathrm { A } } ^ { 3 }$ to $\mathbf { n }$ -MNIST, a data set for classification with motion blur (Basu et al., 2017). Performance results are likewise given in Fig. 6. Based on the same CNN structure and parameters, $\mathsf { R R } _ { \mathrm { A } } ^ { 3 }$ achieves the best performance. This indicates that $\mathsf { R R } _ { \mathrm { A } } ^ { 3 }$ learned more general features via racecar training than $\mathrm { O r t _ { A } }$ and $\mathrm { S t d _ { A } }$ .
+
+![](images/830e079f1f5442918147b420365acd95f95f66674548f7dc33af27318ce84f98.jpg)  
+Figure 6: Accuracy comparisons for base task $A$ and transfer learning task $B$ . $\mathrm { R R } _ { \mathrm { A A } } ^ { 3 }$ and $\mathrm { R R } _ { \mathrm { A B } } ^ { 3 }$ achieve the best performance for the base task and transfer learning task, respectively.
+
+# 5.2 NATURAL IMAGE CLASSIFICATION
+
+Natural images arise in many important application scenarios. Hence, we evaluate our approach with the Cifar data set (Krizhevsky et al., 2009). At first, we train two models as Cifar10 data set classification task $A$ , $\mathsf { R R } _ { \mathrm { A } } ^ { 1 3 }$ and $\mathrm { S t d _ { A } }$ . We again continue training to obtain $\mathrm { R R } _ { \mathrm { A A } } ^ { 1 3 }$ and $\mathrm { S t d _ { A A } }$ , results for which are shown in Fig. 7. The racecar training also improves performance for this natureus $\mathsf { R R } _ { \mathrm { A } } ^ { 1 3 }$ ge cland $\mathrm { S t d _ { A } }$ cation task. For transfer learning task for Cifar-100 data set classification $B$ $( \mathrm { R R } _ { \mathrm { A B } } ^ { 1 3 }$ $\mathrm { S t d } _ { \mathrm { A B } }$ same CNN structure and parameters, ${ \mathrm { S t d } } _ { \mathrm { A B } }$ has difficulties adjusting to the new task, while our model from the initial racecar training slightly outperforms the model trained for scratch for B.
+
+![](images/45031538425224dfc08e6630ee6b074bcee63f86da5e2988891a2ed4b94433e0.jpg)  
+Figure 7: Accuracy comparisons of task $A$ and task $B$ . $\mathbf { R } \dot { \mathbf { R } } _ { \mathbf { A A } } ^ { 1 3 }$ and $\mathrm { R R } _ { \mathrm { A B } } ^ { 1 3 }$ got bestperformance for tast $A$ and $B$ .
+
+# 5.3 GENERATIVE ADVERSARIAL MODELS
+
+In the previous sections, we employed commonly used data sets and transfers to related tasks. Next, we test our approach for a transfer situation with a more challenging transfer from a synthetic single channel data set of synthetic smoke simulations, to RBG videos of real smoke clouds. We use GAN and auto-encoder structures for the following models.
+
+At first, we use a GAN structure (one generator and one discriminator network) for super resolution of the simulation data as task $A$ . $\mathrm { S t d _ { A } }$ is trained via regular training, and $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ uses racecar training for the generator network of the GAN. Regenerated low resolution results and high resolution outputs comparisons are shown in Fig. 8. Both $\mathrm { \Delta R R _ { A } ^ { 6 } }$ and $\mathrm { S t d _ { A } }$ can up scale low resolution data 4 times larger to high resolution data very well. But $\mathrm { R } \mathrm { \bar { R } } _ { \mathrm { A } } ^ { 6 }$ can also recover low resolution versions from high resolution data. $\mathrm { S t d _ { A } }$ fails in regenerating the low resolution images. This shows that $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ not only focused on
+
+![](images/18670f2491978b302de37db12c70c712fdacc302378856658a457fcaa5683089.jpg)  
+Figure 8: Regenerated low resolution results and high resolution outputs comparison between $\mathrm { S t d _ { A } }$ , $\mathsf { R R } _ { \mathrm { A } } ^ { 6 }$ and reference. Only $\mathsf { R R } _ { \mathrm { A } } ^ { 6 }$ successfully recovers the input.
+
+generating good features for the super-resolution task, but also preserves information about the input.
+
+We reuse the generator models $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ and $\mathrm { S t d _ { A } }$ to train two sets of auto-encoder networks: once for the synthetic smoke data as transfer task $B _ { 1 }$ , and as a second task $B _ { 2 }$ for RBG videos ofelstha $\mathsf { R R } _ { A B _ { 1 , 2 } } ^ { 6 }$ d smand train $\mathrm { S t d } _ { A B _ { 1 , 2 } }$ ds (example frames are given in the appendix). This yields mod-, respectively. The resulting accuracies, summarized in Fig. 9, showrms best for both auto-encoding tasks. This is especially encouraging for task $B _ { 2 }$ , as it represents a transfer from fully synthetic training to real-world images.
+
+Synthetic data and real-world images have significant differences in terms of their features. In the worst case, most of the features learned by the regular learning process $\mathrm { S t d _ { A } }$ can not be transferred to the new task. Besides, an inappropriate starting point of the transfer learning task can guide the whole training process towards a wrong direction. Instead, a model with more general features such as $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ can more easily be reused in new tasks, and can provide a better starting point for learning. This indicates the potential of racecar training to obtain generalizable features from synthetic data sets that can be used for tasks working with real-world data.
+
+![](images/13fe393f68acddc5f0a59e22a15b7c51c57230e7f3665c625cbc943eed03731f.jpg)  
+Figure 9: Accuracy comparisons of transfer learning tasks. $\dot { \mathsf { R R } } _ { \mathrm { A A } } ^ { 6 }$ and $\mathrm { R R } _ { \mathrm { A B } } ^ { 6 }$ got best performance for task $B _ { 1 }$ and $B _ { 2 }$ .
+
+![](images/adc2daeb53326160686b8889972916119fa91dc8046390039396cc9f2935b9cd.jpg)  
+Figure 10: Left: stylization test from a natural image to the starry night painting style. Right: stylization test from horse to zebra.
+
+In order to provide a qualitative evaluation in a complex, visual scenario, we turn to the popular task of image stylization. We use V GG19 networks (Simonyan & Zisserman, 2014) in the following, and we train two V GG19 networks $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ and $\mathrm { S t d _ { A } }$ with ImageNet data set (Deng et al., 2009). Based on these, we train $\mathrm { R R } _ { \mathrm { A A } } ^ { 1 6 }$ and $\mathrm { S t d _ { A A } }$ top5 accuracy of which are $7 7 . 5 9 \%$ and $7 5 . 2 8 \%$ , respectively. Consistent with previous test, $\mathrm { R R } _ { \mathrm { A A } } ^ { 1 6 }$ outperforms the $\mathrm { S t d _ { A A } }$ baseline even in this complex case for a network with ca. 143 million weights. Gatys et al. (2016) achieve excellent stylization results, but the results strongly depend on the pre-trained VGG network, i.e., it stylizes and changes structures that are represented by the features in the VGG network. Hence, we employ stylization to visualize which features, general or specialized, the two VGG versions focus on.
+
+![](images/0cdd90580317299f6fe88807c14a7c3829d12e685ac758c6947ef6b93c9b7ec0.jpg)  
+Figure 11: First primary stylization test, $\mathbf { R } \mathbf { \check { R } } _ { \mathrm { A } } ^ { 1 6 }$ did not change specific features in the results.
+
+Gatys et al. (2016) generate stylized results via optimizing two losses, $L _ { s t y l e }$ and $L _ { c o n t e n t }$ , which measure style difference and content difference, respectively (details are given in the appendix. To compare the feature extracting capabilities between the $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ and $\mathrm { S t d _ { A } }$ As a first test, we use two simple shapes as source and style images, as shown in Fig. 11. They have the same background and object color. The only difference is the large-scale shape of the object. Thus, as we aim for applying an style that is identical to the source, we can test whether the features can cleanly separate and preserve the large scale shape features from the ones for the localized style. Comparing the results of $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ and $\mathrm { S t d _ { A } }$ , the output of $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ is almost identical to the input, while stylization with $\mathrm { S t d _ { A } }$ changes the shape of the object introducing undesirable streaks around the outline. This result indicates that $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ is able to cleanly encode the shape of the object and preserve it during the stylization.
+
+runs, we only optimize $L _ { s t y l e }$
+
+![](images/c3e161cd2df671666f5fb0c9e41ebea50d027fd50f3e0fea02f6fb9150295527.jpg)  
+Figure 12: Stylization comparison from low resolution to high resolution. $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ ’s results are closer to the high resolution.
+
+We show more stylization tests in Fig. 10, which optimize both $L _ { c o n t e n t }$ and $L _ { s t y l e }$ . For the left example of Fig. 10 with a Van Gogh style image, both models can generate good stylized results. However, from the results obtained with $\mathrm { S t d _ { A } }$ (orange square area), we can see a star within the building, which indicates that this model mixed style and context information in its features. Across our tests we found that models like this one, trained for more specific features, more often performed simple patch-based matches rather than generating meaningful transfers of styles. However, if the model focuses on more general and abstract features, it can perform a better semantic matching and generate improved stylization results. For the right part of Fig. 10, we show a test transferring a horse image to a zebra style. $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ focuses more on general features, such as grass, zebra, and their positional relationships. As a result the model successfully distinguishes foreground from background, and changes the style for both foreground and background objects with only smaller mistakes. $\mathrm { S t d _ { A } }$ ’s performance is significantly worse, leading to large grass-like areas within the body of the horse.
+
+We confirm the capabilities of the VGG model from racecar training with a low- to high-resolution transfer where the goal is purely to add detail. I.e., we can compute in place errors w.r.t. high-resolution reference. The result is shown in Fig. 12. The VGG model obtained with a regular training run yields significantly higher errors, as visible on the right side of the figure.
+
+![](images/2befeadbccf35f93cae50491a873a606b2c3cdab988d78b2019f8998d9fc36a9.jpg)  
+Figure 13: $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ generates a zebra pattern in the horse’s shadow, but yields generally improved results compared to the regular transfer in $\mathrm { S t d _ { A } }$ .
+
+$\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ can extract more general information from the input, which is helpful with generating semantically meaningful results. However, we found that this property can also confuse the model in some specific situations. For instance, as shown in Fig. 13, at first, $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ can distinguish foreground and background and generate better stylization results than $\mathrm { S t d _ { A } }$ . However, $\mathrm { \tilde { R } R _ { A } ^ { 1 6 } }$ also stylizes the shadow of the horse. This also indicates that $\mathrm { \tilde { R } R _ { A } ^ { 1 6 } }$ focuses more on general features. As a consequence, all horse shape objects are extracted and then stylized with zebra textures, such as the shadow in Fig. 13. However, we generally think that this can provide potentially helpful information in other situations, e.g., for classification tasks. Overall, the quality of the racecar transfer also still surpasses the regular version.
+
+# 6 CONCLUSION
+
+We have proposed a novel training approach for improving neural network generalization by adding a constrained reverse pass. We have shown for a range of tasks that this yields networks with more general features that more easily transfer to new tasks, and even outperform baselines for the original task. Our training approach is very general, and imposes no requirements regarding network structure or training method. As future work, we believe it will be very interesting to evaluate our approach for other architectures from the vast zoo of existing work, e.g., we are particularly interested in analyzing recurrent structures such as LSTMs and GRUs (Hochreiter & Schmidhuber, 1997; Cho et al., 2014).
+
+# REFERENCES
+
+Lynton Ardizzone, Jakob Kruse, Sebastian Wirkert, Daniel Rahner, Eric W Pellegrini, Ralf S Klessen, Lena Maier-Hein, Carsten Rother, and Ullrich Kothe. Analyzing inverse problems with ¨ invertible neural networks. arXiv preprint arXiv:1808.04730, 2018.   
+Nitin Bansal, Xiaohan Chen, and Zhangyang Wang. Can we gain more from orthogonality regularizations in training deep cnns? In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pp. 4266–4276. Curran Associates Inc., 2018.   
+Saikat Basu, Manohar Karki, Sangram Ganguly, Robert DiBiano, Supratik Mukhopadhyay, Shreekant Gayaka, Rajgopal Kannan, and Ramakrishna Nemani. Learning sparse feature representations using probabilistic quadtrees and deep belief nets. Neural Processing Letters, 45(3):855– 867, 2017.   
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.   
+National Research Council. How People Learn: Brain, Mind, Experience, and School: Expanded Edition. The National Academies Press, 2000.   
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Hui Ding, Shaohua Kevin Zhou, and Rama Chellappa. Facenet2expnet: Regularizing a deep face recognition net for expression recognition. In 2017 12th IEEE International Conference on Automatic Face & Gesture Recognition (FG 2017), pp. 118–126. IEEE, 2017.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.
+
+Lixin Duan, Dong Xu, and Ivor Tsang. Learning with augmented features for heterogeneous domain adaptation. arXiv preprint arXiv:1206.4660, 2012.
+
+M-L Eckert, Wolfgang Heidrich, and Nils Thuerey. Coupled fluid density and motion from single views. In Computer Graphics Forum, volume 37, pp. 47–58. Wiley Online Library, 2018.
+
+Leon A Gatys, Alexander S Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2414–2423, 2016.
+
+Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. In Advances in neural information processing systems, pp. 2214–2224, 2017.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Kasthurirangan Gopalakrishnan, Siddhartha K Khaitan, Alok Choudhary, and Ankit Agrawal. Deep convolutional neural networks with transfer learning for computer vision-based data-driven pavement distress detection. Construction and Building Materials, 157:322–330, 2017.
+
+Alison Gopnik, Andrew N Meltzoff, and Patricia K Kuhl. The scientist in the crib: Minds, brains, and how children learn. William Morrow & Co, 1999.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Jorn-Henrik Jacobsen, Arnold Smeulders, and Edouard Oyallon. i-revnet: Deep invertible networks.¨ arXiv preprint arXiv:1802.07088, 2018.
+
+Michael Kazhdan, Thomas Funkhouser, and Szymon Rusinkiewicz. Rotation invariant spherical harmonic representation of $^ \textrm { \scriptsize 3 d }$ shape descriptors. In Symposium on geometry processing, volume 6, pp. 156–164, 2003.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Brian Kulis, Kate Saenko, and Trevor Darrell. What you saw is not what you get: Domain adaptation using asymmetric kernel transforms. In CVPR 2011, pp. 1785–1792. IEEE, 2011.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied ´ to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Aravindh Mahendran and Andrea Vedaldi. Visualizing deep convolutional neural networks using natural pre-images. International Journal of Computer Vision, 120(3):233–255, 2016.
+
+Roman Novak, Yasaman Bahri, Daniel A Abolafia, Jeffrey Pennington, and Jascha SohlDickstein. Sensitivity and generalization in neural networks: an empirical study. arXiv preprint arXiv:1802.08760, 2018.
+
+Peter Prettenhofer and Benno Stein. Cross-language text classification using structural correspondence learning. In Proceedings of the 48th annual meeting of the association for computational linguistics, pp. 1118–1127, 2010.
+
+Hariharan Ravishankar, Prasad Sudhakar, Rahul Venkataramani, Sheshadri Thiruvenkadam, Pavan Annangi, Narayanan Babu, and Vivek Vaidya. Understanding the mechanisms of deep transfer learning for medical images. In Deep Learning and Data Labeling for Medical Applications, pp. 188–196. Springer, 2016.
+
+Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Jos Stam. Stable fluids. In Siggraph, volume 99, pp. 121–128, 1999.
+
+Naftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. In 2015 IEEE Information Theory Workshop (ITW), pp. 1–5. IEEE, 2015.
+
+Lisa Torrey and Jude Shavlik. Transfer learning. In Handbook of research on machine learning applications and trends: algorithms, methods, and techniques, pp. 242–264. IGI Global, 2010.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014.
+
+Amir R Zamir, Alexander Sax, William Shen, Leonidas J Guibas, Jitendra Malik, and Silvio Savarese. Taskonomy: Disentangling task transfer learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3712–3722, 2018.
+
+Lijing Zhang, Yao Lu, Ge Song, and Hanfeng Zheng. Rc-cnn: Reverse connected convolutional neural network for accurate player detection. In Pacific Rim International Conference on Artificial Intelligence, pp. 438–446. Springer, 2018.
+
+Joey Tianyi Zhou, Sinno Jialin Pan, Ivor W Tsang, and Yan Yan. Hybrid heterogeneous transfer learning through deep learning. In Twenty-eighth AAAI conference on artificial intelligence, 2014a.
+
+Joey Tianyi Zhou, Ivor W Tsang, Sinno Jialin Pan, and Mingkui Tan. Heterogeneous domain adaptation for multiple classes. In Artificial Intelligence and Statistics, pp. 1095–1103, 2014b.
+
+Yin Zhu, Yuqiang Chen, Zhongqi Lu, Sinno Jialin Pan, Gui-Rong Xue, Yong Yu, and Qiang Yang. Heterogeneous transfer learning for image classification. In Twenty-Fifth AAAI Conference on Artificial Intelligence, 2011.
+
+# A APPENDIX
+
+Here we will present more details, such as data set information, network structures and training parameters, for all of our mentioned tests above: Mutual Information Sec. A.1, MNIST classification Sec. A.2, Cifar Sec. A.3, smoke Sec. A.4 and VGG Sec. A.5. We will use $C ( k , l , s )$ , $D ( k , l , s )$ to represent convolutional and deconvolutional operations, respectively, and fully connected layers are noted with $F ( l )$ , where $k$ , l, $s$ denote kernel size, output channels and stride size, respectively. Bias of CNN layer is denoted with $b$ . $I / O ( z )$ denote input/output and their dimensionality is given by $z$ . $I _ { r }$ denotes the input of reverse pass network. tanh, relu, lrelu denote corresponding activation functions, where we typically use a leaky tangent of 0.2 for the negative half space. $U P$ , $M P$ and $B N$ denote $2 \times$ nearest-neighbor up sampling, max pooling with $2 \times 2$ filters and stride 2, and batch normalization, respectively. All performance numbers were measured on a Nvidia GeForce GTX 1080 Ti GPUs and Intel Core i7-6850K CPUs.
+
+# A.1 MUTUAL INFORMATION TEST
+
+Below we will introduce more details about tests in Sec. 4.For the numerical task (Shwartz-Ziv & Tishby, 2017), input variable $X$ are 12 binary digits that represent 12 uniformly distributed points on a 2D sphere, and this task is about binary decision rules which are invariant under $O ( 3 )$ rotations of the sphere. $X$ has 4096 different patterns, and they are divided into 64 disjoint orbits of the rotation group, which form a minimal sufficient partition/statistics for spherically symmetric rules (Kazhdan et al., 2003). To generate input-output distribution $P ( X , Y )$ , Shwartz-Ziv & Tishby (2017) applied a stochastic rule $\bar { p ( y = 1 | x ) } = \bar { \Psi ( f ( x ) - \theta ) } , ( x \in X , y \in Y )$ , where $\Psi$ is a standard sigmoidal function $\Psi ( u ) = 1 / ( 1 + e x p ( - \gamma u ) )$ . Shwartz-Ziv & Tishby (2017) use a spherically symmetric real valued function of the pattern $f ( x )$ (evaluated through its spherical harmonics power spectrum (Kazhdan et al., 2003) and compared it to a threshold $\theta$ , which was selected to make $p ( y = 1 ) =$ $\textstyle \sum _ { x } p ( y = 1 | x ) p ( x ) \approx 0 . 5$ , with uniform $p ( x )$ . $\gamma$ is high enough to keep the mutual information $I ( \bar { X } ; Y ) \approx 0 . 9 9$ bits. $80 \%$ of the data (3277 data pairs) are used for training and rests (819 data pairs) are used for testing. The forward and reverse pass structures of the fully connected neural networks are in Table 7. Hyper parameters used for training are listed in Table 8.
+
+All and used . For ecar loss. All layers in the, we used the Spectral Res $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ andd Iso $\mathrm { S t d _ { A } }$ are reused for trainingy Property (SRIP) regu $\mathrm { R R } _ { \mathrm { A A / A B } } ^ { 6 }$ $\mathrm { S t d } _ { \mathrm { A A / A B } }$ $\mathrm { O r t } _ { \mathrm { A } }$   
+(Bansal et al., 2018),
+
+$$
+\mathcal { L } _ { \mathrm { S R I P } } = \beta \sigma ( W ^ { T } W - I ) ,
+$$
+
+where $W$ is the kernel; $I$ denotes an identity matrix; $\beta$ represents the regularization coefficient; $\sigma ( W ) = s u p _ { z \in \mathbb { R } ^ { n } , z \neq 0 } \frac { | | W _ { z } | | } { | | z | | }$ 0 kWzkkzk denotes the spectral norm of W . Details about all models’ accuracy are shown in Table 1 and Table 2.
+
+Mutual information (MI) plane is a powerful tool for neural networks analysis but admittedly not very intuitive. Here we will use MI plane of $\mathrm { S t d _ { A } }$ in Fig. 2 as an example to illustrate MI plane in details. From Table 7, we can see that neural network in this numerical task has 5 middle layers $( L _ { 1 \sim 5 } )$ and one output layer $( L _ { 6 } )$ . The $X$ axis of the MI plane represents the quantity $I ( X ; L )$ , i..e the mutual information between input variable $X$ and output of each layer $L$ . The $Y$ axis of the MI plane represents $I ( L ; Y )$ , the mutual information between output of each layer $L$ and output variable $Y$ . Besides, every point in the graphs is colored w.r.t.
+
+![](images/3f6dfaab508101d0b866a582e91e0d312ffa7a338c076d1874c6a540929befc5.jpg)  
+Figure 14: MI plane of $\mathrm { S t d _ { A } }$ as an example.
+
+the training epochs, i.e., initially black, and yellow once the training is finished. Hence, we can see six lines changing from black to yellow in figure 14 of the updated version. According to the information bottleneck principle [5], the outputs of the early layers contain more information from the input, which means a high value for $I ( X ; L )$ and $I ( L ; Y )$ . We can see that early layers $L _ { 1 3 }$ are located in the top right part of the graph. For later layers, such as $L _ { 6 }$ , parameters of $L _ { 6 }$ are randomly initialized before training, so there are almost no direct relationships between the output of $L _ { 6 }$ and $X$ or $Y$ , which means low values of $I ( X ; L )$ and $I ( L ; Y )$ . Once the model is well trained, $L _ { 6 }$ of $\mathrm { S t d _ { A } }$ is able to generate data which has the same distribution with $Y$ , so $I ( L ; Y )$ has increased and moved to the top left corner of the graph. The line of $L _ { 6 }$ starts from the bottom left part of the graph, and moves to the top left part during training. For $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ in figure 2, the L2 constraint is explicitly applied to decrease difference between $L$ and $L ^ { ' }$ , and the output is pushed to recover lost information of the input, so $I ( X ; L )$ of later layers is increased, and $I ( X ; L )$ of early layers is decreased to make the task easier.
+
+# A.2 MNIST CLASSIFICATION
+
+This section gives details for Sec. 5.1. The regular MNIST data set(LeCun et al., 1998) contains $5 5 k$ images for training and $1 0 k$ images for testing. For the n-MNIST motion blur data set(Basu et al., 2017), there are $6 0 k$ images for training and $1 0 k$ images for testing. Image size of them are all $2 8 \times 2 8$ . Example data from MNIST and $\mathbf { n }$ -MNIST with motion blur are shown in Fig. 15. Details about the forward and reverse pass network structures are shown in Table 9. Hyper parameters are listed in Table 10.
+
+![](images/c55ee87c97745cbfaa90eb884c44216250dd87a174c0e9597968a846d09b1c2d.jpg)  
+Figure 15: Left: data from MNIST; Right: data from n-MNIST with motion blur.
+
+All 3 convolutional layers are used for racecar loss and all layers in $\mathsf { R R } _ { \mathrm { A } } ^ { 3 }$ , $\mathrm { S t d _ { A } }$ and $\mathrm { O r t } _ { \mathrm { A } }$ are reused for training $\mathrm { R R } _ { \mathrm { A A / A B } } ^ { 3 }$ , StdAA/AB and OrtAA/AB. Example training processes of the MNIST tests are shown in Fig. 16. We can see that racecar loss increases the task difficulty, so $\mathsf { R R } _ { \mathrm { A } } ^ { 3 }$ yields a lower performance and longer training time than $\mathrm { S t d _ { A } }$ in the first phase. In the second phase $\mathsf { R R } _ { \mathrm { A } } ^ { 3 }$ outperforms $\mathrm { S t d _ { A } }$ and $\mathrm { O r t } _ { \mathrm { A } }$ in both task $A$ an $B$ , which indicates that racecar training is helpful with general feature extraction. For $\mathrm { O r t } _ { \mathrm { A } }$ , we also use equation 2 as orthogonal regularization. All models’ accuracy results are listed in Table 3 and Table 4.
+
+![](images/f76050184e04b1229e61e4b7a418e0c2a3c8eb85006341543a4d3a1296edfc8d.jpg)  
+Figure 16: Left: training processes of $\mathrm { R R } _ { \mathrm { A } } ^ { 3 }$ (blue, accuracy: 0.9810, cost: 5.675 seconds/epoch), $\mathrm { S t d _ { A } }$ (orange, accuracy: 0.9827, cost: 3.522 seconds/epoch) and OrtA (red, accuracy: 0.9792, cost: 4.969 seconds/epoch). Middle: training processes of $\mathrm { R R } _ { \mathrm { A A } } ^ { 3 }$ (blue), $\mathrm { S t d _ { A A } }$ (orange) and $\mathrm { O r t } _ { \mathrm { A A } }$ (red). Right: training processes os $\mathrm { \hat { R } R _ { A B } ^ { 3 } }$ (green), $\mathrm { S t d } _ { \mathrm { A B } }$ (pink), $\mathrm { O r t } _ { \mathrm { A B } }$ (blue), and $\mathrm { S t d _ { B } }$ (grey).
+
+# A.3 CIFAR TEST
+
+![](images/03c7443f75d7c79bf897bb804f5b0052a90dc568f1316616eb8ec73a7abcf6c4.jpg)  
+Figure 17: Left: training processes of $\mathrm { R R } _ { \mathrm { A } } ^ { 1 3 }$ (blue, accuracy: 0.5784, cost: 64 seconds/epoch) and $\mathrm { S t d _ { A } }$ (orange, accuracy: 0.8272, cost: 63 seconds/epoch). Middle: training processes of $\mathrm { R R } _ { \mathrm { A A } } ^ { 1 3 }$ (green) and $\mathrm { S t d _ { A A } }$ (blue). Right: training processes of $\mathrm { R R } _ { \mathrm { A B } } ^ { 1 3 }$ (blue), $\mathrm { S t d } _ { \mathrm { A B } }$ (pink) and StdB (green).
+
+All 13 convolutional layers are used for raclayer (because of different output size) in $\mathsf { R R } _ { \mathrm { A } } ^ { 1 3 }$ oss aand $\mathrm { S t d _ { A } }$ l layers except the last fuare reused for training $\mathsf { R } \mathsf { \check { R } } _ { \mathrm { A A } / \mathrm { A B } } ^ { 1 3 }$ ctedand StdAA/AB. Example training processes of the Cifar tests are shown in Fig. 17. In phase II, the model $\mathrm { R R } _ { \mathrm { A } } ^ { 1 3 }$ outperform $\mathrm { S t d _ { A } }$ in both task $A$ and $B$ . We show details about all models in Table 5.
+
+# A.4 SMOKE DATA SETS TEST
+
+In this section, we will introduce details for Sec. 5.3. The smoke simulation data was generated with a standard fluid solver (Stam, 1999) with MacCormack advection and MiC-preconditioned CG solver via the mantaflow library. We generated 20 simulations with 120 frames for every simulation. $10 \%$ of the data was used for training. Smoke inflow region, inflow velocity and buoyancy force were randomized to produce varied data. The low resolution data was down-sampled from the high-resolution data by a factor of 4. Data augmentation, such as flipping and rotation was used in addition. The smoke capture data set contains 2500 smoke images (Eckert et al., 2018), and we again used $10 \%$ as training data set. The forward and reverse pass structures of the network are in Table 13. Hyper parameters are listed in Table 14. Note that inputs of discriminator contain high resolution data $( 6 4 , 6 4 , 1 )$ and low resolution $( 1 6 , 1 6 , 1 )$ , which is up-sampled to $( 6 4 , 6 4 , 1 )$ and concatenated with high resolution data.
+
+All gentraining ayersand volved in racecar loss. All 6 layers of, but only 5 layers are reused for training $\mathrm { R R } _ { \mathrm { A } } ^ { 6 }$ ndan $\mathrm { S t d _ { A } }$ reused forbecause of $\mathsf { R R } _ { A B _ { 1 } } ^ { 6 }$ $\mathrm { S t d } _ { A B _ { 1 } }$ $\mathsf { R R } _ { A B _ { 2 } } ^ { 6 }$ $\mathrm { S t d } _ { A B _ { 2 } }$ diffetask $A B _ { 1 }$ data size. The following results give further details for the auto-encoder transfer which uses synthetic, i.e., simulated fluid data. Example training processes of $\mathrm { R R } _ { A B _ { 1 } } ^ { 6 }$ (orange), $\mathrm { S t d } _ { A B _ { 1 } }$ (blue) and model trained from scratch $\mathrm { S t d } _ { B _ { 1 } }$ (red) are shown in Fig. 18. $\mathsf { R R } _ { A B _ { 1 } } ^ { 6 }$ achieved the lowest L2 loss after training. Example outputs of $\mathbf { R R } _ { A B _ { 1 } } ^ { 6 }$ , $\mathrm { S t d } _ { A B _ { 1 } }$ and $\mathrm { S t d } _ { B _ { 1 } }$ are shown in Fig. 19. It becomes clear that model $\mathsf { R R } _ { A B _ { 1 } } ^ { 6 }$ 1  gives the best performance across these models.
+
+![](images/f1a693177f67c9081e45064d5e11f5f0933dfd5db03fc103a9ff216eea40a8de.jpg)  
+Figure 18: Training processes of $\mathbf { R R } _ { A B _ { 1 } } ^ { 6 }$ (orange), $\mathrm { S t d } _ { A B _ { 1 } }$ (blue) and $\mathrm { S t d } _ { B _ { 1 } }$ (red). The green inset shows the final loss values.
+
+![](images/0e4bcae3dc841de2be545704aee85d24374aecbf95c8d45115fadbccfafe936f.jpg)  
+Figure 19: Example outputs comparisons between $\mathsf { R R } _ { A B _ { 1 } } ^ { 6 }$ , $\mathrm { S t d } _ { A B _ { 1 } }$ , $\mathrm { S t d } _ { B _ { 1 } }$ and reference. We can see that $\mathbf { R R } _ { A B _ { 1 } } ^ { 6 }$ works better than $\mathrm { S t d } _ { A B _ { 1 } }$ , while $\mathrm { S t d } _ { B _ { 1 } }$ failed for this task producing a mostly black image.
+
+We similarly illustrate the behavior of the transfer learning task ids. This example likewise uses an auto-encoder structure. Exa $A B _ { 2 }$ for images of real-wtraining processes of $\mathsf { R R } _ { A B _ { 2 } } ^ { 6 }$ $\mathrm { S t d } _ { A B _ { 2 } }$ and model trained from scratch $\mathrm { S t d } _ { B _ { 2 } }$ are shown in Fig. 20. $\mathbf { R R } _ { A B _ { 2 } } ^ { 6 }$ 2yields the best performance at the end of training. Example output comparisons of $\mathbf { R R } _ { A B _ { 2 } } ^ { 6 }$ , $\mathrm { S t d } _ { A B _ { 2 } }$ and $\mathrm { S t d } _ { B _ { 2 } }$ are shown in Fig. 21. We can see that error of $\mathsf { R R } _ { A B _ { 2 } } ^ { 6 }$ is lower than $\mathrm { S t d } _ { A B _ { 2 } }$ and $\mathrm { S t d } _ { B _ { 2 } }$ . Detail comparisons between different models are shown in Table 6.
+
+![](images/297aeb25a89ac327cfdea3a9c630e8a0508287a26b01c98cc23053939041c6fc.jpg)  
+Figure 20: Training processes of $\mathbf { R R } _ { A B _ { 2 } } ^ { 6 }$ (orange), $\mathrm { S t d } _ { A B _ { 2 } }$ (blue) and $\mathrm { S t d } _ { B _ { 2 } }$ (red). The green inset shows the final loss values.
+
+![](images/41afc8d7fac66fc48f422a4c2875c9d9c38de2d79acf3cf4f67718712468113c.jpg)  
+Figure 21: Example outputs and mean absolute error comparisons between $\mathsf { R R } _ { A B _ { 2 } } ^ { 6 }$ , $\mathrm { S t d } _ { A B _ { 2 } }$ , $\mathrm { S t d } _ { B _ { 2 } }$ and reference. We can see that error of $\mathbf { R R } _ { A B _ { 2 } } ^ { 6 }$ is lower than $\mathrm { S t d } _ { A B _ { 2 } }$ and $\mathrm { S t d } _ { B _ { 2 } }$ .
+
+# A.5 VGG TEST
+
+We now give details of the tests in Sec. 5.4. For the ImageNet data set (Deng et al., 2009), 1281167 images of 1000 classes are used for training, and 50k images are used for testing. Image size is $2 2 4 \times 2 2 4$ . The forward and reverse pass of VGG19 are in Table 16. Hyper parameters are listed in Table 15.
+
+All 16 convolutional layers are used for racecar loss. To speed up training process offirstly train a model without racecar loss for 6 epochs with batch size 64, as regular trai $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ , we And then we reuse this model for training $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ and $\mathrm { S t d _ { A } }$ with batch size 24. Example training processes of RR16A and $\mathrm { S t d _ { A } }$ are shown in Fig. 22, while those of $\mathrm { R R } _ { \mathrm { A A } } ^ { 1 6 }$ and $\mathrm { S t d _ { A A } }$ are shown in Fig. 23.
+
+Next, we will give additional details for the stylization tests. Gatys et al. (2016) use $L _ { t o t a l } =$ $\eta L _ { c o n t e n t } + \delta L _ { s t y l e }$ for stylization optimizations, where $\eta$ and $\delta$ are coefficient factors. $L _ { c o n t e n t }$ is used to calculate content difference between source image $p$ and generated image $g$ , as shown in equation 3.
+
+$$
+\begin{array} { r } { L _ { c o n t e n t } ( p , g , t ) = \frac { 1 } { 2 } \sum _ { m , n } ( F _ { p } ^ { m , n , t } - F _ { g } ^ { m , n , t } ) ^ { 2 } , } \end{array}
+$$
+
+![](images/5697ad181aa456b77404dde0a4112a30002d03306c121355b5e91f4b628c2854.jpg)  
+Figure 22: Top5 accuracy of $\mathrm { R R } _ { \mathrm { A } } ^ { 1 6 }$ (red, accuracy: 0.6673, cost: 0.636 second/batch) and $\mathrm { S t d _ { A } }$ (blue, accuracy: 0.7324, cost: 0.308 second/batch).
+
+![](images/65c5d9330bf4229483b5d5af129b90b45c4c5b2aa22523d82ab5efbfbc97fcb2.jpg)  
+Figure 23: Top5 accuracy of $\mathrm { R R } _ { \mathrm { A A } } ^ { 1 6 }$ (grey) and $\mathrm { S t d _ { A A } }$ (blue).
+
+where $F _ { p } ^ { m , n , t }$ is $p ^ { \prime } s$ feature representation of the $m ^ { t h }$ filter at position $n$ in layer $t$ . $\boldsymbol { L _ { s t y l e } }$ is used to calculate style difference between style image $a$ and generated image $g$ , as shown in equation 4. The style loss can be written as:
+
+$$
+\begin{array} { r l } & { G _ { a } ^ { m , n , t } = \sum _ { f } F _ { a } ^ { m , f , t } F _ { a } ^ { n , f , t } , } \\ & { E _ { t } = \frac { 1 } { 4 N _ { t } ^ { 2 } M _ { t } ^ { 2 } } \sum _ { m , n } ( G _ { g } ^ { m , n , t } - G _ { a } ^ { m , n , t } ) ^ { 2 } , } \\ & { L _ { s t y l e } ( a , g ) = \sum _ { t = 0 } ^ { T } \omega _ { t } E _ { t } , } \end{array}
+$$
+
+where $\omega _ { t }$ is are the weighting factors for layer $t$ ; $G$ is the Gram matrix; $N _ { t }$ denotes filter numbers of layer $t$ , and $M _ { t }$ is the dimension of layer $t$ ’s filter; $T$ denotes the number of layers included in the style loss.
+
+Table 1: Model accuracy of MI base task tests   
+Table 2: Model accuracy of MI transfer task tests   
+
+<table><tr><td rowspan=1 colspan=1>trainingruns</td><td rowspan=1 colspan=1>OrtA</td><td rowspan=1 colspan=1>RRA</td><td rowspan=1 colspan=1>RR</td><td rowspan=1 colspan=1>StdA</td><td rowspan=1 colspan=1>OrtAA</td><td rowspan=1 colspan=1>RRAA</td><td rowspan=1 colspan=1>RRAA</td><td rowspan=1 colspan=1>StdAA</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.976</td><td rowspan=1 colspan=1>0.682</td><td rowspan=1 colspan=1>0.767</td><td rowspan=1 colspan=1>0.973</td><td rowspan=1 colspan=1>0.973</td><td rowspan=1 colspan=1>0.855</td><td rowspan=1 colspan=1>0.997</td><td rowspan=1 colspan=1>0.956</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0.944</td><td rowspan=1 colspan=1>0.75</td><td rowspan=1 colspan=1>0.779</td><td rowspan=1 colspan=1>0.986</td><td rowspan=1 colspan=1>0.954</td><td rowspan=1 colspan=1>0.909</td><td rowspan=1 colspan=1>0.99</td><td rowspan=1 colspan=1>0.973</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0.975</td><td rowspan=1 colspan=1>0.731</td><td rowspan=1 colspan=1>0.855</td><td rowspan=1 colspan=1>0.964</td><td rowspan=1 colspan=1>0.979</td><td rowspan=1 colspan=1>0.875</td><td rowspan=1 colspan=1>0.99</td><td rowspan=1 colspan=1>0.986</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.993</td><td rowspan=1 colspan=1>0.923</td><td rowspan=1 colspan=1>0.855</td><td rowspan=1 colspan=1>0.981</td><td rowspan=1 colspan=1>0.994</td><td rowspan=1 colspan=1>0.984</td><td rowspan=1 colspan=1>0.995</td><td rowspan=1 colspan=1>0.965</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>0.965</td><td rowspan=1 colspan=1>0.405</td><td rowspan=1 colspan=1>0.852</td><td rowspan=1 colspan=1>0.94</td><td rowspan=1 colspan=1>0.967</td><td rowspan=1 colspan=1>0.965</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>0.986</td></tr><tr><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>0.971</td><td rowspan=1 colspan=1>0.707</td><td rowspan=1 colspan=1>0.822</td><td rowspan=1 colspan=1>0.967</td><td rowspan=1 colspan=1>0.973</td><td rowspan=1 colspan=1>0.938</td><td rowspan=1 colspan=1>0.994</td><td rowspan=1 colspan=1>0.973</td></tr><tr><td rowspan=1 colspan=1>Std. Dev.</td><td rowspan=1 colspan=1>0.018</td><td rowspan=1 colspan=1>0.187</td><td rowspan=1 colspan=1>0.045</td><td rowspan=1 colspan=1>0.018</td><td rowspan=1 colspan=1>0.015</td><td rowspan=1 colspan=1>0.056</td><td rowspan=1 colspan=1>0.004</td><td rowspan=1 colspan=1>0.013</td></tr></table>
+
+Table 3: Model accuracy of MNIST base task tests   
+
+<table><tr><td rowspan=1 colspan=1>trainingruns</td><td rowspan=1 colspan=1>OrtAB</td><td rowspan=1 colspan=1>RRAB</td><td rowspan=1 colspan=1>RRAB</td><td rowspan=1 colspan=1>StdAB</td><td rowspan=1 colspan=1>StdB</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.978</td><td rowspan=1 colspan=1>0.914</td><td rowspan=1 colspan=1>0.996</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.966</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0.948</td><td rowspan=1 colspan=1>0.956</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.958</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0.976</td><td rowspan=1 colspan=1>0.961</td><td rowspan=1 colspan=1>0.993</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.984</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.994</td><td rowspan=1 colspan=1>0.97</td><td rowspan=1 colspan=1>0.996</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.974</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>0.968</td><td rowspan=1 colspan=1>0.959</td><td rowspan=1 colspan=1>0.998</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.989</td></tr><tr><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>0.973</td><td rowspan=1 colspan=1>0.956</td><td rowspan=1 colspan=1>0.997</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.974</td></tr><tr><td rowspan=1 colspan=1>Std. Dev.</td><td rowspan=1 colspan=1>0.017</td><td rowspan=1 colspan=1>0.022</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.013</td></tr></table>
+
+Table 4: Model accuracy of MNIST transfer task tests   
+
+<table><tr><td rowspan=1 colspan=1>trainingruns</td><td rowspan=1 colspan=1>OrtA</td><td rowspan=1 colspan=1>StdA</td><td rowspan=1 colspan=1>RR</td><td rowspan=1 colspan=1>OrtAA</td><td rowspan=1 colspan=1>StdAA</td><td rowspan=1 colspan=1>RRA</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.9792</td><td rowspan=1 colspan=1>0.9827</td><td rowspan=1 colspan=1>0.981</td><td rowspan=1 colspan=1>0.9819</td><td rowspan=1 colspan=1>0.9854</td><td rowspan=1 colspan=1>0.9856</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0.8322</td><td rowspan=1 colspan=1>0.9815</td><td rowspan=1 colspan=1>0.9824</td><td rowspan=1 colspan=1>0.982</td><td rowspan=1 colspan=1>0.9837</td><td rowspan=1 colspan=1>0.9851</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0.9511</td><td rowspan=1 colspan=1>0.9815</td><td rowspan=1 colspan=1>0.9828</td><td rowspan=1 colspan=1>0.9792</td><td rowspan=1 colspan=1>0.983</td><td rowspan=1 colspan=1>0.9862</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.8841</td><td rowspan=1 colspan=1>0.9817</td><td rowspan=1 colspan=1>0.9816</td><td rowspan=1 colspan=1>0.9814</td><td rowspan=1 colspan=1>0.9842</td><td rowspan=1 colspan=1>0.9867</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>0.8266</td><td rowspan=1 colspan=1>0.9829</td><td rowspan=1 colspan=1>0.9816</td><td rowspan=1 colspan=1>0.9816</td><td rowspan=1 colspan=1>0.9846</td><td rowspan=1 colspan=1>0.9861</td></tr><tr><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>0.895</td><td rowspan=1 colspan=1>0.982</td><td rowspan=1 colspan=1>0.982</td><td rowspan=1 colspan=1>0.981</td><td rowspan=1 colspan=1>0.984</td><td rowspan=1 colspan=1>0.986</td></tr><tr><td rowspan=1 colspan=1>Std. Dev.</td><td rowspan=1 colspan=1>0.0689</td><td rowspan=1 colspan=1>0.0007</td><td rowspan=1 colspan=1>0.0007</td><td rowspan=1 colspan=1>0.0011</td><td rowspan=1 colspan=1>0.0009</td><td rowspan=1 colspan=1>0.0006</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>trainingtimes</td><td rowspan=1 colspan=1>OrtAB</td><td rowspan=1 colspan=1>StdAB</td><td rowspan=1 colspan=1>RRB</td><td rowspan=1 colspan=1>StdB</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.949</td><td rowspan=1 colspan=1>0.956</td><td rowspan=1 colspan=1>0.9612</td><td rowspan=1 colspan=1>0.8714</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0.8629</td><td rowspan=1 colspan=1>0.9458</td><td rowspan=1 colspan=1>0.954</td><td rowspan=1 colspan=1>0.9657</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0.9458</td><td rowspan=1 colspan=1>0.9543</td><td rowspan=1 colspan=1>0.9648</td><td rowspan=1 colspan=1>0.9659</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.9495</td><td rowspan=1 colspan=1>0.9559</td><td rowspan=1 colspan=1>0.9604</td><td rowspan=1 colspan=1>0.8789</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>0.8564</td><td rowspan=1 colspan=1>0.9466</td><td rowspan=1 colspan=1>0.9649</td><td rowspan=1 colspan=1>0.9638</td></tr><tr><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>0.913</td><td rowspan=1 colspan=1>0.952</td><td rowspan=1 colspan=1>0.961</td><td rowspan=1 colspan=1>0.929</td></tr><tr><td rowspan=1 colspan=1>Std. Dev.</td><td rowspan=1 colspan=1>0.0485</td><td rowspan=1 colspan=1>0.0051</td><td rowspan=1 colspan=1>0.0044</td><td rowspan=1 colspan=1>0.0494</td></tr></table>
+
+Table 5: Model accuracy of Cifar tests
+
+<table><tr><td rowspan=1 colspan=1>trainingruns</td><td rowspan=1 colspan=1>StdA</td><td rowspan=1 colspan=1>RR</td><td rowspan=1 colspan=1>StdAA</td><td rowspan=1 colspan=1>RRA</td><td rowspan=1 colspan=1>StdAB</td><td rowspan=1 colspan=1>RRAB</td><td rowspan=1 colspan=1>StdB</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.8263</td><td rowspan=1 colspan=1>0.5784</td><td rowspan=1 colspan=1>0.8351</td><td rowspan=1 colspan=1>0.869</td><td rowspan=1 colspan=1>0.2063</td><td rowspan=1 colspan=1>0.2602</td><td rowspan=1 colspan=1>0.2581</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0.7868</td><td rowspan=1 colspan=1>0.5553</td><td rowspan=1 colspan=1>0.7936</td><td rowspan=1 colspan=1>0.8538</td><td rowspan=1 colspan=1>0.1838</td><td rowspan=1 colspan=1>0.2687</td><td rowspan=1 colspan=1>0.2659</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0.7729</td><td rowspan=1 colspan=1>0.7686</td><td rowspan=1 colspan=1>0.7718</td><td rowspan=1 colspan=1>0.8449</td><td rowspan=1 colspan=1>0.1795</td><td rowspan=1 colspan=1>0.2803</td><td rowspan=1 colspan=1>0.2386</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.865</td><td rowspan=1 colspan=1>0.7382</td><td rowspan=1 colspan=1>0.8472</td><td rowspan=1 colspan=1>0.8692</td><td rowspan=1 colspan=1>0.1738</td><td rowspan=1 colspan=1>0.2969</td><td rowspan=1 colspan=1>0.2418</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>0.781</td><td rowspan=1 colspan=1>0.6775</td><td rowspan=1 colspan=1>0.7787</td><td rowspan=1 colspan=1>0.8418</td><td rowspan=1 colspan=1>0.1704</td><td rowspan=1 colspan=1>0.2733</td><td rowspan=1 colspan=1>0.2621</td></tr><tr><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>0.806</td><td rowspan=1 colspan=1>0.664</td><td rowspan=1 colspan=1>0.805</td><td rowspan=1 colspan=1>0.856</td><td rowspan=1 colspan=1>0.183</td><td rowspan=1 colspan=1>0.276</td><td rowspan=1 colspan=1>0.253</td></tr><tr><td rowspan=1 colspan=1>Std. Dev.</td><td rowspan=1 colspan=1>0.0387</td><td rowspan=1 colspan=1>0.0945</td><td rowspan=1 colspan=1>0.0340</td><td rowspan=1 colspan=1>0.0130</td><td rowspan=1 colspan=1>0.0141</td><td rowspan=1 colspan=1>0.0138</td><td rowspan=1 colspan=1>0.0123</td></tr></table>
+
+Table 6: Model L2 loss of smoke tests. Results for $B _ { 2 } \colon \times 1 0 ^ { 7 }$ .
+
+<table><tr><td rowspan=1 colspan=1>trainingruns</td><td rowspan=1 colspan=1>StdAB1</td><td rowspan=1 colspan=1>RRAB1</td><td rowspan=1 colspan=1>StdB1</td><td rowspan=1 colspan=1>Std AB2</td><td rowspan=1 colspan=1>RRAB2</td><td rowspan=1 colspan=1>StdB2</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>22883</td><td rowspan=1 colspan=1>211.9</td><td rowspan=1 colspan=1>31911</td><td rowspan=1 colspan=1>213</td><td rowspan=1 colspan=1>2.95</td><td rowspan=1 colspan=1>6.13</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>493.3</td><td rowspan=1 colspan=1>139</td><td rowspan=1 colspan=1>22291</td><td rowspan=1 colspan=1>2.37</td><td rowspan=1 colspan=1>1.79</td><td rowspan=1 colspan=1>2.66</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>1828</td><td rowspan=1 colspan=1>210.2</td><td rowspan=1 colspan=1>31911</td><td rowspan=1 colspan=1>11.4</td><td rowspan=1 colspan=1>2.32</td><td rowspan=1 colspan=1>3.43</td></tr><tr><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>8401.43</td><td rowspan=1 colspan=1>187.03</td><td rowspan=1 colspan=1>28704.33</td><td rowspan=1 colspan=1>75.6</td><td rowspan=1 colspan=1>2.36</td><td rowspan=1 colspan=1>4.07</td></tr><tr><td rowspan=1 colspan=1>Std. Dev.</td><td rowspan=1 colspan=1>12559.15</td><td rowspan=1 colspan=1>41.61</td><td rowspan=1 colspan=1>5554.11</td><td rowspan=1 colspan=1>119</td><td rowspan=1 colspan=1>0.578</td><td rowspan=1 colspan=1>1.82</td></tr></table>
+
+Table 7: Forward and reverse pass of the neural network in MI tests   
+
+<table><tr><td>Forward pass (294 weights): I(12)→tanh(FC(10)+b1)→ tanh(FC(7)+b2)→ tanh(FC(5) +b3) →tanh(FC(4) +b4)→ tanh(FC(3)+b5)→tanh(FC(2)+b6)→O(2).</td></tr><tr><td>Reverse pass: O(2)-b6 → tanh(FC(3))-b5 →tanh(FC(4))-b4 → tanh(FC(5)) -b3 → tanh(FC(7))-b2 →tanh(FC(10))-b1 →tanh(FC(12))→I(12).</td></tr></table>
+
+Table 8: Hyper parameters of MI tests   
+
+<table><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>512|Learningrate</td><td rowspan=1 colspan=1>0.0004</td><td rowspan=1 colspan=1>入1~6</td><td rowspan=1 colspan=1>1E-2</td></tr><tr><td rowspan=1 colspan=1>Training Epochs</td><td rowspan=1 colspan=4>20000 for RRA/AA/AB and StdA/AA/AB; 400O0 for StdB</td></tr></table>
+
+Table 9: Forward and reverse pass network of MNIST Classification tests   
+
+<table><tr><td>Forward pass (38645 weights): I(28,28,1) →relu(C(3,64,1)+b1)→ MP →relu(C(3,64,1) +b2)→ MP→relu(C(3,1,1)+b3)= Ir</td></tr><tr><td>→FC(i0)→0(10) Reverse pass:</td></tr><tr><td>Ir -b3→ relu(D(3,64,1))→UP-b2→relu(D(3,64,1))→UP-b1 →relu(D(3,1,1)) →I&#x27;(28,28,1)</td></tr></table>
+
+Table 10: Hyper parameters of MNIST Classification tests   
+
+<table><tr><td>Batch size</td><td>64</td><td>入1~3</td><td>1E-5</td></tr><tr><td>Learning rate</td><td colspan="3">0.001 for RR,StdA and OrtA; 0.0001 for RRA/AB, StdAA/AB/B and OrtAA/AB</td></tr><tr><td>Training Epochs</td><td colspan="3">100 forRR,StdA and OrtA; 400 for RRA, StdAA and OrtAA; 700 for RRB, StdAB and OrtAB</td></tr></table>
+
+Table 11: Forward and reverse pass of the neural network in Cifar tests   
+
+<table><tr><td>Forward pass: I(32,32,3) → relu(BN(C(3,64,1) + bi)) →relu(BN(C(3,64,1) +b2))→MP</td></tr><tr><td>→relu(BN(C(3,128,1) +b3)) →relu(BN(C(3,128,i) +b4))→MP→ relu(BN(C(3,256,1) +b5)) → relu(BN(C(3,256,1) +b6)) →relu(BN(C(3,256,1) +b7))→ MP→relu(BN(C(3,512,1) +b8)) →relu(BN(C(3,512,1) +b9))→relu(BN(C(3,512,1) +b10))→MP→relu(BN(C(3,512,1) +b11)) →relu(BN(C(3,512,1) + b12))→ relu(BN(C(3,512,1) + b13)) = Ir → relu(BN(FC(4096) +b14)) →relu(BN(FC(4096) +b15)) →relu(BN(FC(10) +b16)) →O(10).</td></tr><tr><td>Reverse pass: Ir -b13→ relu(BN(D(3,512,1)))-b12→relu(BN(D(3,512,1)) -b11 →relu(BN(D(3,512,1))) →UP-b10 →relu(BN(D(3,512,1)) -bg →relu(BN(D(3,512,1)) -b8 →relu(BN(D(3,256,1))) →UP-b7 →relu(BN(D(3,256,1)))-b6 →relu(BN(D(3,256,1)) -b5_→ relu(BN(D(3,128,1))) →UP-b4 → relu(BN(D(3,128,1))) -b3 → relu(BN(D(3,64,1))→UP-b2</td></tr></table>
+
+Table 12: Hyper parameters of Cifar tests   
+
+<table><tr><td>Batch size</td><td>200</td><td>入1~13</td><td>1E-7</td></tr><tr><td>Learning rate</td><td colspan="3">0.1 (0 to 80 epochs); 0.01 (81 to epochs); 0.001 (after 120 epochs)</td></tr><tr><td>Training Epochs</td><td colspan="3">180 for RRAA and StdA/AA; 50forRR and StdAB/B</td></tr></table>
+
+Table 13: Forward and reverse pass of network in smoke tests   
+
+<table><tr><td>Generator forward pass: I(16,16,1) →relu(C(5,64,1) +b1)→UP→relu(C(5,128,1) +b2)→UP→relu(C(5,128,1) + b3)</td></tr><tr><td>→relu(C(5,64,1) +b4) →relu(C(5,32,1) +b5)→ relu(C(5,1,1) +b6)→ O(64,64,1)=Ir. Generator reverse pass: Ir -b6→relu(D(5,32,1))-b5 → relu(D(5,64,1))-b4 → relu(D(5,128,1))-b3 →relu(D(5,128,1))</td></tr><tr><td>→MP-b2 →relu(D(5,64,1)) →MP-b1 → relu(D(5,1,1)) →I&#x27;(16,16,1). Discriminator: I(64,64,2) → lrelu(BN(C(5,32,1) +bi)) → lrelu(BN(C(5,64,1) +b2))</td></tr></table>
+
+Table 14: Hyper parameters of smoke tests   
+
+<table><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>0.0002</td><td rowspan=1 colspan=1>入1~6</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>TrainingEpochs</td><td rowspan=1 colspan=5>40000 for RRand StdA;1000for RRAB, RRAB2, StdAB1 and StdAB2</td></tr></table>
+
+Table 15: Hyper parameters of VGG19 training   
+
+<table><tr><td rowspan=1 colspan=1>入1~16</td><td rowspan=1 colspan=1>1E-10</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>0.01 (0 to 7 epochs); 0.001 (7 to 10 epochs);0.0001(10 to 15 epochs); 0.00001 (after 15 epochs)</td></tr><tr><td rowspan=1 colspan=1>Training Epochs</td><td rowspan=1 colspan=1>36 epochs for RR and StdA;22 epochs for RR6 aand StdAA</td></tr></table>
+
+Table 16: Forward and reverse pass of VGG19 network   
+
+<table><tr><td>Forward pass: I(224,224,3) →relu(C(3,64,1) +b1)→ relu(C(3,64,1) +b2)→ MP→ relu(C(3,128,1)+b3) →relu(C(3,128,1) +b4) →MP→relu(C(3,256,1) +b5)→relu(C(3,256,1) +b6)</td></tr><tr><td>→relu(C(3,512,1) + b13) → relu(C(3,512,1) + b14) → relu(C(3,512,1) + b15) →relu(C(3,512,1) +b16)= Ir →MP→relu(FC(4096) +b17)→relu(FC(4096) +b18) →relu(FC(1000)+b19)→O(1000). Reverse pass: Ir -b16 → relu(D(3,512,1)) -b15 →relu(D(3,512,1)) -b14 →relu(D(3,512,1))- b13 →relu(D(3,512,1)) →UP-b12 →relu(D(3,512,1)) -b11→ relu(D(3,512,1)) -b10 →relu(D(3,512,1))-bg→relu(D(3,256,1)) →UP-bg → relu(D(3,256,1))-b7 →relu(D(3,256,1))-b6 →relu(D(3,256,1)) -b5 →relu(D(3,128,1)) →UP-b4 → relu(D(3,128,1)) -b3 → relu(D(3,64,1))→ UP-b2 →relu(D(3,64,1)) -b1 → relu(D(3,3,1)) →I (224,224,3).</td></tr></table>

parse/train/_TGlfdZOHY3/_TGlfdZOHY3.md

@@ -0,0 +1,407 @@
+# ON EPISODES, PROTOTYPICAL NETWORKS, AND FEW-SHOT LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Episodic learning is a popular practice among researchers and practitioners interested in few-shot learning. It consists of organising training in a series of learning problems, each relying on small “support” and “query” sets to mimic the few-shot circumstances encountered during evaluation. In this paper, we investigate the usefulness of episodic learning in Prototypical Networks, one of the most popular algorithms making use of this practice. Surprisingly, in our experiments we found that, for Prototypical Networks, it is detrimental to use the episodic learning strategy of separating training samples between support and query set, as it is a data-inefficient way to exploit training batches. This “non-episodic” version of Prototypical Networks, which corresponds to the classic Neighbourhood Component Analysis, reliably improves over its episodic counterpart in multiple datasets, achieving an accuracy that is competitive with the state-of-the-art, despite being extremely simple.
+
+# 1 INTRODUCTION
+
+The problem of few-shot learning (FSL) – classifying examples from previously unseen classes given only a handful of training data – has considerably grown in popularity within the machine learning community in the last few years. The reason is likely twofold. First, being able to perform well on FSL problems is important for several applications, from learning new characters (Lake et al., 2015) to drug discovery (Altae-Tran et al., 2017). Second, since the aim of researchers interested in meta-learning is to design systems that can quickly learn novel concepts by generalising from previously encountered learning tasks, FSL benchmarks are often adopted as a practical way to empirically validate meta-learning algorithms.
+
+To the best of our knowledge, there is not a widely recognised definition of meta-learning. In a recent survey, Hospedales et al. (2020) informally describe it as “the process of improving a learning algorithm over multiple learning episodes”. Several popular papers in the FSL community (e.g. Vinyals et al. (2016); Ravi & Larochelle (2017); Finn et al. (2017); Snell et al. (2017)) have emphasised the importance of organising training into episodes, i.e. learning problems with a limited amount of training and (pseudo-)test examples that resemble the test-time scenario. This popularity has reached such a point that an “episodic” data-loader is often at the core of new FSL algorithms, a practice facilitated by frameworks such as Deleu et al. (2019) and Grefenstette et al. (2019).
+
+Despite the considerable strides made in FSL over the past few years, several recent works (e.g. Chen et al. (2019); Wang et al. (2019); Dhillon et al. (2020); Tian et al. (2020)) showed that simple baselines can outperform established meta-learning methods by using embeddings pre-trained with standard classification losses. These results have cast a doubt in the FSL community on the usefulness of meta-learning and its pervasive episodes. Inspired by these results, we aim at understanding the practical usefulness of episodic learning in arguably the simplest method which makes use of it: Prototypical Networks (Snell et al., 2017). We chose to analyse Prototypical Networks not only for their simplicity, but also because they often appear as important building blocks of newly-proposed methods (e.g. Oreshkin et al. (2018); Cao et al. (2020); Gidaris et al. (2019); Yoon et al. (2019)).
+
+With a set of ablative experiments, we show that for Prototypical Networks episodic learning $a _ { . }$ ) is detrimental for performance, $^ b$ ) is analogous to randomly discarding examples from a batch and c) it introduces a set of unnecessary hyper-parameters that require careful tuning. We also show how, without episodic learning, Prototypical Networks are connected to the classic Neighbourhood
+
+Component Analysis (NCA) (Goldberger et al., 2005; Salakhutdinov & Hinton, 2007) on deep embeddings. Without bells and whistles, our implementation of the NCA loss achieves an accuracy that is competitive with the state-of-the-art on multiple FSL benchmarks: miniImageNet, CIFAR-FS and tieredImageNet.
+
+# 2 RELATED WORK
+
+Pioneered by the seminal work of Utgoff (1986), Schmidhuber (1987; 1992), Bengio et al. (1992) and Thrun (1996), the general concept of meta-learning is several decades old (for a survey see Vilalta & Drissi (2002); Hospedales et al. (2020)). However, in the last few years it has experienced a surge in popularity, becoming the most used paradigm for learning from very few examples. Several methods addressing the FSL problem by learning on episodes were proposed. MANN (Santoro et al., 2016) uses a Neural Turing Machine (Graves et al., 2014) to save and access the information useful to meta-learn; Bertinetto et al. (2016) propose a deep network in which a “teacher” branch is tasked with predicting the parameters of a “student” branch; Matching Networks (Vinyals et al., 2016) and Prototypical Networks (Snell et al., 2017) are two non-parametric methods in which the contributions of different examples in the support set are weighted by either an LSTM or a softmax over the cosine distances for Matching Networks, and a simple average for Prototypical Networks; Ravi & Larochelle (2017) propose instead to use an LSTM to learn the hyper-parameters of SGD, while MAML (Finn et al., 2017) learns to fine-tune an entire deep network by backpropagating through SGD. Despite these works widely differing in nature, they all stress on the importance of organising training in a series of small learning problems (episodes) that are similar to those encountered during inference at test time.
+
+In contrast with this trend, a handful of papers have recently shown that simple approaches that forego episodes and meta-learning can perform well on FSL benchmarks. These methods all have in common that they pre-train a feature extractor with the cross-entropy loss on the “meta-training classes” of the dataset. Then, at test time a classifier is adapted to the support set by weight imprinting (Qi et al., 2018; Dhillon et al., 2020), fine-tuning (Chen et al., 2019), transductive finetuning (Dhillon et al., 2020) or logistic regression (Tian et al., 2020). Wang et al. (2019) suggest performing test-time classification by using the label of the closest centroid to the query image.
+
+Different from these papers, we try to shed some light on one of the possible causes behind the poor performance of episodic-based algorithms like Prototypical Networks. An analysis similar to ours in spirit is the one of Raghu et al. (2020). After showing that the efficacy of MAML in FSL is due to the adaptation of the final layer and the “reuse” of the features of previous layers, they propose a variant with the same accuracy and computational advantages. In this paper, we focus on an FSL algorithm just as popular and uncover inefficiencies that allow for a notable conceptual simplification of Prototypical Networks, which surprisingly also brings a significant boost in performance.
+
+# 3 BACKGROUND AND METHOD
+
+This section is divided as follows: Sec. 3.1 introduces episodic learning and the formalism used in FSL, Sec. 3.2 reviews Prototypical Networks (often referred to as PNS from now on), Sec 3.3 describes the classic NCA loss and how exactly it relates to PNS, and Sec. 3.4 explains the three options we explored to perform FSL classification with an NCA-trained feature embedding.
+
+# 3.1 EPISODIC LEARNING
+
+A common strategy to train few-shot learning algorithms is to consider a distribution $\hat { \mathcal { E } }$ over possible subsets of labels that is as close as possible to the one encountered during evaluation $\mathcal { E } ^ { \mathrm { ~ I ~ } }$ . Each episodic batch $B _ { E } = \{ S , Q \}$ is obtained by first sampling a subset of labels $L$ from $\hat { \mathcal { E } }$ , and then sampling images constituting both support set $S$ and query set $Q$ from the set of images with labels in $L$ , where $\bar { S } = \{ ( \mathbf { s } _ { 1 } , y _ { 1 } ) , \dotsc , ( \mathbf { s } _ { n } , \bar { y } _ { n } ) \}$ , $Q = \{ ( \mathbf { q } _ { 1 } , y _ { 1 } ) , \dots , ( \mathbf { q } _ { m } , y _ { m } ) \}$ , and $S _ { k }$ and $Q _ { k }$ denote the sets of images with label $y = k$ in the support set and query set respectively. In a Maximum Likelihood Estimation framework, training on these episodes can be written (Vinyals et al., 2016) as
+
+![](images/682de40c4a8b70a1e683b6ca2e88fea18af6514bee0637533f97ca9d1855d0be.jpg)  
+Figure 1: Batch exploitation during training for Prototypical Networks (Snell et al., 2017) (left) vs. Neighborhood Component Analysis (Goldberger et al., 2005) (right) on a toy few-shot problem of 3 “ways”, 3 “shots” and 1 “query” per class. By dividing batches between support set $S$ and query set $Q$ , Prototypical Networks disregards many of the distances between labelled examples that would constitute useful training signal. Details in Sec. 3.3.
+
+the optimisation
+
+$$
+\arg \operatorname* { m a x } _ { \theta } E _ { L \sim \hat { \varepsilon } } \left[ E _ { S \sim L , Q \sim L } \left[ \sum _ { ( q _ { i } , y _ { i } ) \in Q } \log P _ { \theta } \left( y _ { i } | q _ { i } , S \right) \right] \right] .
+$$
+
+In most implementations this corresponds to training on a series of mini-batches in which each image belongs either to the support or the query set. Support and query sets are constructed such that they both contain all the classes of $L$ , and a constant number of images per class. Therefore, episodes are characterised by three values: the number of classes $w = | L |$ (the “ways”), the number of examples per class in the support set $n = | S _ { k } |$ (the “shots”), and the number of examples per class in the query set $m = | Q _ { k } |$ . Importantly, during evaluation the triplet $\{ w , n , m \}$ defines the problem setup. Usually the triplet remains unchanged across methods, although the Meta-Dataset benchmark of Triantafillou et al. (2019) evaluates on episodes with a variable number of ways and shots. At training time the triplet $\{ w , n , m \}$ can be seen as a set of hyper-parameters controlling the batch creation, and that (as we will see in Sec. 4.2) requires careful tuning.
+
+# 3.2 PROTOTYPICAL NETWORKS (PNS)
+
+Prototypical Networks (Snell et al., 2017) are one of the most popular and effective approaches in the few-shot learning literature, and they are at the core of many newly proposed methods (e.g. Oreshkin et al. (2018); Gidaris et al. (2019); Allen et al. (2019); Yoon et al. (2019); Cao et al. (2020)).
+
+During training, episodes constituted by support set $S$ and query set $Q$ are sampled as described in Sec. 3.1. Then, a prototype for each class $k$ is computed as the mean embedding of the samples from the support set belonging to that class: $\mathbf { c } _ { k } = ( 1 / \bar { | } S _ { k } | ) \cdot \textstyle \sum _ { ( \mathbf { s } _ { i } , y _ { k } ) \in S _ { k } } f _ { \theta } ( \mathbf { s } _ { i } )$ , where $f _ { \theta }$ is a deep neural networks with parameters $\theta$ learned via Eq. 1.
+
+Let $C = \{ ( \mathbf { c } _ { 1 } , y _ { 1 } ) , \dots , ( \mathbf { c } _ { k } , y _ { k } ) \}$ be the set of prototypes and corresponding labels. The loss can be written as follows:
+
+$$
+\mathcal { L } _ { \mathrm { p r o t o } } ( S , Q ) = - \frac { 1 } { | Q | } \sum _ { ( { \bf q } _ { i } , y _ { i } ) \in Q } \log \left( \frac { \exp - \left\| \boldsymbol { f } _ { \boldsymbol { \theta } } ( { \bf q } _ { i } ) - { \bf c } _ { y _ { i } } \right\| ^ { 2 } } { \sum _ { k ^ { \prime } } \exp - \left\| \boldsymbol { f } _ { \boldsymbol { \theta } } ( { \bf q } _ { i } ) - { \bf c } _ { k ^ { \prime } } \right\| ^ { 2 } } \right) .
+$$
+
+Here, $k ^ { \prime }$ is an index that goes over all classes. This loss is minimised over a number of training episodes. After training, given a query image $\mathbf { x } _ { i }$ from a new test episode, classification is conducted by simply consulting the nearest-neighboring prototype computed from the support set of the episode, i.e. $\bar { y ( \mathbf { x } _ { i } ) } = \arg \operatorname* { m i n } _ { j \in \{ 1 , \dots , k \} } \| f _ { \theta } ( \mathbf { \bar { x } } _ { i } ) - \bar { \mathbf { c } } _ { j } \|$ .
+
+# 3.3 NEIGHBOURHOOD COMPONENT ANALYSIS (NCA)
+
+Eq. 2 computes the likelihood that a query image belongs to the class a certain prototype is representative of by computing the softmax over the distances to all prototypes. This formulation is similar to
+
+<table><tr><td></td><td>positives</td><td>negatives</td></tr><tr><td>PNs</td><td>wmn</td><td>w(w -1)mn</td></tr><tr><td>NCA</td><td>(mn）w</td><td>(2)(m+n）²</td></tr></table>
+
+Table 1: Number of gradients from positive and negative distance pairs contributing to the loss within a batch for NCA and PNS. Respectively, $w , n$ and $m$ represent the number of ways, shots and queries. In Appendix A.8 we show that the extra number of pairs NCA can exploit grows as $O ( w ^ { 2 } ( m ^ { 2 } + n ^ { 2 } ) )$ ).
+
+the Neighbourhood Component Analysis approach by Goldberger et al. (2005) (and expanded to the non-linear case by Salakhutdinov $\&$ Hinton (2007)), except for a few important differences which we will now discuss.
+
+Let $i \in [ 1 , b ]$ be the indices of the images within a batch $B$ . The NCA loss can be written as:
+
+$$
+\mathcal { L } _ { \mathrm { N C A } } ( X ) = - \frac { 1 } { b } \sum _ { i \in 1 , \dots , b } \log \left( \frac { \sum _ { j \in 1 , \dots , b } \exp { - \left\| { \mathbf z } _ { i } - { \mathbf z } _ { j } \right\| ^ { 2 } } } { \displaystyle \sum _ { k \in 1 , \dots , b } \exp { - \left\| { \mathbf z } _ { i } - { \mathbf z } _ { k } \right\| ^ { 2 } } } \right) ,
+$$
+
+where $\mathbf { z } _ { i } = f _ { \theta } ( \mathbf { x } _ { i } )$ is an image embedding and $y _ { i }$ its corresponding label. By minimising this loss, distances between embeddings from the same class will be minimised, while distances between embeddings from different classes will be maximised. This bears similarities to the (supervised) contrastive loss (Khosla et al., 2020; Chen et al., 2020a), which we discuss in Appendix A.3. For ease of discussion, we refer to the distances between pairs of embeddings from the same class as positives, and to the distances between pairs of embeddings from different classes as negatives.
+
+Importantly, the concepts of support set and query set of Sec. 3.1 and 3.2 here do not apply. More simply, the images (and respective labels) constituting the batch $B = \{ ( \mathbf { x } _ { 1 } , y _ { 1 } ) , \dotsc , ( \mathbf { x } _ { b } , y _ { b } ) \}$ are sampled i.i.d. from the training dataset, as normally happens in standard supervised learning. Considering that in PNS there is no parameter adaptation happening at the level of each episodic batch $B _ { E }$ , $S$ and $Q$ do not have a functional role in the algorithm, and their defining values $\{ w , m , n \}$ can be interpreted as hyper-parameters controlling the data-loader during training. More specifically, PNS differ from NCA in three key aspects:
+
+1. PNS rely on the creation of prototypes, while NCA does not.   
+2. Due to the nature of episodic learning, PNS only consider pairwise distances between the query and the support set; the NCA instead uses all the distances within a batch and treats each example in the same way.   
+3. Because of how $L$ , $S$ and $Q$ are sampled in episodic learning, some images will be inevitably sampled more frequently than others, and some will likely never be seen during training (this corresponds to sampling “with replacement”). NCA instead visits every image of the dataset once and only once within each epoch (sampling “without replacement”).
+
+Notes on data-efficiency in batch exploitation. To expand on point 2 above, Fig. 1 illustrates the difference in batch exploitation. For PNS (left) and a training episode of $w { = } 3$ ways, $n { = } 3$ shots and $m { = } 1$ queries, the total number distances contributing to the loss consists of $w m n = 9$ positives and $w ( w - 1 ) m n = 1 8$ negatives 2. If we consider the same training batch in a nonepisodic way, when computing the NCA loss (Fig. 1 right) we have ${ \binom { m + n } { 2 } } w = 1 8$ positives and ${ \binom { w } { 2 } } ( m + n ) ^ { 2 } = 4 8$ negatives (we summarise these equations in Table 1). This difference in batch exploitation is significant; in Appendix A.8 we show that it grows exponentially as $O ( w ^ { 2 } ( m ^ { 2 } + n ^ { 2 } ) )$ .
+
+To investigate the effect of the three key differences between PNS and NCA illustrated in this section, in Sec. 4 we conduct a wide range of experiments.
+
+# 3.4 FEW-SHOT CLASSIFICATION DURING EVALUATION
+
+Once $f _ { \theta }$ has been trained, there are many possible ways to perform few-shot classification during evaluation. In this paper we consider three simple approaches that are particularly aligned for embeddings learned via metric-based losses such as Eq. 2 or Eq. 3.
+
+$k$ -NN. To classify an image $\mathbf q _ { i } \in Q$ , we first compute the Euclidean distance to each support point $\mathbf { s } _ { j } \in S$ $: d _ { i j } = \| f _ { \boldsymbol \theta } ( \mathbf { q } _ { i } ) - f _ { \boldsymbol \theta } ( \mathbf { s } _ { j } ) ) \| ^ { 2 }$ . Then, we simply assign $y ( \mathbf { q } _ { i } )$ to be majority label of the $k$ nearest neighbours. A downside here is that $k$ is a hyper-parameter that has to be chosen, although a reasonable choice in the FSL setup is to set it equal to the number of “shots” $n$ .
+
+1-NN with Class Centroids. Similar to $k$ -NN, we can perform classification by inheriting the label of the closest class centroid, i.e. $\begin{array} { r } { y (  { \mathbf { q } } _ { i } ) = \arg \operatorname* { m i n } _ { j \in \{ 1 , \dots , k \} } \| f _ { \boldsymbol { \theta } } (  { \mathbf { x } } _ { i } ) -  { \mathbf { c } } _ { j } \| } \end{array}$ . This is the approach used at test-time by Snell et al. (2017) and Wang et al. (2019).
+
+Soft Assignments. This is what the original NCA paper (Goldberger et al., 2005) used for evaluation. To classify an image $\mathbf { q } _ { i } ~ \in ~ { \cal Q }$ , we compute the values $p _ { i j } ~ = ~ \exp ( - \| f _ { \theta } (  { \mathbf { q } } _ { i } ) ~ -$ $\begin{array} { r } { f _ { \theta } ( \mathbf { s } _ { j } ) ) \vert \vert ^ { 2 } ) / \sum _ { \mathbf { s } _ { k } \in S } \exp ( - \vert \vert f _ { \theta } ( \mathbf { q } _ { i } ) - f _ { \theta } ( \mathbf { s } _ { k } ) \vert \vert ^ { 2 } ) } \end{array}$ for all $\mathbf { s } _ { j } ~ \in ~ S$ , which is the probability that image $i$ is sampled from image $j$ . We then compute the likelihood for each class $k$ : $\textstyle \sum _ { s _ { j } \in S _ { k } } p _ { i j }$ , and choose the class with the highest likelihood $y ( \mathbf { q } _ { i } ) = \arg \operatorname* { m a x } _ { k } \sum _ { s _ { j } \in S _ { k } } p _ { i j }$ . This approach is the only one closely aligned with the training procedure, and has a direct probabilistic interpretation.
+
+We also experimented with using the NCA loss on the support set to perform adaptation at test time, which we discuss in Appendix A.1.
+
+# 4 EXPERIMENTS
+
+In the following, Sec. 4.1 describes our experimental setup. Sec. 4.2 shows the effect of the hyperparameters controlling the creation of episodes in PNS. In Sec. 4.3 we perform a set of ablation studies to better illustrate the relationship between PNS and the NCA. Finally, in Sec. 4.4 we compare our version of the NCA to several recent methods on three FSL benchmarks.
+
+# 4.1 EXPERIMENTAL SETUP
+
+We conduct our experiments on miniImageNet (Vinyals et al., 2016), CIFAR-FS (Bertinetto et al., 2019) and tieredImageNet (Ren et al., 2018), using the ResNet12 variant first adopted by Lee et al. (2019) as embedding function $f _ { \theta }$ . A detailed description of benchmarks, architecture and implementation details is deferred to Appendix A.4, while below we discuss the most important choices of the experimental setup.
+
+Like Wang et al. (2019), for all our experiments (including those with Prototypical Networks) we centre and normalise the feature embeddings before performing classification, as it is considerably beneficial for performance. After training, we compute the mean feature vectors of all the images in the training set: $\begin{array} { r } { \bar { \mathbf { x } } = \frac { 1 } { | \mathcal { D } ^ { \mathrm { t r a i n } } | } \sum _ { \mathbf { x } \in \mathcal { D } ^ { t r a i n } } \mathbf { x } . } \end{array}$ . Then, all feature vectors in the test set are updated as xi ← xi − x¯, and normalised by xi ← xikxik .
+
+We compared the inference methods discussed in Sec. 3.4 on miniImageNet and CIFAR-FS. Results can be found in Table 2. We chose to use 1-NN with class centroids in all our experiments, as it performs significantly better than $k$ -NN or Soft Assignment. This might sound surprising, as the Soft Assignment approach closely reflects the training protocol and outputs class probabilities. We speculate its inferior performance could be caused by poor model calibration (Guo et al., 2017): since the classes between training and evaluation are disjoint, the model is unlikely to produce calibrated probabilities. As such, within the softmax, outliers behaving as false positives can happen to highly influence the final decision, and those behaving as false negatives can end up being almost completely ignored (their contribution is squashed toward zero). With the nearest centroid classification approach outliers are still clearly an issue, but their effect can be less dramatic.
+
+As standard, performance is assessed on episodes of 5-way, 15-query and either 1- or 5-shot. Each model is evaluated on 10,000 episodes sampled from the test set (or the validation set, in some experiments). To further reduce the variance, we trained each model five times with five different random seeds, for a total of 50,000 episodes per configuration, from which error bars are computed.
+
+miniImageNet   
+Table 2: Comparison between the different evaluation methods discussed in Sec. 3.4.   
+
+<table><tr><td>method</td><td>5-shot val</td><td>5-shot test</td></tr><tr><td>Soft Assignment</td><td>79.11 ± 0.27</td><td>77.16 ± 0.10</td></tr><tr><td>k-NN</td><td>75.82 ± 0.21</td><td>73.52 ±0.12</td></tr><tr><td>1-NN centroid</td><td>80.61±0.20</td><td>78.30 ± 0.14</td></tr><tr><td></td><td>CIFAR-FS</td><td></td></tr><tr><td>Soft Assignment</td><td>76.12 ± 0.32</td><td>83.31 ± 0.37</td></tr><tr><td>k-NN</td><td>73.46 ± 0.39</td><td>80.94 ± 0.38</td></tr><tr><td>1-NN centroid</td><td>77.80±0.35</td><td>85.13 ±0.32</td></tr></table>
+
+![](images/787fcc0a3c7f353f6d0d23738ee75b237c7fba525200d727ad836d7be5a29209.jpg)  
+Figure 2: 1-shot (left) and 5-shot accuracies (right) on the val. set of CIFAR-FS. Models trained using NCA, or Proto-nets with different configurations: 1-shot with $a { = } 8$ and 5-shot with $a { = } 8$ , 16 or 32. Values correspond to the mean accuracy of five models trained with different random seeds. Please see Sec. 4.2 for details.
+
+# 4.2 CONSIDERATIONS ON EPISODES AND DATA EFFICIENCY
+
+Despite Prototypical Networks being one of the simplest FSL methods, the creation of episodes requires the use of several hyper-parameters $( \{ w , m , n \}$ , Sec. 3.1) which can significantly affect performance. Snell et al. (2017) state that the number of shots $n$ between training and testing should match and that one should use a higher number of ways $w$ during training time. In their experiments, they train 1-shot models with $w = 3 0$ , $n = 1$ , $m = 1 5$ and 5-shot models with $w = 2 0$ , $n = 5$ , $m = 1 5$ . This makes the corresponding batch sizes of these episodes 480 and 400, respectively. Since, as seen in Sec. 3.3, the number of positives and negatives grows rapidly for both PNS and NCA (although at a different rate), this makes a fair comparison between models trained on different types of episodes difficult.
+
+We investigate the effect of changing these hyper-parameters in a systematic manner. To compare configurations fairly across episode/batch sizes, we define each configuration by its number of shots $n$ , the batch size $b$ and the total number of images per class $a$ (which accounts for the sum between support and query set, $a = n + m ,$ ). For example, if we train a 5-shot model with $a = 8$ and $b = 2 5 6$ , it means that its corresponding training episodes will have $n = 5$ , $q = 8 - 5 = 3$ , and $w =$ $2 5 6 / 8 = 3 2$ . Using this notation, we train configurations of PNS covering several combinations of these hyper-parameters so that the resulting batch size corresponds to an episode is 128, 256 or 512. Then, we train three configurations of NCA, where the only hyper-parameter is the batch size.
+
+Results for CIFAR-FS can be found in Fig. 2, where we report results for NCA and PNS with $a = 8$ , 16 or 32. Results for miniImageNet observe the same trend and are deferred to Appendix A.6. Note that the results of 1-shot with $a = 1 6$ and $a = 3 2$ are not reported, as they fare significantly worse. Several things can be noticed. First, NCA performs better than all PNS configurations, no matter the batch size. Second, PNS is very sensitive to different hyper-parameter configurations. For instance, with batches of size 128, PNS trained with episodes of 5-shot and $a = 3 2$ performs significantly worse than a PNS trained with episodes of 5-shot and $a = 1 6$ . Finally, we can also notice that, contrary to what has been previously reported (Snell et al., 2017; Cao et al., 2020), the 5-shot model with the best configuration is always strictly better than any 1-shot configuration. We speculate that this is probably due to the fact that we compare configurations keeping the batch size constant.
+
+![](images/378d174e86a8463b548944cdf9989681b1fa7f1af0417280c46488bd5b815969.jpg)  
+Figure 3: 1-shot and 5-shot accuracies on the miniImageNet test set for models trained with a batch size of 256 while only sampling a $\%$ of the total number of available pairs. Reported values correspond to the mean accuracy of five models trained with different random seeds. Individual points contain models trained using PNS which are plotted on the $\mathbf { X }$ -axis based on the relative percentage of distance pairs that are used in their computation compared to NCA on the same batch size. Please see Sec. 4.2 for details.
+
+Episodic batches vs random sub-sampling of standard batches. Despite the NCA outperforming all PNS configurations (Fig. 2), one might posit that by using more distances within a batch, NCA is more computationally costly and thus the episodic strategy of PNS can sometimes be advantageous (e.g. real-time applications with large batches). To investigate this, we perform an experiment where we train NCA models by randomly sampling a fraction of the total number of distances used in the loss. Then, for comparison, we include different PNS models after having computed to which percentage of discarded pairs (in a normal batch) their episodic batch corresponds to.
+
+Results can be found in Fig. 3. As expected, we can see how sub-sampling a fraction of the total available number of pairs within a batch negatively affects performance. To answer to possible concerns on computational efficiency, we can notice that the PNS points lie very close to the undersampling version of the NCA, which signals that the episodic strategy of PNS is roughly equivalent to train with the NCA and only exploiting a fraction of the distances available in a batch.
+
+We see as we move right on the curve in Fig. 3, that the PN performance increases as well. In Appendix A.9 we look more carefully whether the difference in performance between the different episodic batch setups of Fig. 2 can be explained by the differences in the number of distance pairs used in the batch configurations. We indeed find that generally speaking the higher the number of pairs the better, however, one should also consider the positive/negative balance and the number of classes present within a batch.
+
+# 4.3 ABLATION EXPERIMENTS
+
+To better analyse why NCA performs better than PNS, in this section we consider the three key differences discussed earlier by performing a series of ablations on models trained on batches of size 256. Results are summarised in Fig. 4. We refer the reader to Appendix A.1 to obtain detailed steps describing how these ablations affect Eq. 2 and Eq. 3, while Appendix A.7 contains the same analysis also for batches of size 128 and 512.
+
+First, we compare two variants of NCA: one in which the sampling of the training batches happens sequentially and without replacement, as it is standard in supervised learning, and one where the batches are sampled with replacement. Interestingly, this modification (row 1 and 2 of Fig. 4) has a negligible effect across the two datasets and four splits considered, meaning that the replacement sampling introduced by episodic learning will not interfere with the other ablations.
+
+We then perform a series of ablations on episodic batches, i.e. sampled with the method described in Sec. 3.1. For each ablation, we perform experiments on PNS trained with 1-shot and 5-shot, both with $a = 8$ . This means that both the 1-shot and 5-shot models have 32 classes and 8 images per class, allowing a fair comparison. The batch size is 256 for the NCA too. We first train standard PNS models. Next, we train a PNS model where “prototypes” are not computed (point 1 of Sec. 3.3), meaning that distances are considered between individual points, but a separation between query and support set remains. Then, we perform an ablation where we ignore the separation between support and query set (point 2 of Sec. 3.3), and compute the NCA on the union of the support and query set, while still computing prototypes for the points that would belong to the support set. Last, we perform an ablation where we consider all the previous points together: we sample with replacement, we ignore the separation between support and query set and we do not compute prototypes. This amounts to the NCA loss, except that it is computed on batches with a fixed number of classes and a fixed number of images per class. Notice that in Fig. 4 there is only one row dedicated to 1-shot models. This is because we cannot generate prototypes from 1-shot models, so we cannot have a “no proto” ablation. Furthermore, for 1-shot models the “no S/Q” ablation is equivalent to the NCA with a fixed batch composition. From Fig. 4, we can see that disabling prototypes (row 6) negatively affects the performance of 5-shot (row 5), albeit slightly. On the other hand, enabling the computation between all pairs increases the performance (last row), Importantly, enabling all the ablations (row 3) completely recovers the performance lost by PNS.
+
+![](images/d846cc09a7dd57288e9008e707f160d4426fa3c70630d43f864c50e40d192fb7.jpg)  
+Figure 4: Ablation experiments on NCA and Prototypical Networks, both on batches or episodes of size 256 on the validation set of miniImageNet and CIFAR-FS. Please refer to Sec. 4.3 for details.
+
+The fact that each single ablation does not have much influence on the performance, but their combination does, could be explained by the number of distance pairs exploited by the individual ablations. Using the formulas described at the end of Section 3.3, we compute the number of positives and negatives used for each ablation. For row 6 there are 480 positives, and 14,880 negatives. For row 7 there are 576 positives and 20,170 negatives. In both cases, the number is significantly lower than the corresponding NCA, which gets 896 positives and 31,744 negatives, and this could explain the jump in performance from row 6/7 to 3. Moreover, from row 5/6 to 7 we see a slight increase in performance, which can also be explained by the (slightly) larger number of distance pairs.
+
+These experiments nonetheless highlight that the separation of roles between the images belonging to support and query set, which is typical of episodic learning (Vinyals et al., 2016), is detrimental for the performance of Prototypical Networks. Instead, using the NCA loss on standard mini-batches allows full exploitation of the training data and significantly improves performance. Moreover, the NCA has the advantage of simplifying the overall training procedure, as the hyper-parameters for the creation of episodes $\{ w , n , m \}$ no longer need to be considered.
+
+Additionally, in Appendix A.7 we repeat the same analysis done here to the simplest variant of Matching Networks (Vinyals et al., 2016) and obtain the same conclusion; also in this case, the separation of roles between support and query samples severely affects performance.
+
+# 4.4 COMPARISON WITH THE STATE-OF-THE-ART
+
+We now benchmark our models on three FSL datasets, with the purpose of contextualising their performance against the modern literature.
+
+When considering which methods to compare against, we chose those $a$ ) which have been recently published, $b$ ) that are using a ResNet12 (which we found the most commonly used) and $c _ { \mathrm { \scriptscriptstyle . } }$ ) with a setup that is not significantly more complicated than ours. For example, we only report the results of the main approach proposed by Tian et al. (2020) and not their sequential self-distillation (Furlanello et al., 2018) variant, which requires re-training multiple times and can be applied to most methods.
+
+Results can be found in Table 3 for miniImageNet and CIFAR-FS and Table 4 for tieredImageNet. In Table 3 we report Prototypical Networks results for both the episodic setup from Snell et al. (2017) and the best one (batch size 512, 5-shot, $a { = } 1 6$ ) found from the experiment of Fig. 2, which brings a considerable improvement over the original. We did not optimised for a new setup for Prototypical Networks on tieredImageNet, as the larger dataset and the higher number of classes would have made the hyper-parameter search too demanding. Notice how our vanilla NCA is competitive or superior to recent methods, despite being extremely simple. It fairs surprisingly well against methods that use meta-learning (and episodic learning), and also against the high-performing simple baselines based on pre-training with the cross-entropy loss.
+
+Table 3: Comparison of methods that use ResNet12 on miniImageNet and CIFAR-FS (test set).   
+
+<table><tr><td></td><td colspan="2">minilmageNet</td><td colspan="2">CIFAR-FS</td></tr><tr><td></td><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>Episodic methods</td><td></td><td></td><td></td><td></td></tr><tr><td>adaResNet (Munkhdalai et al.,2018)</td><td>56.88 ±0.62</td><td>71.94 ± 0.57</td><td></td><td></td></tr><tr><td>TADAM(Oreshkin et al., 2018)</td><td>58.50 ±0.30</td><td>76.70 ± 0.30</td><td></td><td></td></tr><tr><td>Shot-Free (Ravichandran et al.,2019)</td><td>60.71±n/a</td><td>77.64±n/a</td><td>69.2±n/a</td><td>84.7±n/a</td></tr><tr><td>TEAM (Qiao et al.,2019)</td><td>60.07±n/a</td><td>75.90±n/a</td><td></td><td></td></tr><tr><td>MTL (Sun et al.,2019)</td><td>61.20 ± 1.80</td><td>75.50 ±0.80</td><td></td><td></td></tr><tr><td>TapNet (Yoon et al.,2019)</td><td>61.65 ± 0.15</td><td>76.36 ±0.10</td><td></td><td></td></tr><tr><td>MetaOptNet-SVM(Lee et al.,2019)</td><td>62.64 ± 0.61</td><td>78.63 ± 0.46</td><td>72.0±0.7</td><td>84.2 ±0.5</td></tr><tr><td>Variatonal FSL (Zhang et al., 2019)</td><td>61.23±0.26</td><td>77.69 ±0.17</td><td></td><td></td></tr><tr><td>Simple baselines</td><td></td><td></td><td></td><td></td></tr><tr><td>Transductive finetuning (Dhillon et al., 2020)</td><td>62.35 ±0.66</td><td>74.53 ± 0.54</td><td>70.76 ± 0.74</td><td>81.56 ±0.53</td></tr><tr><td>RFIC-simple (Tian et al.,2020)</td><td>62.02±0.63</td><td>79.64 ± 0.44</td><td>71.5 ±0.8</td><td>86.0±0.5</td></tr><tr><td>Meta-Baseline (Chen et al.,2020b)</td><td>63.17±0.23</td><td>79.26 ± 0.17</td><td></td><td></td></tr><tr><td>Our implementations:</td><td></td><td></td><td></td><td></td></tr><tr><td>Proto-nets (Snell et al. (2017) setup)</td><td>59.93±0.23</td><td>75.89 ±0.16</td><td>70.20±0.22</td><td>83.96 ±0.16</td></tr><tr><td>Proto-nets (our setup)</td><td>61.32 ±0.23</td><td>77.77 ± 0.15</td><td>70.41 ± 0.31</td><td>84.46 ±0.29</td></tr><tr><td>SimpleShot (Wang et al.,2019)</td><td>62.16 ±0.23</td><td>78.33 ± 0.17</td><td>70.01 ± 0.21</td><td>84.50 ± 0.11</td></tr><tr><td>NCA (ours)</td><td>62.52±0.24</td><td>78.3±0.14</td><td>72.48±0.40</td><td>85.13±0.29</td></tr></table>
+
+Table 4: Comparison of methods that use ResNet12 on tieredImageNet (test set).   
+
+<table><tr><td colspan="3">tieredImageNet</td></tr><tr><td>Method</td><td>1-shot</td><td>5-shot</td></tr><tr><td>Shot-Free (Ravichandran et al.,2019)</td><td>63.52±n/a</td><td>82.59±n/a</td></tr><tr><td>RFIC-simple (Tian et al., 2020)</td><td>69.74±0.72</td><td>84.41±0.55</td></tr><tr><td>Meta-Baseline (Chen et al.,2020b)</td><td>68.62 ± 0.27</td><td>83.29 ±0.18</td></tr><tr><td>MetaOptNet-SVM(Lee et al.,2019)</td><td>65.99 ± 0.72</td><td>81.56 ± 0.53</td></tr><tr><td>Our implementations:</td><td></td><td></td></tr><tr><td>Proto-nets (Snell et al. (2017) setup)</td><td>65.45 ± 0.23</td><td>81.14 ± 0.17</td></tr><tr><td>SimpleShot (Wang et al., 2019)</td><td>66.17 ± 0.15</td><td>80.64±0.20</td></tr><tr><td>NCA (ours)</td><td>68.36 ± 0.11</td><td>83.20±0.18</td></tr></table>
+
+# 5 CONCLUSION
+
+Towards the aim of understanding the reasons behind the poor competitiveness of meta-learning methods with respect to simple baselines, in this paper we start by investigating the role of episodes in the popular Prototypical Networks. We found that their performance is highly sensitive to the set of hyper-parameters used to sample the episodes. By replacing the Prototypical Networks’ loss with the classic Neighbourhood Component Analysis, we are able to ignore these hyper-parameters while significantly improving the few-shot classification accuracy. With a series of experiments, we found out that the performance discrepancy mostly arises from the separation between support and query set within each episode, and that Prototypical Networks’ episodic strategy is almost empirically equivalent to randomly discarding a large fraction of distances within a standard mini-batch. Finally, we show that our variant of the NCA achieves an accuracy on multiple popular FSL benchmarks that is comparable or superior with state-of-the-art methods of similar complexity, making it a simple and appealing baseline for future work.
+
+# REFERENCES
+
+Kelsey R Allen, Evan Shelhamer, Hanul Shin, and Joshua B Tenenbaum. Infinite mixture prototypes for few-shot learning. In International Conference on Machine Learning, 2019.
+
+Han Altae-Tran, Bharath Ramsundar, Aneesh S Pappu, and Vijay Pande. Low data drug discovery with one-shot learning. ACS central science, 2017.
+
+Samy Bengio, Yoshua Bengio, Jocelyn Cloutier, and Jan Gecsei. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks. Univ. of Texas, 1992.
+
+Luca Bertinetto, Joao F Henriques, Jack Valmadre, Philip Torr, and Andrea Vedaldi. Learning feed- ˜ forward one-shot learners. In Advances in Neural Information Processing Systems, 2016.
+
+Luca Bertinetto, Joao F Henriques, Philip HS Torr, and Andrea Vedaldi. Meta-learning with differ-˜ entiable closed-form solvers. In International Conference on Learning Representations, 2019.
+
+Tianshi Cao, Marc Law, and Sanja Fidler. A theoretical analysis of the number of shots in few-shot learning. In International Conference on Learning Representations, 2020.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020a.
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. arXiv preprint arXiv:1904.04232, 2019.
+
+Yinbo Chen, Xiaolong Wang, Zhuang Liu, Huijuan Xu, and Trevor Darrell. A new meta-baseline for few-shot learning. arXiv preprint arXiv:2003.04390, 2020b.
+
+Tristan Deleu, Tobias Wurfl, Mandana Samiei, Joseph Paul Cohen, and Yoshua Bengio. Torchmeta: ¨ A meta-learning library for pytorch. arXiv preprint arXiv:1909.06576, 2019.
+
+Guneet S Dhillon, Pratik Chaudhari, Avinash Ravichandran, and Stefano Soatto. A baseline for few-shot image classification. In International Conference on Learning Representations, 2020.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, 2017.
+
+Tommaso Furlanello, Zachary Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. In International Conference on Machine Learning, 2018.
+
+Golnaz Ghiasi, Tsung-Yi Lin, and Quoc V Le. Dropblock: A regularization method for convolutional networks. In Advances in Neural Information Processing Systems, 2018.
+
+Spyros Gidaris, Andrei Bursuc, Nikos Komodakis, Patrick Perez, and Matthieu Cord. Boosting few- ´ shot visual learning with self-supervision. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+
+Jacob Goldberger, Geoffrey E Hinton, Sam T Roweis, and Russ R Salakhutdinov. Neighbourhood components analysis. In Advances in Neural Information Processing Systems, 2005.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Edward Grefenstette, Brandon Amos, Denis Yarats, Phu Mon Htut, Artem Molchanov, Franziska Meier, Douwe Kiela, Kyunghyun Cho, and Soumith Chintala. Generalized inner loop metalearning. arXiv preprint arXiv:1910.01727, 2019.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian q Weinberger. On calibration of modern neural networks. In International Conference on Machine Learning, 2017.
+
+Timothy Hospedales, Antreas Antoniou, Paul Micaelli, and Amos Storkey. Meta-learning in neural networks: A survey. arXiv preprint arXiv:2004.05439, 2020.
+
+Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. Supervised contrastive learning. arXiv preprint arXiv:2004.11362, 2020.
+
+Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 2015.
+
+Kwonjoon Lee, Subhransu Maji, Avinash Ravichandran, and Stefano Soatto. Meta-learning with differentiable convex optimization. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+
+George A Miller. Wordnet: a lexical database for english. Communications of the ACM, 38(11): 39–41, 1995.
+
+Tsendsuren Munkhdalai, Xingdi Yuan, Soroush Mehri, and Adam Trischler. Rapid adaptation with conditionally shifted neurons. In International Conference on Machine Learning, 2018.
+
+Boris Oreshkin, Pau Rodr´ıguez Lopez, and Alexandre Lacoste. Tadam: Task dependent adaptive ´ metric for improved few-shot learning. In Advances in Neural Information Processing Systems, 2018.
+
+Hang Qi, Matthew Brown, and David G Lowe. Low-shot learning with imprinted weights. In IEEE Conference on Computer Vision and Pattern Recognition, 2018.
+
+Limeng Qiao, Yemin Shi, Jia Li, Yaowei Wang, Tiejun Huang, and Yonghong Tian. Transductive episodic-wise adaptive metric for few-shot learning. In IEEE International Conference on Computer Vision, 2019.
+
+Aniruddh Raghu, Maithra Raghu, Samy Bengio, and Oriol Vinyals. Rapid learning or feature reuse? towards understanding the effectiveness of maml. In International Conference on Learning Representations, 2020.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In International Conference on Learning Representations, 2017.
+
+Avinash Ravichandran, Rahul Bhotika, and Stefano Soatto. Few-shot learning with embedded class models and shot-free meta training. In IEEE International Conference on Computer Vision, 2019.
+
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. In International Conference on Learning Representations, 2018.
+
+Ruslan Salakhutdinov and Geoff Hinton. Learning a nonlinear embedding by preserving class neighbourhood structure. In Artificial Intelligence and Statistics, 2007.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Metalearning with memory-augmented neural networks. In International Conference on Machine Learning, 2016.
+
+Jurgen Schmidhuber. ¨ Evolutionary principles in self-referential learning, or on learning how to learn: the meta-meta-... hook. PhD thesis, Technische Universitat M¨ unchen, 1987. ¨
+
+Jurgen Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent ¨ networks. Neural Computation, 1992.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, 2017.
+
+Qianru Sun, Yaoyao Liu, Tat-Seng Chua, and Bernt Schiele. Meta-transfer learning for few-shot learning. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+
+Sebastian Thrun. Is learning the n-th thing any easier than learning the first? In Advances in Neural Information Processing Systems, 1996.
+
+Yonglong Tian, Yue Wang, Dilip Krishnan, Joshua B Tenenbaum, and Phillip Isola. Rethinking fewshot image classification: a good embedding is all you need? arXiv preprint arXiv:2003.11539, 2020.
+
+Eleni Triantafillou, Tyler Zhu, Vincent Dumoulin, Pascal Lamblin, Utku Evci, Kelvin Xu, Ross Goroshin, Carles Gelada, Kevin Swersky, Pierre-Antoine Manzagol, et al. Meta-dataset: A dataset of datasets for learning to learn from few examples. In International Conference on Learning Representations, 2019.
+
+Paul E Utgoff. Shift of bias for inductive concept learning. Machine learning: An artificial intelligence approach, 1986.
+
+Ricardo Vilalta and Youssef Drissi. A perspective view and survey of meta-learning. Artificial Intelligence Review, 2002.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in Neural Information Processing Systems, 2016.
+
+Yan Wang, Wei-Lun Chao, Kilian Q Weinberger, and Laurens van der Maaten. Simpleshot: Revisiting nearest-neighbor classification for few-shot learning. arXiv preprint arXiv:1911.04623, 2019.
+
+Sung Whan Yoon, Jun Seo, and Jaekyun Moon. Tapnet: Neural network augmented with taskadaptive projection for few-shot learning. In International Conference on Machine Learning, 2019.
+
+Jian Zhang, Chenglong Zhao, Bingbing Ni, Minghao Xu, and Xiaokang Yang. Variational few-shot learning. In IEEE International Conference on Computer Vision, 2019.
+
+# A APPENDIX
+
+# A.1 PERFORMANCE IMPROVEMENTS
+
+Adapting to the support set. Prototypical Networks does not perform any kind of parameter adaptation at test time. On the one hand this is convenient, as it allows fast inference; on the other hand, useful information from the support set $S$ might remain unexploited.
+
+In the 5-shot case it is possible to minimise the NCA loss since it can directly be computed on the support set: $\mathcal { L } _ { \mathrm { N C A } } ( S )$ . We tried training a positive semi-definite matrix $A$ on the outputs of the trained neural network, which corresponds to learning a Mahalanobis distance metric as in Goldberger et al. (2005). However, we found that there was no meaningful increase in performance. Differently, we did find that fine-tuning the whole neural network $f _ { \theta }$ by $\operatorname { a r g m i n } _ { \theta } { \mathcal { L } } _ { \mathrm { N C A } } ( S )$ was beneficial (see Table 5). However, given the computational cost, we opted for non performing adaptation to the support sets in our experiments of Sec. 4.
+
+Features concatenation. For NCA, we also found that concatenating the output of intermediate layers modestly improves performance at (almost) no additional cost. We used the output of the average pool layers from all ResNet blocks except the first and we refer to this variant as NCA multi-layer. However, since this is an orthogonal variation that can be applied to several methods, we do not consider it for our experiments of Sec. 4.
+
+Results on miniImageNet an CIFAR-FS are shown in Table 5.
+
+# A.2 DETAILS ABOUT THE ABLATION STUDIES OF SECTION 4.3
+
+Referring to the three key differences between the Prototypical Networks and the NCA losses listed in Sec. 3.3, in this section we detail how to obtain the ablations we used to perform the experiments of Sec. 4.3.
+
+We can “disable” the creation of prototypes (point 1), which will change the prototypical loss of Eq. 2 to
+
+$$
+\mathcal { L } ( S , Q ) = - \frac { 1 } { \vert Q \vert + \vert S \vert } \sum _ { ( { \bf q } _ { i } , y ) \in Q } \log \left( \frac { \sum _ { ( { \bf s } _ { j } , y ^ { \prime } ) \in S _ { y } } \exp - \left. { \bf q } _ { i } - { \bf s } _ { j } \right. ^ { 2 } } { \sum _ { ( { \bf s } _ { k } , y ^ { \prime \prime } ) \in S } \exp - \left. { \bf q } _ { i } - { \bf s } _ { k } \right. ^ { 2 } } \right) .
+$$
+
+This is similar to $\mathcal { L } _ { \mathrm { N C A } }$ (Eq. 3), where the positives are represented by the distances from $Q$ to $S _ { k }$ and the negatives by the distances from $Q$ to $S \setminus S _ { k }$ . The only difference now is the separation of the batch into a query and support set.
+
+Independently, we can “disable” point 2, which gives us
+
+$$
+\mathcal { L } ( S , Q ) = - \frac { 1 } { | Q | + | S | } \sum _ { ( \mathbf { z } _ { i } , y _ { i } ) \in Q \cup C } \log ( \frac { \sum _ { y _ { j } , y _ { j } ) \in Q \cup C } \exp { - \| \mathbf { z } _ { i } - \mathbf { z } _ { j } \| ^ { 2 } } } { \underset { ( \mathbf { z } _ { k } , y _ { k } ) \in Q \cup C } { \sum \ell } } ) ,
+$$
+
+which essentially combines the prototypes with the query set, and computes the NCA loss on that total set of embeddings.
+
+Finally, we can “disable” both point 1 and 2, which gives us
+
+$$
+\mathcal { L } ( S , Q ) = - \frac { 1 } { \left| Q \right| + \left| S \right| } \sum _ { ( \mathbf { z } _ { i } , y _ { i } ) \in Q \cup S } \log \left( \frac { \sum _ { y _ { j } = y _ { i } } ^ { \sum } \exp - \left\| \mathbf { z } _ { i } - \mathbf { z } _ { j } \right\| ^ { 2 } } { \underset { ( \mathbf { z } _ { k } , y _ { k } ) \in Q \cup S } { \sum \neq \idotsint } \exp - \left\| \mathbf { z } _ { i } - \mathbf { z } _ { k } \right\| ^ { 2 } } \right) .
+$$
+
+This almost exactly corresponds to the NCA loss, where the only difference is the construction of batches with a fixed number of classes and a fixed number of images per class.
+
+miniImageNet   
+CIFAR-FS   
+Table 5: Comparison between vanilla NCA, NCA using multiple evaluation layers and NCA performing optimisation on the support set (ss). The NCA can only be optimised in the 5-shot case, since there are not enough positives distances in the 1-shot case. Support set is optimised for 5 epochs using Adam with learning rate 0.0001 and weight decay 0.0005. For details, see Sec. A.1   
+
+<table><tr><td>method</td><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>NCA</td><td>62.52 ± 0.24</td><td>78.3 ± 0.14</td><td>72.48 ± 0.40</td><td>85.13± 0.29</td></tr><tr><td>NCA multi-layer</td><td>63.21 ± 0.08</td><td>79.27 ±0.08</td><td>72.44 ± 0.36</td><td>85.42 ± 0.29</td></tr><tr><td>NCA (ours) multi-layer + ss</td><td>-</td><td>79.79 ± 0.08</td><td>-</td><td>85.66 ± 0.32</td></tr></table>
+
+# A.3 DIFFERENCES BETWEEN THE NCA AND CONTRASTIVE LOSSES
+
+Eq. 3 is similar to the contrastive loss functions (Khosla et al., 2020; Chen et al., 2020a) that are used in self-supervised learning and representation learning. The main differences are that 1.) In contrastive losses, the denominator only contains negative pairs and 2.) the inner sum in the numerator is moved outside of the logarithm in the supervised contrastive loss function from Khosla et al. (2020). We opted to work with the NCA loss because we found it performs better than the supervised constrastive loss in a few-shot learning setting. Using the supervised contrastive loss we only managed to obtain $5 1 . 0 5 \%$ 1-shot and $6 3 . 3 6 \%$ 5-shot performance on the miniImagenet test set.
+
+# A.4 IMPLEMENTATION DETAILS
+
+Benchmarks. In our experiments, we use three popular FSL benchmarks. miniImageNet (Vinyals et al., 2016) is a subset of ImageNet generated by randomly sampling 100 classes, each with 600 randomly sampled images. We adopt the commonly used splits of Ravi & Larochelle (2017) who use 64 classes for meta-training, 16 for meta-validation and 20 for meta-testing. CIFAR-FS was proposed by Bertinetto et al. (2019) as an anagolous version of miniImagenet for CIFAR-100. It uses the same sized splits and same number of images per split as miniImageNet. tieredImageNet (Ren et al., 2018) is also constructed from ImageNet, but contains 608 classes, with 351 training classes, 97 validation classes and 160 test classes. The class split have been generated using WordNet (Miller, 1995) to ensure that the training classes are semantically “distant” to the validation and test classes. For all datasets, we use images of size $8 4 \times 8 4$ .
+
+Architecture. In all our experiments, $f _ { \theta }$ is represented by a ResNet12 with widths [64, 160, 320, 640]. We chose this architecture, initially introduced by Lee et al. (2019), as it is the one which is most frequently adopted by recent FSL methods. Unlike most methods, we do not use a DropBlock regulariser (Ghiasi et al., 2018), as we did not notice it to meaningfully contribute to performance.
+
+Optimisation. To train all the models used for our experiments, unless differently specified, we used a SGD optimiser with Nesterov momentum, weight decay of 0.0005 and initial learning rate of 0.1. For miniImageNet and CIFAR-FS we decrease the learning rate by a factor of 10 after $70 \%$ of epochs have been trained, and train for a total of 120 epochs. As data augmentations, we use random horizontal flipping and centre cropping.
+
+Only for the experiments of Sec. 4.4, we slightly change our training setup. On CIFAR-FS, we increase the number of training epochs from 120 to 240, which improved accuracy of about $0 . 5 \%$ . For tieredImageNet, we train for 120 epochs and decrease the learning rate by a factor of 10 after $50 \%$ and $7 5 \%$ of the training progress. For tieredImageNet only we increased the batch size to 1024, as we found it being beneficial. For the other datasets it did not improve performance. These changes affect all our methods and baselines: NCA, Prototypical Networks (with both old and new batch setup), and SimpleShot (Wang et al., 2019).
+
+Projection network. Similarly to (Khosla et al., 2020; Chen et al., 2020a), we also experimented (for both PNS and NCA) with a projection network (but only for the comparison of Sec. 4.4). The projection network is a single linear layer $A \in \mathbb { R } ^ { M \times P }$ that is placed on top of $f _ { \theta }$ at training time, where $M$ is the output dimension of the neural network $f _ { \theta }$ and $P$ is the output dimension of $A$ , which can be considered as a hyper-parameter. The output of $A$ is only used during training. At test time, we do not use the output of $A$ and directly use the output of $f _ { \theta }$ . For CIFAR-FS and tieredImageNet, we found this did not help performance. For miniImageNet however we found that this improved performance, and we set $P = 1 2 8$ (which worked best for both PNS and NCA). Note that this is not an unfair advantage over other methods. Compared to SimpleShot (Wang et al., 2019) and other simple baselines, we actually use fewer parameters without the projection network (effectively making our ResNet12 a ResNet11) since they use an extra fully connected layer to minimise cross entropy during pre-training.
+
+miniImageNet   
+CIFAR-FS   
+Table 6: Comparison of results on validation set of miniImageNet and CIFAR-FS using the hyperparameters used in SimpleShot(Wang et al., 2019) and the hyperparameters used in this paper (ours). Results are on batch size 256 (as used in Wang et al. (2019)) with the PNS episodic batch being $a { = } 1 6$ , as it is the best performing episodic setup we found.   
+
+<table><tr><td>method</td><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>PNs (SimpleShot)</td><td>57.99 ±0.21</td><td>74.33 ± 0.16</td><td>53.76 ±0.22</td><td>68.54± 0.19</td></tr><tr><td>PNs (ours)</td><td>62.79 ±0.12</td><td>78.82 ± 0.09</td><td>59.60 ± 0.13</td><td>74.64± 0.11</td></tr><tr><td>NCA (SimpleShot)</td><td>61.21 ± 0.22</td><td>76.39 ± 0.16</td><td>59.41± 0.24</td><td>73.29 ± 0.19</td></tr><tr><td>NCA (ours)</td><td>64.94 ± 0.13</td><td>80.12 ±0.09</td><td>62.07 ± 0.14</td><td>76.26 ±0.10</td></tr></table>
+
+# A.5 CHOICE OF HYPER-PARAMETERS
+
+During the experimental design, we wanted to ensure a fair comparison between the NCA and PNs. As a testimony of this effort, we obtained very competitive results for PNs (see for example the comparison to recent papers where architectures of similar capacity were used (Wang et al., 2019; Chen et al., 2019)). In particular:
+
+• We always use the normalisation strategy of Wang et al. (2019), as it is beneficial also for PNs.   
+Unless expressively specified, we always used PNs 5-shot model, which in our implementation outperforms the 1-shot model (for both 1-shot and 5-shot evaluation). Instead, (Snell et al., 2017) train and tests with the same number of shots. Apart from the episodes hyper-parameters of PNs, which we did search and optimise over to create the plots of Fig. 2, the only other hyper-parameters of PNs are those related to the training schedule, which are the same as the NCA. To set them, we started from the simple SGD schedule used by Wang et al. (2019) and only marginally modified it by increasing the number of training epochs to 120, increasing the batch size to 512 and setting weight decay and learning rate to $5 e { - 4 }$ and 0.1, respectively. As a sanity check, we trained both the NCA and PNs with the exact training schedule used by Wang et al. (2019). Results are reported in Table 6, and show that the schedule we used for this paper is considerably better for both PNs and NCA. In general, we observed that the modifications were beneficial for both NCA and PNs, and improvements in performance in NCA and PNs were highly correlated. This is to be expected given the high similarity between the two methods and losses.
+
+A.6 ADDITIONAL RESULTS FOR SEC. 4.2
+
+Fig. 5 complements the results of Fig. 2 from Sec. 4.2
+
+# A.7 ADDITIONAL RESULTS FOR SEC. 4.3
+
+Matching Networks (Vinyals et al., 2016) are closely related to PNs (Snell et al., 2017), and even equivalent in the 1-shot case. The difference is in the use of the support set in the multi-shot case. Whereas PNs generate prototypes by averaging the embedding of the support set, Matching Networks adopt a weighted nearest-neighbour approach using an attention mechanism. If the attention mechanism is a softmax over the distances (which the authors suggest in Sec. 2.1.1 of their paper), we obtain the soft-assignment approach discussed in Sec. 3.4 of this paper. The only two differences between Matching Networks with a softmax attention mechanism and PNs are the lack of protoypes and the use of the cosine distance, instead of the Euclidean distance (Snell et al. (2017) has shown that the Euclidean distance is a better choice in FSL).
+
+![](images/1a21157d9635de40bd189e50aa5d659788e69c1d7626e81e35fb91c9365b4c2c.jpg)  
+Figure 5: 1-shot (left) and 5-shot accuracies (right) on the validation set of miniImageNet for different batch sizes. Models are trained using NCA or Proto-nets with different configurations: 1-shot with $a = 8$ and 5-shot with $a = 8$ , 16 or 32. Reported values correspond to the mean accuracy of five models trained with different random seeds. Please see Sec. 4.2 for details.
+
+![](images/586df99c2485d5b98fbdda21783b89aab8b28de2fff9ca8be0efc3534b6a407a.jpg)  
+Figure 6: Ablation experiments on NCA and Matching Networks, both on batches or episodes of size 256 on the validation set of miniImageNet and CIFAR-FS. All methods use soft assignment (Sec. 3.4) at test time.
+
+Given this similarity, and because of the relevance Matching Networks has in the few-shot learning community, we repeated the ablation experiment of Fig. 4. The results can be found in Table 6. In particular, we perform experiments on Matching Networks (without a Full Context Embedding) using the softmax attention mechanism, and using a Euclidean distance metric instead of a cosine distance metric. At training time, Matching Networks corresponds to the “no prototype” method in row 6 of Fig. 4. Therefore, the only difference between Matching Networks and NCA during training is the separation between the support and query set, leaving us with only one ablation to perform. At test time, evaluating Matching Networks is equivalent to using the soft-assignment approach described in Sec. 3.4. Therefore, for a fair comparison, for both NCA and “NCA fixedbatch composition” methods we also use the soft-assignment evaluation at test time.
+
+As we can see, disregarding the separation between the support and query set also improves the performance of Matching Networks, and significantly so. This corroborates the findings of Sec. 4.3: the separation of roles between images in the support and query sets, typical of episodic learning, is detrimental to the performance of not only PN, but also Matching Networks. Instead, using the (closely related) NCA on standard random mini-batches allows for better exploitation of the training data, while simultaneously simplifying the training procedure.
+
+Ablation experiments for different batch sizes. We repeated the ablation experiments done for batch size 256 (Fig. 4) also for size 128 and 512. Results can be found in Fig. 7 and Fig. 8. As we can see, the overall trend is maintained. A difference is the meaningful gap in performance between row 1 and 3 in Fig. 7 (size 128), which disappers in Fig. 8 (batch 512).
+
+This is likely due to the number of positives available in an excessively small batch size. Since our vanilla NCA relies on using distance pairs and creates batches by simply sampling images randomly from the dataset, there is a limit to how small a batch can be (which depends on the number of classes of the dataset). As an example, consider the extreme case of a batch of size 4. For the datasets considered, it is very likely that such a batch will contain no positive pairs. For a batch size of 128 and a training set of 64 classes, with a parameter-free sampler the NCA will have in expectation only one positive pair per class. Conversely, the NCA ablation with a fixed batch composition (i.e. with a set number of images per class) will have a higher number of positive pairs (at the cost of a reduced number of classes per batch). We believe this can explain the difference, as positive pairs constitute a less frequent (and potentially more informative) training signal. For the sake of simplicity, and since this only affects smaller batch sizes, we opted to use a vanilla, parameter-free sampler for the NCA in the rest of our experiments. Notice that, for batch size 512, there is even a slight $( 0 . 2 \% )$ decrease in performance using the fixed-batch composition w.r.t. the vanilla NCA.
+
+![](images/2a7bcf0d55c308fcb0d99af2f80acb5cb99af993b10d4908ddd0e6a2c94a8c80.jpg)  
+Figure 7: Ablation experiments on NCA and Prototypical Networks, both on batches or episodes of size 128 on the validation set of miniImageNet and CIFAR-FS. Please refer to Sec. 4.3 for details.
+
+![](images/6577ff3809045014e4c16910504e66a409d6d1bca3b496d09f03dccd862fc2ea.jpg)  
+Figure 8: Ablation experiments on NCA and Prototypical Networks, both on batches or episodes of size 512 on the validation set of miniImageNet and CIFAR-FS. Please refer to Sec. 4.3 for details.
+
+# A.8 DETAILS ABOUT NUMBER OF PAIRS DESCRIPTION OF SECTION 3.3
+
+In this section we demonstrate that the total number of training pairs that NCA can exploit within a batch is always strictly superior than the one exploited by the episodic batch strategy used by Prototypical Networks.
+
+To ensure we have a “valid” episodic batch with a nonzero number of both positive and negative distance pairs, we assume that $n , m \geq 1$ , and $w \geq 2$ .
+
+Below, we show that the number of positives for NCA, i.e. the one for PNs, which is mnw: ${ \binom { m + n } { 2 } } w$ , is always greater or equal than
+
+$$
+\begin{array} { r l } & { \binom { m + n } { 2 } w = \frac { ( m + n ) ! } { 2 ! ( m + n - 2 ) ! } w } \\ & { \qquad = \frac { 1 } { 2 } ( m + n ) ( m + n - 1 ) w } \\ & { \qquad = \frac { 1 } { 2 } ( m ^ { 2 } + 2 m n - m + n ^ { 2 } - n ) w } \\ & { \qquad = \frac { 1 } { 2 } ( m ( m - 1 ) + 2 m n + n ( n - 1 ) ) w } \\ & { \qquad \geq \frac { 1 } { 2 } ( 2 m n ) w = w m n . } \end{array}
+$$
+
+Similarly, we can show for negative distance pairs that ${ \binom { w } { 2 } } ( m + n ) ^ { 2 } > w ( w - 1 ) m n$ :
+
+<table><tr><td>rank</td><td>method</td><td># pos</td><td>#neg</td><td># total pairs</td></tr><tr><td>1</td><td>NCA</td><td>1792</td><td>129024</td><td>130816</td></tr><tr><td>2</td><td>5-shot a=16</td><td>1760</td><td>54560</td><td>56320</td></tr><tr><td>3</td><td>5-shot a=8</td><td>960</td><td>60480</td><td>61440</td></tr><tr><td>4</td><td>5-shot a=32</td><td>2160</td><td>32400</td><td>34560</td></tr><tr><td>5</td><td>1-shot a=8</td><td>448</td><td>28224</td><td>28672</td></tr></table>
+
+Table 7: Number of positives and negatives used in the batch size 512 experiments of Fig. 2.
+
+$$
+\begin{array} { l } { { { \binom { w } { 2 } } ( m + n ) ^ { 2 } = \displaystyle \frac { w ! } { 2 ! ( w - 2 ) ! } ( m ^ { 2 } + 2 m n + n ^ { 2 } ) } } \\ { { \mathrm { } } } \\ { { \mathrm { } = \displaystyle \frac { 1 } { 2 } w ( w - 1 ) ( m ^ { 2 } + 2 m n + n ^ { 2 } ) } } \\ { { \mathrm { } } } \\ { { \mathrm { } > \displaystyle \frac { 1 } { 2 } w ( w - 1 ) ( 2 m n ) } } \\ { { \mathrm { } = w ( w - 1 ) m n . } } \end{array}
+$$
+
+This means that the NCA has at least the same number of positives as Prototypical Networks, and always has strictly more negative distances.
+
+The total number of extra pairs that NCA can rely on is $\begin{array} { r } { \frac { w } { 2 } ( w ( m ^ { 2 } + n ^ { 2 } ) - m - n ) } \end{array}$ .
+
+# A.9 DETAILS ABOUT NUMBER OF PAIRS DESCRIPTION OF SECTION 4.2
+
+In Table 7 we plot the number of positives and negatives (gradients contributing to the loss) for the NCA and different episodic configurations of PNs, to see whether the difference in performance can be explained by the difference in the number of distance pairs that can be exploited in a certain batch configuration. This is often true, as the ranking can almost be fully explained by the number of total pairs in the right column. However, there are two exceptions to this: 5-shot with $\mathsf { a } { = } 1 6$ and 5-shot with $\scriptstyle \mathbf { a } = { } 8$ .
+
+To understand this, we can see that the number of positive pairs is much higher for $_ { \mathrm { a } = 1 6 }$ than for $\scriptstyle \mathrm { a = } 8$ . Since the positive pairs constitute a less frequent (and potentially more informative) training signal, this can explain the difference. The $\scriptstyle \mathbf { a } = 3 2$ variant has an even higher number of positives than $\mathsf { a } { = } 1 6$ , but the loss in performance there could be explained by a drastically lower number of negatives, and by the fact that the number of ways used during training is lower. So, while indeed generally speaking the higher number of pairs the better (which is also corroborated by Fig. 3, where moving right on the $\mathbf { X }$ -axis sees higher performance for both NCA and PNs), one should also consider how this interacts with the positive/negative balance and the number of classes present within a batch.

parse/train/rJlk6iRqKX/rJlk6iRqKX.md

@@ -0,0 +1,423 @@
+# QUERY-EFFICIENT HARD-LABEL BLACK-BOXATTACK: AN OPTIMIZATION-BASED APPROACH
+
+Minhao Cheng, Huan Zhang & Cho-Jui Hsieh
+
+Department of Computer Science University of California, Los Angeles {mhcheng,huanzhang,chohsieh}@cs.ucla.edu
+
+Thong Le Department of Computer Science University of California, Davis thmle@ucdavis.edu
+
+Pin-Yu Chen  
+IBM Research AI  
+pin-yu.chen@ibm.com
+
+Jinfeng Yi JD AI Research yijinfeng@jd.com
+
+# ABSTRACT
+
+We study the problem of attacking machine learning models in the hard-label black-box setting, where no model information is revealed except that the attacker can make queries to probe the corresponding hard-label decisions. This is a very challenging problem since the direct extension of state-of-the-art white-box attacks (e.g., C&W or PGD) to the hard-label black-box setting will require minimizing a non-continuous step function, which is combinatorial and cannot be solved by a gradient-based optimizer. The only two current approaches are based on random walk on the boundary (Brendel et al., 2017) and random trials to evaluate the loss function (Ilyas et al., 2018), which require lots of queries and lacks convergence guarantees. We propose a novel way to formulate the hard-label black-box attack as a real-valued optimization problem which is usually continuous and can be solved by any zeroth order optimization algorithm, such as randomized gradientfree method (Nesterov & Spokoiny, 2017). We demonstrate that our proposed method outperforms the previous stochastic approaches to attacking convolutional neural networks on MNIST, CIFAR, and ImageNet datasets. More interestingly, the proposed algorithm can also be used to attack other discrete and non-continuous machine learning models, such as Gradient Boosting Decision Trees.
+
+# 1 INTRODUCTION
+
+It has been observed recently that machine learning algorithms, especially deep neural networks, are vulnerable to adversarial examples (Goodfellow et al., 2014; Szegedy et al., 2013; Moosavi-Dezfooli et al.; Moosavi Dezfooli et al., 2016; Chen et al., 2018a; Cheng et al., 2018). For example, in image classification problems, attack algorithms (Carlini & Wagner, 2017; Goodfellow et al., 2014; Chen et al., 2017) can find adversarial examples for almost every image with very small humanimperceptible perturbation. The problem of finding an adversarial example can be posed as solving an optimization problem—within a small neighbourhood around the original example, find a point to optimize the cost function measuring the “successfulness” of an attack. Solving this objective function with gradient-based optimizer leads to state-of-the-art attacks (Carlini & Wagner, 2017; Goodfellow et al., 2014; Chen et al., 2017; Szegedy et al., 2013; Madry et al., 2018).
+
+Most current attacks (Goodfellow et al., 2014; Carlini & Wagner, 2017; Szegedy et al., 2013; Chen et al., 2018b) consider the “white-box” setting, where the machine learning model is fully exposed to the attacker. In this setting, the gradient of an attacking objective function can be computed by back-propagation, so attacks can be done very easily. This white-box setting is clearly unrealistic when the model parameters are unknown to an attacker. Instead, several recent works consider the “score-based black-box” setting, where the machine learning model is unknown to the attacker, but it is possible to make queries to obtain the corresponding probability outputs of the model (Chen et al., 2017; Ilyas et al., 2018). However, in many cases real-world models will not provide probability outputs to users. Instead, only the final decision (e.g., top-1 predicted class) can be observed. It is therefore interesting to show whether machine learning model is vulnerable in this setting.
+
+Furthermore, existing gradient-based attacks cannot be applied to some non-continuous machine learning models which involve discrete decisions. For example, the robustness of decision-tree based models (random forest and gradient boosting decision trees (GBDT)) cannot be evaluated using gradient-based approaches, since the gradient of these functions may not exist.
+
+In this paper, we develop an optimization-based framework for attacking machine learning models in a more realistic and general “hard-label black-box” setting. We assume that the model is not revealed and the attacker can only make queries to acquire the corresponding hard-label decision instead of the probability outputs (also known as soft labels).
+
+We make hard-label black-box attacks query-efficient by reformulating the attack as a novel realvalued optimization problem, which is usually continuous and much easier to solve. Although the objective function of this reformulation cannot be written in an analytical form, we show how to use (hard-label) model queries to evaluate its function value and thus any zeroth order optimization algorithm can be applied to solve it. In the experiments, we show our algorithm can be successfully used to attack hard-label black-box CNN models on MNIST, CIFAR, and ImageNet with far less number of queries compared to the state-of-art algorithm both in $L _ { 2 }$ and $L _ { \infty }$ metric.
+
+Moreover, since our algorithm does not depend on the gradient of the classifier, we can apply it to attack other non-differentiable classifiers besides neural networks. We show an interesting application in attacking Gradient Boosting Decision Tree, which cannot be attacked by all the existing gradientbased methods even in the white-box setting. Our method can successfully find adversarial examples with imperceptible perturbations for a GBDT within 30,000 queries.
+
+# 2 BACKGROUND AND RELATED WORK
+
+We will first introduce our problem setting and give a brief literature review to highlight the difficulty of attacking hard-label black-box models.
+
+Problem Setting For simplicity, we consider attacking a $K$ -way multi-class classification model in this paper. Given the classification model $f : \mathbb { R } ^ { d }  \{ 1 , \dots , K \}$ and an original example $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ , the goal is to generate an adversarial example $_ { \textbf { \em x } }$ such that
+
+$$
+\operatorname { c l o s e \ t o } x _ { 0 } \quad { \mathrm { a n d } } \quad f ( x ) \neq f ( x _ { 0 } ) \quad { \mathrm { ( i . e . , ~ } } x { \mathrm { ~ i s ~ m i s c l a s s i f i e d ~ b y ~ m o d e l ~ } } f . { \mathrm { ) } }
+$$
+
+White-box attacks Most attack algorithms in the literature consider the white-box setting, where the classifier $f$ is exposed to the attacker. For neural networks, under this assumption, backpropagation can be conducted on the target model because both network structure and weights are known by the attacker. For classification models in neural networks, it is usually assumed that $f ( \pmb { x } ) = \mathrm { a r g m a x } _ { i } ( Z ( \pmb { x } ) _ { i } )$ , where $Z ( \pmb { x } ) \in \mathbb { R } ^ { K }$ is the final (logit) layer output, and $Z ( { \pmb x } ) _ { i }$ is the prediction score for the $i$ -th class. The objectives in (1) can then be naturally formulated as the following optimization problem:
+
+$$
+\underset { \pmb { x } } { \mathrm { a r g m i n } } \left\{ \mathrm { D i s } ( \pmb { x } , \pmb { x } _ { 0 } ) + c \mathcal { L } ( Z ( \pmb { x } ) ) \right\} : = h ( \pmb { x } ) ,
+$$
+
+where $\operatorname { D i s } ( \cdot , \cdot )$ is some distance measurement (e.g., $L _ { 2 } , L _ { 1 }$ or $L _ { \infty }$ norm in Euclidean space), $\mathcal { L } ( \cdot )$ is the loss function corresponding to the goal of the attack, and $c$ is a balancing parameter. For untargeted attack, where the goal is to make the target classifier misclassify, the loss function can be defined as
+
+$$
+\mathcal { L } ( Z ( \pmb { x } ) ) = \operatorname* { m a x } \{ [ Z ( \pmb { x } ) ] _ { y _ { 0 } } - \operatorname* { m a x } _ { i \neq y _ { 0 } } [ Z ( \pmb { x } ) ] _ { i } , - \kappa \} ,
+$$
+
+where $y _ { 0 }$ is the original label predicted by the classifier, $\kappa$ is the margin (usually set to be 1 or 0) of the hinge loss. For targeted attack, where the goal is to turn it into a specific target class $t$ , the loss function can also be defined accordingly.
+
+Therefore, attacking a machine learning model can be posed as solving this optimization problem (Carlini & Wagner, 2017; Chen et al., 2018b), which is also known as the C&W attack or the EAD attack depending on the choice of the distance measurement. To solve (2), one can apply any gradient-based optimization algorithm such as SGD or Adam, since the gradient of $\bar { \mathcal { L } } ( Z ( \pmb { x } ) )$ can be computed via back-propagation.
+
+The ability of computing gradient also enables many different attacks in the white-box setting. For example, eq (2) can also be turned into a constrained optimization problem, which can then be solved by projected gradient descent (PGD) (Madry et al., 2018). FGSM (Goodfellow et al., 2014) is the special case of one step PGD with $L _ { \infty }$ norm distance. Other algorithms such as Deepfool (Moosavi Dezfooli et al., 2016) also solve similar optimization problems to construct adversarial examples.
+
+Previous work on black-box attack In real-world systems, usually the underlying machine learning model will not be revealed and thus white-box attacks cannot be applied. This motivates the study of attacking machine learning models in the black-box setting, where attackers do not have any information about the function $f$ . And the only valid operation is to make queries to the model and acquire the corresponding output $f ( { \pmb x } )$ . The first approach for black-box attack is using transfer attack (Papernot et al., 2017) – instead of attacking the original model $f$ , attackers try to construct a substitute model $\hat { f }$ to mimic $f$ and then attack $\hat { f }$ using white-box attack methods. This approach has been well studied and analyzed in (Liu et al., 2017; Bhagoji et al., 2017). However, recent papers have shown that attacking the substitute model usually leads to much larger distortion and low success rate (Chen et al., 2017). Therefore, instead, (Chen et al., 2017) considers the score-based black-box setting, where attackers can use $_ { \textbf { \em x } }$ to query the softmax layer output in addition to the final classification result. In this case, they can reconstruct the loss function (3) and evaluate it as long as the objective function $h ( { \pmb x } )$ exists for any $_ { \textbf { \em x } }$ . Thus a zeroth order optimization approach can be directly applied to minimize $\dot { h } ( { \pmb x } )$ . (Tu et al., 2018) further improves the query complexity of (Chen et al., 2017) by introducing an autoencoder-based approach to reduce query counts and an adaptive random gradient estimation to balance query counts and distortion.
+
+Difficulty of hard-label black-box attacks Throughout this paper, the hard-label black-box setting refers to cases where real-world ML systems only provide limited prediction results of an input query. Specifically, only the final decision (top-1 predicted label) instead of probability outputs is known to an attacker.
+
+Attacking in this setting is indeed very challenging. In Figure 1a, we show a simple 3-layer neural network’s decision boundary. Note that the $\bar { \mathcal { L } } ( \bar { Z } ( { \pmb x } ) )$ term is continuous as in Figure 1b because the logit layer output is real-valued functions. However, in the hard-label black-box setting, only $f ( \cdot )$ is available instead of $Z ( \cdot )$ . Since $f ( \cdot )$ can only be a one-hot vector, if we plug-in $f$ into the loss function, $ { \mathcal { L } } ( f ( {  { \boldsymbol { \mathbf { x } } } } ) )$ (as shown in Figure 1c) will be discontinuous and with discrete outputs.
+
+![](images/a9c65e9919f4ff130cdc7613faa3c02e0f587f4ddd99ae5fdd6be4b9e69500be.jpg)  
+Figure 1: (a) A neural network classifier. (b) illustrates the loss function of C&W attack, which is continuous and hence can be easily optimized. (c) is the C&W loss function in the hard-label setting, which is discrete and discontinuous. (d) our proposed attack objective $g ( \pmb \theta )$ for this problem, which is continuous and easier to optimize. See detailed discussions in Section 3.
+
+Optimizing this function will require combinatorial optimization or search algorithms, which is challenging given the high dimensionality of the problem. The only two current approaches (Brendel et al., 2017; Ilyas et al., 2018) are based on random-walk on the boundary and random trails on the loss function. Although these “Boundary attack” and “Limited attack” can find adversarial examples with comparable distortion with white-box attacks, they need lots of queries to explore the high-dimensional space and lack convergence guarantees. We show that our optimization-based algorithm can significantly reduce the number of queries, and has guaranteed convergence in the number of iterations (queries) when the objective function is lipschitz smooth.
+
+# 3 ALGORITHMS
+
+Now we introduce a novel way to re-formulate hard-label black-box attack as another optimization problem, show how to evaluate the function value using hard-label queries, and then apply a zeroth order optimization algorithm to solve it.
+
+# 3.1 A BOUNDARY-BASED RE-FORMULATION
+
+For a given example $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ , true label $y _ { 0 }$ and the hard-label black-box function $f : \mathbb { R } ^ { d }  \{ 1 , \dots , K \}$ , we define our objective function $g : \mathbb { R } ^ { d }  \mathbb { R }$ depending on the type of attack:
+
+$$
+{ \begin{array} { r l l } { \displaystyle { \mathrm { U n t a r g e t e d ~ a t t a c k : } } ~ g ( \theta ) = { \underset { \lambda > 0 } { \mathrm { m i n } } } ~ \lambda } & { \displaystyle { \mathrm { s . t } } } & { f ( { \boldsymbol { x } } _ { 0 } + \lambda { \frac { \theta } { | | \theta | | } } ) \neq y _ { 0 } } \\ { \displaystyle { \mathrm { T a r g e t e d ~ a t t a c k ~ ( g i v e n ~ t a r g e t ~ } } t ) \colon ~ g ( \theta ) = { \underset { \lambda > 0 } { \mathrm { m i n } } } ~ \lambda } & { \displaystyle { \mathrm { s . t } } } & { f ( { \boldsymbol { x } } _ { 0 } + \lambda { \frac { \theta } { | | \theta | | } } ) = t } \end{array} }
+$$
+
+In this formulation, $\pmb { \theta }$ represents the search direction and $g ( \pmb \theta )$ is the distance from $\scriptstyle { \pmb x } _ { 0 }$ to the nearest adversarial example along the direction $\pmb \theta$ . The difference between (4) and (5) corresponds to the different definitions of “successfulness” in untargeted and targeted attack, where the former one aims to turn the prediction into any incorrect label and the later one aims to turn the prediction into the target label. For untargeted attack, $g ( \pmb \theta )$ also corresponds to the distance to the decision boundary along the direction $\pmb \theta$ . In image problems the input domain of $f$ is bounded, so we will impose corresponding upper/lower bounds in the definition of (4) and (5).
+
+Instead of searching for an adversarial example, we search the direction $\pmb \theta$ to minimize the distortion $g ( \pmb \theta )$ , which leads to the following optimization problem:
+
+$$
+\operatorname* { m i n } _ { \theta } { g ( \theta ) } .
+$$
+
+Finally, the adversarial example can be found by ${ \pmb x } ^ { * } ~ = ~ { \pmb x } _ { 0 } +$ $g ( \theta ^ { * } ) \frac { \theta ^ { * } } { | | \theta ^ { * } | | }$ , where $\pmb { \theta } ^ { * }$ is the optimal solution of (6).
+
+![](images/5e091468b1e587579d5661029ca85ada551fdab314d399e8122dd55af686a84e.jpg)  
+Figure 2: Illustration
+
+Note that unlike the C&W or PGD objective functions, which are discontinuous step functions in the hard-label setting (see Section 2), $g ( \pmb \theta )$ maps input direction to real-valued output (distance to decision boundary), which is usually continuous – a small change of $\pmb \theta$ usually leads to a small change of $g ( \pmb \theta )$ , as can be seen from Figure 2.
+
+Moreover, we give three examples of $f ( { \pmb x } )$ defined in two dimension input space and their corresponding $g ( \pmb \theta )$ . In Figure 3a, we have a continuous classification function defined as follows
+
+$$
+f ( \pmb { x } ) = \left\{ \begin{array} { l l } { 1 , } & { \mathrm { i f } \| \pmb { x } \| _ { 2 } ^ { 2 } \geq 0 . 4 } \\ { 0 , } & { \mathrm { o t h e r w i s e } . } \end{array} \right.
+$$
+
+In this case, as shown in Figure 3c, $g ( \pmb \theta )$ is continuous. Moreover, in Figure 3b and Figure 1a, we show decision boundaries generated by GBDT and neural network classifier, which are not continuous. However, as showed in Figure 3d and Figure 1d, even if the classifier function is not continuous, $g ( \pmb \theta )$ is still continuous. This makes it easy to apply zeroth order method to solve (6).
+
+![](images/f6b5027cdc3fed662e150bdcb799b49c5c72db8dd0682229b5f61fabcfdfdd6d.jpg)  
+Figure 3: Examples of decision boundary of classification function $f ( { \pmb x } )$ and corresponding $g ( \pmb \theta )$
+
+Compute $g ( \pmb \theta )$ up to certain accuracy. We are not able to evaluate the gradient of $g$ , but we can evaluate the function value of $g$ using the hard-label queries to the original function $f$ . For simplicity, we focus on untargeted attack here, but the same procedure can be applied to targeted attack as well.
+
+First, we discuss how to compute $g ( \pmb \theta )$ directly without additional information. This is used in the initialization step of our algorithm. For a given normalized $\pmb \theta$ , we do a coarse-grained search and then a binary search. In coarse-grained search, we query the points $\{ \pmb { x } _ { 0 } + \alpha \pmb { \theta } , \pmb { x } _ { 0 } + 2 \alpha \pmb { \theta } , \ldots \}$ one by one until we find $f ( \pmb { x } + i \alpha \pmb { \theta } ) \neq y _ { 0 }$ . This means the boundary lies between $[ { \pmb x } _ { 0 } + ( i - 1 ) \alpha { \pmb \theta } , { \pmb x } _ { 0 } + i \alpha { \pmb \theta } ]$ . We then enter the second phase and conduct a binary search to find the solution within this region (same with line 11–17 in Algorithm 1). Note that there is an upper bound of the first stage if we choose $\pmb \theta$ by the direction of ${ \pmb x } - { \pmb x } _ { 0 }$ with some $_ { \textbf { \em x } }$ from another class. This procedure is used to find the initial $\pmb { \theta } _ { 0 }$ and corresponding $g ( \pmb \theta _ { 0 } )$ in our optimization algorithm. We omit the detailed algorithm for this part since it is similar to Algorithm 1.
+
+Next, we discuss how to compute $g ( \pmb \theta )$ when we know the solution is very close to a reference point $v$ . This is used in all the function evaluations in our optimization algorithm, since the current solution is usually close to the previous solution, and when we estimate the gradient using (7), the queried direction will only be a slight modification of the previous one. In this case, we first increase or decrease $v$ in the local region to find the interval that contains the nearby boundary (e.g, $f ( \pmb { x } _ { 0 } + v \pmb { \theta } ) = y _ { 0 }$ and $f ( \pmb { x } _ { 0 } + \pmb { v } ^ { \prime } \pmb { \theta } ) \breve { \neq } y _ { 0 } )$ , then conduct a binary search to find the final value of $g$ Our procedure for computing the $g$ value is presented in Algorithm 1.
+
+# Algorithm 1 Compute $g ( \pmb \theta )$ locally
+
+1: Input: Hard-label model $f$ , original image $x _ { 0 }$ , query direction $\pmb { \theta }$ , previous solution $v$ , in  
+crease/decrease ratio $\alpha = 0 . 0 1$ , stopping tolerance $\epsilon$ (maximum tolerance of computed error)   
+2: $\pmb { \theta }  \pmb { \theta } / | | \pmb { \theta } | |$   
+3: if $f ( \pmb { x } _ { 0 } + v \pmb { \theta } ) = y _ { 0 }$ then   
+4: $\dot { v } _ { l e f t }  \dot { v } , v _ { r i g h t }  ( 1 + \alpha ) v$   
+5: while $f ( \pmb { x } _ { 0 } + v _ { r i g h t } \pmb { \theta } ) = y _ { 0 } \ \mathbf { d o }$   
+6: $v _ { r i g h t }  ( 1 + \alpha ) v _ { r i g h t }$   
+7: else   
+8: $\begin{array} { r l } & { v _ { r i g h t }  v , v _ { l e f t }  ( 1 - \alpha ) v } \\ & { \mathbf { w h i l e } f ( \pmb { x } _ { 0 } + v _ { l e f t } \pmb { \theta } ) \neq y _ { 0 } \mathbf { \delta } \mathbf { d o } } \\ & { \qquad v _ { l e f t }  ( 1 - \alpha ) v _ { l e f t } } \end{array}$   
+9:   
+10:   
+11: ## Binary Search within $[ v _ { l e f t } , v _ { r i g h t } ]$   
+12: while $v _ { r i g h t } - v _ { l e f t } > \epsilon \mathbf { d o }$   
+13: $v _ { m i d } \gets ( v _ { r i g h t } + v _ { l e f t } ) / 2$   
+14: if $f ( \pmb { x } _ { 0 } + v _ { m i d } \pmb { \theta } ) = y _ { 0 }$ then   
+15: $v _ { l e f t } \gets v _ { m i d }$   
+16: else   
+17: $v _ { r i g h t } \gets v _ { m i d }$   
+18: return vright
+
+3.2 HARD-LABEL BLACK-BOX ATTACKS WITH $L _ { \infty }$ NORM CONSTRAINT
+
+Although we could let $\| \pmb \theta \| = \| \pmb \theta \| _ { \infty }$ in (4) and (5) directly, $g ( \pmb \theta )$ will be harder to optimize in practice because of introducing the max term in $\| \cdot \| _ { \infty }$ . Instead, with an $L _ { \infty }$ constraint $\varepsilon$ , we design a smooth approximation loss as follows:
+
+$$
+\begin{array} { r l } & { g ( \pmb { \theta } ) = \underset { \lambda } { \operatorname* { m i n } } \{ \underset { i = 1 } { \overset { d } { \sum } } ( \operatorname* { m a x } \{ \lambda \frac { \left| \pmb { \theta } _ { i } \right| } { \left\| \pmb { \theta } \right\| _ { \infty } } - \varepsilon , 0 \} ) ^ { 2 } \} \quad \textnormal { s . t } \quad f ( \pmb { x } _ { 0 } + \lambda \frac { \pmb { \theta } } { \left\| \pmb { \theta } \right\| _ { \infty } } ) \neq y _ { 0 } } \\ & { g ( \pmb { \theta } ) = \underset { \lambda } { \operatorname* { m i n } } \{ \underset { i = 1 } { \overset { d } { \sum } } ( \operatorname* { m a x } \{ \lambda \frac { \left| \pmb { \theta } _ { i } \right| } { \left\| \pmb { \theta } \right\| _ { \infty } } - \varepsilon , 0 \} ) ^ { 2 } \} \quad \textnormal { s . t } \quad f ( \pmb { x } _ { 0 } + \lambda \frac { \pmb { \theta } } { \left\| \pmb { \theta } \right\| _ { \infty } } ) = t . } \end{array}
+$$
+
+Here $\theta _ { i }$ is the i-th coordinate of $\pmb \theta$ . Notably, when $\lambda \leq \varepsilon$ , we have $g ( \pmb \theta ) = 0$ . That’s to say, we have obtained a legitimate $\pmb \theta$ to make a valid adversarial example ${ \pmb x } _ { 0 } + \lambda ^ { * } \frac { { \pmb \theta } } { \| { \pmb \theta } \| _ { \infty } }$ .
+
+# 3.3 ZEROTH ORDER OPTIMIZATION
+
+To solve the optimization problem (6) for which we can only evaluate function value instead of gradient, zeroth order optimization algorithms can be naturally applied. In fact, after the reformulation, the problem can be potentially solved by any zeroth order optimization algorithm, like zeroth order gradient descent, genetic algorithm (Alzantot et al., 2018) or coordinate descent (see Conn et al. (2009) for a comprehensive survey).
+
+Here we propose to solve (1) using Randomized Gradient-Free (RGF) method proposed in (Nesterov & Spokoiny, 2017; Ghadimi $\&$ Lan, 2013). In practice, we found it outperforms zeroth-order coordinate descent. At each iteration, the gradient is estimated by
+
+$$
+\hat { \pmb g } = \frac { \breve { g ( \pmb \theta + \beta \pmb u ) } - g ( \pmb \theta ) } { \beta } \cdot \pmb u
+$$
+
+1: Input: Hard-label model $f$ , original image $x _ { 0 }$ , initial $\pmb { \theta } _ { 0 }$ .   
+2: for $t = 0 , 1 , 2 , \ldots , T$ do   
+3: Randomly choose $\mathbf { \pmb { u } } _ { t }$ from a zero-mean Gaussian distribution   
+4: Evaluate $\dot { \boldsymbol g } ( \pmb \theta _ { t } )$ and $g ( \pmb \theta _ { t } + \beta \pmb u )$ using Algorithm 1   
+5: Compute gˆ = $\hat { \pmb { g } } = \frac { g ( \pmb { \theta } _ { t } + \beta \pmb { u } ) - g ( \pmb { \theta } _ { t } ) } { \beta } \cdot \pmb { u }$   
+6: Update θt+1 = θt − ηtgˆ   
+7: return ${ \pmb x } _ { 0 } + g ( { \pmb \theta } _ { T } ) { \pmb \theta } _ { T }$
+
+where $\textbf { \em u }$ is a random Gaussian vector, and $\beta > 0$ is a smoothing parameter (we set $\beta = 0 . 0 0 5$ in all our experiments). The solution is then updated by $\pmb { \theta }  \pmb { \theta } - \eta \hat { \pmb g }$ with a step size $\eta$ . The procedure is summarized in Algorithm 2.
+
+Also, if $g ( \pmb \theta )$ is Lipschitz-smooth, we are able to bound the number of iterations needed with $O ( \textstyle { \frac { d } { \delta ^ { 2 } } } )$ for our algorithm to achieve stationary points. See the appendix for details.
+
+# 3.3.1 IMPLEMENTATION DETAILS
+
+There are several implementation details when we apply this algorithm. First, for high-dimensional problems, we found the estimation in (7) is very noisy. Therefore, instead of using one vector, we sample $q$ vectors from Gaussian distribution and average their estimators to get $\hat { \pmb { g } }$ . We set $q = 2 0$ in all the experiments. Second, instead of using a fixed step size (suggested in theory), we use a backtracking line-search approach to find step size at each step. This leads to additional query counts, but makes the algorithm more stable and eliminates the need to hand-tuning the step size. Third, instead of using a random direction $\pmb \theta$ as initialization, we sample $t$ vectors from Gaussian distribution and choose the one with smallest $g ( \pmb \theta )$ as our initialization. It helps us to find a good initialization direction and thus get a smaller distortion in the end with limited number of additional queries. We set $t = 1 0 0$ in all the experiments.
+
+# 4 EXPERIMENTAL RESULTS
+
+We test the performance of our hard-label black-box attack algorithm on convolutional neural network (CNN) models and compare with Boundary attack (Brendel et al., 2017), Limited attack (Ilyas et al., 2018) and a random trail baseline. Furthermore, we show our method can be applied to attack Gradient Boosting Decision Tree (GBDT) and present some interesting findings.
+
+# 4.1 ATTACKING CNN IMAGE CLASSIFICATION MODELS
+
+We use three standard datasets: MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky, 2009) and ImageNet-1000 (Deng et al., 2009). To have a fair comparison with previous work, we adopt the same networks used in both Carlini & Wagner (2017) and Brendel et al. (2017). In detail, both MNIST and CIFAR use the same network structure with four convolution layers, two max-pooling layers and two fully-connected layers. Using the parameters provided by Carlini & Wagner (2017), we could achieve $9 9 . 5 \%$ test accuracy on MNIST and $8 2 . 5 \%$ test accuracy on CIFAR-10, which is similar to accuracy reported in Carlini & Wagner (2017). For Imagenet-1000, we use the pretrained network Resnet-50 (He et al., 2016) and Inception-V3 (Szegedy et al., 2016) provided by torchvision1, which could achieve $7 6 . 1 5 \%$ and $7 7 . 4 5 \%$ top-1 test accuracy respectively. For simplicity, all images are normalized into $[ 0 , 1 ] ^ { d }$ scale. All models are trained using Pytorch and our source code is publicly available2.
+
+We include the following algorithms for comparisons in attacking performance:
+
+Opt-based black-box attack (Opt-attack): our proposed algorithm.   
+Boundary black-box attack (Brendel et al., 2017) (Boundary-attack): first work on attacking hard-label black box model in L2 distance metric. We use the authors’ implementation and the parameters provided in Foolbox3.
+
+Table 1: Results for ( $L _ { 2 }$ -norm based) untargeted attacks. ASR stands for Attack Success Rate.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">MNIST</td><td colspan="2">CIFAR10</td><td colspan="2">Imagenet (ResNet-50)</td></tr><tr><td>Avg L2</td><td># queries</td><td>Avg L2</td><td># queries</td><td>AvgL2</td><td># queries</td></tr><tr><td rowspan="2">Boundary-attack</td><td>1.1222</td><td>60,293</td><td>0.1575</td><td>123,879</td><td>5.9791</td><td>123,407</td></tr><tr><td>1.1087</td><td>143,357</td><td>0.1501</td><td>220,144</td><td>3.7725</td><td>260,797</td></tr><tr><td rowspan="3">Opt-attack</td><td>1.188</td><td>22.940</td><td>0.2050</td><td>40,941</td><td>6.9796</td><td>71,100</td></tr><tr><td>1.049</td><td>51,683</td><td>0.1625</td><td>77,327</td><td>4.7100</td><td>127,086</td></tr><tr><td>1.011</td><td>126,486</td><td>0.1451</td><td>133,662</td><td>3.1120</td><td>237,342</td></tr><tr><td>C&amp;W(white-box)</td><td>0.9921</td><td>-</td><td>0.1012</td><td>1</td><td>1.9365</td><td>-</td></tr><tr><td>Random distortion</td><td>1.0(2% ASR)</td><td>300,000</td><td>0.15(10% ASR)</td><td>300,000</td><td>3.11(0% ASR)</td><td>480,000</td></tr></table>
+
+Limited black-box attack (Ilyas et al., 2018) (Limited-attack): previous work on targeted blackbox attack in $L _ { \infty }$ distance constraint in the hard-label setting. We use the authors’ implementation and the parameters provided in Github4. • C&W white-box attack (Carlini & Wagner, 2017): one of the current state-of-the-art attacking algorithm in the white-box setting. We do binary search on parameter $c$ per image to achieve the best performance. Attacking in the white-box setting is a much easier problem, so we include C&W attack just for reference and indicate the best performance we can possibly achieve. Random distortion: we use 300,000 and 480,000 i.i.d random directions as the baseline. We note that while all other methods could achieve $100 \%$ attack success rate (ASR), the ASR of random distortion appears to be quite low.
+
+For all the cases except Limited-attack, we conduct adversarial attacks for randomly sampled $N = 1 0 0$ images from validation sets. Note that all three attacks (Opt-attack, Boundary-attack, C&W attack) have $100 \%$ successful rates, and we report the average $L _ { 2 }$ distortion, defined by $\begin{array} { r } { \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \| \pmb { x } ^ { ( i ) } - \pmb { x } _ { 0 } ^ { ( i ) } \| _ { 2 } } \end{array}$ , where $\pmb { x } ^ { ( i ) }$ is the adversarial example constructed by an attack algorithm and x(i)0 is the original $i$ -th example. For black-box attack algorithms, we also report average and median number of queries for comparison. To compare with Limited-attack, we randomly sampled 50 images and report targeted ASR with average and median number of queries when limiting $L _ { \infty }$ distortion to be 0.3 and 0.15 for ImageNet dataset. We also restrict the maximum number of queries to be 1,000,000 for all attacks.
+
+# 4.1.1 UNTARGETED ATTACK
+
+For untargeted attack, the goal is to turn a correctly classified image into any other label. The results are presented in Table 1. Note that for both Opt-attack and Boundary-attack, by changing the stopping conditions we can attain different distortions by varying the number of queries.
+
+First, we compare Boundary-attack and the proposed Opt-attack in Table 1 and Table 5 in appendix. Our algorithm consistently achieves smaller distortion with less number of queries than Boundaryattack. For example, on MNIST data, we are able to reduce the number of queries by 3-4 folds, and Boundary-attack converges to worse solutions in all the 3 datasets. In addition, we include the average L2 norm distortion plot with different query budgets in Figure 5(a) in appendix. And our method consistently outperforms the Boundary-attack and achieves nearly $2 \mathbf { x }$ speedup on both datasets.
+
+Compared with C&W attack, we found black-box attacks attain slightly worse distortion on MNIST and CIFAR. This is reasonable because white-box attack has much more information than black-box attack and is strictly easier. We note that the experiments in Brendel et al. (2017) conclude that C&W and Boundary-attack have similar performance because they only run C&W attack with a single regularization parameter $c$ , without doing binary search to obtain the optimal parameter. For ImageNet, since we constraint the number of queries, the distortion of black-box attacks is much worse than C&W attack. The gap can be reduced by increasing the number of queries as showed in Figure 5(b) in appendix.
+
+# 4.1.2 TARGETED ATTACK
+
+The results for targeted attack is presented in Table 2 and Table 5 in appendix. Following the experiments in Brendel et al. (2017), for each randomly sampled image with label $i$ we set target label $t = ( i + 1 )$ module 10. On MNIST, we found our algorithm is more than 4 times faster (in terms of number of queries) than Boundary-attack and converges to a better solution. On CIFAR, our algorithm has similar efficiency with Boundary-attack at the first 60,000 queries, but converges to a slightly worse solution. Also, we show an example quality comparison from the same starting point to the original sample in Figure 4. And we also include some adversarial example in Figure 4.
+
+For attacks in $L _ { \infty }$ norm constraint, we conduct experimental comparisons with Limited-attack5. the results are shown in Table 3. In the cases of an $L _ { \infty }$ constraint $\epsilon \in \{ 0 . 1 5 , 0 . 3 \}$ , our Opt-attack roughly halves the average number of queiries relative to Limited-attack. In addition, our ASR is $40 \%$ higher than Limited-attack when $\epsilon = 0 . 1 5$ .
+
+![](images/ff100d228c022b49675dfca19807b03525c1726379cb8e9318d00633e86a63de.jpg)  
+Figure 4: (a)(b): Example quality comparison between targeted Opt-attack and Boundary-attack . Opt-attack can achieve a better result with less queries. (c)(d): Some adversarial examples generated by Opt-attack . From initialization image (left), through several number of model queries, we could generate a adversarial example very close to original image (right).
+
+Table 2: Results of $L _ { 2 }$ -norm based) targeted attack.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">MNIST</td><td colspan="2">CIFAR10</td></tr><tr><td>Avg L2</td><td># queries</td><td>Avg L2</td><td># queries</td></tr><tr><td rowspan="3">Boundary-attack (black-box)</td><td>2.3158</td><td>30,103</td><td>0.2850</td><td>55,552</td></tr><tr><td>2.0052</td><td>58,508</td><td>0.2213</td><td>140,572</td></tr><tr><td>1.8668</td><td>192,018</td><td>0.2122</td><td>316,791</td></tr><tr><td rowspan="3">Opt-attack (black-box)</td><td>1.8522</td><td>46,248</td><td>0.2758</td><td>61,869</td></tr><tr><td>1.7744</td><td>57,741</td><td>0.2369</td><td>141,437</td></tr><tr><td>1.7114</td><td>73,293</td><td>0.2300</td><td>186,753</td></tr><tr><td>C&amp;W (white-box)</td><td>1.4178</td><td>1</td><td>0.1901</td><td>1</td></tr></table>
+
+Table 3: Results of targeted attacks in $L _ { \infty }$ constraint. ASR stands for Attack Success Rate.   
+
+<table><tr><td></td><td></td><td colspan="3">ImageNet (Inception V3)</td></tr><tr><td></td><td>E</td><td>ASR</td><td>Avg queries</td><td>Median queries</td></tr><tr><td rowspan="2">Opt-attack</td><td>0.30</td><td>100%</td><td>167,080</td><td>119,925</td></tr><tr><td>0.15</td><td>90%</td><td>310,952</td><td>183,217</td></tr><tr><td rowspan="2">Limited-attack</td><td>0.30</td><td>100%</td><td>436,561</td><td>295,918</td></tr><tr><td>0.15</td><td>50%</td><td>896,558</td><td>981,272</td></tr></table>
+
+Table 4: Results of $L _ { 2 }$ -norm based) untargeted attack on gradient boosting decision tree.   
+
+<table><tr><td></td><td colspan="2">HIGGS</td><td colspan="2">MNIST</td></tr><tr><td></td><td>AvgL2</td><td>#queries</td><td>AvgL2</td><td>#queries</td></tr><tr><td rowspan="3">Opt-attack</td><td>0.3458</td><td>4,229</td><td>0.6113</td><td>5,125</td></tr><tr><td>0.2179</td><td>11,139</td><td>0.5576</td><td>11,858</td></tr><tr><td>0.1704</td><td>29,598</td><td>0.5505</td><td>32,230</td></tr></table>
+
+# 4.1.3 ATTACKING GRADIENT BOOSTING DECISION TREE (GBDT)
+
+To evaluate our method’s ability to attack models with discrete decision functions, we conduct our untargeted attack on gradient booting decision tree (GBDT). In this experiment, we use two standard datasets: HIGGS (Baldi et al., 2014) for binary classification and MNIST (LeCun et al., 1998) for multi-class classification. We use popular LightGBM framework to train the GBDT models and use suggested parameters in https://github.com/Koziev/MNIST_Boosting. To be more specific, for MNIST model, it has 100 trees and the max number of leaves in each tree is 100. For Higgs model, it has 255 trees and the max number of leaves in each tree is 500. And we don’t limit the max depth on both models. We could achieve 0.8457 AUC for HIGGS and $9 8 . 0 9 \%$ accuracy for MNIST. The results of untargeted attack on GBDT are given in Table 4.
+
+As shown in Table 4, by using around 30K queries, we could get a small distortion on both datasets, which firstly uncovers the vulnerability of GBDT models. Tree-based methods are well-known for its good interpretability. And because of that, they are widely used in the industry. However, we show that even with good interpretability and a similar prediction accuracy with convolution neural network, the GBDT models are vulnerable under our Opt-attack. This result raises a question about tree-based models’ robustness, which will be an interesting direction in the future.
+
+# 5 CONCLUSION
+
+In this paper, we propose a generic and optimization-based hard-label black-box attack algorithm, which can be applied to discrete and non-continuous models other than neural networks, such as the gradient boosting decision tree. Our method enjoys query-efficiency and has a theoretical convergence guarantee on the attack performance under mild assumptions. Moreover, our attack achieves smaller or similar distortion using 3-4 times less queries compared with the state-of-the-art algorithms.
+
+# ACKNOWLEDGEMENT
+
+We acknowledge the support by NSF IIS1719097, Intel faculty award, Google Cloud and AITRICS.
+
+# REFERENCES
+
+Moustafa Alzantot, Yash Sharma, Supriyo Chakraborty, and Mani Srivastava. Genattack: Practical black-box attacks with gradient-free optimization. arXiv preprint arXiv:1805.11090, 2018.
+
+Pierre Baldi, Peter Sadowski, and Daniel Whiteson. Searching for exotic particles in high-energy physics with deep learning. Nature communications, 5:4308, 2014.
+
+Arjun Nitin Bhagoji, Warren He, Bo Li, and Dawn Song. Exploring the space of black-box attacks on deep neural networks. arXiv preprint arXiv:1712.09491, 2017.
+
+Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. arXiv preprint arXiv:1712.04248, 2017.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In Security and Privacy (SP), 2017 IEEE Symposium on, pp. 39–57. IEEE, 2017.
+
+Hongge Chen, Huan Zhang, Pin-Yu Chen, Jinfeng Yi, and Cho-Jui Hsieh. Attacking visual language grounding with adversarial examples: A case study on neural image captioning. In ACL, 2018a.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017.
+
+Pin-Yu Chen, Yash Sharma, Huan Zhang, Jinfeng Yi, and Cho-Jui Hsieh. Ead: elastic-net attacks to deep neural networks via adversarial examples. In AAAI, 2018b.
+
+Minhao Cheng, Jinfeng Yi, Huan Zhang, Pin-Yu Chen, and Cho-Jui Hsieh. Seq2sick: Evaluating the robustness of sequence-to-sequence models with adversarial examples. CoRR, 2018.
+
+Andrew R Conn, Katya Scheinberg, and Luis N Vicente. Introduction to derivative-free optimization, volume 8. Siam, 2009.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.
+
+Saeed Ghadimi and Guanghui Lan. Stochastic first-and zeroth-order methods for nonconvex stochastic programming. SIAM Journal on Optimization, 23(4):2341–2368, 2013.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1804.08598, 2018.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. ICLR, 2017.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations.
+
+Seyed Mohsen Moosavi Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), number EPFL-CONF-218057, 2016.
+
+Yurii Nesterov. Random gradient-free minimization of convex functions. Technical report, 2011.
+
+Yurii Nesterov and Vladimir Spokoiny. Random gradient-free minimization of convex functions. Foundations of Computational Mathematics, 17(2):527–566, 2017.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519. ACM, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.
+
+Chun-Chen Tu, Pai-Shun Ting, Pin-Yu Chen, Sijia Liu, Huan Zhang, Jinfeng Yi, Cho-Jui Hsieh, and Shin-Ming Cheng. Autozoom: Autoencoder-based zeroth order optimization method for attacking black-box neural networks. CoRR, abs/1805.11770, 2018.
+
+# 6 APPENDIX
+
+# 6.1 MEDIAN RESULT
+
+Table 5: Results of median L2 distortion on different attack methods.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Type</td><td colspan="2">MNIST</td><td colspan="2">CIFAR10</td><td colspan="2">Imagenet (ResNet-50)</td></tr><tr><td>Median L2</td><td>#queries</td><td>Median L2</td><td># queries</td><td>Median L2</td><td># queries</td></tr><tr><td rowspan="2">Boundary-attack</td><td>Untargeted</td><td>1.0832</td><td>142.686</td><td>0.1359</td><td>235,285</td><td>2.7879</td><td>261,258</td></tr><tr><td>Targeted</td><td>1.8004</td><td>171,151</td><td>0.1962</td><td>314,839</td><td>1</td><td>-</td></tr><tr><td rowspan="2">Opt-attack</td><td>Untargeted</td><td>1.0206</td><td>127,077</td><td>0.1344</td><td>159,276</td><td>2.0687</td><td>246,755</td></tr><tr><td>Targeted</td><td>1.7375</td><td>72,318</td><td>0.2020</td><td>158,438</td><td>1</td><td>1</td></tr></table>
+
+# 6.2 RESULTS ON DIFFERENT NUMBER OF SAMPLE DIRECTIONS $u _ { t }$
+
+Table 6: Results of average L2 distortion on different number of sample directions $u _ { t }$ .   
+
+<table><tr><td colspan="5">MNIST</td></tr><tr><td># of directions Ut</td><td>Average L2</td><td>Average # queries</td><td>Median L2</td><td>Median # queries</td></tr><tr><td rowspan="5">Opt-attack</td><td>1</td><td>2.0525</td><td>9,820 2.0188</td><td>8,093</td></tr><tr><td>5</td><td>1.0550</td><td>59,901 1.0639</td><td>56,890</td></tr><tr><td>10</td><td>1.0345</td><td>63,652 1.0420</td><td>62,209</td></tr><tr><td>15</td><td>1.0257</td><td>71,045</td><td>1.0256 73,227</td></tr><tr><td>20</td><td>1.0112</td><td>126,486</td><td>1.0206</td></tr><tr><td>25</td><td>1.0098</td><td>146,516</td><td>1.0117</td><td>127,077 145,862</td></tr></table>
+
+![](images/b606049498856b759e3ee03ed56850e8cc171e9ea515a218157a174d696f7dcb.jpg)  
+Figure 5: Left:Log distortion comparison of Boundary-attack (solid curves) vs Opt-attack (dotted curves) over number of queries for 6 different images. Right: Average L2-distortion versus number of queries plot.
+
+# 6.4 THEORETICAL ANALYSIS
+
+If $g ( \pmb \theta )$ can be computed exactly, it has been proved in Nesterov & Spokoiny (2017) that RGF in Algorithm 2 requires at most $O ( \textstyle { \frac { d } { \delta ^ { 2 } } } )$ iterations to converge to a point with $\lVert \nabla g ( \pmb { \theta } ) \rVert ^ { 2 } \leq \delta ^ { 2 }$ . However, in our algorithm the function value $g ( \pmb \theta )$ cannot be computed exactly; instead, we compute it up to $\epsilon$ -precision, and this precision can be controlled by binary threshold in Algorithm 1. We thus extend the proof in Nesterov & Spokoiny (2017) to include the case of approximate function value evaluation, as described in the following theorem.
+
+Theorem 1 In Algorithm 2, suppose g has Lipschitz-continuous gradient with constant $L _ { 1 } ( g )$ and $g ^ { * }$ (optimal value) is finite. If the error of function value evaluation is controlled by $\epsilon = \dot { O } ( \beta \delta ^ { 2 } )$ and $\begin{array} { r } { \beta \le \frac { \delta } { d L _ { 1 } ( g ) } } \end{array}$ , then in order to obtain $\frac { 1 } { N + 1 } \sum _ { k = 0 } ^ { N } E \chi _ { k } ( \| \nabla g ( \pmb { \theta } _ { k } ) \| ^ { 2 } ) \leq \delta ^ { 2 }$ , the upper bound of total number of iterations is $O ( \textstyle { \frac { d } { \delta ^ { 2 } } } )$ .
+
+Note that the binary search procedure could obtain the desired function value precision in ${ \cal O } ( \log \delta )$ steps. By using the same idea with Theorem 1 and following the proof in Nesterov & Spokoiny (2017), we could also achieve $\begin{array} { r } { O \big ( \frac { d ^ { 2 } } { \delta ^ { 3 } } \big ) } \end{array}$ complexity when $g ( \pmb \theta )$ is non-smooth but Lipschitz continuous.
+
+Because there is a stopping criterion in Algorithm 1, we couldn’t achieve the exact $g ( \pmb \theta )$ . Instead, we could get $\tilde { g }$ with $\epsilon$ error, i.e., $g ( \pmb \theta ) - \epsilon \leq \tilde { g } ( \pmb \theta ) \leq g ( \pmb \theta ) + \epsilon$ . Also, we define $\begin{array} { r } { \hat { \pmb g } ( \pmb \theta ) = \frac { \tilde { g } ( \pmb \theta + \beta \pmb u ) - \tilde { g } ( \pmb \theta ) } { \beta } \cdot \pmb u } \end{array}$ to be the noise gradient estimator.
+
+Following Nesterov (2011), we define the Guassian smoothing approximation over $g ( \theta )$ , i.e,
+
+$$
+g _ { \beta } ( \theta ) = \frac { 1 } { \kappa } \int _ { E } g ( \theta + \beta u ) e ^ { - \frac { 1 } { 2 } | | u | | ^ { 2 } } d u .
+$$
+
+Also, we have the upper bounds for the moments $\begin{array} { r } { M _ { p } = \frac { 1 } { \kappa } \int _ { E } | | u | | ^ { p } e ^ { - \frac { 1 } { 2 } | | u | | ^ { 2 } } d u } \end{array}$ from Nesterov (2011) Lemma 1.
+
+For $p \in [ 0 , 2 ]$ , we have
+
+If $p \geq 2$ , we have two-sided bounds
+
+$$
+\begin{array} { c } { { M _ { p } \leq d ^ { p / 2 } . } } \\ { { } } \\ { { n ^ { p / 2 } \leq M _ { p } \leq ( p + n ) ^ { p / 2 } . } } \end{array}
+$$
+
+Suppose f has a lipschitz-continuous gradient with constant $L _ { 1 } ( g )$ , then
+
+$$
+| g ( y ) - g ( x ) - \langle \nabla g ( x ) , y - x \rangle | \leq \frac { 1 } { 2 } L _ { 1 } ( g ) | | x - y | | ^ { 2 }
+$$
+
+We could bound $E _ { u } ( | | \hat { g } ( \pmb { \theta } ) | | ^ { 2 } )$ as follows,
+
+Since
+
+$$
+\begin{array} { r l } & { \overset { \mathrm { r u n s e } } { ( \bar { g } ( \theta + \beta u ) - \tilde { g } ( \theta ) ) ^ { 2 } } = [ \bar { g } ( \theta + \beta u ) - \tilde { g } ( \theta ) - \beta \langle \nabla g ( \theta ) , u \rangle + \beta \langle \nabla g ( \theta ) , u \rangle ] ^ { 2 } } \\ & { \qquad \leq 2 ( g ( \theta + \beta u ) - g ( \theta ) + \epsilon _ { \theta + \beta u } - \epsilon _ { \theta } - \beta \langle \nabla g ( \theta ) , u \rangle ) ^ { 2 } + 2 \beta ^ { 2 } \langle \nabla g ( \theta ) , u \rangle ^ { 2 } } \end{array}
+$$
+
+Because $| \epsilon _ { \pmb { \theta } + \beta u } - \epsilon _ { \pmb { \theta } } | \leq 2 \epsilon$ ,
+
+$$
+[ \tilde { g } ( \pmb { \theta } + \beta u ) - \tilde { g } ( \pmb { \theta } ) ] ^ { 2 } \leq 2 ( \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ( g ) | | u | | ^ { 2 } ) ^ { 2 } + 4 \beta ^ { 2 } L _ { 1 } ( g ) | | u | | ^ { 2 } \epsilon + 8 \epsilon ^ { 2 } + 2 \beta ^ { 2 } \langle \nabla g ( \pmb { \theta } ) , u \rangle ^ { 2 }
+$$
+
+Take expectation over $\mathbf { u }$ , and with Theorem 3 in Nesterov (2011), which is $E _ { u } ( | | g ^ { \prime } ( \pmb \theta , u ) \cdot u | | ^ { 2 } ) \leq$ (d + 4)||∇g(θ)||2
+
+$$
+\begin{array} { r l } & { \displaystyle \Xi ^ { - \gamma } | | \boldsymbol { \nabla } \boldsymbol { y } \boldsymbol { \cup } \boldsymbol { \sigma } \boldsymbol { \jmath } | | } \\ & { \displaystyle \Xi _ { u } \big ( | | \hat { g } ( \pmb { \theta } ) | | ^ { 2 } \big ) \leq \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) E _ { u } \big ( | | u | | ^ { 6 } ) + 2 E _ { u } \big ( | | g ^ { \prime } ( \pmb { \theta } , u ) \cdot u | | ^ { 2 } \big ) + 4 L _ { 1 } ( g ) \epsilon E _ { u } \big ( | | u | | ^ { 4 } \big ) + 8 \frac { \epsilon ^ { 2 } } { \beta ^ { 2 } } E _ { u } \big ( | | u | | ^ { 2 } \big ) } \\ & { \displaystyle \qquad \leq \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) | | \boldsymbol { \nabla } g ( \pmb { \theta } ) | | ^ { 2 } + 4 \epsilon L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } + 8 \frac { \epsilon ^ { 2 } } { \beta ^ { 2 } } d } \end{array}
+$$
+
+With $\epsilon = O ( \delta ^ { 2 } \beta )$ , we could bound $E _ { u } ( | | \tilde { g } ( \pmb { \theta } ) | | ^ { 2 } )$
+
+$$
+E _ { u } ( | | \hat { g } ( \pmb { \theta } ) | | ^ { 2 } ) \leq \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) | | \nabla g ( \pmb { \theta } ) | | ^ { 2 } + 4 \beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \delta ^ { 2 } + 8 d \delta ^ { 4 }
+$$
+
+And with
+
+$$
+| | \nabla g ( \pmb \theta ) | | ^ { 2 } \leq 2 | | \nabla g _ { \beta } ( \pmb \theta ) | | ^ { 2 } + \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 4 ) ^ { 2 }
+$$
+
+Which is proved in Nesterov (2011) Lemma 4.
+
+Therefore, since $( n + 6 ) ^ { 3 } + 2 ( n + 4 ) ^ { 3 } \leq 3 ( n + 5 ) ^ { 3 }$ , we could get
+
+$$
+\begin{array} { l } { { E _ { u } ( | | \hat { g } ( \pmb { \theta } ) | | ^ { 2 } ) \le \displaystyle \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) | | \nabla g ( \pmb { \theta } ) | | ^ { 2 } + 2 ( d + 4 ) | | \nabla g ( \pmb { \theta } ) | | ^ { 2 } } } \\ { { \displaystyle ~ + 4 \beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \delta ^ { 2 } + 8 d \delta ^ { 4 } } } \\ { { \displaystyle ~ \le \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) ( 2 | | \nabla g _ { \beta } ( \pmb { \theta } ) | | ^ { 2 } + \frac { \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 4 ) ^ { 2 } ) } } \\ { { \displaystyle ~ + 4 \beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \delta ^ { 2 } + 8 d \delta ^ { 4 } } } \\ { { \displaystyle ~ \le 4 ( d + 4 ) | | \nabla g _ { \beta } ( x ) | | ^ { 2 } + \frac { 3 \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 5 ) ^ { 3 } + 4 \beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \delta ^ { 2 } + 8 d \delta ^ { 4 } } } \end{array}
+$$
+
+Therefore, since $g _ { \beta } ( \pmb \theta )$ has Lipshcitz-continuous gradient:
+
+$$
+| g _ { \beta } ( \pmb { \theta } _ { k + 1 } ) - g _ { \beta } ( \pmb { \theta } _ { k } ) + \alpha \langle \nabla g _ { \beta } ( \pmb { \theta } _ { k } ) , \hat { g } _ { \beta } ( \pmb { \theta } _ { k } ) \rangle | \leq \frac { 1 } { 2 } \alpha ^ { 2 } L _ { 1 } ( g _ { \beta } ) | | \hat { g } _ { \beta } ( \pmb { \theta } _ { k } ) | | ^ { 2 }
+$$
+
+So that
+
+$$
+g _ { \beta } ( \pmb \theta _ { k + 1 } ) \leq g _ { \beta } ( \pmb \theta _ { k } ) - \alpha \langle \nabla g _ { \beta } ( \pmb \theta _ { k } ) , \hat { g } _ { \beta } ( \pmb \theta _ { k } ) \rangle + \frac { 1 } { 2 } \alpha ^ { 2 } L _ { 1 } ( g _ { \beta } ) | | \hat { g } _ { \beta } ( \pmb \theta _ { k } ) | | ^ { 2 }
+$$
+
+Since
+
+$$
+\begin{array} { l } { \displaystyle E _ { u } ( \hat { g } ( \pmb \theta _ { k } ) ) = \frac { 1 } { \kappa } \int _ { E } \frac { g ( \pmb \theta + \beta u ) - g ( \pmb \theta ) + \epsilon _ { \theta + \beta u } - \epsilon _ { \theta } } { \beta } u e ^ { - \frac { 1 } { 2 } | | u | | ^ { 2 } } d u } \\ { \displaystyle \quad \quad = \nabla g _ { \beta } ( \pmb \theta _ { k } ) + \frac { 1 } { \kappa } \int _ { E } \frac { \epsilon _ { \theta + \beta u } - \epsilon _ { \theta } } { \beta } u e ^ { - \frac { 1 } { 2 } | | u | | ^ { 2 } } d u } \\ { \displaystyle \quad \quad \leq \nabla g _ { \beta } ( \pmb \theta _ { k } ) + \frac { 2 \epsilon } { \beta } n ^ { 1 / 2 } \cdot \mathbb { 1 } } \end{array}
+$$
+
+where $\mathbb { 1 }$ is a all-one vector. Taking the expectation in $u _ { k }$ , we obtain
+
+$$
+\begin{array} { l } { { \displaystyle \Xi _ { u _ { k } } ( g _ { \beta } ( { \pmb \theta } _ { k + 1 } ) ) \le g _ { \beta } ( { \pmb \theta } _ { k } ) - \alpha _ { k } \| \nabla g _ { \beta } ( { \pmb \theta } _ { k } ) \| ^ { 2 } + \alpha _ { k } \langle \nabla g _ { \beta } ( { \pmb \theta } _ { k } ) , \frac { 2 \epsilon } { \beta } d ^ { 1 / 2 } \cdot \mathbb { 1 } \rangle + \frac { 1 } { 2 } \alpha _ { k } ^ { 2 } L _ { 1 } ( g _ { \beta } ) E _ { u _ { k } } \| \hat { g } _ { \beta } ( { \pmb \theta } _ { k } ) } } \\ { { \displaystyle \Xi _ { u _ { k } } ( g _ { \beta } ( { \pmb \theta } _ { k + 1 } ) ) \le g _ { \beta } ( { \pmb \theta } _ { k } ) - \alpha _ { k } \| \nabla g _ { \beta } ( { \pmb \theta } _ { k } ) \| ^ { 2 } + \alpha _ { k } \frac { 2 \epsilon } { \beta } n ^ { 1 / 2 } \| \nabla g _ { \beta } ( { \pmb \theta } _ { k } ) \| } } \\ { { \displaystyle \qquad + \frac { 1 } { 2 } \alpha _ { k } ^ { 2 } L _ { 1 } ( g ) ( 4 ( d + 4 ) \| \nabla g _ { \beta } ( { \pmb \theta } _ { k } ) \| ^ { 2 } + \frac { 3 \beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 5 ) ^ { 3 } + 4 \beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \delta ^ { 2 } + 8 \beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } ) } . } \end{array}
+$$
+
+Choosing $\begin{array} { r } { \alpha _ { k } = \hat { \alpha } = \frac { 1 } { 4 ( d + 4 ) L _ { 1 } ( g ) } } \end{array}$ , we obtain
+
+$$
+\begin{array} { l } { { \displaystyle E _ { u _ { k } } \big ( g _ { \beta } \big ( \theta _ { k } + 1 \big ) \big ) \le g _ { \beta } \big ( \theta _ { k } \big ) - \frac 1 2 \hat { \alpha } \big | | \nabla g _ { \beta } \big ( \theta _ { k } \big ) | | ^ { 2 } + \hat { \alpha } \frac { 2 \epsilon } { \beta } d ^ { 1 / 2 } | | \nabla g _ { \beta } \big ( \theta _ { k } \big ) | | + \frac { 3 \beta ^ { 2 } } { 6 4 } L _ { 1 } ( g ) \frac { ( d + 5 ) ^ { 3 } } { ( d + 4 ) ^ { 2 } } } } \\ { { \displaystyle \qquad + \frac { \beta } { 8 } \delta ^ { 2 } + \frac { d } { 4 ( d + 4 ) ^ { 2 } L _ { 1 } ( g ) } \delta ^ { 4 } } } \end{array}
+$$
+
+(22) Since $( d + 5 ) ^ { 3 } \leq ( d + 8 ) ( d + 4 ) ^ { 2 }$ , taking expectation over $\mathcal { U } _ { k }$ , where ${ \mathcal { U } } _ { k } = \{ u _ { 1 } , u _ { 2 } , \ldots , u _ { k } \}$ , we get $\begin{array} { r } { \displaystyle { \mathfrak { s } } _ { k + 1 } \leq \phi _ { k } - \frac { 1 } { 2 } \hat { \alpha } E \mu _ { k } ( \| \nabla g _ { \beta } ( \pmb { \theta } _ { k } ) \| ^ { 2 } ) + \frac { 3 \bar { \beta } ^ { 2 } ( \bar { d } + 8 ) } { 6 4 } L _ { 1 } ( g ) + \frac { \beta } { 8 } \delta ^ { 2 } + \frac { d } { 4 ( d + 4 ) ^ { 2 } L _ { 1 } ( g ) } \delta ^ { 4 } + \hat { \alpha } d ^ { 1 / 2 } E _ { \mathcal { U } _ { k } } ( \| \nabla g _ { \beta } ( \pmb { \theta } _ { k } ) \| ^ { 2 } ) + \frac { 3 \bar { \beta } ^ { 2 } ( \bar { d } + 8 ) } { 4 } L _ { 1 } ( g ) } \end{array}$ β(θk)||)δ2
+
+Where $\phi _ { k } = E _ { \mathcal { U } _ { k - 1 } ( g ( \pmb { \theta } _ { k } ) ) } , k \geq 1$ and $\phi _ { 0 } = g ( \theta _ { 0 } )$
+
+Assuming $g ( x ) \geq g ^ { * }$ , summing over $\mathbf { k }$ and divided by $_ { \mathrm { N + 1 } }$ , we get
+
+$$
+\begin{array} { l } { \displaystyle \frac { 1 } { N + 1 } \sum _ { k = 0 } ^ { N } E _ { \mathcal { U } _ { k } } ( | | \nabla g _ { \beta } ( \theta _ { k } ) | | ^ { 2 } ) \le 8 ( d + 4 ) L _ { 1 } ( g ) [ \frac { g ( x _ { 0 } ) - g ^ { * } } { N + 1 } + \frac { 3 \beta ^ { 2 } ( d + 8 ) } { 1 6 } L _ { 1 } ( g ) + \frac { \beta } { 8 } \delta ^ { 2 } } \\ { \displaystyle \qquad + \frac { d } { 4 ( d + 4 ) ^ { 2 } L _ { 1 } ( g ) } \delta ^ { 4 } + \frac { 1 } { N + 1 } \sum _ { k = 0 } ^ { N } E _ { \mathcal { U } _ { k } } ( | | \nabla g _ { \beta } ( \theta _ { k } ) | | ) \delta ^ { 2 } ] } \\ { \displaystyle \mathrm { l e a r l y , ~ } \frac { 1 } { N + 1 } \sum _ { k = 0 } ^ { N } E _ { \mathcal { U } _ { k } } ( | | \nabla g _ { \beta } ( \theta _ { k } ) | | ) \le \delta ^ { 2 } . } \end{array}
+$$
+
+$E _ { \mathcal { U } _ { k } } ( | | \nabla g _ { \beta } ( \pmb { \theta } _ { k } ) | | ^ { 2 } )$ $\begin{array} { r } { \vartheta _ { k } ^ { 2 } = E _ { \mathcal { U } _ { k } } ( | | \nabla g ( \pmb { \theta } _ { k } ) | | ^ { 2 } ) \leq 2 E _ { \mathcal { U } _ { k } } ( | | \nabla g _ { \beta } ( \pmb { \theta } _ { k } ) | | ^ { 2 } ) + \frac { \beta ^ { 2 } ( d + 4 ) ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) , \vartheta } \end{array}$ $\frac { 1 } { N + 1 } \sum _ { k = 0 } ^ { N } \vartheta _ { k } ^ { 2 } \leq \delta ^ { 2 }$ β2(d+4)22 L21(g), ϑ2k is in the same order of $\begin{array} { r } { \beta \le \frac { \delta } { d L _ { 1 } ( g ) } } \end{array}$ , then $_ \mathrm { N }$ is bounded by $O ( \textstyle { \frac { d } { \delta ^ { 2 } } } )$

parse/train/rJlk6iRqKX/rJlk6iRqKX_content_list.json

@@ -0,0 +1,1978 @@
+[
+    {
+        "type": "text",
+        "text": "QUERY-EFFICIENT HARD-LABEL BLACK-BOXATTACK: AN OPTIMIZATION-BASED APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            746,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Minhao Cheng, Huan Zhang & Cho-Jui Hsieh ",
+        "bbox": [
+            186,
+            169,
+            508,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science University of California, Los Angeles {mhcheng,huanzhang,chohsieh}@cs.ucla.edu ",
+        "bbox": [
+            184,
+            185,
+            570,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Thong Le Department of Computer Science University of California, Davis thmle@ucdavis.edu ",
+        "bbox": [
+            593,
+            170,
+            813,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen  \nIBM Research AI  \npin-yu.chen@ibm.com",
+        "bbox": [
+            183,
+            246,
+            372,
+            287
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jinfeng Yi JD AI Research yijinfeng@jd.com ",
+        "bbox": [
+            521,
+            246,
+            681,
+            287
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            324,
+            544,
+            339
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We study the problem of attacking machine learning models in the hard-label black-box setting, where no model information is revealed except that the attacker can make queries to probe the corresponding hard-label decisions. This is a very challenging problem since the direct extension of state-of-the-art white-box attacks (e.g., C&W or PGD) to the hard-label black-box setting will require minimizing a non-continuous step function, which is combinatorial and cannot be solved by a gradient-based optimizer. The only two current approaches are based on random walk on the boundary (Brendel et al., 2017) and random trials to evaluate the loss function (Ilyas et al., 2018), which require lots of queries and lacks convergence guarantees. We propose a novel way to formulate the hard-label black-box attack as a real-valued optimization problem which is usually continuous and can be solved by any zeroth order optimization algorithm, such as randomized gradientfree method (Nesterov & Spokoiny, 2017). We demonstrate that our proposed method outperforms the previous stochastic approaches to attacking convolutional neural networks on MNIST, CIFAR, and ImageNet datasets. More interestingly, the proposed algorithm can also be used to attack other discrete and non-continuous machine learning models, such as Gradient Boosting Decision Trees. ",
+        "bbox": [
+            233,
+            358,
+            766,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            616,
+            336,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It has been observed recently that machine learning algorithms, especially deep neural networks, are vulnerable to adversarial examples (Goodfellow et al., 2014; Szegedy et al., 2013; Moosavi-Dezfooli et al.; Moosavi Dezfooli et al., 2016; Chen et al., 2018a; Cheng et al., 2018). For example, in image classification problems, attack algorithms (Carlini & Wagner, 2017; Goodfellow et al., 2014; Chen et al., 2017) can find adversarial examples for almost every image with very small humanimperceptible perturbation. The problem of finding an adversarial example can be posed as solving an optimization problem—within a small neighbourhood around the original example, find a point to optimize the cost function measuring the “successfulness” of an attack. Solving this objective function with gradient-based optimizer leads to state-of-the-art attacks (Carlini & Wagner, 2017; Goodfellow et al., 2014; Chen et al., 2017; Szegedy et al., 2013; Madry et al., 2018). ",
+        "bbox": [
+            174,
+            643,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most current attacks (Goodfellow et al., 2014; Carlini & Wagner, 2017; Szegedy et al., 2013; Chen et al., 2018b) consider the “white-box” setting, where the machine learning model is fully exposed to the attacker. In this setting, the gradient of an attacking objective function can be computed by back-propagation, so attacks can be done very easily. This white-box setting is clearly unrealistic when the model parameters are unknown to an attacker. Instead, several recent works consider the “score-based black-box” setting, where the machine learning model is unknown to the attacker, but it is possible to make queries to obtain the corresponding probability outputs of the model (Chen et al., 2017; Ilyas et al., 2018). However, in many cases real-world models will not provide probability outputs to users. Instead, only the final decision (e.g., top-1 predicted class) can be observed. It is therefore interesting to show whether machine learning model is vulnerable in this setting. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, existing gradient-based attacks cannot be applied to some non-continuous machine learning models which involve discrete decisions. For example, the robustness of decision-tree based models (random forest and gradient boosting decision trees (GBDT)) cannot be evaluated using gradient-based approaches, since the gradient of these functions may not exist. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we develop an optimization-based framework for attacking machine learning models in a more realistic and general “hard-label black-box” setting. We assume that the model is not revealed and the attacker can only make queries to acquire the corresponding hard-label decision instead of the probability outputs (also known as soft labels). ",
+        "bbox": [
+            174,
+            165,
+            825,
+            220
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We make hard-label black-box attacks query-efficient by reformulating the attack as a novel realvalued optimization problem, which is usually continuous and much easier to solve. Although the objective function of this reformulation cannot be written in an analytical form, we show how to use (hard-label) model queries to evaluate its function value and thus any zeroth order optimization algorithm can be applied to solve it. In the experiments, we show our algorithm can be successfully used to attack hard-label black-box CNN models on MNIST, CIFAR, and ImageNet with far less number of queries compared to the state-of-art algorithm both in $L _ { 2 }$ and $L _ { \\infty }$ metric. ",
+        "bbox": [
+            174,
+            227,
+            825,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Moreover, since our algorithm does not depend on the gradient of the classifier, we can apply it to attack other non-differentiable classifiers besides neural networks. We show an interesting application in attacking Gradient Boosting Decision Tree, which cannot be attacked by all the existing gradientbased methods even in the white-box setting. Our method can successfully find adversarial examples with imperceptible perturbations for a GBDT within 30,000 queries. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            398
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            412,
+            509,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We will first introduce our problem setting and give a brief literature review to highlight the difficulty of attacking hard-label black-box models. ",
+        "bbox": [
+            173,
+            436,
+            823,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Problem Setting For simplicity, we consider attacking a $K$ -way multi-class classification model in this paper. Given the classification model $f : \\mathbb { R } ^ { d }  \\{ 1 , \\dots , K \\}$ and an original example $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { 0 }$ , the goal is to generate an adversarial example $_ { \\textbf { \\em x } }$ such that ",
+        "bbox": [
+            173,
+            468,
+            823,
+            510
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95a453891c093649b17452a7b613071b406e3a5ba2ad942de912c445dd86805c.jpg",
+        "text": "$$\n\\operatorname { c l o s e \\ t o } x _ { 0 } \\quad { \\mathrm { a n d } } \\quad f ( x ) \\neq f ( x _ { 0 } ) \\quad { \\mathrm { ( i . e . , ~ } } x { \\mathrm { ~ i s ~ m i s c l a s s i f i e d ~ b y ~ m o d e l ~ } } f . { \\mathrm { ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            516,
+            754,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "White-box attacks Most attack algorithms in the literature consider the white-box setting, where the classifier $f$ is exposed to the attacker. For neural networks, under this assumption, backpropagation can be conducted on the target model because both network structure and weights are known by the attacker. For classification models in neural networks, it is usually assumed that $f ( \\pmb { x } ) = \\mathrm { a r g m a x } _ { i } ( Z ( \\pmb { x } ) _ { i } )$ , where $Z ( \\pmb { x } ) \\in \\mathbb { R } ^ { K }$ is the final (logit) layer output, and $Z ( { \\pmb x } ) _ { i }$ is the prediction score for the $i$ -th class. The objectives in (1) can then be naturally formulated as the following optimization problem: ",
+        "bbox": [
+            173,
+            556,
+            825,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11770870bd8af75846effaee5db4f4851c8727620aa1b06ea3db62d6eba10099.jpg",
+        "text": "$$\n\\underset { \\pmb { x } } { \\mathrm { a r g m i n } } \\left\\{ \\mathrm { D i s } ( \\pmb { x } , \\pmb { x } _ { 0 } ) + c \\mathcal { L } ( Z ( \\pmb { x } ) ) \\right\\} : = h ( \\pmb { x } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            659,
+            647,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\operatorname { D i s } ( \\cdot , \\cdot )$ is some distance measurement (e.g., $L _ { 2 } , L _ { 1 }$ or $L _ { \\infty }$ norm in Euclidean space), $\\mathcal { L } ( \\cdot )$ is the loss function corresponding to the goal of the attack, and $c$ is a balancing parameter. For untargeted attack, where the goal is to make the target classifier misclassify, the loss function can be defined as ",
+        "bbox": [
+            173,
+            691,
+            825,
+            744
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8c2c7e2f14fb183a736fe33aeaaa5611ef93b3e29c7e90cfb6963f5913f1525b.jpg",
+        "text": "$$\n\\mathcal { L } ( Z ( \\pmb { x } ) ) = \\operatorname* { m a x } \\{ [ Z ( \\pmb { x } ) ] _ { y _ { 0 } } - \\operatorname* { m a x } _ { i \\neq y _ { 0 } } [ Z ( \\pmb { x } ) ] _ { i } , - \\kappa \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            744,
+            660,
+            768
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { 0 }$ is the original label predicted by the classifier, $\\kappa$ is the margin (usually set to be 1 or 0) of the hinge loss. For targeted attack, where the goal is to turn it into a specific target class $t$ , the loss function can also be defined accordingly. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Therefore, attacking a machine learning model can be posed as solving this optimization problem (Carlini & Wagner, 2017; Chen et al., 2018b), which is also known as the C&W attack or the EAD attack depending on the choice of the distance measurement. To solve (2), one can apply any gradient-based optimization algorithm such as SGD or Adam, since the gradient of $\\bar { \\mathcal { L } } ( Z ( \\pmb { x } ) )$ can be computed via back-propagation. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            890
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The ability of computing gradient also enables many different attacks in the white-box setting. For example, eq (2) can also be turned into a constrained optimization problem, which can then be solved by projected gradient descent (PGD) (Madry et al., 2018). FGSM (Goodfellow et al., 2014) is the special case of one step PGD with $L _ { \\infty }$ norm distance. Other algorithms such as Deepfool (Moosavi Dezfooli et al., 2016) also solve similar optimization problems to construct adversarial examples. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Previous work on black-box attack In real-world systems, usually the underlying machine learning model will not be revealed and thus white-box attacks cannot be applied. This motivates the study of attacking machine learning models in the black-box setting, where attackers do not have any information about the function $f$ . And the only valid operation is to make queries to the model and acquire the corresponding output $f ( { \\pmb x } )$ . The first approach for black-box attack is using transfer attack (Papernot et al., 2017) – instead of attacking the original model $f$ , attackers try to construct a substitute model $\\hat { f }$ to mimic $f$ and then attack $\\hat { f }$ using white-box attack methods. This approach has been well studied and analyzed in (Liu et al., 2017; Bhagoji et al., 2017). However, recent papers have shown that attacking the substitute model usually leads to much larger distortion and low success rate (Chen et al., 2017). Therefore, instead, (Chen et al., 2017) considers the score-based black-box setting, where attackers can use $_ { \\textbf { \\em x } }$ to query the softmax layer output in addition to the final classification result. In this case, they can reconstruct the loss function (3) and evaluate it as long as the objective function $h ( { \\pmb x } )$ exists for any $_ { \\textbf { \\em x } }$ . Thus a zeroth order optimization approach can be directly applied to minimize $\\dot { h } ( { \\pmb x } )$ . (Tu et al., 2018) further improves the query complexity of (Chen et al., 2017) by introducing an autoencoder-based approach to reduce query counts and an adaptive random gradient estimation to balance query counts and distortion. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            387
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Difficulty of hard-label black-box attacks Throughout this paper, the hard-label black-box setting refers to cases where real-world ML systems only provide limited prediction results of an input query. Specifically, only the final decision (top-1 predicted label) instead of probability outputs is known to an attacker. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Attacking in this setting is indeed very challenging. In Figure 1a, we show a simple 3-layer neural network’s decision boundary. Note that the $\\bar { \\mathcal { L } } ( \\bar { Z } ( { \\pmb x } ) )$ term is continuous as in Figure 1b because the logit layer output is real-valued functions. However, in the hard-label black-box setting, only $f ( \\cdot )$ is available instead of $Z ( \\cdot )$ . Since $f ( \\cdot )$ can only be a one-hot vector, if we plug-in $f$ into the loss function, $ { \\mathcal { L } } ( f ( {  { \\boldsymbol { \\mathbf { x } } } } ) )$ (as shown in Figure 1c) will be discontinuous and with discrete outputs. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a9c65e9919f4ff130cdc7613faa3c02e0f587f4ddd99ae5fdd6be4b9e69500be.jpg",
+        "image_caption": [
+            "Figure 1: (a) A neural network classifier. (b) illustrates the loss function of C&W attack, which is continuous and hence can be easily optimized. (c) is the C&W loss function in the hard-label setting, which is discrete and discontinuous. (d) our proposed attack objective $g ( \\pmb \\theta )$ for this problem, which is continuous and easier to optimize. See detailed discussions in Section 3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            532,
+            795,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimizing this function will require combinatorial optimization or search algorithms, which is challenging given the high dimensionality of the problem. The only two current approaches (Brendel et al., 2017; Ilyas et al., 2018) are based on random-walk on the boundary and random trails on the loss function. Although these “Boundary attack” and “Limited attack” can find adversarial examples with comparable distortion with white-box attacks, they need lots of queries to explore the high-dimensional space and lack convergence guarantees. We show that our optimization-based algorithm can significantly reduce the number of queries, and has guaranteed convergence in the number of iterations (queries) when the objective function is lipschitz smooth. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            861,
+            321,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Now we introduce a novel way to re-formulate hard-label black-box attack as another optimization problem, show how to evaluate the function value using hard-label queries, and then apply a zeroth order optimization algorithm to solve it. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 A BOUNDARY-BASED RE-FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            495,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a given example $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { 0 }$ , true label $y _ { 0 }$ and the hard-label black-box function $f : \\mathbb { R } ^ { d }  \\{ 1 , \\dots , K \\}$ , we define our objective function $g : \\mathbb { R } ^ { d }  \\mathbb { R }$ depending on the type of attack: ",
+        "bbox": [
+            174,
+            122,
+            825,
+            154
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a9c8a4747fe0f42e6a12f59790aede82b2d10bc407facf0bcb30a20f00d498a.jpg",
+        "text": "$$\n{ \\begin{array} { r l l } { \\displaystyle { \\mathrm { U n t a r g e t e d ~ a t t a c k : } } ~ g ( \\theta ) = { \\underset { \\lambda > 0 } { \\mathrm { m i n } } } ~ \\lambda } & { \\displaystyle { \\mathrm { s . t } } } & { f ( { \\boldsymbol { x } } _ { 0 } + \\lambda { \\frac { \\theta } { | | \\theta | | } } ) \\neq y _ { 0 } } \\\\ { \\displaystyle { \\mathrm { T a r g e t e d ~ a t t a c k ~ ( g i v e n ~ t a r g e t ~ } } t ) \\colon ~ g ( \\theta ) = { \\underset { \\lambda > 0 } { \\mathrm { m i n } } } ~ \\lambda } & { \\displaystyle { \\mathrm { s . t } } } & { f ( { \\boldsymbol { x } } _ { 0 } + \\lambda { \\frac { \\theta } { | | \\theta | | } } ) = t } \\end{array} }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            148,
+            763,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this formulation, $\\pmb { \\theta }$ represents the search direction and $g ( \\pmb \\theta )$ is the distance from $\\scriptstyle { \\pmb x } _ { 0 }$ to the nearest adversarial example along the direction $\\pmb \\theta$ . The difference between (4) and (5) corresponds to the different definitions of “successfulness” in untargeted and targeted attack, where the former one aims to turn the prediction into any incorrect label and the later one aims to turn the prediction into the target label. For untargeted attack, $g ( \\pmb \\theta )$ also corresponds to the distance to the decision boundary along the direction $\\pmb \\theta$ . In image problems the input domain of $f$ is bounded, so we will impose corresponding upper/lower bounds in the definition of (4) and (5). ",
+        "bbox": [
+            173,
+            222,
+            825,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Instead of searching for an adversarial example, we search the direction $\\pmb \\theta$ to minimize the distortion $g ( \\pmb \\theta )$ , which leads to the following optimization problem: ",
+        "bbox": [
+            173,
+            332,
+            614,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8141e06af8ca5755458369368f4560f7f91c5e763e494f66e5a9b7809f2b679d.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } { g ( \\theta ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            372,
+            431,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, the adversarial example can be found by ${ \\pmb x } ^ { * } ~ = ~ { \\pmb x } _ { 0 } +$ $g ( \\theta ^ { * } ) \\frac { \\theta ^ { * } } { | | \\theta ^ { * } | | }$ , where $\\pmb { \\theta } ^ { * }$ is the optimal solution of (6). ",
+        "bbox": [
+            173,
+            392,
+            614,
+            424
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/5e091468b1e587579d5661029ca85ada551fdab314d399e8122dd55af686a84e.jpg",
+        "image_caption": [
+            "Figure 2: Illustration "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            643,
+            358,
+            808,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that unlike the C&W or PGD objective functions, which are discontinuous step functions in the hard-label setting (see Section 2), $g ( \\pmb \\theta )$ maps input direction to real-valued output (distance to decision boundary), which is usually continuous – a small change of $\\pmb \\theta$ usually leads to a small change of $g ( \\pmb \\theta )$ , as can be seen from Figure 2. ",
+        "bbox": [
+            173,
+            431,
+            616,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we give three examples of $f ( { \\pmb x } )$ defined in two dimension input space and their corresponding $g ( \\pmb \\theta )$ . In Figure 3a, we have a continuous classification function defined as follows ",
+        "bbox": [
+            176,
+            506,
+            825,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b50773520b89e68248f38d803078226baac87870180a04c59ec6ce5d19af3824.jpg",
+        "text": "$$\nf ( \\pmb { x } ) = \\left\\{ \\begin{array} { l l } { 1 , } & { \\mathrm { i f } \\| \\pmb { x } \\| _ { 2 } ^ { 2 } \\geq 0 . 4 } \\\\ { 0 , } & { \\mathrm { o t h e r w i s e } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            534,
+            596,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this case, as shown in Figure 3c, $g ( \\pmb \\theta )$ is continuous. Moreover, in Figure 3b and Figure 1a, we show decision boundaries generated by GBDT and neural network classifier, which are not continuous. However, as showed in Figure 3d and Figure 1d, even if the classifier function is not continuous, $g ( \\pmb \\theta )$ is still continuous. This makes it easy to apply zeroth order method to solve (6). ",
+        "bbox": [
+            174,
+            574,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/f6b5027cdc3fed662e150bdcb799b49c5c72db8dd0682229b5f61fabcfdfdd6d.jpg",
+        "image_caption": [
+            "Figure 3: Examples of decision boundary of classification function $f ( { \\pmb x } )$ and corresponding $g ( \\pmb \\theta )$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            637,
+            787,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compute $g ( \\pmb \\theta )$ up to certain accuracy. We are not able to evaluate the gradient of $g$ , but we can evaluate the function value of $g$ using the hard-label queries to the original function $f$ . For simplicity, we focus on untargeted attack here, but the same procedure can be applied to targeted attack as well. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First, we discuss how to compute $g ( \\pmb \\theta )$ directly without additional information. This is used in the initialization step of our algorithm. For a given normalized $\\pmb \\theta$ , we do a coarse-grained search and then a binary search. In coarse-grained search, we query the points $\\{ \\pmb { x } _ { 0 } + \\alpha \\pmb { \\theta } , \\pmb { x } _ { 0 } + 2 \\alpha \\pmb { \\theta } , \\ldots \\}$ one by one until we find $f ( \\pmb { x } + i \\alpha \\pmb { \\theta } ) \\neq y _ { 0 }$ . This means the boundary lies between $[ { \\pmb x } _ { 0 } + ( i - 1 ) \\alpha { \\pmb \\theta } , { \\pmb x } _ { 0 } + i \\alpha { \\pmb \\theta } ]$ . We then enter the second phase and conduct a binary search to find the solution within this region (same with line 11–17 in Algorithm 1). Note that there is an upper bound of the first stage if we choose $\\pmb \\theta$ by the direction of ${ \\pmb x } - { \\pmb x } _ { 0 }$ with some $_ { \\textbf { \\em x } }$ from another class. This procedure is used to find the initial $\\pmb { \\theta } _ { 0 }$ and corresponding $g ( \\pmb \\theta _ { 0 } )$ in our optimization algorithm. We omit the detailed algorithm for this part since it is similar to Algorithm 1. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we discuss how to compute $g ( \\pmb \\theta )$ when we know the solution is very close to a reference point $v$ . This is used in all the function evaluations in our optimization algorithm, since the current solution is usually close to the previous solution, and when we estimate the gradient using (7), the queried direction will only be a slight modification of the previous one. In this case, we first increase or decrease $v$ in the local region to find the interval that contains the nearby boundary (e.g, $f ( \\pmb { x } _ { 0 } + v \\pmb { \\theta } ) = y _ { 0 }$ and $f ( \\pmb { x } _ { 0 } + \\pmb { v } ^ { \\prime } \\pmb { \\theta } ) \\breve { \\neq } y _ { 0 } )$ , then conduct a binary search to find the final value of $g$ Our procedure for computing the $g$ value is presented in Algorithm 1. ",
+        "bbox": [
+            173,
+            151,
+            825,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Compute $g ( \\pmb \\theta )$ locally ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            262,
+            406,
+            277
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Hard-label model $f$ , original image $x _ { 0 }$ , query direction $\\pmb { \\theta }$ , previous solution $v$ , in  \ncrease/decrease ratio $\\alpha = 0 . 0 1$ , stopping tolerance $\\epsilon$ (maximum tolerance of computed error)   \n2: $\\pmb { \\theta }  \\pmb { \\theta } / | | \\pmb { \\theta } | |$   \n3: if $f ( \\pmb { x } _ { 0 } + v \\pmb { \\theta } ) = y _ { 0 }$ then   \n4: $\\dot { v } _ { l e f t }  \\dot { v } , v _ { r i g h t }  ( 1 + \\alpha ) v$   \n5: while $f ( \\pmb { x } _ { 0 } + v _ { r i g h t } \\pmb { \\theta } ) = y _ { 0 } \\ \\mathbf { d o }$   \n6: $v _ { r i g h t }  ( 1 + \\alpha ) v _ { r i g h t }$   \n7: else   \n8: $\\begin{array} { r l } & { v _ { r i g h t }  v , v _ { l e f t }  ( 1 - \\alpha ) v } \\\\ & { \\mathbf { w h i l e } f ( \\pmb { x } _ { 0 } + v _ { l e f t } \\pmb { \\theta } ) \\neq y _ { 0 } \\mathbf { \\delta } \\mathbf { d o } } \\\\ & { \\qquad v _ { l e f t }  ( 1 - \\alpha ) v _ { l e f t } } \\end{array}$   \n9:   \n10:   \n11: ## Binary Search within $[ v _ { l e f t } , v _ { r i g h t } ]$   \n12: while $v _ { r i g h t } - v _ { l e f t } > \\epsilon \\mathbf { d o }$   \n13: $v _ { m i d } \\gets ( v _ { r i g h t } + v _ { l e f t } ) / 2$   \n14: if $f ( \\pmb { x } _ { 0 } + v _ { m i d } \\pmb { \\theta } ) = y _ { 0 }$ then   \n15: $v _ { l e f t } \\gets v _ { m i d }$   \n16: else   \n17: $v _ { r i g h t } \\gets v _ { m i d }$   \n18: return vright ",
+        "bbox": [
+            176,
+            281,
+            826,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 HARD-LABEL BLACK-BOX ATTACKS WITH $L _ { \\infty }$ NORM CONSTRAINT ",
+        "bbox": [
+            174,
+            573,
+            681,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although we could let $\\| \\pmb \\theta \\| = \\| \\pmb \\theta \\| _ { \\infty }$ in (4) and (5) directly, $g ( \\pmb \\theta )$ will be harder to optimize in practice because of introducing the max term in $\\| \\cdot \\| _ { \\infty }$ . Instead, with an $L _ { \\infty }$ constraint $\\varepsilon$ , we design a smooth approximation loss as follows: ",
+        "bbox": [
+            176,
+            593,
+            825,
+            633
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/211fda83116883031255d141f9585279a67e32a154a62171748a2e5da9321367.jpg",
+        "text": "$$\n\\begin{array} { r l } & { g ( \\pmb { \\theta } ) = \\underset { \\lambda } { \\operatorname* { m i n } } \\{ \\underset { i = 1 } { \\overset { d } { \\sum } } ( \\operatorname* { m a x } \\{ \\lambda \\frac { \\left| \\pmb { \\theta } _ { i } \\right| } { \\left\\| \\pmb { \\theta } \\right\\| _ { \\infty } } - \\varepsilon , 0 \\} ) ^ { 2 } \\} \\quad \\textnormal { s . t } \\quad f ( \\pmb { x } _ { 0 } + \\lambda \\frac { \\pmb { \\theta } } { \\left\\| \\pmb { \\theta } \\right\\| _ { \\infty } } ) \\neq y _ { 0 } } \\\\ & { g ( \\pmb { \\theta } ) = \\underset { \\lambda } { \\operatorname* { m i n } } \\{ \\underset { i = 1 } { \\overset { d } { \\sum } } ( \\operatorname* { m a x } \\{ \\lambda \\frac { \\left| \\pmb { \\theta } _ { i } \\right| } { \\left\\| \\pmb { \\theta } \\right\\| _ { \\infty } } - \\varepsilon , 0 \\} ) ^ { 2 } \\} \\quad \\textnormal { s . t } \\quad f ( \\pmb { x } _ { 0 } + \\lambda \\frac { \\pmb { \\theta } } { \\left\\| \\pmb { \\theta } \\right\\| _ { \\infty } } ) = t . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            176,
+            632,
+            820,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $\\theta _ { i }$ is the i-th coordinate of $\\pmb \\theta$ . Notably, when $\\lambda \\leq \\varepsilon$ , we have $g ( \\pmb \\theta ) = 0$ . That’s to say, we have obtained a legitimate $\\pmb \\theta$ to make a valid adversarial example ${ \\pmb x } _ { 0 } + \\lambda ^ { * } \\frac { { \\pmb \\theta } } { \\| { \\pmb \\theta } \\| _ { \\infty } }$ . ",
+        "bbox": [
+            176,
+            718,
+            823,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 ZEROTH ORDER OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            434,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To solve the optimization problem (6) for which we can only evaluate function value instead of gradient, zeroth order optimization algorithms can be naturally applied. In fact, after the reformulation, the problem can be potentially solved by any zeroth order optimization algorithm, like zeroth order gradient descent, genetic algorithm (Alzantot et al., 2018) or coordinate descent (see Conn et al. (2009) for a comprehensive survey). ",
+        "bbox": [
+            173,
+            780,
+            826,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here we propose to solve (1) using Randomized Gradient-Free (RGF) method proposed in (Nesterov & Spokoiny, 2017; Ghadimi $\\&$ Lan, 2013). In practice, we found it outperforms zeroth-order coordinate descent. At each iteration, the gradient is estimated by ",
+        "bbox": [
+            174,
+            854,
+            823,
+            897
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5a5392a82c5fb1b6b3a6f21d7075ad4b5cc1a2044f85e2764cb210e9da57710.jpg",
+        "text": "$$\n\\hat { \\pmb g } = \\frac { \\breve { g ( \\pmb \\theta + \\beta \\pmb u ) } - g ( \\pmb \\theta ) } { \\beta } \\cdot \\pmb u\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            895,
+            591,
+            929
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Hard-label model $f$ , original image $x _ { 0 }$ , initial $\\pmb { \\theta } _ { 0 }$ .   \n2: for $t = 0 , 1 , 2 , \\ldots , T$ do   \n3: Randomly choose $\\mathbf { \\pmb { u } } _ { t }$ from a zero-mean Gaussian distribution   \n4: Evaluate $\\dot { \\boldsymbol g } ( \\pmb \\theta _ { t } )$ and $g ( \\pmb \\theta _ { t } + \\beta \\pmb u )$ using Algorithm 1   \n5: Compute gˆ = $\\hat { \\pmb { g } } = \\frac { g ( \\pmb { \\theta } _ { t } + \\beta \\pmb { u } ) - g ( \\pmb { \\theta } _ { t } ) } { \\beta } \\cdot \\pmb { u }$   \n6: Update θt+1 = θt − ηtgˆ   \n7: return ${ \\pmb x } _ { 0 } + g ( { \\pmb \\theta } _ { T } ) { \\pmb \\theta } _ { T }$ ",
+        "bbox": [
+            179,
+            122,
+            629,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\textbf { \\em u }$ is a random Gaussian vector, and $\\beta > 0$ is a smoothing parameter (we set $\\beta = 0 . 0 0 5$ in all our experiments). The solution is then updated by $\\pmb { \\theta }  \\pmb { \\theta } - \\eta \\hat { \\pmb g }$ with a step size $\\eta$ . The procedure is summarized in Algorithm 2. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            311
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Also, if $g ( \\pmb \\theta )$ is Lipschitz-smooth, we are able to bound the number of iterations needed with $O ( \\textstyle { \\frac { d } { \\delta ^ { 2 } } } )$ for our algorithm to achieve stationary points. See the appendix for details. ",
+        "bbox": [
+            176,
+            320,
+            823,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            418,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "There are several implementation details when we apply this algorithm. First, for high-dimensional problems, we found the estimation in (7) is very noisy. Therefore, instead of using one vector, we sample $q$ vectors from Gaussian distribution and average their estimators to get $\\hat { \\pmb { g } }$ . We set $q = 2 0$ in all the experiments. Second, instead of using a fixed step size (suggested in theory), we use a backtracking line-search approach to find step size at each step. This leads to additional query counts, but makes the algorithm more stable and eliminates the need to hand-tuning the step size. Third, instead of using a random direction $\\pmb \\theta$ as initialization, we sample $t$ vectors from Gaussian distribution and choose the one with smallest $g ( \\pmb \\theta )$ as our initialization. It helps us to find a good initialization direction and thus get a smaller distortion in the end with limited number of additional queries. We set $t = 1 0 0$ in all the experiments. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            416,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We test the performance of our hard-label black-box attack algorithm on convolutional neural network (CNN) models and compare with Boundary attack (Brendel et al., 2017), Limited attack (Ilyas et al., 2018) and a random trail baseline. Furthermore, we show our method can be applied to attack Gradient Boosting Decision Tree (GBDT) and present some interesting findings. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 ATTACKING CNN IMAGE CLASSIFICATION MODELS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            618,
+            570,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use three standard datasets: MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky, 2009) and ImageNet-1000 (Deng et al., 2009). To have a fair comparison with previous work, we adopt the same networks used in both Carlini & Wagner (2017) and Brendel et al. (2017). In detail, both MNIST and CIFAR use the same network structure with four convolution layers, two max-pooling layers and two fully-connected layers. Using the parameters provided by Carlini & Wagner (2017), we could achieve $9 9 . 5 \\%$ test accuracy on MNIST and $8 2 . 5 \\%$ test accuracy on CIFAR-10, which is similar to accuracy reported in Carlini & Wagner (2017). For Imagenet-1000, we use the pretrained network Resnet-50 (He et al., 2016) and Inception-V3 (Szegedy et al., 2016) provided by torchvision1, which could achieve $7 6 . 1 5 \\%$ and $7 7 . 4 5 \\%$ top-1 test accuracy respectively. For simplicity, all images are normalized into $[ 0 , 1 ] ^ { d }$ scale. All models are trained using Pytorch and our source code is publicly available2. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We include the following algorithms for comparisons in attacking performance: ",
+        "bbox": [
+            173,
+            795,
+            694,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Opt-based black-box attack (Opt-attack): our proposed algorithm.   \nBoundary black-box attack (Brendel et al., 2017) (Boundary-attack): first work on attacking hard-label black box model in L2 distance metric. We use the authors’ implementation and the parameters provided in Foolbox3. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            871
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/210382ecc9f1bba07483275c09e709a5969519ca9a12a6697fefc80e5f1fded6.jpg",
+        "table_caption": [
+            "Table 1: Results for ( $L _ { 2 }$ -norm based) untargeted attacks. ASR stands for Attack Success Rate. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">MNIST</td><td colspan=\"2\">CIFAR10</td><td colspan=\"2\">Imagenet (ResNet-50)</td></tr><tr><td>Avg L2</td><td># queries</td><td>Avg L2</td><td># queries</td><td>AvgL2</td><td># queries</td></tr><tr><td rowspan=\"2\">Boundary-attack</td><td>1.1222</td><td>60,293</td><td>0.1575</td><td>123,879</td><td>5.9791</td><td>123,407</td></tr><tr><td>1.1087</td><td>143,357</td><td>0.1501</td><td>220,144</td><td>3.7725</td><td>260,797</td></tr><tr><td rowspan=\"3\">Opt-attack</td><td>1.188</td><td>22.940</td><td>0.2050</td><td>40,941</td><td>6.9796</td><td>71,100</td></tr><tr><td>1.049</td><td>51,683</td><td>0.1625</td><td>77,327</td><td>4.7100</td><td>127,086</td></tr><tr><td>1.011</td><td>126,486</td><td>0.1451</td><td>133,662</td><td>3.1120</td><td>237,342</td></tr><tr><td>C&amp;W(white-box)</td><td>0.9921</td><td>-</td><td>0.1012</td><td>1</td><td>1.9365</td><td>-</td></tr><tr><td>Random distortion</td><td>1.0(2% ASR)</td><td>300,000</td><td>0.15(10% ASR)</td><td>300,000</td><td>3.11(0% ASR)</td><td>480,000</td></tr></table>",
+        "bbox": [
+            176,
+            88,
+            836,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Limited black-box attack (Ilyas et al., 2018) (Limited-attack): previous work on targeted blackbox attack in $L _ { \\infty }$ distance constraint in the hard-label setting. We use the authors’ implementation and the parameters provided in Github4. • C&W white-box attack (Carlini & Wagner, 2017): one of the current state-of-the-art attacking algorithm in the white-box setting. We do binary search on parameter $c$ per image to achieve the best performance. Attacking in the white-box setting is a much easier problem, so we include C&W attack just for reference and indicate the best performance we can possibly achieve. Random distortion: we use 300,000 and 480,000 i.i.d random directions as the baseline. We note that while all other methods could achieve $100 \\%$ attack success rate (ASR), the ASR of random distortion appears to be quite low. ",
+        "bbox": [
+            174,
+            229,
+            826,
+            366
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For all the cases except Limited-attack, we conduct adversarial attacks for randomly sampled $N = 1 0 0$ images from validation sets. Note that all three attacks (Opt-attack, Boundary-attack, C&W attack) have $100 \\%$ successful rates, and we report the average $L _ { 2 }$ distortion, defined by $\\begin{array} { r } { \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\| \\pmb { x } ^ { ( i ) } - \\pmb { x } _ { 0 } ^ { ( i ) } \\| _ { 2 } } \\end{array}$ , where $\\pmb { x } ^ { ( i ) }$ is the adversarial example constructed by an attack algorithm and x(i)0 is the original $i$ -th example. For black-box attack algorithms, we also report average and median number of queries for comparison. To compare with Limited-attack, we randomly sampled 50 images and report targeted ASR with average and median number of queries when limiting $L _ { \\infty }$ distortion to be 0.3 and 0.15 for ImageNet dataset. We also restrict the maximum number of queries to be 1,000,000 for all attacks. ",
+        "bbox": [
+            173,
+            373,
+            825,
+            505
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 UNTARGETED ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            387,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For untargeted attack, the goal is to turn a correctly classified image into any other label. The results are presented in Table 1. Note that for both Opt-attack and Boundary-attack, by changing the stopping conditions we can attain different distortions by varying the number of queries. ",
+        "bbox": [
+            176,
+            531,
+            821,
+            573
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we compare Boundary-attack and the proposed Opt-attack in Table 1 and Table 5 in appendix. Our algorithm consistently achieves smaller distortion with less number of queries than Boundaryattack. For example, on MNIST data, we are able to reduce the number of queries by 3-4 folds, and Boundary-attack converges to worse solutions in all the 3 datasets. In addition, we include the average L2 norm distortion plot with different query budgets in Figure 5(a) in appendix. And our method consistently outperforms the Boundary-attack and achieves nearly $2 \\mathbf { x }$ speedup on both datasets. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compared with C&W attack, we found black-box attacks attain slightly worse distortion on MNIST and CIFAR. This is reasonable because white-box attack has much more information than black-box attack and is strictly easier. We note that the experiments in Brendel et al. (2017) conclude that C&W and Boundary-attack have similar performance because they only run C&W attack with a single regularization parameter $c$ , without doing binary search to obtain the optimal parameter. For ImageNet, since we constraint the number of queries, the distortion of black-box attacks is much worse than C&W attack. The gap can be reduced by increasing the number of queries as showed in Figure 5(b) in appendix. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 TARGETED ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            362,
+            800
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results for targeted attack is presented in Table 2 and Table 5 in appendix. Following the experiments in Brendel et al. (2017), for each randomly sampled image with label $i$ we set target label $t = ( i + 1 )$ module 10. On MNIST, we found our algorithm is more than 4 times faster (in terms of number of queries) than Boundary-attack and converges to a better solution. On CIFAR, our algorithm has similar efficiency with Boundary-attack at the first 60,000 queries, but converges to a slightly worse solution. Also, we show an example quality comparison from the same starting point to the original sample in Figure 4. And we also include some adversarial example in Figure 4. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            900
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For attacks in $L _ { \\infty }$ norm constraint, we conduct experimental comparisons with Limited-attack5. the results are shown in Table 3. In the cases of an $L _ { \\infty }$ constraint $\\epsilon \\in \\{ 0 . 1 5 , 0 . 3 \\}$ , our Opt-attack roughly halves the average number of queiries relative to Limited-attack. In addition, our ASR is $40 \\%$ higher than Limited-attack when $\\epsilon = 0 . 1 5$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ff100d228c022b49675dfca19807b03525c1726379cb8e9318d00633e86a63de.jpg",
+        "image_caption": [
+            "Figure 4: (a)(b): Example quality comparison between targeted Opt-attack and Boundary-attack . Opt-attack can achieve a better result with less queries. (c)(d): Some adversarial examples generated by Opt-attack . From initialization image (left), through several number of model queries, we could generate a adversarial example very close to original image (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            167,
+            813,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b922b95ee936522eb5588b3c32d8ea51577efbc1146331de2c9188b19e6d1b76.jpg",
+        "table_caption": [
+            "Table 2: Results of $L _ { 2 }$ -norm based) targeted attack. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">MNIST</td><td colspan=\"2\">CIFAR10</td></tr><tr><td>Avg L2</td><td># queries</td><td>Avg L2</td><td># queries</td></tr><tr><td rowspan=\"3\">Boundary-attack (black-box)</td><td>2.3158</td><td>30,103</td><td>0.2850</td><td>55,552</td></tr><tr><td>2.0052</td><td>58,508</td><td>0.2213</td><td>140,572</td></tr><tr><td>1.8668</td><td>192,018</td><td>0.2122</td><td>316,791</td></tr><tr><td rowspan=\"3\">Opt-attack (black-box)</td><td>1.8522</td><td>46,248</td><td>0.2758</td><td>61,869</td></tr><tr><td>1.7744</td><td>57,741</td><td>0.2369</td><td>141,437</td></tr><tr><td>1.7114</td><td>73,293</td><td>0.2300</td><td>186,753</td></tr><tr><td>C&amp;W (white-box)</td><td>1.4178</td><td>1</td><td>0.1901</td><td>1</td></tr></table>",
+        "bbox": [
+            245,
+            395,
+            753,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b6910f34432622e2d3bd2a6f069c141bea2ff28b9a0c7678d406e555f08e0dc8.jpg",
+        "table_caption": [
+            "Table 3: Results of targeted attacks in $L _ { \\infty }$ constraint. ASR stands for Attack Success Rate. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"3\">ImageNet (Inception V3)</td></tr><tr><td></td><td>E</td><td>ASR</td><td>Avg queries</td><td>Median queries</td></tr><tr><td rowspan=\"2\">Opt-attack</td><td>0.30</td><td>100%</td><td>167,080</td><td>119,925</td></tr><tr><td>0.15</td><td>90%</td><td>310,952</td><td>183,217</td></tr><tr><td rowspan=\"2\">Limited-attack</td><td>0.30</td><td>100%</td><td>436,561</td><td>295,918</td></tr><tr><td>0.15</td><td>50%</td><td>896,558</td><td>981,272</td></tr></table>",
+        "bbox": [
+            183,
+            574,
+            488,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7ae8ad32e7b9c64fa15c31b96f1226551914f3589a1f476605aba84066084498.jpg",
+        "table_caption": [
+            "Table 4: Results of $L _ { 2 }$ -norm based) untargeted attack on gradient boosting decision tree. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">HIGGS</td><td colspan=\"2\">MNIST</td></tr><tr><td></td><td>AvgL2</td><td>#queries</td><td>AvgL2</td><td>#queries</td></tr><tr><td rowspan=\"3\">Opt-attack</td><td>0.3458</td><td>4,229</td><td>0.6113</td><td>5,125</td></tr><tr><td>0.2179</td><td>11,139</td><td>0.5576</td><td>11,858</td></tr><tr><td>0.1704</td><td>29,598</td><td>0.5505</td><td>32,230</td></tr></table>",
+        "bbox": [
+            508,
+            574,
+            816,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 ATTACKING GRADIENT BOOSTING DECISION TREE (GBDT) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            650,
+            667
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our method’s ability to attack models with discrete decision functions, we conduct our untargeted attack on gradient booting decision tree (GBDT). In this experiment, we use two standard datasets: HIGGS (Baldi et al., 2014) for binary classification and MNIST (LeCun et al., 1998) for multi-class classification. We use popular LightGBM framework to train the GBDT models and use suggested parameters in https://github.com/Koziev/MNIST_Boosting. To be more specific, for MNIST model, it has 100 trees and the max number of leaves in each tree is 100. For Higgs model, it has 255 trees and the max number of leaves in each tree is 500. And we don’t limit the max depth on both models. We could achieve 0.8457 AUC for HIGGS and $9 8 . 0 9 \\%$ accuracy for MNIST. The results of untargeted attack on GBDT are given in Table 4. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            794
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 4, by using around 30K queries, we could get a small distortion on both datasets, which firstly uncovers the vulnerability of GBDT models. Tree-based methods are well-known for its good interpretability. And because of that, they are widely used in the industry. However, we show that even with good interpretability and a similar prediction accuracy with convolution neural network, the GBDT models are vulnerable under our Opt-attack. This result raises a question about tree-based models’ robustness, which will be an interesting direction in the future. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a generic and optimization-based hard-label black-box attack algorithm, which can be applied to discrete and non-continuous models other than neural networks, such as the gradient boosting decision tree. Our method enjoys query-efficiency and has a theoretical convergence guarantee on the attack performance under mild assumptions. Moreover, our attack achieves smaller or similar distortion using 3-4 times less queries compared with the state-of-the-art algorithms. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            195
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            212,
+            328,
+            224
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We acknowledge the support by NSF IIS1719097, Intel faculty award, Google Cloud and AITRICS. ",
+        "bbox": [
+            176,
+            234,
+            825,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            270,
+            285,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Moustafa Alzantot, Yash Sharma, Supriyo Chakraborty, and Mani Srivastava. Genattack: Practical black-box attacks with gradient-free optimization. arXiv preprint arXiv:1805.11090, 2018. ",
+        "bbox": [
+            174,
+            292,
+            825,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pierre Baldi, Peter Sadowski, and Daniel Whiteson. Searching for exotic particles in high-energy physics with deep learning. Nature communications, 5:4308, 2014. ",
+        "bbox": [
+            174,
+            330,
+            821,
+            359
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Arjun Nitin Bhagoji, Warren He, Bo Li, and Dawn Song. Exploring the space of black-box attacks on deep neural networks. arXiv preprint arXiv:1712.09491, 2017. ",
+        "bbox": [
+            173,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. arXiv preprint arXiv:1712.04248, 2017. ",
+        "bbox": [
+            174,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In Security and Privacy (SP), 2017 IEEE Symposium on, pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            173,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hongge Chen, Huan Zhang, Pin-Yu Chen, Jinfeng Yi, and Cho-Jui Hsieh. Attacking visual language grounding with adversarial examples: A case study on neural image captioning. In ACL, 2018a. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            571
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen, Yash Sharma, Huan Zhang, Jinfeng Yi, and Cho-Jui Hsieh. Ead: elastic-net attacks to deep neural networks via adversarial examples. In AAAI, 2018b. ",
+        "bbox": [
+            173,
+            582,
+            820,
+            611
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Minhao Cheng, Jinfeng Yi, Huan Zhang, Pin-Yu Chen, and Cho-Jui Hsieh. Seq2sick: Evaluating the robustness of sequence-to-sequence models with adversarial examples. CoRR, 2018. ",
+        "bbox": [
+            173,
+            619,
+            821,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew R Conn, Katya Scheinberg, and Luis N Vicente. Introduction to derivative-free optimization, volume 8. Siam, 2009. ",
+        "bbox": [
+            173,
+            656,
+            823,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            173,
+            694,
+            826,
+            737
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Saeed Ghadimi and Guanghui Lan. Stochastic first-and zeroth-order methods for nonconvex stochastic programming. SIAM Journal on Optimization, 23(4):2341–2368, 2013. ",
+        "bbox": [
+            174,
+            746,
+            823,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            176,
+            782,
+            823,
+            811
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            820,
+            825,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1804.08598, 2018. ",
+        "bbox": [
+            173,
+            871,
+            825,
+            900
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            909,
+            691,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. ICLR, 2017. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. ",
+        "bbox": [
+            173,
+            214,
+            823,
+            243
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Seyed Mohsen Moosavi Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), number EPFL-CONF-218057, 2016. ",
+        "bbox": [
+            176,
+            251,
+            823,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yurii Nesterov. Random gradient-free minimization of convex functions. Technical report, 2011. ",
+        "bbox": [
+            171,
+            303,
+            808,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yurii Nesterov and Vladimir Spokoiny. Random gradient-free minimization of convex functions. Foundations of Computational Mathematics, 17(2):527–566, 2017. ",
+        "bbox": [
+            171,
+            327,
+            823,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519. ACM, 2017. ",
+        "bbox": [
+            176,
+            363,
+            825,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            171,
+            414,
+            825,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            176,
+            452,
+            823,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chun-Chen Tu, Pai-Shun Ting, Pin-Yu Chen, Sijia Liu, Huan Zhang, Jinfeng Yi, Cho-Jui Hsieh, and Shin-Ming Cheng. Autozoom: Autoencoder-based zeroth order optimization method for attacking black-box neural networks. CoRR, abs/1805.11770, 2018. ",
+        "bbox": [
+            176,
+            502,
+            821,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.1 MEDIAN RESULT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            331,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/1f91c62d3a952beb2dca06577ae6777f07d2a08b62c2b5e912fc7102a0da072a.jpg",
+        "table_caption": [
+            "Table 5: Results of median L2 distortion on different attack methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Type</td><td colspan=\"2\">MNIST</td><td colspan=\"2\">CIFAR10</td><td colspan=\"2\">Imagenet (ResNet-50)</td></tr><tr><td>Median L2</td><td>#queries</td><td>Median L2</td><td># queries</td><td>Median L2</td><td># queries</td></tr><tr><td rowspan=\"2\">Boundary-attack</td><td>Untargeted</td><td>1.0832</td><td>142.686</td><td>0.1359</td><td>235,285</td><td>2.7879</td><td>261,258</td></tr><tr><td>Targeted</td><td>1.8004</td><td>171,151</td><td>0.1962</td><td>314,839</td><td>1</td><td>-</td></tr><tr><td rowspan=\"2\">Opt-attack</td><td>Untargeted</td><td>1.0206</td><td>127,077</td><td>0.1344</td><td>159,276</td><td>2.0687</td><td>246,755</td></tr><tr><td>Targeted</td><td>1.7375</td><td>72,318</td><td>0.2020</td><td>158,438</td><td>1</td><td>1</td></tr></table>",
+        "bbox": [
+            176,
+            189,
+            839,
+            277
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.2 RESULTS ON DIFFERENT NUMBER OF SAMPLE DIRECTIONS $u _ { t }$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            638,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab96a18f2dea70f20322ae297a3f978926ec6d63548759f986f9d118968e3f45.jpg",
+        "table_caption": [
+            "Table 6: Results of average L2 distortion on different number of sample directions $u _ { t }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"5\">MNIST</td></tr><tr><td># of directions Ut</td><td>Average L2</td><td>Average # queries</td><td>Median L2</td><td>Median # queries</td></tr><tr><td rowspan=\"5\">Opt-attack</td><td>1</td><td>2.0525</td><td>9,820 2.0188</td><td>8,093</td></tr><tr><td>5</td><td>1.0550</td><td>59,901 1.0639</td><td>56,890</td></tr><tr><td>10</td><td>1.0345</td><td>63,652 1.0420</td><td>62,209</td></tr><tr><td>15</td><td>1.0257</td><td>71,045</td><td>1.0256 73,227</td></tr><tr><td>20</td><td>1.0112</td><td>126,486</td><td>1.0206</td></tr><tr><td>25</td><td>1.0098</td><td>146,516</td><td>1.0117</td><td>127,077 145,862</td></tr></table>",
+        "bbox": [
+            173,
+            362,
+            854,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/b606049498856b759e3ee03ed56850e8cc171e9ea515a218157a174d696f7dcb.jpg",
+        "image_caption": [
+            "Figure 5: Left:Log distortion comparison of Boundary-attack (solid curves) vs Opt-attack (dotted curves) over number of queries for 6 different images. Right: Average L2-distortion versus number of queries plot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            558,
+            789,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.4 THEORETICAL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            811,
+            392,
+            827
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "If $g ( \\pmb \\theta )$ can be computed exactly, it has been proved in Nesterov & Spokoiny (2017) that RGF in Algorithm 2 requires at most $O ( \\textstyle { \\frac { d } { \\delta ^ { 2 } } } )$ iterations to converge to a point with $\\lVert \\nabla g ( \\pmb { \\theta } ) \\rVert ^ { 2 } \\leq \\delta ^ { 2 }$ . However, in our algorithm the function value $g ( \\pmb \\theta )$ cannot be computed exactly; instead, we compute it up to $\\epsilon$ -precision, and this precision can be controlled by binary threshold in Algorithm 1. We thus extend the proof in Nesterov & Spokoiny (2017) to include the case of approximate function value evaluation, as described in the following theorem. ",
+        "bbox": [
+            173,
+            838,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 In Algorithm 2, suppose g has Lipschitz-continuous gradient with constant $L _ { 1 } ( g )$ and $g ^ { * }$ (optimal value) is finite. If the error of function value evaluation is controlled by $\\epsilon = \\dot { O } ( \\beta \\delta ^ { 2 } )$ and $\\begin{array} { r } { \\beta \\le \\frac { \\delta } { d L _ { 1 } ( g ) } } \\end{array}$ , then in order to obtain $\\frac { 1 } { N + 1 } \\sum _ { k = 0 } ^ { N } E \\chi _ { k } ( \\| \\nabla g ( \\pmb { \\theta } _ { k } ) \\| ^ { 2 } ) \\leq \\delta ^ { 2 }$ , the upper bound of total number of iterations is $O ( \\textstyle { \\frac { d } { \\delta ^ { 2 } } } )$ . ",
+        "bbox": [
+            173,
+            102,
+            826,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Note that the binary search procedure could obtain the desired function value precision in ${ \\cal O } ( \\log \\delta )$ steps. By using the same idea with Theorem 1 and following the proof in Nesterov & Spokoiny (2017), we could also achieve $\\begin{array} { r } { O \\big ( \\frac { d ^ { 2 } } { \\delta ^ { 3 } } \\big ) } \\end{array}$ complexity when $g ( \\pmb \\theta )$ is non-smooth but Lipschitz continuous. ",
+        "bbox": [
+            173,
+            209,
+            826,
+            257
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Because there is a stopping criterion in Algorithm 1, we couldn’t achieve the exact $g ( \\pmb \\theta )$ . Instead, we could get $\\tilde { g }$ with $\\epsilon$ error, i.e., $g ( \\pmb \\theta ) - \\epsilon \\leq \\tilde { g } ( \\pmb \\theta ) \\leq g ( \\pmb \\theta ) + \\epsilon$ . Also, we define $\\begin{array} { r } { \\hat { \\pmb g } ( \\pmb \\theta ) = \\frac { \\tilde { g } ( \\pmb \\theta + \\beta \\pmb u ) - \\tilde { g } ( \\pmb \\theta ) } { \\beta } \\cdot \\pmb u } \\end{array}$ to be the noise gradient estimator. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            311
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Following Nesterov (2011), we define the Guassian smoothing approximation over $g ( \\theta )$ , i.e, ",
+        "bbox": [
+            171,
+            318,
+            779,
+            333
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31c60e39ae521537448a9064c5c93d612c469bac7b91ef1dd936ae1c00fe7120.jpg",
+        "text": "$$\ng _ { \\beta } ( \\theta ) = \\frac { 1 } { \\kappa } \\int _ { E } g ( \\theta + \\beta u ) e ^ { - \\frac { 1 } { 2 } | | u | | ^ { 2 } } d u .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            332,
+            622,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Also, we have the upper bounds for the moments $\\begin{array} { r } { M _ { p } = \\frac { 1 } { \\kappa } \\int _ { E } | | u | | ^ { p } e ^ { - \\frac { 1 } { 2 } | | u | | ^ { 2 } } d u } \\end{array}$ from Nesterov (2011) Lemma 1. ",
+        "bbox": [
+            173,
+            363,
+            823,
+            395
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For $p \\in [ 0 , 2 ]$ , we have ",
+        "bbox": [
+            173,
+            398,
+            326,
+            415
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "If $p \\geq 2$ , we have two-sided bounds ",
+        "bbox": [
+            174,
+            429,
+            410,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f92fe9c940442f667986307d40c8729a096042087840eced8d30a71f716229bc.jpg",
+        "text": "$$\n\\begin{array} { c } { { M _ { p } \\leq d ^ { p / 2 } . } } \\\\ { { } } \\\\ { { n ^ { p / 2 } \\leq M _ { p } \\leq ( p + n ) ^ { p / 2 } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            411,
+            588,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Suppose f has a lipschitz-continuous gradient with constant $L _ { 1 } ( g )$ , then ",
+        "bbox": [
+            174,
+            556,
+            642,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0667de958064abb0273ba2f6dc111652af5b74d49b2e3f74bbb03ffaef3d240.jpg",
+        "text": "$$\n| g ( y ) - g ( x ) - \\langle \\nabla g ( x ) , y - x \\rangle | \\leq \\frac { 1 } { 2 } L _ { 1 } ( g ) | | x - y | | ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            570,
+            674,
+            599
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We could bound $E _ { u } ( | | \\hat { g } ( \\pmb { \\theta } ) | | ^ { 2 } )$ as follows, ",
+        "bbox": [
+            174,
+            597,
+            449,
+            613
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Since ",
+        "bbox": [
+            173,
+            619,
+            214,
+            632
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66b74aee1ebb46d8b2a4aa1530a100add70985dca55cd8a94bdc0d7c4b16affa.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\overset { \\mathrm { r u n s e } } { ( \\bar { g } ( \\theta + \\beta u ) - \\tilde { g } ( \\theta ) ) ^ { 2 } } = [ \\bar { g } ( \\theta + \\beta u ) - \\tilde { g } ( \\theta ) - \\beta \\langle \\nabla g ( \\theta ) , u \\rangle + \\beta \\langle \\nabla g ( \\theta ) , u \\rangle ] ^ { 2 } } \\\\ & { \\qquad \\leq 2 ( g ( \\theta + \\beta u ) - g ( \\theta ) + \\epsilon _ { \\theta + \\beta u } - \\epsilon _ { \\theta } - \\beta \\langle \\nabla g ( \\theta ) , u \\rangle ) ^ { 2 } + 2 \\beta ^ { 2 } \\langle \\nabla g ( \\theta ) , u \\rangle ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            627,
+            820,
+            670
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Because $| \\epsilon _ { \\pmb { \\theta } + \\beta u } - \\epsilon _ { \\pmb { \\theta } } | \\leq 2 \\epsilon$ , ",
+        "bbox": [
+            173,
+            679,
+            361,
+            694
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ebf0bd0d3aa9aaa9dfddbf1e7c0d8d183e29a9e4ecc4e89a503d092e5bff596f.jpg",
+        "text": "$$\n[ \\tilde { g } ( \\pmb { \\theta } + \\beta u ) - \\tilde { g } ( \\pmb { \\theta } ) ] ^ { 2 } \\leq 2 ( \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ( g ) | | u | | ^ { 2 } ) ^ { 2 } + 4 \\beta ^ { 2 } L _ { 1 } ( g ) | | u | | ^ { 2 } \\epsilon + 8 \\epsilon ^ { 2 } + 2 \\beta ^ { 2 } \\langle \\nabla g ( \\pmb { \\theta } ) , u \\rangle ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            693,
+            776,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Take expectation over $\\mathbf { u }$ , and with Theorem 3 in Nesterov (2011), which is $E _ { u } ( | | g ^ { \\prime } ( \\pmb \\theta , u ) \\cdot u | | ^ { 2 } ) \\leq$ (d + 4)||∇g(θ)||2 ",
+        "bbox": [
+            173,
+            724,
+            833,
+            751
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/572530f30dca56d58f4531ae633bfd35841f35a1bc78b57fa700f81831fb94c2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle \\Xi ^ { - \\gamma } | | \\boldsymbol { \\nabla } \\boldsymbol { y } \\boldsymbol { \\cup } \\boldsymbol { \\sigma } \\boldsymbol { \\jmath } | | } \\\\ & { \\displaystyle \\Xi _ { u } \\big ( | | \\hat { g } ( \\pmb { \\theta } ) | | ^ { 2 } \\big ) \\leq \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) E _ { u } \\big ( | | u | | ^ { 6 } ) + 2 E _ { u } \\big ( | | g ^ { \\prime } ( \\pmb { \\theta } , u ) \\cdot u | | ^ { 2 } \\big ) + 4 L _ { 1 } ( g ) \\epsilon E _ { u } \\big ( | | u | | ^ { 4 } \\big ) + 8 \\frac { \\epsilon ^ { 2 } } { \\beta ^ { 2 } } E _ { u } \\big ( | | u | | ^ { 2 } \\big ) } \\\\ & { \\displaystyle \\qquad \\leq \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) | | \\boldsymbol { \\nabla } g ( \\pmb { \\theta } ) | | ^ { 2 } + 4 \\epsilon L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } + 8 \\frac { \\epsilon ^ { 2 } } { \\beta ^ { 2 } } d } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            744,
+            834,
+            819
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "With $\\epsilon = O ( \\delta ^ { 2 } \\beta )$ , we could bound $E _ { u } ( | | \\tilde { g } ( \\pmb { \\theta } ) | | ^ { 2 } )$ ",
+        "bbox": [
+            174,
+            828,
+            496,
+            843
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e3f475624fa40cf5b8d0608bb43ac4e5672c290b7393ff164b8903eb94cadc6.jpg",
+        "text": "$$\nE _ { u } ( | | \\hat { g } ( \\pmb { \\theta } ) | | ^ { 2 } ) \\leq \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) | | \\nabla g ( \\pmb { \\theta } ) | | ^ { 2 } + 4 \\beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \\delta ^ { 2 } + 8 d \\delta ^ { 4 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            844,
+            774,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "And with ",
+        "bbox": [
+            173,
+            871,
+            238,
+            885
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32132ee7bb32e7ffda6fdbf3e5b3861bef3e84121797bb538716f6936dd81d27.jpg",
+        "text": "$$\n| | \\nabla g ( \\pmb \\theta ) | | ^ { 2 } \\leq 2 | | \\nabla g _ { \\beta } ( \\pmb \\theta ) | | ^ { 2 } + \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 4 ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            881,
+            656,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Which is proved in Nesterov (2011) Lemma 4. ",
+        "bbox": [
+            173,
+            909,
+            483,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Therefore, since $( n + 6 ) ^ { 3 } + 2 ( n + 4 ) ^ { 3 } \\leq 3 ( n + 5 ) ^ { 3 }$ , we could get ",
+        "bbox": [
+            171,
+            102,
+            611,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/63a054530db6c3f85c535f8cdb20c41bf56f577d9d1403e3676b4cd56efcba18.jpg",
+        "text": "$$\n\\begin{array} { l } { { E _ { u } ( | | \\hat { g } ( \\pmb { \\theta } ) | | ^ { 2 } ) \\le \\displaystyle \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) | | \\nabla g ( \\pmb { \\theta } ) | | ^ { 2 } + 2 ( d + 4 ) | | \\nabla g ( \\pmb { \\theta } ) | | ^ { 2 } } } \\\\ { { \\displaystyle ~ + 4 \\beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \\delta ^ { 2 } + 8 d \\delta ^ { 4 } } } \\\\ { { \\displaystyle ~ \\le \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 6 ) ^ { 3 } + 2 ( d + 4 ) ( 2 | | \\nabla g _ { \\beta } ( \\pmb { \\theta } ) | | ^ { 2 } + \\frac { \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 4 ) ^ { 2 } ) } } \\\\ { { \\displaystyle ~ + 4 \\beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \\delta ^ { 2 } + 8 d \\delta ^ { 4 } } } \\\\ { { \\displaystyle ~ \\le 4 ( d + 4 ) | | \\nabla g _ { \\beta } ( x ) | | ^ { 2 } + \\frac { 3 \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 5 ) ^ { 3 } + 4 \\beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \\delta ^ { 2 } + 8 d \\delta ^ { 4 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            121,
+            789,
+            255
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Therefore, since $g _ { \\beta } ( \\pmb \\theta )$ has Lipshcitz-continuous gradient: ",
+        "bbox": [
+            174,
+            258,
+            555,
+            273
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6872928b33039a1f7210c0f0621c7189be7b5ced43a80ac9b494dddb87db34b9.jpg",
+        "text": "$$\n| g _ { \\beta } ( \\pmb { \\theta } _ { k + 1 } ) - g _ { \\beta } ( \\pmb { \\theta } _ { k } ) + \\alpha \\langle \\nabla g _ { \\beta } ( \\pmb { \\theta } _ { k } ) , \\hat { g } _ { \\beta } ( \\pmb { \\theta } _ { k } ) \\rangle | \\leq \\frac { 1 } { 2 } \\alpha ^ { 2 } L _ { 1 } ( g _ { \\beta } ) | | \\hat { g } _ { \\beta } ( \\pmb { \\theta } _ { k } ) | | ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            272,
+            735,
+            301
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "So that ",
+        "bbox": [
+            173,
+            297,
+            223,
+            313
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89f47e5e187480ac11aac5d7870adcac999c859cf44c65dcccaa23ba011478d1.jpg",
+        "text": "$$\ng _ { \\beta } ( \\pmb \\theta _ { k + 1 } ) \\leq g _ { \\beta } ( \\pmb \\theta _ { k } ) - \\alpha \\langle \\nabla g _ { \\beta } ( \\pmb \\theta _ { k } ) , \\hat { g } _ { \\beta } ( \\pmb \\theta _ { k } ) \\rangle + \\frac { 1 } { 2 } \\alpha ^ { 2 } L _ { 1 } ( g _ { \\beta } ) | | \\hat { g } _ { \\beta } ( \\pmb \\theta _ { k } ) | | ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            308,
+            730,
+            338
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Since ",
+        "bbox": [
+            173,
+            335,
+            214,
+            349
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e38c43f66fd1db66059f8317e80b8f55129845e890e35c5b2c96d90bf55484bd.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle E _ { u } ( \\hat { g } ( \\pmb \\theta _ { k } ) ) = \\frac { 1 } { \\kappa } \\int _ { E } \\frac { g ( \\pmb \\theta + \\beta u ) - g ( \\pmb \\theta ) + \\epsilon _ { \\theta + \\beta u } - \\epsilon _ { \\theta } } { \\beta } u e ^ { - \\frac { 1 } { 2 } | | u | | ^ { 2 } } d u } \\\\ { \\displaystyle \\quad \\quad = \\nabla g _ { \\beta } ( \\pmb \\theta _ { k } ) + \\frac { 1 } { \\kappa } \\int _ { E } \\frac { \\epsilon _ { \\theta + \\beta u } - \\epsilon _ { \\theta } } { \\beta } u e ^ { - \\frac { 1 } { 2 } | | u | | ^ { 2 } } d u } \\\\ { \\displaystyle \\quad \\quad \\leq \\nabla g _ { \\beta } ( \\pmb \\theta _ { k } ) + \\frac { 2 \\epsilon } { \\beta } n ^ { 1 / 2 } \\cdot \\mathbb { 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            337,
+            722,
+            445
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 }$ is a all-one vector. Taking the expectation in $u _ { k }$ , we obtain ",
+        "bbox": [
+            173,
+            443,
+            620,
+            457
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42b5355337e2d571da4e27db0da01a90a2305095653904e3d7adde6d0ed2dd5f.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\Xi _ { u _ { k } } ( g _ { \\beta } ( { \\pmb \\theta } _ { k + 1 } ) ) \\le g _ { \\beta } ( { \\pmb \\theta } _ { k } ) - \\alpha _ { k } \\| \\nabla g _ { \\beta } ( { \\pmb \\theta } _ { k } ) \\| ^ { 2 } + \\alpha _ { k } \\langle \\nabla g _ { \\beta } ( { \\pmb \\theta } _ { k } ) , \\frac { 2 \\epsilon } { \\beta } d ^ { 1 / 2 } \\cdot \\mathbb { 1 } \\rangle + \\frac { 1 } { 2 } \\alpha _ { k } ^ { 2 } L _ { 1 } ( g _ { \\beta } ) E _ { u _ { k } } \\| \\hat { g } _ { \\beta } ( { \\pmb \\theta } _ { k } ) } } \\\\ { { \\displaystyle \\Xi _ { u _ { k } } ( g _ { \\beta } ( { \\pmb \\theta } _ { k + 1 } ) ) \\le g _ { \\beta } ( { \\pmb \\theta } _ { k } ) - \\alpha _ { k } \\| \\nabla g _ { \\beta } ( { \\pmb \\theta } _ { k } ) \\| ^ { 2 } + \\alpha _ { k } \\frac { 2 \\epsilon } { \\beta } n ^ { 1 / 2 } \\| \\nabla g _ { \\beta } ( { \\pmb \\theta } _ { k } ) \\| } } \\\\ { { \\displaystyle \\qquad + \\frac { 1 } { 2 } \\alpha _ { k } ^ { 2 } L _ { 1 } ( g ) ( 4 ( d + 4 ) \\| \\nabla g _ { \\beta } ( { \\pmb \\theta } _ { k } ) \\| ^ { 2 } + \\frac { 3 \\beta ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) ( d + 5 ) ^ { 3 } + 4 \\beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } \\delta ^ { 2 } + 8 \\beta L _ { 1 } ( g ) ( d + 4 ) ^ { 2 } ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            455,
+            839,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Choosing $\\begin{array} { r } { \\alpha _ { k } = \\hat { \\alpha } = \\frac { 1 } { 4 ( d + 4 ) L _ { 1 } ( g ) } } \\end{array}$ , we obtain ",
+        "bbox": [
+            173,
+            560,
+            464,
+            580
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d673ac4ebe8985d6917e69d812abf6c2ac2e0c25d11c35b0bb17bc30392d0d4b.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle E _ { u _ { k } } \\big ( g _ { \\beta } \\big ( \\theta _ { k } + 1 \\big ) \\big ) \\le g _ { \\beta } \\big ( \\theta _ { k } \\big ) - \\frac 1 2 \\hat { \\alpha } \\big | | \\nabla g _ { \\beta } \\big ( \\theta _ { k } \\big ) | | ^ { 2 } + \\hat { \\alpha } \\frac { 2 \\epsilon } { \\beta } d ^ { 1 / 2 } | | \\nabla g _ { \\beta } \\big ( \\theta _ { k } \\big ) | | + \\frac { 3 \\beta ^ { 2 } } { 6 4 } L _ { 1 } ( g ) \\frac { ( d + 5 ) ^ { 3 } } { ( d + 4 ) ^ { 2 } } } } \\\\ { { \\displaystyle \\qquad + \\frac { \\beta } { 8 } \\delta ^ { 2 } + \\frac { d } { 4 ( d + 4 ) ^ { 2 } L _ { 1 } ( g ) } \\delta ^ { 4 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            578,
+            810,
+            648
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(22) Since $( d + 5 ) ^ { 3 } \\leq ( d + 8 ) ( d + 4 ) ^ { 2 }$ , taking expectation over $\\mathcal { U } _ { k }$ , where ${ \\mathcal { U } } _ { k } = \\{ u _ { 1 } , u _ { 2 } , \\ldots , u _ { k } \\}$ , we get $\\begin{array} { r } { \\displaystyle { \\mathfrak { s } } _ { k + 1 } \\leq \\phi _ { k } - \\frac { 1 } { 2 } \\hat { \\alpha } E \\mu _ { k } ( \\| \\nabla g _ { \\beta } ( \\pmb { \\theta } _ { k } ) \\| ^ { 2 } ) + \\frac { 3 \\bar { \\beta } ^ { 2 } ( \\bar { d } + 8 ) } { 6 4 } L _ { 1 } ( g ) + \\frac { \\beta } { 8 } \\delta ^ { 2 } + \\frac { d } { 4 ( d + 4 ) ^ { 2 } L _ { 1 } ( g ) } \\delta ^ { 4 } + \\hat { \\alpha } d ^ { 1 / 2 } E _ { \\mathcal { U } _ { k } } ( \\| \\nabla g _ { \\beta } ( \\pmb { \\theta } _ { k } ) \\| ^ { 2 } ) + \\frac { 3 \\bar { \\beta } ^ { 2 } ( \\bar { d } + 8 ) } { 4 } L _ { 1 } ( g ) } \\end{array}$ β(θk)||)δ2 ",
+        "bbox": [
+            174,
+            654,
+            906,
+            705
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Where $\\phi _ { k } = E _ { \\mathcal { U } _ { k - 1 } ( g ( \\pmb { \\theta } _ { k } ) ) } , k \\geq 1$ and $\\phi _ { 0 } = g ( \\theta _ { 0 } )$ ",
+        "bbox": [
+            174,
+            715,
+            504,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Assuming $g ( x ) \\geq g ^ { * }$ , summing over $\\mathbf { k }$ and divided by $_ { \\mathrm { N + 1 } }$ , we get ",
+        "bbox": [
+            173,
+            738,
+            614,
+            753
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7efd7de29aac20ee393857a17e6f001343241691062290da944d86df4d317f56.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\frac { 1 } { N + 1 } \\sum _ { k = 0 } ^ { N } E _ { \\mathcal { U } _ { k } } ( | | \\nabla g _ { \\beta } ( \\theta _ { k } ) | | ^ { 2 } ) \\le 8 ( d + 4 ) L _ { 1 } ( g ) [ \\frac { g ( x _ { 0 } ) - g ^ { * } } { N + 1 } + \\frac { 3 \\beta ^ { 2 } ( d + 8 ) } { 1 6 } L _ { 1 } ( g ) + \\frac { \\beta } { 8 } \\delta ^ { 2 } } \\\\ { \\displaystyle \\qquad + \\frac { d } { 4 ( d + 4 ) ^ { 2 } L _ { 1 } ( g ) } \\delta ^ { 4 } + \\frac { 1 } { N + 1 } \\sum _ { k = 0 } ^ { N } E _ { \\mathcal { U } _ { k } } ( | | \\nabla g _ { \\beta } ( \\theta _ { k } ) | | ) \\delta ^ { 2 } ] } \\\\ { \\displaystyle \\mathrm { l e a r l y , ~ } \\frac { 1 } { N + 1 } \\sum _ { k = 0 } ^ { N } E _ { \\mathcal { U } _ { k } } ( | | \\nabla g _ { \\beta } ( \\theta _ { k } ) | | ) \\le \\delta ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            755,
+            784,
+            876
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$E _ { \\mathcal { U } _ { k } } ( | | \\nabla g _ { \\beta } ( \\pmb { \\theta } _ { k } ) | | ^ { 2 } )$ $\\begin{array} { r } { \\vartheta _ { k } ^ { 2 } = E _ { \\mathcal { U } _ { k } } ( | | \\nabla g ( \\pmb { \\theta } _ { k } ) | | ^ { 2 } ) \\leq 2 E _ { \\mathcal { U } _ { k } } ( | | \\nabla g _ { \\beta } ( \\pmb { \\theta } _ { k } ) | | ^ { 2 } ) + \\frac { \\beta ^ { 2 } ( d + 4 ) ^ { 2 } } { 2 } L _ { 1 } ^ { 2 } ( g ) , \\vartheta } \\end{array}$ $\\frac { 1 } { N + 1 } \\sum _ { k = 0 } ^ { N } \\vartheta _ { k } ^ { 2 } \\leq \\delta ^ { 2 }$ β2(d+4)22 L21(g), ϑ2k is in the same order of $\\begin{array} { r } { \\beta \\le \\frac { \\delta } { d L _ { 1 } ( g ) } } \\end{array}$ , then $_ \\mathrm { N }$ is bounded by $O ( \\textstyle { \\frac { d } { \\delta ^ { 2 } } } )$ ",
+        "bbox": [
+            173,
+            99,
+            826,
+            172
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJrTwxbCb/rJrTwxbCb.md

@@ -0,0 +1,249 @@
+# EMPIRICAL ANALYSIS OF THE HESSIAN OF OVERPARAMETRIZED NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We study the properties of common loss surfaces through their Hessian matrix. In particular, in the context of deep learning, we empirically show that the spectrum of the Hessian is composed of two parts: (1) the bulk centered near zero, (2) and outliers away from the bulk. We present numerical evidence and mathematical justifications to the following conjectures laid out by Sagun et al. (2016): Fixing data, increasing the number of parameters merely scales the bulk of the spectrum; fixing the dimension and changing the data (for instance adding more clusters or making the data less separable) only affects the outliers. We believe that our observations have striking implications for non-convex optimization in high dimensions. First, the flatness of such landscapes (which can be measured by the singularity of the Hessian) implies that classical notions of basins of attraction may be quite misleading. And that the discussion of wide/narrow basins may be in need of a new perspective around over-parametrization and redundancy that are able to create large connected components at the bottom of the landscape. Second, the dependence of a small number of large eigenvalues to the data distribution can be linked to the spectrum of the covariance matrix of gradients of model outputs. With this in mind, we may reevaluate the connections within the data-architecturealgorithm framework of a model, hoping that it would shed light on the geometry of high-dimensional and non-convex spaces in modern applications. In particular, we present a case that links the two observations: small and large batch gradient descent appear to converge to different basins of attraction but we show that they are in fact connected through their flat region and so belong to the same basin.
+
+# 1 INTRODUCTION
+
+In this paper, we study the geometry of the loss surface of supervised learning problems through the lens of their second order properties. To introduce the framework, suppose we are given data in the form of input-label pairs, $\mathbf { \dot { \mathcal { D } } } = \{ ( x ^ { i } , y ^ { i } ) \} _ { i = 1 } ^ { N }$ where $x \in \mathbb { R } ^ { d }$ and $y \in \mathbb R$ that are sampled i.i.d. from a possibly unknown distribution $\nu$ , a model that is parametrized by $w \in \mathbb { R } ^ { M }$ ; so that the number of examples is $N$ and the number of parameters of the system is $M$ . Suppose also that there is a predictor $f ( w , x )$ . The supervised learning process aims to solve for $w$ so that $f ( w , x ) \approx y$ . To make the $\cdot \approx$ precise, we use a non-negative loss function that measures how close the predictor is to the true label, $\ell ( f ( w , x ) , y )$ . We wish to find a parameter $w ^ { * }$ such that $w ^ { * } = \arg \operatorname* { m i n } \mathcal { L } ( w )$ where,
+
+$$
+\mathcal { L } ( w ) : = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \ell ( f ( w , x ^ { i } ) , y ^ { i } ) .
+$$
+
+In particular, one is curious about the relationship between $\mathcal { L } ( w )$ and $\begin{array} { r } { \hat { \mathcal { L } } ( w ) : = \int \ell d ( \nu ) } \end{array}$ . By the law of large numbers, at a given point $w$ , $\mathcal { L } _ { w } \to \hat { \mathcal { L } } _ { w }$ almost surely as $N  \infty$ for fixed $M$ . However in modern applications, especially in deep learning, the number of parameters $M$ is comparable to the number of examples $N$ (if not much larger). And the behaviour of the two quantities may be drastically different (for a recent analysis on provable estimates see (Mei et al., 2016)).
+
+A classical algorithm to find $w ^ { * }$ is gradient descent (GD), in which the optimization process is carried out using the gradient of $\mathcal { L }$ . A new parameter is found iteratively by taking a step in the direction of the negative gradient whose size is scaled with a constant step size $\eta$ that is chosen from line-search minimization. Two problems emerge: (1) Gradient computation can be expensive, (2) Line-search can be expensive. More involved algorithms, such as Newton-type methods, make use of second-order information (Nocedal & Wright, 2006). Under sufficient regularity conditions we may observe: $\mathcal { L } ( w + \Delta w ) \approx \mathcal { L } ( w ) + \Delta w \nabla \mathcal { L } ( \bar { w } ) + \Delta w ^ { T } \nabla ^ { 2 } \mathcal { L } ( w ) \Delta w$ . A third problem emerges beyond an even more expansive computational cost of the Hessian: (3) Most methods require the Hessian to be non-degenerate to a certain extent.
+
+When the gradients are computationally expensive, one can alternatively use its stochastic version (SGD) that replaces the above gradient with the gradient of averages of losses over subsets (such a subset will be called the mini-batch) of $\mathcal { D }$ (see (Bottou, 2010) for a classical reference). The benefit of SGD on real-life time limits is obvious, and GD may be impractical for practical purposes in many problems. In any case, the stochastic gradient can be seen as an approximation to the true gradient, and hence it is important to understand how the two directions are related to one another. Therefore, the discussion around the geometry of the loss surface can be enlightening in the comparison of the two algorithms: Does SGD locate solutions of a different nature than GD? Do they follow different paths? If so, which one is better in terms of generalization performance?
+
+For the second problem of expensive line-search, there are two classical solutions: using a small, constant step size, or scheduling the step size according to a certain rule. In practice, in the context of deep learning, the values for both approaches are determined heuristically, by trial and error. More involved optimal step size choices involve some kind of second-order information that can be obtained from the Hessian of the loss function (Schaul et al., 2013). From a computational point of view, obtaining the Hessian is extremely expensive, however obtaining some of its largest and smallest eigenvalues and eigenvectors are not that expensive. Is it enough to know only those eigenvalues and eigenvectors that are large in magnitude? How do they change through training? Would such a method work in SGD as well as it would on GD?
+
+For the third problem, let’s look at the Hessian a little closer. A critical point is defined by $w$ such that $| | \nabla \mathcal { L } ( w ) | | = 0$ and the nature of it can be determined by looking at the signs of its Hessian matrix. If all eigenvalues are positive the point is called a local minimum, if $r$ of them are negative and the rest are positive, then it is called a saddle point with index $r$ . At the critical point, the eigenvectors indicate the directions in which the value of the function locally changes. Moreover, the changes are proportional to the corresponding -signed- eigenvalue. Under sufficient regularity conditions, it is rather straightforward to show that gradient-based methods converge to points where the gradient is zero. Recently Lee et al. (2016) showed that they indeed converge to minimizers. However, a significant and untested assumption to establish these convergence results is that the Hessian of the loss is non-degenerate. A relaxation of the above convergence to the case of non-isolated critical points can be found in (Panageas & Piliouras, 2016). What about the critical points of machine learning loss functions? Do they satisfy the non-degeneracy assumptions? If they don’t, can we still apply the results of provable theorems to gain intuition?
+
+# 1.1 A HISTORICAL OVERVIEW
+
+One of the first instances of the comparison of GD and SGD in the context of neural networks dates back to the late eighties and early nineties. Bottou (1991) points out that large eigenvalues of the Hessian of the loss can create the illusion of the existence of local minima and GD can get stuck there, it further claims that the help of the inherent noise in SGD may help to get out of this obstacle. The origin of this observation is due to Bourrely (1989), as well as numerical justifications. However, given the computational limits of the time, these experiments relied on low-dimensional neural networks with few hidden units. The picture may be drastically different in higher dimensions. In fact, provable results in statistical physics tell us that, in certain real-valued non-convex functions, the local minima concentrate at an error level near that of the global minima. A theoretical review on this can be found in (Auffinger et al., 2013), while Sagun et al. (2014) and Ballard et al. (2017) provide an experimental simulation as well as a numerical study for neural networks. They notably find that high error local minima traps do not appear when the model is over-parametrized.
+
+These concentration results can help explain why we find that the solutions attained by different optimizers like GD and SGD often have comparable training accuracies. However, while these methods find comparable solutions in terms of training error there is no guarantee they generalize equally. A recent work in this direction compares the generalization performance of small batch and large batch methods (Keskar et al., 2016). They demonstrate that the large batch methods always generalize a little bit worse even when they have similar training accuracies. The paper further makes the observation that the basins found by small batch methods are wider, thereby contributing to the claim that wide basins, as opposed to narrow ones, generalize better.
+
+The final part of the historical account is devoted to the observation of flatness of the landscape in neural networks and its consequences through the lens of the Hessian. In the early nineties, Hochreiter & Schmidhuber (1997) remarks that there are parts of the landscape in which the weights can be perturbed without significantly changing the loss value. Such regions at the bottom of the landscape are called the flat minima, which can be considered as another way of saying a very wide minima. It is further noted that such minima have better generalization properties and a new loss function that makes use of the Hessian of the loss function has been proposed that targets the flat minima. The computational complexity issues have been attempted to be resolved using the $R$ -operator of Pearlmutter (1994). However, the new loss requires all the entries of the Hessian, and even with the $R$ -operator, it is unimaginably slow for today’s large networks. More recently, an exact numerical calculation of the Hessian has been carried out by Sagun et al. (2016). It turns out that the Hessian can have near zero eigenvalues even at a given random initial point, and that the spectrum of it is composed of two parts: (1) the bulk, and (2) the outliers. The bulk is mostly full of zero eigenvalues with a fast decaying tail, and the outliers are only a handful which appears to depend on the data. This implies that, locally, most directions in the weight space are flat, and leads to little or no change in the loss value, except for the directions of eigenvectors that correspond to the large eigenvalues of the Hessian.
+
+# 1.2 OVERVIEW OF RESULTS
+
+In this work, we present a phenomenological study in which we provide various observations on the local geometry at the bottom of the landscape and discuss their implications on certain features of solution spaces: Connectedness of basins found by large and small batch methods.
+
+1. Flatness at the bottom of the landscape: At the bottom, most of the eigenvalues in the spectrum of the Hessian are near zero, except for a small number of relatively larger ones.   
+2. A possible explanation through over-parametrization: The decomposition of the Hessian as a sum of two matrices, where the first one is the sample covariance matrix of the gradients of model outputs and the second one is the Hessian of the function that describes the model outputs. We argue that the second term can be ignored as training progress which leaves us with the covariance term which leads to degeneracy in the Hessian when there are more parameters than samples.   
+3. Dependence of eigenvalues to model-data-algorithm: We empirically examine the spectrum to uncover intricate dependencies within the data-architecture-algorithm triangle: (1) more complex data produce more outliers, (2) increasing the network size doesn’t affect the density of large eigenvalues, (3) large batch methods produce the same number of outliers that are larger in magnitude, and finally (4) there are negative eigenvalues even after the training process appears to show no further progress but their magnitude is much smaller than the outliers.   
+4. A new interpretation of basins: It has been a common practice to discuss certain features of basins found by various algorithms. Some recent examples, such as Keskar et al. (2016); Chaudhari et al. (2016); Jastrz˛ebski et al. (2017), appear to draw the big-picture of isolated basins at the bottom of the landscape. One tool that is commonly used to demonstrate such claims is to evaluate the loss on a line that connects two solutions found by different methods. First of all, the notion of the basin itself can be misleading given the negative eigenvalues pointed out in the previous item. Moreover, we claim that this idea of isolated basins may be misleading based on the above observations of the dramatic level of flatness of the local geometry. In particular, we show that two solutions with different qualities can be shown to be in the same basin even with a loss evaluation on a straight line connecting the two.
+
+Remark 1: Throughout this paper we use the notions of data complexity and over-parametrization vaguely. The complexity of data can be defined in various ways and further research is required to determine the precise notion that is required that would link complexity to the spectrum. Overparametrization, similarly, can be defined in various ways: $M > > N$ , $M \to \infty$ for fixed $N$ , or $\bar { M } / N \to c$ for a certain constant, etc... However, more realistic notions of both complexity of the data and the over-parametrization should take the architecture into account, and detailed treatment of this should follow another work.
+
+Remark 2: The notion of the basin, also, can be defined precisely. However, it is unclear whether any algorithm used in practice actually locates the bottom of a basin described in classical ways. For instance, the norm of the gradients are small but not at the machine precision, and the eigenvalues of the Hessian still has a negative part even after SGD continues a long while without a meaningful decrease in the loss value. This is presumably the fault of the algorithm itself, however, it requires a further study, and hence such notions of sharp vs. wide minima in various recent work should be taken with a grain of salt.
+
+Remark 3: Even when one has a way to measure the width of a ‘basin’, such ways of measuring the approximate width are all relative. In a recent study, Dinh et al. (2017) shows how ‘sharp minima’ can still generalize with proper modifications to the loss function. We note that it takes a non-linear transformation to deform relative widths of basins. And, in this work, we focus on relative values as opposed to absolute values to get a consistent comparison across different setups.
+
+# 2 SOME PROPERTIES OF THE HESSIAN
+
+# 2.1 A FIRST LOOK AT THE SPECTRUM
+
+We begin by an exact calculation of the spectrum of the Hessian at a random initial point, and at the end of training. Note that the plots are arranged in a way that they show the eigenvalues in the $y$ -axis, and indicate the order of the eigenvalue in the $x$ -axis. This choice is necessary to indicate the scale of the degeneracy while still showing all the eigenvalues in the same plot. Figure 1 shows the full spectrum of the Hessian at the random initial point of training and after the final training point. The model of this example is a two hidden layer network with a total of $5 K$ parameters that is trained using gradient descent. Also note that, throughout the paper, the exact full Hessian is computed via the Hessian-vector products (Pearlmutter, 1994) up to the machine precision.
+
+![](images/a42ea3f545a3f89905e25602d5c37ba418bb503275e022376b20de2a029082c5.jpg)  
+Figure 1: Ordered eigenvalues at a random initial point, and at the final point of GD. $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue.
+
+# 2.2 GENERALIZED GAUSS-NEWTON DECOMPOSITION OF THE HESSIAN
+
+In order to study its spectrum, we will describe how the Hessian can be decomposed into two meaningful matrices (LeCun et al., 1998; Martens, 2010). Suppose the loss function is given as a composition of two functions, the model function $f _ { \bullet } : \mathbb { R } ^ { M } \xrightarrow { \bullet \bullet } \mathbb { R }$ is the real-valued output of a network that depends on the parameters; and the loss function $\ell _ { \bullet } : \mathbb { R } \longrightarrow \mathbb { R } ^ { + }$ is a convex function.
+
+Here, $\bullet$ refers to the given example. Examples include the regression: the mean-square loss composed with a real-valued output function, and classification: the negative log-likelihood loss composed with the dot product of the output of a softmax layer with the label vector.
+
+For ease of reading, we indicate the dependencies of functions $\ell$ and $f$ to data by the index of the example, or omit it altogether in case it is not necessary, and unless noted otherwise the gradients are taken with respect to $w$ . The gradient and the Hessian of the loss for a given example are given by
+
+$$
+\begin{array} { r l } & { \nabla \ell ( f ( w ) ) = \ell ^ { \prime } ( f ( w ) ) \nabla f ( w ) } \\ & { \nabla ^ { 2 } \ell ( f ( w ) ) = \ell ^ { \prime \prime } ( f ( w ) ) \nabla f ( w ) \nabla f ( w ) ^ { T } + \ell ^ { \prime } ( f ( w ) ) \nabla ^ { 2 } f ( w ) } \end{array}
+$$
+
+where $\bullet ^ { T }$ denotes the transpose operation (here the gradient is a column-vector). Note that since $\ell$ is convex $\ell ^ { \prime \prime } ( s ) \geq 0$ and we can take its square root which allows us to rewrite the Hessian of the loss as follows:
+
+$$
+\nabla ^ { 2 } \mathcal { L } ( w ) = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } [ \sqrt { \ell _ { i } ^ { \prime \prime } ( f _ { i } ( w ) ) } \nabla f _ { i } ( w ) ] [ \sqrt { \ell _ { i } ^ { \prime \prime } ( f _ { i } ( w ) ) } \nabla f _ { i } ( w ) ] ^ { T } + \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \ell _ { i } ^ { \prime } ( f _ { i } ( w ) ) \nabla ^ { 2 } f _ { i } ( w )
+$$
+
+In general, it isn’t straightforward to discuss the spectrum of the sums of matrices by looking at the individual ones. Nevertheless, looking at the decomposition, we can still infer what we should expect. At a point close to a local minimum, the average gradient is close to zero. However, this doesn’t necessarily imply that the gradients for individual samples are also zero. However, if $\ell ^ { \prime } ( f ( \hat { w } ) )$ and $\nabla ^ { 2 } f ( { \hat { w } } )$ are not correlated, then we can ignore the second term. And so the Hessian can be approximated by the first term:
+
+$$
+\nabla ^ { 2 } \mathcal { L } ( \hat { w } ) \approx \frac { 1 } { N } \sum _ { i = 1 } ^ { N } [ \sqrt { \ell _ { i } ^ { \prime \prime } ( f _ { i } ( \hat { w } ) ) } \nabla f _ { i } ( \hat { w } ) ] [ \sqrt { \ell _ { i } ^ { \prime \prime } ( f _ { i } ( \hat { w } ) ) } \nabla f _ { i } ( \hat { w } ) ] ^ { T }
+$$
+
+Here, Equation 5 is the sum of rank one matrices (via the outer products of gradients of $f$ multiplied by some non-negative number), therefore, the sum can be written as a product of an $M \times N$ matrix with its transpose where the columns of the matrix are formed by the scaled gradients of $f$ . Immediately, this implies that there are at least $M - N$ many trivial eigenvalues of the right-hand side in Equation 5.
+
+From a theoretical point of view, the tool that is required for the above problem should be a mapping of eigenvalues of the population matrix to the sample covariance matrix. Recent provable results on this can be found in Bloemendal et al. (2016) (please refer to the appendix for a review of this approach). We emphasize that this result require independent inputs, and extensions to correlated data appear to be unavailable to the best of our knowledge.
+
+# 3 IMPLICATIONS OF FLATNESS FOR THE GEOMETRY OF THE ENERGY LANDSCAPE
+
+In this section, we leave the decomposition behind and focus on experimental results of the spectrum of the full Hessian through the exact Hessian-vector products. We discuss how data, model, and algorithm affect the spectrum of the Hessian of the loss.
+
+# 3.1 THE RELATION BETWEEN DATA AND EIGENVALUES
+
+In many cases of practical interest, the data contains redundancies. In such cases, the number of non-trivial eigenvalues could be even smaller than $N$ . For instance, if one deals with a classification problem where the training data has $k$ classes with relatively small deviation among each of them, it is reasonable to expect that there will be an order of $k$ many non-trivial eigenvalues of the first term of the above decomposition of the Hessian in Equation 5. Then, if the second term is small (for instance when all the gradients per example are zero), we would expect to see $k$ many outliers in the spectrum of the Hessian of the loss. To test this idea, we used a feed-forward neural network with a 100- dimensional input layer, two hidden layers each of which with 30 hidden units, and a $k$ dimensional output layer that is combined with softmax for $k$ -class classification. We randomly sampled from $k$ Gaussian clusters in the input space and normalized the data globally. Then we carried out the training using SGD on ReLU network for the following number of clusters: $k : \{ 2 , 5 , 1 0 , 2 0 , 5 0 \}$ .
+
+![](images/4fbebe062090713f1dfd0f8b7475c18fe8b82c9d4cde1a97c8ab2996dc176580.jpg)  
+Figure 2: Ordered plot of eigenvalues with a visible gap. $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue.
+
+The number of large eigenvalues that are above the gap in Figure 2 match exactly the number of classes in the dataset. This experiment is repeated for various different setups. Please refer to Table 1 in the appendix for more experiments on this.
+
+# .2 THE RELATION BETWEEN NUMBER OF PARAMETERS AND EIGENVALUE
+
+We test the effect of growing the size of the network when data, architecture, and algorithm are fixed. In some sense, we make the system more and more over-parametrized. Based on the intutions developed above we should not observe a change in the size and number of the large eigenvalues of the Hessian at the bottom. To test this, we sample 1K examples from the MNIST dataset and fix them as the training set. Then we form four different networks each of which has a different number of nodes in its hidden layer $( n _ { \mathrm { h i d d e n } } \in \{ 1 0 , 3 0 , 5 0 , 7 0 \} )$ . All four networks are trained with the same step size and the same number of iterations and the exact Hessian is computed at the end. Figure 3 shows the largest 120 eigenvalues of each of the four Hessians ranked in an increasing order. For the right edge of the spectrum (that is, for the large positive eigenvalues), the shape of the plot remains invariant as the number of parameters increase (Figure 3).
+
+# 3.3 THE RELATION BETWEEN THE ALGORITHM AND EIGENVALUES
+
+Finally, we turn to describing the nature of solutions found by the large and small batch methods for the training landscape. We train a convnet that is composed of 2 convolution layers with relu-maxpool followed by two fully-connected layers. The training set is a subsampled MNIST with 1K training examples. The small batch method uses a mini-batch size of 10, and the large-batch one uses 512. A learning rate for which both algorithms converge is fixed for both LB and SB. Note that the stochastic gradients are averaged over the mini-batch. Therefore, fixing the learning rate allows the algorithms to take steps whose lengths are proportional to the norms of the corresponding stochastic gradients averaged over the mini-batch. This way we ensure that both methods are compared fairly when we look at them after a fixed number of iterations. We train until the same number of iterations have been reached. Then, we calculate the Hessian and the spectrum of the Hessian in Figure 4. The large batch method locates points with larger positive eigenvalues.
+
+This observation is consistent with Keskar et al. (2016) as the way they measure flatness takes local rates of increase in a neighborhood of the solution into account which is intimately linked to the size of the large eigenvalues.
+
+![](images/f751607ab68bf5feee8f1c81ac1d411f8954d6dde92aa433b4a21923c88e66df.jpg)  
+Figure 3: Right edge of the spectrum of the Hessian of the loss for a fully connected network on MNIST with increasing dimensions. $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue.
+
+![](images/fb42f773ad6f94809f91f414af482070514e830e20d01184d707a08d98f7fc5b.jpg)  
+Figure 4: Outlier eigenvalues of LB ( $\mathit { b s } = 5 1 2$ ) vs SB $b s = 1 0$ ). $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue.
+
+# 3.4 TRAILING NEGATIVE EIGENVALUES AFTER TRAINING
+
+Lastly, we observe that the negative eigenvalues at the end of the training are orders of magnitude smaller than the large ones. The very existence of the negative eigenvalues indicates that the algorithm didn’t locate a local minimum, yet. Note that the stopping criterion in most practical cases is arbitrary. Training is stopped after there is no meaningful decrease in the loss value or increase in the test accuracy. In our experiments, the training ran well beyond the point of this saturation. In this time-scale, the loss decays in much smaller values. And we may expect convergence to a localminimum at large (possibly exponentially long) time-scales. However, from a practical point of view, it appears that the properties of the landscape at this fine-grained scale is less relevant in terms of its test performance. Anyhow, we observe that there are a number of negative eigenvalues but their magnitude is much smaller compared to the positive eigenvalues.
+
+The reason we look at the ranked negative eigenvalues in percentages rather than the order is the result of the experiment in Section 3.2. Adding more weights to the system scale the small scale eigenvalues proportionally, the number of outliers remain unchanged whereas the ratio of negative $x$ -axis indicates the order of the eigenvalue in percentages, $y$ -axis indicates the eigenvalues.
+
+![](images/4406d2d101a4651dbf0ea934cdc919de22794f459db105c77b087176aaac1049.jpg)  
+Figure 5: Negative eigenvalues at the bottom when increasing the number of hidden nodes (compare with Figure 3).
+
+![](images/7dd126bf66a93a6e21f5ee37b57d65ff0d19fb71c8926a33bc4e8193b4bf60ae.jpg)  
+Figure 6: Negative eigenvalues at the bottom for LB-SB experiment on MNIST (compare with Figure 4).
+
+eigenvalues remain the same. Moreover, they appear to be converging to have the same shape (Figure 6). Also, note that the negative eigenvalues can only come from the second term of the decomposition in Equation 5. Unless the second term contributes to the spectrum in an asymmetrical way, the observation that the negative eigenvalues are small confirms our previous suspicions that the effect of the ignored term in the decomposition is small.
+
+# 4 DISCUSSION ON BASINS OF SOLUTIONS AND GENERALIZATION
+
+Finally, we revisit the issue through the lens of the following question: What does overparametrization imply on the discussion around GD vs. SGD (or large batch vs small batch) especially for their generalization properties? In this final section, we will argue that, contrary to what is believed in Keskar et al. (2016) and Chaudhari et al. (2016) the two algorithms do not have to be falling into different basins.
+
+As noted in the introduction, for a while the common sense explanation on why SGD works well (in fact better) than GD (or large batch methods) was that the non-convex landscape had local minima at high energies which would trap large-batch or full-batch methods. Something that SGD with small batch shouldn’t suffer due to the inherent noise in the algorithm. However, there are various experiments that have been carried out in the past that show that, for reasonable large systems, this is not the case. For instance, Sagun et al. (2014) demonstrate that a two hidden layer fully connected network on MNIST can be trained by GD to reach at the same level of loss values as SGD 1. In fact, when the step size is fixed to the same value for both of the algorithms, they reach the same loss value at the same number of iterations. The training accuracy for both algorithms are the same, and the gap between test accuracies diminish as the size of the network increase with GD falling ever so slightly behind. It is also shown in Keskar et al. (2016) that training accuracies for both large and small batch methods are comparably good. Furthermore, Zhang et al. (2016) demonstrates that training landscape is easy to optimize even when there is no clear notion of generalization. Such observations are consistent with our observations: over-parametrization (due to the architecture of the model) leads to flatness at the bottom of the landscape which is easy to optimize.
+
+When we turn our attention to generalization, Keskar et al. (2016) note that LB methods find a basin that is different than the one found by SB methods, and they are characterized by how wide the basin is. As noted in Figure 4, indeed the large eigenvalues are larger in LB than in SB, but is it enough to justify that they are in different basins, especially given the fact that the number of flat directions are enormous.
+
+4.1 ARE THEY REALLY DIFFERENT BASINS? CASE OF CIFAR10 WITH LB VS SB
+
+The observation that LB converges to sharper basins that are separated by wells from the wider basins found by SB has been an observation that triggered attention. In this section, we present two solutions with different qualities as measured by the generalization error and we show that they are in fact in the same ‘basin’ by showing that the evaluation of the loss doesn’t go through a barrier between the two solutions. We start by two common pitfalls that one may fall into in testing this:
+
+The problem with epoch based time scales: A common way to plot training profiles in larger scale neural networks is to stop every epoch to reserve extra computational power to calculate various statistics of the model at its current position. This becomes problematic when one compares training with different batch sizes, primarily because the larger batch model takes fewer steps in a given epoch. Recall that the overall loss is averaged, therefore, for a fixed point in the weight space, the empirical average of the gradients is an unbiased estimator for the expected gradient. Hence it is reasonable to expect that the norms of the large batch methods match to the ones of the small batch. And for a fair comparison, one should use the same learning rate for both training procedures. This suggests that a better comparison between GD and SGD (or LB and SB) should be scaled with the number of steps, so that, on average both algorithms are able to take similar number of steps of comparable sizes. The experiments we present use the number of iterations as the time-scale.
+
+The problem with line interpolations in the weight space: The architecture of typical neural networks have many internal symmetries, one of which is the flip symmetry: when one swaps two nodes (along with the weights connected to it) at a given layer, the resulting network is identical to the original one. Therefore, when one trains two systems to compare, it may well be possible that the two fall into different flip symmetrical configurations that may look more similar when they are reordered. Therefore, training two systems with levels of randomness (seed, batch-size, choice of the initial point, etc.) may result in two points in the weight space that present a barrier only because of such symmetries. In an attempt to partially alleviate this problem we switch dynamics of an already trained system.
+
+1. Part I: Train full CIFAR10 data for a bare AlexNet (bare meaning: no momentum, no dropout, and no batch normalization) with a batch-size of 1, 000. Record every 100 steps for 250 times.   
+2. Part II: Continue training from the endpoint of the previous step with a smaller batch-size of 32. Everything else, including the constant learning rate is kept the same. And train another 250 periods each of which with 100 steps.
+
+The key observation is the jump in the training and test losses, and a drop in the corresponding accuracies (Figure 8). Toward the end of Part II the small batch reaches to a slightly better accuracy (about $\sim 1 \%$ ). And this looks in line with the observations in Keskar et al. (2016), in that, it appears that the LB solution and SB solutions are separated by a barrier and that the latter of which generalizes better. Moreover, the line interpolations extending away from either endpoint appear to be confirming the sharpness of LB solution. However, we find the straight line interpolation connecting the endpoints of Part $I$ and Part $\boldsymbol { { I I } }$ turns out to not contain any barriers (Figure 9). This suggests that while the Part I and Part $\mathit { I I }$ converge to two solutions with different properties, these solutions have been in the same basin all along. This raises the striking possibility that those other seemingly different solutions may be similarly connected by a flat region to form a larger basin (modulo internal symmetries).
+
+Another interpretation of this experiment, also, goes through the Gauss-Newton decomposition introduced in Equation 5. When we decrease the batch size, we increase the noise in the covariance of the gradients, and hence the first term starts to dominate. Even when the weight space has large flat regions, the fluctuations of the stochastic noise should be precisely in the directions of the large eigenvalues. Therefore, at the beginning of Part II, the loss increases because the point fluctuates in the directions corresponding to the large eigenvalues, and eventually settles at a point that lies at the interior of the same level set, essentially staying in the same basin.
+
+![](images/5c5f663577c8905a19568647d00c87c0e4a933a78191dbe2bb7d22018e7cb1d6.jpg)  
+Figure 8: Large batch training immediately followed by small batch training on the full dataset of CIFAR10 with a raw version of AlexNet. The accuracy increases by about $1 \%$ : Part $I$ and Part $\boldsymbol { { I I } }$ locate solutions with different generalization properties.
+
+![](images/00062df2c9db72157e87cfcfab556fa17a73ef0bc785e7112e2fbd5d668d050d.jpg)  
+Figure 9: Loss and accuracy evaluation on the straight line that contains LB and SB solutions. The accuracy of the SB solution is $\sim 1 \%$ better than the LB solution, but there is no barrier between the two points.
+
+# 4.2 FURTHER DISCUSSIONS
+
+One of the most striking implications of flatness may be the connected structure of the solution space. We may wonder whether two given solutions can be connected by a continuous path of solutions. This question has been explored in a recent work: in Freeman & Bruna (2016) it is shown that for one hidden layer rectified neural networks the solution space is connected which is consistent with the flatness of the landscape. The classical notion of basins of attractions may not be the suitable objects to study for neural networks. Rather, we may look at the exploration of interiors of level sets of the landscape. We may be tempted to speculate that such an exploration may indeed result in point that generalizes better. However, the flat space itself is very high dimensional which comes with its own computational issues.
+
+The training curve can be seen as composed of two parts: (1) high gain part where the norm of the gradients are large, (2) noise of the gradients is larger relative to the size of the stochastic gradients (see (Shwartz-Ziv & Tishby, 2017) for a recent reference). We speculate that the first part is relatively easy and even a large batch method can locate a large level set that contains points that generalize better than what’s initially found. From a practical point of view, using larger batches with larger step sizes can, in fact, accelerate training. An example of this can be found in Goyal et al. (2017), where training Imagenet with a minibatch size of 8192 can match small batch performance. On a final note for further consideration, we remark that we used standard pre-processing and initialization methods that are commonly used in practice. Fixing these two aspects, we modified the data, model, and algorithm in order to study their relative effects. However, the effects of pre-processing and initialization on the Hessian is highly non-trivial and deserves a separate attention.
+
+# 5 CONCLUSION
+
+We have shown that the level of the singularity of the Hessian cannot be ignored from theoretical considerations. Furthermore, we use the generalized Gauss-Newton decomposition of the Hessian to argue the cluster of zero eigenvalues are to be expected in practical applications. This allows us to reconsider the division between initial fast decay and final slow progress of training. We see that even large batch methods are able to get to the same basin where small batch methods go. As opposed to the common intuition, the observed generalization gap between the two is not due to small batch finding a different, better, wider basin. Instead, the two solutions appear to be in the same basin. This lack of a barrier between solutions is demonstrated by finding paths between the two points that lie in the same level set. To conclude, we propose a major shift in perspective on considerations of the energy landscape in deep learning problems.
+
+# REFERENCES
+
+Antonio Auffinger, Gérard Ben Arous, and Jiˇrí Cern ˇ y. Random matrices and complexity of spin \` glasses. Communications on Pure and Applied Mathematics, 66(2):165–201, 2013.
+
+Jinho Baik, Gérard Ben Arous, Sandrine Péché, et al. Phase transition of the largest eigenvalue for nonnull complex sample covariance matrices. The Annals of Probability, 33(5):1643–1697, 2005.
+
+Andrew J Ballard, Ritankar Das, Stefano Martiniani, Dhagash Mehta, Levent Sagun, Jacob D Stevenson, and David J Wales. Energy landscapes for machine learning. Physical Chemistry Chemical Physics, 2017.
+
+Alex Bloemendal, Antti Knowles, Horng-Tzer Yau, and Jun Yin. On the principal components of sample covariance matrices. Probability Theory and Related Fields, 164(1-2):459–552, 2016.
+
+Léon Bottou. Stochastic gradient learning in neural networks. Proceedings of Neuro-Nımes, 91(8), 1991.
+
+Léon Bottou. Large-scale machine learning with stochastic gradient descent. In Proceedings of COMPSTAT’2010, pp. 177–186. Physica-Verlag HD, 2010.
+
+J Bourrely. Parallelization of a neural network learning algorithm on a hypercube. Hypercube and distributed computers. Elsiever Science Publishing, 1989.
+
+Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. arXiv preprint arXiv:1611.01838, 2016.
+
+Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv preprint arXiv:1703.04933, 2017.
+
+C Daniel Freeman and Joan Bruna. Topology and geometry of deep rectified network optimization landscapes. arXiv preprint arXiv:1611.01540, 2016.
+
+Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997.
+
+Stanisław Jastrz˛ebski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos Storkey. Three factors influencing minima in sgd. arXiv preprint arXiv:1711.04623, 2017.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.   
+Yann LeCun, Léon Bottou, GB Orr, and K-R Müller. Efficient backprop. Lecture notes in computer science, pp. 9–50, 1998.   
+Jason D Lee, Max Simchowitz, Michael I Jordan, and Benjamin Recht. Gradient descent converges to minimizers. University of California, Berkeley, 1050:16, 2016.   
+Vladimir A Marcenko and Leonid Andreevich Pastur. Distribution of eigenvalues for some sets of ˇ random matrices. Mathematics of the USSR-Sbornik, 1(4):457, 1967.   
+James Martens. Deep learning via hessian-free optimization. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 735–742, 2010.   
+Song Mei, Yu Bai, and Andrea Montanari. The landscape of empirical risk for non-convex losses. arXiv preprint arXiv:1607.06534, 2016.   
+Jorge Nocedal and Stephen J Wright. Numerical optimization, second edition. Numerical optimization, pp. 497–528, 2006.   
+Ioannis Panageas and Georgios Piliouras. Gradient descent only converges to minimizers: Nonisolated critical points and invariant regions. arXiv preprint arXiv:1605.00405, 2016.   
+Barak A Pearlmutter. Fast exact multiplication by the hessian. Neural computation, 6(1):147–160, 1994.   
+Levent Sagun, V. Ugur Güney, Gérard Ben Arous, and Yann LeCun. Explorations on high dimensional ˘ landscapes. ICLR 2015 Workshop Contribution, arXiv:1412.6615, 2014.   
+Levent Sagun, Léon Bottou, and Yann LeCun. Singularity of the hessian in deep learning. arXiv preprint arXiv:1611.07476, 2016.   
+Tom Schaul, Sixin Zhang, and Yann LeCun. No more pesky learning rates. ICML (3), 28:343–351, 2013.   
+Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.   
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+# A OUTLIER EIGENVALUES
+
+In the subsequent experiments, we used a feed-forward neural network with a 100 dimensional input layer, two hidden layers each of which with 30 hidden units, and a $k$ dimensional output layer that is combined with softmax for $k$ -class classification. We sampled random $k$ Gaussian clusters in the input space and normalized the data globally. Then we carried out the training for the following sets of parameters: $k : \{ 2 , 5 , 1 0 , 2 0 , 5 0 \}$ , algorithm: {GD, SGD}, non-linearity: {tanh, ReLU}, initial multipler for the covariance of the input distribution: $\{ 1 , 1 0 \}$ . Then we counted the number of large eigenvalues according to three different cutoff methods: largest consecutive gap, largest consecutive ratio, and a heuristic method of determining the threshold by searching for the elbow in the scree plot (see Figure 2). In Table 1 we marked the ones that are off by $\pm 1$ .
+
+<table><tr><td>alg-size</td><td>cov</td><td>mean&amp;std</td><td>nc</td><td>gap</td><td>ratio</td><td>heur</td><td>cutoff</td></tr><tr><td>GD tanh 4022</td><td>1.0</td><td>1.19e-05,1.19e-05</td><td>2</td><td>2</td><td>3</td><td>N/A</td><td>N/A</td></tr><tr><td>GD tanh 4115</td><td>1.0</td><td>2.52e-05,2.52e-05</td><td>5</td><td>2</td><td>17</td><td>N/A</td><td>N/A</td></tr><tr><td>GD tanh 4270</td><td>1.0</td><td>3.75e-05,3.75e-05</td><td>10</td><td>2</td><td>4</td><td>N/A</td><td>N/A</td></tr><tr><td>GD tanh 4580</td><td>1.0</td><td>5.37e-05, 5.37e-05</td><td>20</td><td>3</td><td>4</td><td>N/A</td><td>N/A</td></tr><tr><td>GDReLU4022</td><td>1.0</td><td>7.13e-06,7.13e-06</td><td>2</td><td>3</td><td>4</td><td>2</td><td>0.003</td></tr><tr><td>GD ReLU 4115</td><td>1.0</td><td>1.55e-05, 1.55e-05</td><td>5</td><td>6</td><td>7</td><td>5</td><td>0.003</td></tr><tr><td>GD ReLU4270</td><td>1.0</td><td>3.04e-05,3.04e-05</td><td>10</td><td>11</td><td>12</td><td>10</td><td>0.003</td></tr><tr><td>GD ReLU4580</td><td>1.0</td><td>5.65e-05,5.65e-05</td><td>20</td><td>4</td><td>21</td><td>21</td><td>0.003</td></tr><tr><td>GD ReLU5510</td><td>1.0</td><td>1.16e-04, 1.16e-04</td><td>50</td><td>50</td><td>51</td><td>49</td><td>0.003</td></tr><tr><td>SGD1 ReLU4022</td><td>1.0</td><td>8.96e-06, 8.96e-06</td><td>2</td><td>3</td><td>4</td><td>2</td><td>0.002</td></tr><tr><td>SGD ReLU 4115</td><td>1.0</td><td>1.62e-05, 1.62e-05</td><td></td><td>6</td><td>7</td><td>7</td><td>0.002</td></tr><tr><td>SGD ReLU4270</td><td>1.0</td><td>2.97e-05,2.97e-05</td><td></td><td>2</td><td>14</td><td>15</td><td>0.002</td></tr><tr><td>SGD ReLU 4580</td><td>1.0</td><td>4.53e-05,4.53e-05</td><td></td><td>2</td><td>3</td><td>21</td><td>0.002</td></tr><tr><td>SGD ReLU 5510</td><td>1.0</td><td>6.78e-05, 6.78e-05</td><td></td><td>50</td><td>51</td><td>49</td><td>0.002</td></tr><tr><td>SGD1 ReLU4022</td><td>10.0</td><td>9.49e-05,9.49e-05</td><td>2</td><td>2</td><td>4</td><td>2</td><td>0.015</td></tr><tr><td>SGD ReLU 4115</td><td>10.0</td><td>1.68e-04, 1.68e-04</td><td></td><td>5</td><td>6</td><td>5</td><td>0.015</td></tr><tr><td>SGD ReLU 4270</td><td>10.0</td><td>1.92e-04, 1.92e-04</td><td></td><td>2</td><td>11</td><td>9</td><td>0.015</td></tr><tr><td>SGD ReLU 4580</td><td>10.0</td><td>3.10e-04,3.10e-04</td><td>20</td><td>20</td><td>21</td><td>19</td><td>0.015</td></tr><tr><td>SGD ReLU 5510</td><td>10.0</td><td>1.67e-04, 1.67e-04</td><td>50</td><td>50</td><td>51</td><td>49</td><td>0.005</td></tr></table>
+
+Table 1: Counting outliers for matching the number of blobs. Dictionary of table elements: {cov: scale of covariance for inputs, mean&std: of the eigenvalues, nc: number of clusters, gap: largest consecutive gaps, ratio: largest consecutive ratios, heur: heuristic threshold, cutoff: the value of the heur.}
+
+# B THE SPECTRUM OF THE GENERALIZED GAUSS-NEWTON MATRIX
+
+In this section, we will show that the spectrum of the Generalized Gauss-Newton matrix can be characterized theoretically under some conditions. Suppose that we can express the scaled gradient $( \sqrt { \ell _ { i } ^ { \prime \prime } ( f _ { i } ( \hat { w } ) ) } \nabla f _ { i } ( \hat { w } )$ from Equation 5) as $g = T x$ with the matrix $T \in M \times d$ depending only on the parameters $w$ - which is the case for linear models. Then we can write: $\begin{array} { r } { G = \frac { 1 } { N } \sum _ { i \in \mathcal { D } } g _ { i } g _ { i } ^ { T } = } \end{array}$ $\scriptstyle { \frac { 1 } { N } } T X X ^ { T } T ^ { T }$ , where at the e $X = \{ x ^ { 1 } , \ldots , x ^ { N } \}$ is an ized $d \times N$ matrix. Furthermhat the entries of e, without loss of generality,are independent with zero $X$   
+mean and unit variance. One of the first steps in studying $G$ goes through understanding its principle components. In particular, we would like to understand how the eigenvalues and eigenvectors of $G$ are related to the ones of $\Sigma$ where $\begin{array} { r } { \Sigma : = \mathbb { E } ( G ) = \frac { 1 } { N } T X X ^ { T } T ^ { T } = \breve { T } T ^ { T } } \end{array}$ .
+
+In the simplest case, we have $\Sigma = I d$ so that the gradients are uncorrelated and the eigenvalues of $G$ are distributed according to the Marcenko-Pastur law in the limit where ˇ $N , M \to \infty$ and $\textstyle \alpha : = { \frac { M } { N } }$ . The result dates back to sixties and can be found in (Marcenko & Pastur, 1967). Note that ˇ if $M \stackrel { \_ } { > } N$ then there are $M - N$ trivial eigenvalues of $G$ at zero. Also, the width of the nontrivial distribution essentially depends on the ratio $\alpha$ . Clearly, setting the expected covariance to identity is very limiting. One of the earliest relaxations appear in (Baik et al., 2005). They prove a phase transition for the largest eigenvalues of the sample covariance matrix which has been known as the BBP phase transition. A case that may be useful for our setup is as follows:
+
+Theorem 1 (Baik, Arous, Péché, et al., 2005). If $\Sigma = d i a g ( \ell , 1 , \dots , 1 )$ , $\ell > 1$ , and $M , N \to \infty$ with $\begin{array} { r } { \frac { M } { N } = \alpha \ge 1 } \end{array}$ . Let $c = 1 + \sqrt { \alpha }$ , and let’s call the top eigenvalue of the sample covariance matrix as $\lambda _ { m a x }$ then:
+
+• If $\dot { \cdot } 1 \leq \ell < c$ then $\lambda _ { m a x }$ is at the right edge of the spectrum with Tracy-Widom fluctuations. • If $c < \ell$ then $\lambda _ { m a x }$ is an outlier that is away from bulk centered at $\textstyle { \ell ( 1 + { \frac { \alpha } { \ell - 1 } } ) }$ with Gaussian fluctuations.
+
+Typically, due to the correlations in the problem we don’t have $\Sigma$ to be the identity matrix or a diagonal matrix with spikes. This makes the analysis of their spectrum a lot more difficult. A solution for this slightly more general case with non-trivial correlations has been provided only recently by Bloemendal et al. (2016). We will briefly review these results here see how they are related to the first term of the above decomposition.
+
+Theorem 2 (Bloemendal, Knowles, Yau, and Yin, 2016). If $d = M$ , $\Sigma - I d$ has bounded rank, $\log N$ is comparable to $\log M$ , and entries of $X$ are independent with mean zero and variance one, then the spectrum of $\Sigma$ can be precisely mapped to the one of $G$ as $M , N \to \infty$ for fixed $\textstyle \alpha = { \frac { M } { N } }$ . Let $K = m i n \{ M , N \}$ , and the decomposition of the spectrum can be described as follows:
+
+• Zeros: $M - K$ many eigenvalues located at zero (i $f M > N ,$ ).   
+• Bulk: Order $K$ many eigenvalues are distributed according to Marˇcenko-Pastur law.   
+• Right outliers: All eigenvalues of $\Sigma$ that exceed a certain value produce large-positive outlier eigenvalues to the right of the spectrum of $G$ .   
+• Left outliers: All eigenvalues of $\Sigma$ that are close to zero produce small outlier eigenvalues between 0 and the left edge of the bulk of $G$ .
+
+Moreover, the eigenvectors of outliers of $G$ are close to the corresponding ones of $\Sigma$
+
+This theorem essentially describes the way in which one obtains outlier eigenvalues in the sample covariance matrix assuming the population covariance is known. Here is an example:
+
+![](images/14fbcfe88d568ad1d54cf2c1514c70323512138de1ca1d350367672645843720.jpg)  
+Figure 10: Spectrum of the logistic regression loss with tanh unit: when data has a single Gaussian blob (left), when data has two Gaussian blobs (right). In the latter case, the spectrum has outlier eigenvalues at 454.4, 819.5, and 92.7 for $a l p h a = 1 , 2 , 0 . 0 2$ , respectively.
+
+Example 1 (Logistic regression). Consider the log-loss $\begin{array} { r } { \ell ( s , y ) = - y \log { \frac { 1 } { 1 + e ^ { - s } } } - ( 1 - y ) \log ( 1 - } \end{array}$ 11+e−s ) and a single neuron with the sigmoid non-linearity. Note that \`(s, y) is convex in s for fixed $y$ , and we can apply the decomposition using $\ell$ and $f ( w , x ) = \langle w , x \rangle$ . In this case we have $M = d$ , also, note that the second part of the Hessian in Equation 4 is zero since $\nabla ^ { 2 } f ( w , x ) = 0$ . So the Hessian of the loss is just the first term. It is straightforward to calculate that the gradient per sample is of the form $g = c ( w , x ) I d _ { M } x$ for a positive constant $c = c ( w , x )$ that doesn’t depend on $y$ . This case falls into the classical Marchenko-Pastur law (left pane of Figure 10). ˇ
+
+Example 2. Once we have more than one class this picture fails to hold. For, $\ell ( s ) = - \log ( s )$ , and $\begin{array} { r } { f ( w ; ( x , y ) ) = \frac { \exp ^ { - \langle w _ { y } , x \rangle } } { \sum _ { k } \exp ^ { - \langle w _ { y ^ { k } } , x \rangle } } } \end{array}$ the spectrum changes. It turns out that in that case the weights have one large outlier eigenvalue, and a bulk that’s close to zero (right pane of Figure 10).

parse/train/rJrTwxbCb/rJrTwxbCb_content_list.json

@@ -0,0 +1,1311 @@
+[
+    {
+        "type": "text",
+        "text": "EMPIRICAL ANALYSIS OF THE HESSIAN OF OVERPARAMETRIZED NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            826,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We study the properties of common loss surfaces through their Hessian matrix. In particular, in the context of deep learning, we empirically show that the spectrum of the Hessian is composed of two parts: (1) the bulk centered near zero, (2) and outliers away from the bulk. We present numerical evidence and mathematical justifications to the following conjectures laid out by Sagun et al. (2016): Fixing data, increasing the number of parameters merely scales the bulk of the spectrum; fixing the dimension and changing the data (for instance adding more clusters or making the data less separable) only affects the outliers. We believe that our observations have striking implications for non-convex optimization in high dimensions. First, the flatness of such landscapes (which can be measured by the singularity of the Hessian) implies that classical notions of basins of attraction may be quite misleading. And that the discussion of wide/narrow basins may be in need of a new perspective around over-parametrization and redundancy that are able to create large connected components at the bottom of the landscape. Second, the dependence of a small number of large eigenvalues to the data distribution can be linked to the spectrum of the covariance matrix of gradients of model outputs. With this in mind, we may reevaluate the connections within the data-architecturealgorithm framework of a model, hoping that it would shed light on the geometry of high-dimensional and non-convex spaces in modern applications. In particular, we present a case that links the two observations: small and large batch gradient descent appear to converge to different basins of attraction but we show that they are in fact connected through their flat region and so belong to the same basin. ",
+        "bbox": [
+            232,
+            266,
+            766,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            336,
+            613
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study the geometry of the loss surface of supervised learning problems through the lens of their second order properties. To introduce the framework, suppose we are given data in the form of input-label pairs, $\\mathbf { \\dot { \\mathcal { D } } } = \\{ ( x ^ { i } , y ^ { i } ) \\} _ { i = 1 } ^ { N }$ where $x \\in \\mathbb { R } ^ { d }$ and $y \\in \\mathbb R$ that are sampled i.i.d. from a possibly unknown distribution $\\nu$ , a model that is parametrized by $w \\in \\mathbb { R } ^ { M }$ ; so that the number of examples is $N$ and the number of parameters of the system is $M$ . Suppose also that there is a predictor $f ( w , x )$ . The supervised learning process aims to solve for $w$ so that $f ( w , x ) \\approx y$ . To make the $\\cdot \\approx$ precise, we use a non-negative loss function that measures how close the predictor is to the true label, $\\ell ( f ( w , x ) , y )$ . We wish to find a parameter $w ^ { * }$ such that $w ^ { * } = \\arg \\operatorname* { m i n } \\mathcal { L } ( w )$ where, ",
+        "bbox": [
+            173,
+            628,
+            825,
+            743
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a06230da445801d761a1cbb264bdf67c029635b48c9dcb278ce343c700dcc1f2.jpg",
+        "text": "$$\n\\mathcal { L } ( w ) : = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\ell ( f ( w , x ^ { i } ) , y ^ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            750,
+            606,
+            792
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In particular, one is curious about the relationship between $\\mathcal { L } ( w )$ and $\\begin{array} { r } { \\hat { \\mathcal { L } } ( w ) : = \\int \\ell d ( \\nu ) } \\end{array}$ . By the law of large numbers, at a given point $w$ , $\\mathcal { L } _ { w } \\to \\hat { \\mathcal { L } } _ { w }$ almost surely as $N  \\infty$ for fixed $M$ . However in modern applications, especially in deep learning, the number of parameters $M$ is comparable to the number of examples $N$ (if not much larger). And the behaviour of the two quantities may be drastically different (for a recent analysis on provable estimates see (Mei et al., 2016)). ",
+        "bbox": [
+            173,
+            800,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A classical algorithm to find $w ^ { * }$ is gradient descent (GD), in which the optimization process is carried out using the gradient of $\\mathcal { L }$ . A new parameter is found iteratively by taking a step in the direction of the negative gradient whose size is scaled with a constant step size $\\eta$ that is chosen from line-search minimization. Two problems emerge: (1) Gradient computation can be expensive, (2) Line-search can be expensive. More involved algorithms, such as Newton-type methods, make use of second-order information (Nocedal & Wright, 2006). Under sufficient regularity conditions we may observe: $\\mathcal { L } ( w + \\Delta w ) \\approx \\mathcal { L } ( w ) + \\Delta w \\nabla \\mathcal { L } ( \\bar { w } ) + \\Delta w ^ { T } \\nabla ^ { 2 } \\mathcal { L } ( w ) \\Delta w$ . A third problem emerges beyond an even more expansive computational cost of the Hessian: (3) Most methods require the Hessian to be non-degenerate to a certain extent. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When the gradients are computationally expensive, one can alternatively use its stochastic version (SGD) that replaces the above gradient with the gradient of averages of losses over subsets (such a subset will be called the mini-batch) of $\\mathcal { D }$ (see (Bottou, 2010) for a classical reference). The benefit of SGD on real-life time limits is obvious, and GD may be impractical for practical purposes in many problems. In any case, the stochastic gradient can be seen as an approximation to the true gradient, and hence it is important to understand how the two directions are related to one another. Therefore, the discussion around the geometry of the loss surface can be enlightening in the comparison of the two algorithms: Does SGD locate solutions of a different nature than GD? Do they follow different paths? If so, which one is better in terms of generalization performance? ",
+        "bbox": [
+            174,
+            194,
+            825,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the second problem of expensive line-search, there are two classical solutions: using a small, constant step size, or scheduling the step size according to a certain rule. In practice, in the context of deep learning, the values for both approaches are determined heuristically, by trial and error. More involved optimal step size choices involve some kind of second-order information that can be obtained from the Hessian of the loss function (Schaul et al., 2013). From a computational point of view, obtaining the Hessian is extremely expensive, however obtaining some of its largest and smallest eigenvalues and eigenvectors are not that expensive. Is it enough to know only those eigenvalues and eigenvectors that are large in magnitude? How do they change through training? Would such a method work in SGD as well as it would on GD? ",
+        "bbox": [
+            174,
+            327,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the third problem, let’s look at the Hessian a little closer. A critical point is defined by $w$ such that $| | \\nabla \\mathcal { L } ( w ) | | = 0$ and the nature of it can be determined by looking at the signs of its Hessian matrix. If all eigenvalues are positive the point is called a local minimum, if $r$ of them are negative and the rest are positive, then it is called a saddle point with index $r$ . At the critical point, the eigenvectors indicate the directions in which the value of the function locally changes. Moreover, the changes are proportional to the corresponding -signed- eigenvalue. Under sufficient regularity conditions, it is rather straightforward to show that gradient-based methods converge to points where the gradient is zero. Recently Lee et al. (2016) showed that they indeed converge to minimizers. However, a significant and untested assumption to establish these convergence results is that the Hessian of the loss is non-degenerate. A relaxation of the above convergence to the case of non-isolated critical points can be found in (Panageas & Piliouras, 2016). What about the critical points of machine learning loss functions? Do they satisfy the non-degeneracy assumptions? If they don’t, can we still apply the results of provable theorems to gain intuition? ",
+        "bbox": [
+            174,
+            458,
+            825,
+            638
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 A HISTORICAL OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            665,
+            395,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One of the first instances of the comparison of GD and SGD in the context of neural networks dates back to the late eighties and early nineties. Bottou (1991) points out that large eigenvalues of the Hessian of the loss can create the illusion of the existence of local minima and GD can get stuck there, it further claims that the help of the inherent noise in SGD may help to get out of this obstacle. The origin of this observation is due to Bourrely (1989), as well as numerical justifications. However, given the computational limits of the time, these experiments relied on low-dimensional neural networks with few hidden units. The picture may be drastically different in higher dimensions. In fact, provable results in statistical physics tell us that, in certain real-valued non-convex functions, the local minima concentrate at an error level near that of the global minima. A theoretical review on this can be found in (Auffinger et al., 2013), while Sagun et al. (2014) and Ballard et al. (2017) provide an experimental simulation as well as a numerical study for neural networks. They notably find that high error local minima traps do not appear when the model is over-parametrized. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These concentration results can help explain why we find that the solutions attained by different optimizers like GD and SGD often have comparable training accuracies. However, while these methods find comparable solutions in terms of training error there is no guarantee they generalize equally. A recent work in this direction compares the generalization performance of small batch and large batch methods (Keskar et al., 2016). They demonstrate that the large batch methods always generalize a little bit worse even when they have similar training accuracies. The paper further makes the observation that the basins found by small batch methods are wider, thereby contributing to the claim that wide basins, as opposed to narrow ones, generalize better. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The final part of the historical account is devoted to the observation of flatness of the landscape in neural networks and its consequences through the lens of the Hessian. In the early nineties, Hochreiter & Schmidhuber (1997) remarks that there are parts of the landscape in which the weights can be perturbed without significantly changing the loss value. Such regions at the bottom of the landscape are called the flat minima, which can be considered as another way of saying a very wide minima. It is further noted that such minima have better generalization properties and a new loss function that makes use of the Hessian of the loss function has been proposed that targets the flat minima. The computational complexity issues have been attempted to be resolved using the $R$ -operator of Pearlmutter (1994). However, the new loss requires all the entries of the Hessian, and even with the $R$ -operator, it is unimaginably slow for today’s large networks. More recently, an exact numerical calculation of the Hessian has been carried out by Sagun et al. (2016). It turns out that the Hessian can have near zero eigenvalues even at a given random initial point, and that the spectrum of it is composed of two parts: (1) the bulk, and (2) the outliers. The bulk is mostly full of zero eigenvalues with a fast decaying tail, and the outliers are only a handful which appears to depend on the data. This implies that, locally, most directions in the weight space are flat, and leads to little or no change in the loss value, except for the directions of eigenvectors that correspond to the large eigenvalues of the Hessian. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            402
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.2 OVERVIEW OF RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            379,
+            434
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present a phenomenological study in which we provide various observations on the local geometry at the bottom of the landscape and discuss their implications on certain features of solution spaces: Connectedness of basins found by large and small batch methods. ",
+        "bbox": [
+            176,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Flatness at the bottom of the landscape: At the bottom, most of the eigenvalues in the spectrum of the Hessian are near zero, except for a small number of relatively larger ones.   \n2. A possible explanation through over-parametrization: The decomposition of the Hessian as a sum of two matrices, where the first one is the sample covariance matrix of the gradients of model outputs and the second one is the Hessian of the function that describes the model outputs. We argue that the second term can be ignored as training progress which leaves us with the covariance term which leads to degeneracy in the Hessian when there are more parameters than samples.   \n3. Dependence of eigenvalues to model-data-algorithm: We empirically examine the spectrum to uncover intricate dependencies within the data-architecture-algorithm triangle: (1) more complex data produce more outliers, (2) increasing the network size doesn’t affect the density of large eigenvalues, (3) large batch methods produce the same number of outliers that are larger in magnitude, and finally (4) there are negative eigenvalues even after the training process appears to show no further progress but their magnitude is much smaller than the outliers.   \n4. A new interpretation of basins: It has been a common practice to discuss certain features of basins found by various algorithms. Some recent examples, such as Keskar et al. (2016); Chaudhari et al. (2016); Jastrz˛ebski et al. (2017), appear to draw the big-picture of isolated basins at the bottom of the landscape. One tool that is commonly used to demonstrate such claims is to evaluate the loss on a line that connects two solutions found by different methods. First of all, the notion of the basin itself can be misleading given the negative eigenvalues pointed out in the previous item. Moreover, we claim that this idea of isolated basins may be misleading based on the above observations of the dramatic level of flatness of the local geometry. In particular, we show that two solutions with different qualities can be shown to be in the same basin even with a loss evaluation on a straight line connecting the two. ",
+        "bbox": [
+            210,
+            505,
+            825,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Remark 1: Throughout this paper we use the notions of data complexity and over-parametrization vaguely. The complexity of data can be defined in various ways and further research is required to determine the precise notion that is required that would link complexity to the spectrum. Overparametrization, similarly, can be defined in various ways: $M > > N$ , $M \\to \\infty$ for fixed $N$ , or $\\bar { M } / N \\to c$ for a certain constant, etc... However, more realistic notions of both complexity of the data and the over-parametrization should take the architecture into account, and detailed treatment of this should follow another work. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark 2: The notion of the basin, also, can be defined precisely. However, it is unclear whether any algorithm used in practice actually locates the bottom of a basin described in classical ways. For instance, the norm of the gradients are small but not at the machine precision, and the eigenvalues of the Hessian still has a negative part even after SGD continues a long while without a meaningful decrease in the loss value. This is presumably the fault of the algorithm itself, however, it requires a further study, and hence such notions of sharp vs. wide minima in various recent work should be taken with a grain of salt. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark 3: Even when one has a way to measure the width of a ‘basin’, such ways of measuring the approximate width are all relative. In a recent study, Dinh et al. (2017) shows how ‘sharp minima’ can still generalize with proper modifications to the loss function. We note that it takes a non-linear transformation to deform relative widths of basins. And, in this work, we focus on relative values as opposed to absolute values to get a consistent comparison across different setups. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2 SOME PROPERTIES OF THE HESSIAN",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            508,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 A FIRST LOOK AT THE SPECTRUM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            444,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We begin by an exact calculation of the spectrum of the Hessian at a random initial point, and at the end of training. Note that the plots are arranged in a way that they show the eigenvalues in the $y$ -axis, and indicate the order of the eigenvalue in the $x$ -axis. This choice is necessary to indicate the scale of the degeneracy while still showing all the eigenvalues in the same plot. Figure 1 shows the full spectrum of the Hessian at the random initial point of training and after the final training point. The model of this example is a two hidden layer network with a total of $5 K$ parameters that is trained using gradient descent. Also note that, throughout the paper, the exact full Hessian is computed via the Hessian-vector products (Pearlmutter, 1994) up to the machine precision. ",
+        "bbox": [
+            173,
+            435,
+            826,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a42ea3f545a3f89905e25602d5c37ba418bb503275e022376b20de2a029082c5.jpg",
+        "image_caption": [
+            "Figure 1: Ordered eigenvalues at a random initial point, and at the final point of GD. $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            560,
+            700,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 GENERALIZED GAUSS-NEWTON DECOMPOSITION OF THE HESSIAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            681,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to study its spectrum, we will describe how the Hessian can be decomposed into two meaningful matrices (LeCun et al., 1998; Martens, 2010). Suppose the loss function is given as a composition of two functions, the model function $f _ { \\bullet } : \\mathbb { R } ^ { M } \\xrightarrow { \\bullet \\bullet } \\mathbb { R }$ is the real-valued output of a network that depends on the parameters; and the loss function $\\ell _ { \\bullet } : \\mathbb { R } \\longrightarrow \\mathbb { R } ^ { + }$ is a convex function. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\bullet$ refers to the given example. Examples include the regression: the mean-square loss composed with a real-valued output function, and classification: the negative log-likelihood loss composed with the dot product of the output of a softmax layer with the label vector. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For ease of reading, we indicate the dependencies of functions $\\ell$ and $f$ to data by the index of the example, or omit it altogether in case it is not necessary, and unless noted otherwise the gradients are taken with respect to $w$ . The gradient and the Hessian of the loss for a given example are given by ",
+        "bbox": [
+            174,
+            152,
+            821,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cd8c3b8603c33771db0cb7a1e7ea064cca2679b9e700b3794fc6ecfd8c231cb.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla \\ell ( f ( w ) ) = \\ell ^ { \\prime } ( f ( w ) ) \\nabla f ( w ) } \\\\ & { \\nabla ^ { 2 } \\ell ( f ( w ) ) = \\ell ^ { \\prime \\prime } ( f ( w ) ) \\nabla f ( w ) \\nabla f ( w ) ^ { T } + \\ell ^ { \\prime } ( f ( w ) ) \\nabla ^ { 2 } f ( w ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            198,
+            700,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\bullet ^ { T }$ denotes the transpose operation (here the gradient is a column-vector). Note that since $\\ell$ is convex $\\ell ^ { \\prime \\prime } ( s ) \\geq 0$ and we can take its square root which allows us to rewrite the Hessian of the loss as follows: ",
+        "bbox": [
+            176,
+            242,
+            825,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/daa1e68f3b661e274d99796eda7164fd674a361a9e60f3d41d3d93aa4119c402.jpg",
+        "text": "$$\n\\nabla ^ { 2 } \\mathcal { L } ( w ) = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } [ \\sqrt { \\ell _ { i } ^ { \\prime \\prime } ( f _ { i } ( w ) ) } \\nabla f _ { i } ( w ) ] [ \\sqrt { \\ell _ { i } ^ { \\prime \\prime } ( f _ { i } ( w ) ) } \\nabla f _ { i } ( w ) ] ^ { T } + \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\ell _ { i } ^ { \\prime } ( f _ { i } ( w ) ) \\nabla ^ { 2 } f _ { i } ( w )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            306,
+            797,
+            351
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In general, it isn’t straightforward to discuss the spectrum of the sums of matrices by looking at the individual ones. Nevertheless, looking at the decomposition, we can still infer what we should expect. At a point close to a local minimum, the average gradient is close to zero. However, this doesn’t necessarily imply that the gradients for individual samples are also zero. However, if $\\ell ^ { \\prime } ( f ( \\hat { w } ) )$ and $\\nabla ^ { 2 } f ( { \\hat { w } } )$ are not correlated, then we can ignore the second term. And so the Hessian can be approximated by the first term: ",
+        "bbox": [
+            173,
+            359,
+            826,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc1591c4ec6740c5258f081f8924e7ea959b4a1c5c29f8ce78b5f302d37e5d8a.jpg",
+        "text": "$$\n\\nabla ^ { 2 } \\mathcal { L } ( \\hat { w } ) \\approx \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } [ \\sqrt { \\ell _ { i } ^ { \\prime \\prime } ( f _ { i } ( \\hat { w } ) ) } \\nabla f _ { i } ( \\hat { w } ) ] [ \\sqrt { \\ell _ { i } ^ { \\prime \\prime } ( f _ { i } ( \\hat { w } ) ) } \\nabla f _ { i } ( \\hat { w } ) ] ^ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            460,
+            710,
+            505
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, Equation 5 is the sum of rank one matrices (via the outer products of gradients of $f$ multiplied by some non-negative number), therefore, the sum can be written as a product of an $M \\times N$ matrix with its transpose where the columns of the matrix are formed by the scaled gradients of $f$ . Immediately, this implies that there are at least $M - N$ many trivial eigenvalues of the right-hand side in Equation 5. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "From a theoretical point of view, the tool that is required for the above problem should be a mapping of eigenvalues of the population matrix to the sample covariance matrix. Recent provable results on this can be found in Bloemendal et al. (2016) (please refer to the appendix for a review of this approach). We emphasize that this result require independent inputs, and extensions to correlated data appear to be unavailable to the best of our knowledge. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 IMPLICATIONS OF FLATNESS FOR THE GEOMETRY OF THE ENERGY LANDSCAPE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            680,
+            753,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we leave the decomposition behind and focus on experimental results of the spectrum of the full Hessian through the exact Hessian-vector products. We discuss how data, model, and algorithm affect the spectrum of the Hessian of the loss. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 THE RELATION BETWEEN DATA AND EIGENVALUES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            568,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In many cases of practical interest, the data contains redundancies. In such cases, the number of non-trivial eigenvalues could be even smaller than $N$ . For instance, if one deals with a classification problem where the training data has $k$ classes with relatively small deviation among each of them, it is reasonable to expect that there will be an order of $k$ many non-trivial eigenvalues of the first term of the above decomposition of the Hessian in Equation 5. Then, if the second term is small (for instance when all the gradients per example are zero), we would expect to see $k$ many outliers in the spectrum of the Hessian of the loss. To test this idea, we used a feed-forward neural network with a 100- dimensional input layer, two hidden layers each of which with 30 hidden units, and a $k$ dimensional output layer that is combined with softmax for $k$ -class classification. We randomly sampled from $k$ Gaussian clusters in the input space and normalized the data globally. Then we carried out the training using SGD on ReLU network for the following number of clusters: $k : \\{ 2 , 5 , 1 0 , 2 0 , 5 0 \\}$ . ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4fbebe062090713f1dfd0f8b7475c18fe8b82c9d4cde1a97c8ab2996dc176580.jpg",
+        "image_caption": [
+            "Figure 2: Ordered plot of eigenvalues with a visible gap. $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            164,
+            700,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The number of large eigenvalues that are above the gap in Figure 2 match exactly the number of classes in the dataset. This experiment is repeated for various different setups. Please refer to Table 1 in the appendix for more experiments on this. ",
+        "bbox": [
+            176,
+            439,
+            823,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": ".2 THE RELATION BETWEEN NUMBER OF PARAMETERS AND EIGENVALUE",
+        "text_level": 1,
+        "bbox": [
+            189,
+            505,
+            702,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We test the effect of growing the size of the network when data, architecture, and algorithm are fixed. In some sense, we make the system more and more over-parametrized. Based on the intutions developed above we should not observe a change in the size and number of the large eigenvalues of the Hessian at the bottom. To test this, we sample 1K examples from the MNIST dataset and fix them as the training set. Then we form four different networks each of which has a different number of nodes in its hidden layer $( n _ { \\mathrm { h i d d e n } } \\in \\{ 1 0 , 3 0 , 5 0 , 7 0 \\} )$ . All four networks are trained with the same step size and the same number of iterations and the exact Hessian is computed at the end. Figure 3 shows the largest 120 eigenvalues of each of the four Hessians ranked in an increasing order. For the right edge of the spectrum (that is, for the large positive eigenvalues), the shape of the plot remains invariant as the number of parameters increase (Figure 3). ",
+        "bbox": [
+            174,
+            532,
+            825,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 THE RELATION BETWEEN THE ALGORITHM AND EIGENVALUES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            694,
+            648,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we turn to describing the nature of solutions found by the large and small batch methods for the training landscape. We train a convnet that is composed of 2 convolution layers with relu-maxpool followed by two fully-connected layers. The training set is a subsampled MNIST with 1K training examples. The small batch method uses a mini-batch size of 10, and the large-batch one uses 512. A learning rate for which both algorithms converge is fixed for both LB and SB. Note that the stochastic gradients are averaged over the mini-batch. Therefore, fixing the learning rate allows the algorithms to take steps whose lengths are proportional to the norms of the corresponding stochastic gradients averaged over the mini-batch. This way we ensure that both methods are compared fairly when we look at them after a fixed number of iterations. We train until the same number of iterations have been reached. Then, we calculate the Hessian and the spectrum of the Hessian in Figure 4. The large batch method locates points with larger positive eigenvalues. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This observation is consistent with Keskar et al. (2016) as the way they measure flatness takes local rates of increase in a neighborhood of the solution into account which is intimately linked to the size of the large eigenvalues. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f751607ab68bf5feee8f1c81ac1d411f8954d6dde92aa433b4a21923c88e66df.jpg",
+        "image_caption": [
+            "Figure 3: Right edge of the spectrum of the Hessian of the loss for a fully connected network on MNIST with increasing dimensions. $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            106,
+            700,
+            328
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb42f773ad6f94809f91f414af482070514e830e20d01184d707a08d98f7fc5b.jpg",
+        "image_caption": [
+            "Figure 4: Outlier eigenvalues of LB ( $\\mathit { b s } = 5 1 2$ ) vs SB $b s = 1 0$ ). $x$ -axis is the rank of the eigenvalue, and $y$ -axis the value of the eigenvalue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            411,
+            700,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 TRAILING NEGATIVE EIGENVALUES AFTER TRAINING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            583,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we observe that the negative eigenvalues at the end of the training are orders of magnitude smaller than the large ones. The very existence of the negative eigenvalues indicates that the algorithm didn’t locate a local minimum, yet. Note that the stopping criterion in most practical cases is arbitrary. Training is stopped after there is no meaningful decrease in the loss value or increase in the test accuracy. In our experiments, the training ran well beyond the point of this saturation. In this time-scale, the loss decays in much smaller values. And we may expect convergence to a localminimum at large (possibly exponentially long) time-scales. However, from a practical point of view, it appears that the properties of the landscape at this fine-grained scale is less relevant in terms of its test performance. Anyhow, we observe that there are a number of negative eigenvalues but their magnitude is much smaller compared to the positive eigenvalues. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The reason we look at the ranked negative eigenvalues in percentages rather than the order is the result of the experiment in Section 3.2. Adding more weights to the system scale the small scale eigenvalues proportionally, the number of outliers remain unchanged whereas the ratio of negative $x$ -axis indicates the order of the eigenvalue in percentages, $y$ -axis indicates the eigenvalues. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4406d2d101a4651dbf0ea934cdc919de22794f459db105c77b087176aaac1049.jpg",
+        "image_caption": [
+            "Figure 5: Negative eigenvalues at the bottom when increasing the number of hidden nodes (compare with Figure 3). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            470,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7dd126bf66a93a6e21f5ee37b57d65ff0d19fb71c8926a33bc4e8193b4bf60ae.jpg",
+        "image_caption": [
+            "Figure 6: Negative eigenvalues at the bottom for LB-SB experiment on MNIST (compare with Figure 4). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            104,
+            810,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            197,
+            333,
+            795,
+            348
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "eigenvalues remain the same. Moreover, they appear to be converging to have the same shape (Figure 6). Also, note that the negative eigenvalues can only come from the second term of the decomposition in Equation 5. Unless the second term contributes to the spectrum in an asymmetrical way, the observation that the negative eigenvalues are small confirms our previous suspicions that the effect of the ignored term in the decomposition is small. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ON BASINS OF SOLUTIONS AND GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            476,
+            725,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we revisit the issue through the lens of the following question: What does overparametrization imply on the discussion around GD vs. SGD (or large batch vs small batch) especially for their generalization properties? In this final section, we will argue that, contrary to what is believed in Keskar et al. (2016) and Chaudhari et al. (2016) the two algorithms do not have to be falling into different basins. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            577
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As noted in the introduction, for a while the common sense explanation on why SGD works well (in fact better) than GD (or large batch methods) was that the non-convex landscape had local minima at high energies which would trap large-batch or full-batch methods. Something that SGD with small batch shouldn’t suffer due to the inherent noise in the algorithm. However, there are various experiments that have been carried out in the past that show that, for reasonable large systems, this is not the case. For instance, Sagun et al. (2014) demonstrate that a two hidden layer fully connected network on MNIST can be trained by GD to reach at the same level of loss values as SGD 1. In fact, when the step size is fixed to the same value for both of the algorithms, they reach the same loss value at the same number of iterations. The training accuracy for both algorithms are the same, and the gap between test accuracies diminish as the size of the network increase with GD falling ever so slightly behind. It is also shown in Keskar et al. (2016) that training accuracies for both large and small batch methods are comparably good. Furthermore, Zhang et al. (2016) demonstrates that training landscape is easy to optimize even when there is no clear notion of generalization. Such observations are consistent with our observations: over-parametrization (due to the architecture of the model) leads to flatness at the bottom of the landscape which is easy to optimize. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When we turn our attention to generalization, Keskar et al. (2016) note that LB methods find a basin that is different than the one found by SB methods, and they are characterized by how wide the basin is. As noted in Figure 4, indeed the large eigenvalues are larger in LB than in SB, but is it enough to justify that they are in different basins, especially given the fact that the number of flat directions are enormous. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            842
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.1 ARE THEY REALLY DIFFERENT BASINS? CASE OF CIFAR10 WITH LB VS SB ",
+        "bbox": [
+            176,
+            154,
+            743,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The observation that LB converges to sharper basins that are separated by wells from the wider basins found by SB has been an observation that triggered attention. In this section, we present two solutions with different qualities as measured by the generalization error and we show that they are in fact in the same ‘basin’ by showing that the evaluation of the loss doesn’t go through a barrier between the two solutions. We start by two common pitfalls that one may fall into in testing this: ",
+        "bbox": [
+            174,
+            183,
+            823,
+            252
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The problem with epoch based time scales: A common way to plot training profiles in larger scale neural networks is to stop every epoch to reserve extra computational power to calculate various statistics of the model at its current position. This becomes problematic when one compares training with different batch sizes, primarily because the larger batch model takes fewer steps in a given epoch. Recall that the overall loss is averaged, therefore, for a fixed point in the weight space, the empirical average of the gradients is an unbiased estimator for the expected gradient. Hence it is reasonable to expect that the norms of the large batch methods match to the ones of the small batch. And for a fair comparison, one should use the same learning rate for both training procedures. This suggests that a better comparison between GD and SGD (or LB and SB) should be scaled with the number of steps, so that, on average both algorithms are able to take similar number of steps of comparable sizes. The experiments we present use the number of iterations as the time-scale. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            411
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The problem with line interpolations in the weight space: The architecture of typical neural networks have many internal symmetries, one of which is the flip symmetry: when one swaps two nodes (along with the weights connected to it) at a given layer, the resulting network is identical to the original one. Therefore, when one trains two systems to compare, it may well be possible that the two fall into different flip symmetrical configurations that may look more similar when they are reordered. Therefore, training two systems with levels of randomness (seed, batch-size, choice of the initial point, etc.) may result in two points in the weight space that present a barrier only because of such symmetries. In an attempt to partially alleviate this problem we switch dynamics of an already trained system. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            544
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "1. Part I: Train full CIFAR10 data for a bare AlexNet (bare meaning: no momentum, no dropout, and no batch normalization) with a batch-size of 1, 000. Record every 100 steps for 250 times.   \n2. Part II: Continue training from the endpoint of the previous step with a smaller batch-size of 32. Everything else, including the constant learning rate is kept the same. And train another 250 periods each of which with 100 steps. ",
+        "bbox": [
+            212,
+            560,
+            825,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The key observation is the jump in the training and test losses, and a drop in the corresponding accuracies (Figure 8). Toward the end of Part II the small batch reaches to a slightly better accuracy (about $\\sim 1 \\%$ ). And this looks in line with the observations in Keskar et al. (2016), in that, it appears that the LB solution and SB solutions are separated by a barrier and that the latter of which generalizes better. Moreover, the line interpolations extending away from either endpoint appear to be confirming the sharpness of LB solution. However, we find the straight line interpolation connecting the endpoints of Part $I$ and Part $\\boldsymbol { { I I } }$ turns out to not contain any barriers (Figure 9). This suggests that while the Part I and Part $\\mathit { I I }$ converge to two solutions with different properties, these solutions have been in the same basin all along. This raises the striking possibility that those other seemingly different solutions may be similarly connected by a flat region to form a larger basin (modulo internal symmetries). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another interpretation of this experiment, also, goes through the Gauss-Newton decomposition introduced in Equation 5. When we decrease the batch size, we increase the noise in the covariance of the gradients, and hence the first term starts to dominate. Even when the weight space has large flat regions, the fluctuations of the stochastic noise should be precisely in the directions of the large eigenvalues. Therefore, at the beginning of Part II, the loss increases because the point fluctuates in the directions corresponding to the large eigenvalues, and eventually settles at a point that lies at the interior of the same level set, essentially staying in the same basin. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5c5f663577c8905a19568647d00c87c0e4a933a78191dbe2bb7d22018e7cb1d6.jpg",
+        "image_caption": [
+            "Figure 8: Large batch training immediately followed by small batch training on the full dataset of CIFAR10 with a raw version of AlexNet. The accuracy increases by about $1 \\%$ : Part $I$ and Part $\\boldsymbol { { I I } }$ locate solutions with different generalization properties. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            292,
+            106,
+            705,
+            311
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/00062df2c9db72157e87cfcfab556fa17a73ef0bc785e7112e2fbd5d668d050d.jpg",
+        "image_caption": [
+            "Figure 9: Loss and accuracy evaluation on the straight line that contains LB and SB solutions. The accuracy of the SB solution is $\\sim 1 \\%$ better than the LB solution, but there is no barrier between the two points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            388,
+            704,
+            595
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.2 FURTHER DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            377,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One of the most striking implications of flatness may be the connected structure of the solution space. We may wonder whether two given solutions can be connected by a continuous path of solutions. This question has been explored in a recent work: in Freeman & Bruna (2016) it is shown that for one hidden layer rectified neural networks the solution space is connected which is consistent with the flatness of the landscape. The classical notion of basins of attractions may not be the suitable objects to study for neural networks. Rather, we may look at the exploration of interiors of level sets of the landscape. We may be tempted to speculate that such an exploration may indeed result in point that generalizes better. However, the flat space itself is very high dimensional which comes with its own computational issues. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The training curve can be seen as composed of two parts: (1) high gain part where the norm of the gradients are large, (2) noise of the gradients is larger relative to the size of the stochastic gradients (see (Shwartz-Ziv & Tishby, 2017) for a recent reference). We speculate that the first part is relatively easy and even a large batch method can locate a large level set that contains points that generalize better than what’s initially found. From a practical point of view, using larger batches with larger step sizes can, in fact, accelerate training. An example of this can be found in Goyal et al. (2017), where training Imagenet with a minibatch size of 8192 can match small batch performance. On a final note for further consideration, we remark that we used standard pre-processing and initialization methods that are commonly used in practice. Fixing these two aspects, we modified the data, model, and algorithm in order to study their relative effects. However, the effects of pre-processing and initialization on the Hessian is highly non-trivial and deserves a separate attention. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            318,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We have shown that the level of the singularity of the Hessian cannot be ignored from theoretical considerations. Furthermore, we use the generalized Gauss-Newton decomposition of the Hessian to argue the cluster of zero eigenvalues are to be expected in practical applications. This allows us to reconsider the division between initial fast decay and final slow progress of training. We see that even large batch methods are able to get to the same basin where small batch methods go. As opposed to the common intuition, the observed generalization gap between the two is not due to small batch finding a different, better, wider basin. Instead, the two solutions appear to be in the same basin. This lack of a barrier between solutions is demonstrated by finding paths between the two points that lie in the same level set. To conclude, we propose a major shift in perspective on considerations of the energy landscape in deep learning problems. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            364
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            385,
+            285,
+            398
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antonio Auffinger, Gérard Ben Arous, and Jiˇrí Cern ˇ y. Random matrices and complexity of spin \\` glasses. Communications on Pure and Applied Mathematics, 66(2):165–201, 2013. ",
+        "bbox": [
+            174,
+            406,
+            823,
+            435
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jinho Baik, Gérard Ben Arous, Sandrine Péché, et al. Phase transition of the largest eigenvalue for nonnull complex sample covariance matrices. The Annals of Probability, 33(5):1643–1697, 2005. ",
+        "bbox": [
+            173,
+            444,
+            823,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew J Ballard, Ritankar Das, Stefano Martiniani, Dhagash Mehta, Levent Sagun, Jacob D Stevenson, and David J Wales. Energy landscapes for machine learning. Physical Chemistry Chemical Physics, 2017. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Bloemendal, Antti Knowles, Horng-Tzer Yau, and Jun Yin. On the principal components of sample covariance matrices. Probability Theory and Related Fields, 164(1-2):459–552, 2016. ",
+        "bbox": [
+            174,
+            532,
+            823,
+            561
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Léon Bottou. Stochastic gradient learning in neural networks. Proceedings of Neuro-Nımes, 91(8), 1991. ",
+        "bbox": [
+            174,
+            570,
+            823,
+            598
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Léon Bottou. Large-scale machine learning with stochastic gradient descent. In Proceedings of COMPSTAT’2010, pp. 177–186. Physica-Verlag HD, 2010. ",
+        "bbox": [
+            176,
+            607,
+            823,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J Bourrely. Parallelization of a neural network learning algorithm on a hypercube. Hypercube and distributed computers. Elsiever Science Publishing, 1989. ",
+        "bbox": [
+            174,
+            643,
+            823,
+            674
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. arXiv preprint arXiv:1611.01838, 2016. ",
+        "bbox": [
+            174,
+            681,
+            823,
+            724
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv preprint arXiv:1703.04933, 2017. ",
+        "bbox": [
+            176,
+            732,
+            823,
+            762
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C Daniel Freeman and Joan Bruna. Topology and geometry of deep rectified network optimization landscapes. arXiv preprint arXiv:1611.01540, 2016. ",
+        "bbox": [
+            176,
+            770,
+            823,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            176,
+            806,
+            823,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997. ",
+        "bbox": [
+            173,
+            858,
+            797,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stanisław Jastrz˛ebski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos Storkey. Three factors influencing minima in sgd. arXiv preprint arXiv:1711.04623, 2017. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.   \nYann LeCun, Léon Bottou, GB Orr, and K-R Müller. Efficient backprop. Lecture notes in computer science, pp. 9–50, 1998.   \nJason D Lee, Max Simchowitz, Michael I Jordan, and Benjamin Recht. Gradient descent converges to minimizers. University of California, Berkeley, 1050:16, 2016.   \nVladimir A Marcenko and Leonid Andreevich Pastur. Distribution of eigenvalues for some sets of ˇ random matrices. Mathematics of the USSR-Sbornik, 1(4):457, 1967.   \nJames Martens. Deep learning via hessian-free optimization. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 735–742, 2010.   \nSong Mei, Yu Bai, and Andrea Montanari. The landscape of empirical risk for non-convex losses. arXiv preprint arXiv:1607.06534, 2016.   \nJorge Nocedal and Stephen J Wright. Numerical optimization, second edition. Numerical optimization, pp. 497–528, 2006.   \nIoannis Panageas and Georgios Piliouras. Gradient descent only converges to minimizers: Nonisolated critical points and invariant regions. arXiv preprint arXiv:1605.00405, 2016.   \nBarak A Pearlmutter. Fast exact multiplication by the hessian. Neural computation, 6(1):147–160, 1994.   \nLevent Sagun, V. Ugur Güney, Gérard Ben Arous, and Yann LeCun. Explorations on high dimensional ˘ landscapes. ICLR 2015 Workshop Contribution, arXiv:1412.6615, 2014.   \nLevent Sagun, Léon Bottou, and Yann LeCun. Singularity of the hessian in deep learning. arXiv preprint arXiv:1611.07476, 2016.   \nTom Schaul, Sixin Zhang, and Yann LeCun. No more pesky learning rates. ICML (3), 28:343–351, 2013.   \nRavid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.   \nChiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016. ",
+        "bbox": [
+            171,
+            94,
+            828,
+            642
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A OUTLIER EIGENVALUES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            408,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the subsequent experiments, we used a feed-forward neural network with a 100 dimensional input layer, two hidden layers each of which with 30 hidden units, and a $k$ dimensional output layer that is combined with softmax for $k$ -class classification. We sampled random $k$ Gaussian clusters in the input space and normalized the data globally. Then we carried out the training for the following sets of parameters: $k : \\{ 2 , 5 , 1 0 , 2 0 , 5 0 \\}$ , algorithm: {GD, SGD}, non-linearity: {tanh, ReLU}, initial multipler for the covariance of the input distribution: $\\{ 1 , 1 0 \\}$ . Then we counted the number of large eigenvalues according to three different cutoff methods: largest consecutive gap, largest consecutive ratio, and a heuristic method of determining the threshold by searching for the elbow in the scree plot (see Figure 2). In Table 1 we marked the ones that are off by $\\pm 1$ . ",
+        "bbox": [
+            173,
+            132,
+            825,
+            258
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/69883c60d101ad6328f3ba55fa3a03132297f383ffb1706fecbf29f37979a01d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>alg-size</td><td>cov</td><td>mean&amp;std</td><td>nc</td><td>gap</td><td>ratio</td><td>heur</td><td>cutoff</td></tr><tr><td>GD tanh 4022</td><td>1.0</td><td>1.19e-05,1.19e-05</td><td>2</td><td>2</td><td>3</td><td>N/A</td><td>N/A</td></tr><tr><td>GD tanh 4115</td><td>1.0</td><td>2.52e-05,2.52e-05</td><td>5</td><td>2</td><td>17</td><td>N/A</td><td>N/A</td></tr><tr><td>GD tanh 4270</td><td>1.0</td><td>3.75e-05,3.75e-05</td><td>10</td><td>2</td><td>4</td><td>N/A</td><td>N/A</td></tr><tr><td>GD tanh 4580</td><td>1.0</td><td>5.37e-05, 5.37e-05</td><td>20</td><td>3</td><td>4</td><td>N/A</td><td>N/A</td></tr><tr><td>GDReLU4022</td><td>1.0</td><td>7.13e-06,7.13e-06</td><td>2</td><td>3</td><td>4</td><td>2</td><td>0.003</td></tr><tr><td>GD ReLU 4115</td><td>1.0</td><td>1.55e-05, 1.55e-05</td><td>5</td><td>6</td><td>7</td><td>5</td><td>0.003</td></tr><tr><td>GD ReLU4270</td><td>1.0</td><td>3.04e-05,3.04e-05</td><td>10</td><td>11</td><td>12</td><td>10</td><td>0.003</td></tr><tr><td>GD ReLU4580</td><td>1.0</td><td>5.65e-05,5.65e-05</td><td>20</td><td>4</td><td>21</td><td>21</td><td>0.003</td></tr><tr><td>GD ReLU5510</td><td>1.0</td><td>1.16e-04, 1.16e-04</td><td>50</td><td>50</td><td>51</td><td>49</td><td>0.003</td></tr><tr><td>SGD1 ReLU4022</td><td>1.0</td><td>8.96e-06, 8.96e-06</td><td>2</td><td>3</td><td>4</td><td>2</td><td>0.002</td></tr><tr><td>SGD ReLU 4115</td><td>1.0</td><td>1.62e-05, 1.62e-05</td><td></td><td>6</td><td>7</td><td>7</td><td>0.002</td></tr><tr><td>SGD ReLU4270</td><td>1.0</td><td>2.97e-05,2.97e-05</td><td></td><td>2</td><td>14</td><td>15</td><td>0.002</td></tr><tr><td>SGD ReLU 4580</td><td>1.0</td><td>4.53e-05,4.53e-05</td><td></td><td>2</td><td>3</td><td>21</td><td>0.002</td></tr><tr><td>SGD ReLU 5510</td><td>1.0</td><td>6.78e-05, 6.78e-05</td><td></td><td>50</td><td>51</td><td>49</td><td>0.002</td></tr><tr><td>SGD1 ReLU4022</td><td>10.0</td><td>9.49e-05,9.49e-05</td><td>2</td><td>2</td><td>4</td><td>2</td><td>0.015</td></tr><tr><td>SGD ReLU 4115</td><td>10.0</td><td>1.68e-04, 1.68e-04</td><td></td><td>5</td><td>6</td><td>5</td><td>0.015</td></tr><tr><td>SGD ReLU 4270</td><td>10.0</td><td>1.92e-04, 1.92e-04</td><td></td><td>2</td><td>11</td><td>9</td><td>0.015</td></tr><tr><td>SGD ReLU 4580</td><td>10.0</td><td>3.10e-04,3.10e-04</td><td>20</td><td>20</td><td>21</td><td>19</td><td>0.015</td></tr><tr><td>SGD ReLU 5510</td><td>10.0</td><td>1.67e-04, 1.67e-04</td><td>50</td><td>50</td><td>51</td><td>49</td><td>0.005</td></tr></table>",
+        "bbox": [
+            217,
+            268,
+            779,
+            553
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Counting outliers for matching the number of blobs. Dictionary of table elements: {cov: scale of covariance for inputs, mean&std: of the eigenvalues, nc: number of clusters, gap: largest consecutive gaps, ratio: largest consecutive ratios, heur: heuristic threshold, cutoff: the value of the heur.} ",
+        "bbox": [
+            173,
+            569,
+            826,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B THE SPECTRUM OF THE GENERALIZED GAUSS-NEWTON MATRIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            642,
+            745,
+            660
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will show that the spectrum of the Generalized Gauss-Newton matrix can be characterized theoretically under some conditions. Suppose that we can express the scaled gradient $( \\sqrt { \\ell _ { i } ^ { \\prime \\prime } ( f _ { i } ( \\hat { w } ) ) } \\nabla f _ { i } ( \\hat { w } )$ from Equation 5) as $g = T x$ with the matrix $T \\in M \\times d$ depending only on the parameters $w$ - which is the case for linear models. Then we can write: $\\begin{array} { r } { G = \\frac { 1 } { N } \\sum _ { i \\in \\mathcal { D } } g _ { i } g _ { i } ^ { T } = } \\end{array}$ $\\scriptstyle { \\frac { 1 } { N } } T X X ^ { T } T ^ { T }$ , where at the e $X = \\{ x ^ { 1 } , \\ldots , x ^ { N } \\}$ is an ized $d \\times N$ matrix. Furthermhat the entries of e, without loss of generality,are independent with zero $X$   \nmean and unit variance. One of the first steps in studying $G$ goes through understanding its principle components. In particular, we would like to understand how the eigenvalues and eigenvectors of $G$ are related to the ones of $\\Sigma$ where $\\begin{array} { r } { \\Sigma : = \\mathbb { E } ( G ) = \\frac { 1 } { N } T X X ^ { T } T ^ { T } = \\breve { T } T ^ { T } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            672,
+            825,
+            808
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the simplest case, we have $\\Sigma = I d$ so that the gradients are uncorrelated and the eigenvalues of $G$ are distributed according to the Marcenko-Pastur law in the limit where ˇ $N , M \\to \\infty$ and $\\textstyle \\alpha : = { \\frac { M } { N } }$ . The result dates back to sixties and can be found in (Marcenko & Pastur, 1967). Note that ˇ if $M \\stackrel { \\_ } { > } N$ then there are $M - N$ trivial eigenvalues of $G$ at zero. Also, the width of the nontrivial distribution essentially depends on the ratio $\\alpha$ . Clearly, setting the expected covariance to identity is very limiting. One of the earliest relaxations appear in (Baik et al., 2005). They prove a phase transition for the largest eigenvalues of the sample covariance matrix which has been known as the BBP phase transition. A case that may be useful for our setup is as follows: ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Baik, Arous, Péché, et al., 2005). If $\\Sigma = d i a g ( \\ell , 1 , \\dots , 1 )$ , $\\ell > 1$ , and $M , N \\to \\infty$ with $\\begin{array} { r } { \\frac { M } { N } = \\alpha \\ge 1 } \\end{array}$ . Let $c = 1 + \\sqrt { \\alpha }$ , and let’s call the top eigenvalue of the sample covariance matrix as $\\lambda _ { m a x }$ then: ",
+        "bbox": [
+            176,
+            103,
+            825,
+            147
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "• If $\\dot { \\cdot } 1 \\leq \\ell < c$ then $\\lambda _ { m a x }$ is at the right edge of the spectrum with Tracy-Widom fluctuations. • If $c < \\ell$ then $\\lambda _ { m a x }$ is an outlier that is away from bulk centered at $\\textstyle { \\ell ( 1 + { \\frac { \\alpha } { \\ell - 1 } } ) }$ with Gaussian fluctuations. ",
+        "bbox": [
+            209,
+            157,
+            823,
+            209
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Typically, due to the correlations in the problem we don’t have $\\Sigma$ to be the identity matrix or a diagonal matrix with spikes. This makes the analysis of their spectrum a lot more difficult. A solution for this slightly more general case with non-trivial correlations has been provided only recently by Bloemendal et al. (2016). We will briefly review these results here see how they are related to the first term of the above decomposition. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            290
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Bloemendal, Knowles, Yau, and Yin, 2016). If $d = M$ , $\\Sigma - I d$ has bounded rank, $\\log N$ is comparable to $\\log M$ , and entries of $X$ are independent with mean zero and variance one, then the spectrum of $\\Sigma$ can be precisely mapped to the one of $G$ as $M , N \\to \\infty$ for fixed $\\textstyle \\alpha = { \\frac { M } { N } }$ . Let $K = m i n \\{ M , N \\}$ , and the decomposition of the spectrum can be described as follows: ",
+        "bbox": [
+            174,
+            292,
+            826,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "• Zeros: $M - K$ many eigenvalues located at zero (i $f M > N ,$ ).   \n• Bulk: Order $K$ many eigenvalues are distributed according to Marˇcenko-Pastur law.   \n• Right outliers: All eigenvalues of $\\Sigma$ that exceed a certain value produce large-positive outlier eigenvalues to the right of the spectrum of $G$ .   \n• Left outliers: All eigenvalues of $\\Sigma$ that are close to zero produce small outlier eigenvalues between 0 and the left edge of the bulk of $G$ . ",
+        "bbox": [
+            214,
+            358,
+            825,
+            465
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Moreover, the eigenvectors of outliers of $G$ are close to the corresponding ones of $\\Sigma$ ",
+        "bbox": [
+            173,
+            476,
+            727,
+            491
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "This theorem essentially describes the way in which one obtains outlier eigenvalues in the sample covariance matrix assuming the population covariance is known. Here is an example: ",
+        "bbox": [
+            173,
+            501,
+            825,
+            530
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/14fbcfe88d568ad1d54cf2c1514c70323512138de1ca1d350367672645843720.jpg",
+        "image_caption": [
+            "Figure 10: Spectrum of the logistic regression loss with tanh unit: when data has a single Gaussian blob (left), when data has two Gaussian blobs (right). In the latter case, the spectrum has outlier eigenvalues at 454.4, 819.5, and 92.7 for $a l p h a = 1 , 2 , 0 . 0 2$ , respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            536,
+            816,
+            696
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Example 1 (Logistic regression). Consider the log-loss $\\begin{array} { r } { \\ell ( s , y ) = - y \\log { \\frac { 1 } { 1 + e ^ { - s } } } - ( 1 - y ) \\log ( 1 - } \\end{array}$ 11+e−s ) and a single neuron with the sigmoid non-linearity. Note that \\`(s, y) is convex in s for fixed $y$ , and we can apply the decomposition using $\\ell$ and $f ( w , x ) = \\langle w , x \\rangle$ . In this case we have $M = d$ , also, note that the second part of the Hessian in Equation 4 is zero since $\\nabla ^ { 2 } f ( w , x ) = 0$ . So the Hessian of the loss is just the first term. It is straightforward to calculate that the gradient per sample is of the form $g = c ( w , x ) I d _ { M } x$ for a positive constant $c = c ( w , x )$ that doesn’t depend on $y$ . This case falls into the classical Marchenko-Pastur law (left pane of Figure 10). ˇ ",
+        "bbox": [
+            173,
+            756,
+            825,
+            861
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Example 2. Once we have more than one class this picture fails to hold. For, $\\ell ( s ) = - \\log ( s )$ , and $\\begin{array} { r } { f ( w ; ( x , y ) ) = \\frac { \\exp ^ { - \\langle w _ { y } , x \\rangle } } { \\sum _ { k } \\exp ^ { - \\langle w _ { y ^ { k } } , x \\rangle } } } \\end{array}$ the spectrum changes. It turns out that in that case the weights have one large outlier eigenvalue, and a bulk that’s close to zero (right pane of Figure 10). ",
+        "bbox": [
+            174,
+            863,
+            825,
+            917
+        ],
+        "page_idx": 13
+    }
+]

parse/train/v_4XcXsAZUn/v_4XcXsAZUn_content_list.json

@@ -0,0 +1,1114 @@
+[
+    {
+        "type": "text",
+        "text": "Robustness of Graph Neural Networks at Scale ",
+        "text_level": 1,
+        "bbox": [
+            210,
+            122,
+            785,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Simon Geisler, Tobias Schmidt, Hakan ¸Sirin, Daniel Zügner, Aleksandar Bojchevski, and Stephan Günnemann Department of Informatics Technical University of Munich {geisler, schmidtt, sirin, zuegnerd, bojchevs, guennemann}@in.tum.de ",
+        "bbox": [
+            207,
+            200,
+            792,
+            271
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            306,
+            535,
+            323
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) are increasingly important given their popularity and the diversity of applications. Yet, existing studies of their vulnerability to adversarial attacks rely on relatively small graphs. We address this gap and study how to attack and defend GNNs at scale. We propose two sparsity-aware first-order optimization attacks that maintain an efficient representation despite optimizing over a number of parameters which is quadratic in the number of nodes. We show that common surrogate losses are not well-suited for global attacks on GNNs. Our alternatives can double the attack strength. Moreover, to improve GNNs’ reliability we design a robust aggregation function, Soft Median, resulting in an effective defense at all scales. We evaluate our attacks and defense with standard GNNs on graphs more than 100 times larger compared to previous work. We even scale one order of magnitude further by extending our techniques to a scalable GNN. ",
+        "bbox": [
+            232,
+            335,
+            766,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            310,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The evidence that Graph Neural Networks (GNNs) are not robust to adversarial perturbations is compelling [14, 20, 50]. However, the graphs in previous robustness studies are tiny. This is worrying, given that GNNs are already deployed in many real-world Internet-scale applications $\\boxed { \\boxed { 5 } } \\boxed { \\boxed { 4 4 } } \\boxed { }$ . For example, PubMed $\\pmb { \\mathbb { B 3 } }$ (19,717 nodes) is often considered to be a large-scale graph and around $2 0 \\mathrm { G B }$ of memory is required for an attack based on its dense adjacency matrix. Such memory requirements are impractical and limit advancements of the field. In this work, we set the foundation for the holistic study of adversarial robustness of GNNs at scale. We study graphs with up to 111 million nodes for local attacks (i.e. attacking a single node) and 2.5 million nodes for global attacks (i.e. attacking all nodes at once). As it turns out, ",
+        "bbox": [
+            174,
+            556,
+            517,
+            775
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/489fa1947f5ba90ad39f4467c320d9233f93dde3bc0fa498f5df0a276e45bddc.jpg",
+        "image_caption": [
+            "Figure 1: GPU memory consumption for a global attack with Projected Gradient Descent (PGD) $\\mathbb { \\lVert \\rVert 3 \\rVert }$ , its quadratic extrapolation, and our Projected Randomized Block Coordinate Descent (PR-BCD) $\\textcircled { \\ S 3 }$ . Both yield similar adversarial accuracy. Beyond attacks, our defense $\\textcircled { \\ S 4 }$ also scales to these graphs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            553,
+            556,
+            795,
+            661
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "GNNs at scale are also highly vulnerable to adversarial attacks. In Fig. 1, we show the substantial improvement of memory efficiency of our attack over a popular prior work for attacking a GNN globally. Analogous to our attacks, our effective defense scales to graphs with 111 million nodes and beyond. ",
+        "bbox": [
+            176,
+            776,
+            821,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Scope. We focus on adversarial robustness w.r.t. structure attacks on GNNs for node classification ",
+        "bbox": [
+            171,
+            824,
+            815,
+            839
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a68d169efa9b84c67e942762f886a45e9ec0fa68b058af03c492e80db36850e8.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\tilde { A } \\ \\mathrm { s . t . } \\ \\lVert \\tilde { A } - A \\rVert _ { 0 } < \\Delta } \\mathcal { L } ( f _ { \\theta } ( \\tilde { A } , X ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            842,
+            598,
+            871
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "with loss function $\\mathcal { L }$ (or its surrogate $\\mathcal { L } ^ { \\prime }$ ), budget $\\Delta$ , and fixed model parameters $\\theta$ . The GNN $f _ { \\theta } ( A , X )$ is applied to a graph $\\mathcal { G } = ( A , X )$ with node attributes $\\ b { X } \\in \\mathbb { R } ^ { \\hat { n } \\times d }$ , the adjacency matrix $\\pmb { A } \\in \\{ 0 , 1 \\} ^ { n \\times n }$ , and $m$ edges. We focus on evasion (test time) attacks, but our methods can be used in poisoning (train time) attacks $\\boxed { \\boxplus 9 } \\rbrack$ . We distinguish between local attacks on a single node and global attacks that target a large fraction of nodes with a shared budget $\\Delta$ . We study white-box attacks since they have the most powerful threat model and can be used to understand the robustness w.r.t. “worst-case noise” of a model, as well as to assess the efficacy of defenses. For these reasons white-box attacks are important and practical from the perspective of a defender. ",
+        "bbox": [
+            174,
+            875,
+            826,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Broader impact. Since we enable the study of robustness at scale, which previously was practically infeasible, an adversary can potentially abuse our attacks. The risk is minimized given that we assume perfect knowledge about the graph, model, and labels. Nonetheless, our findings suggest that one should be careful when deploying GNNs, and highlight that further research is needed. To mitigate this risk, we must be able to evaluate it. We also propose a scalable defense that shows strong performance empirically but we urge practitioners to consider potential trade-offs, e.g. improving robustness at the expense of accuracy for different groups of users. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. We address three major challenges hindering the study of GNNs’ adversarial robustness at scale and propose viable solutions including an extensive empirical evaluation: (1) Previous losses are not well-suited for global attacks on GNNs; (2) Attacks on GNNs scale quadratically in the number of nodes or worse; (3) Similarly, previous robust GNNs are typically not scalable. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(1) Surrogate loss. We study the limitation of state-of-the-art surrogate losses for attacking the accuracy of a GNN over all nodes [8, 9, 17, 27, 41, 43, 49] in $\\boxed { \\ S 2 }$ Especially in combination with small/realistic budgets $\\Delta$ and on large graphs, previous surrogate losses lead to weak attacks. In particular, Cross Entropy (CE) or the widely used Carlini-Wagner loss $[ 6 , 4 3 ]$ are weak surrogates for such global attacks. Our novel losses that overcome these limitations easily improve the strength of the attack by $100 \\%$ on common datasets. For larger graphs, this gap even becomes more significant. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(2) Attacks. Attacks solving a discrete optimization problem easily become computationally infeasible because of the vast amount of potential adjacency matrices $( { \\check { O } } ( 2 ^ { n ^ { 2 } } ) )$ . An approximate solution can be found with first-order optimization but we then still optimize over a quadratic number of parameters $( n ^ { 2 } )$ . There is no trivial way to sparsify existing attacks as we need to represent each edge explicitly to obtain its gradient (i.e. space complexity $\\bar { \\Theta } ( n ^ { 2 } ) )$ . Nevertheless, we overcome this limitation and propose two strategies to apply first-order optimization without the burden of a dense adjacency matrix. In $\\textcircled { \\ S 3 }$ we describe how to add/remove edges between existing nodes based on Randomized Block Coordinate Descent (R-BCD) at an additional memory requirement of $\\mathcal { O } ( \\Delta )$ . Due to the limited scalability of traditional GNNs, we also consider the case where we attack PPRGo [5], a scalable GNN. Here, we even obtain an algorithm with constant complexity in the nodes $n$ . ",
+        "bbox": [
+            173,
+            435,
+            825,
+            574
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(3) Defense. We propose Soft Median in $\\textcircled { \\ S 4 } -$ a computationally efficient, robust, differentiable aggregation function inspired by Geisler et al. $ { \\mathbb { I } }  { \\mathrm { 1 8 } }  { \\Vert }$ , by taking advantage of recent advancements in differentiable sorting $\\dot { \\textmu }$ . Using our Soft Median we observe similar robustness to $\\mathbb { \\lVert 1 8 \\rVert }$ , but with a significantly lower memory footprint, which enables us to defend GNNs at scale. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Surrogate Losses for Global Attacks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            669,
+            508,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "During training and in first-order attacks, we ideally wish to optimize a target metric which is often discontinuous (e.g. accuracy and 0/1 loss $\\mathcal { L } _ { 0 / 1 }$ ). However, for gradient-based optimization we commonly substitute the actual target loss by a surrogate $\\mathcal { L } ^ { \\prime } \\approx \\mathcal { L }$ (e.g. cross entropy for $\\mathcal { L } _ { 0 / 1 }$ ). In the context of i.i.d. samples (e.g. images), a single example is attacked in isolation with its own budget, which is similar to a local attack for GNNs. When a single node’s prediction is attacked, it is often sufficient to maximize the cross entropy for the attacked node/image (untargeted attack): $\\mathrm { C E } ( y , p ) = - \\log ( p _ { c ^ { * } } )$ . where $y$ is the label and $\\pmb { p }$ is the vector of confidence scores. ",
+        "bbox": [
+            173,
+            709,
+            826,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Many global attacks for GNNs [8, 41, 43, 49] maximize the average CE to attack all nodes with a combined budget $\\Delta$ . However, a loss like CE can be ineffective, particularly when the number of nodes is large in comparison to the budget $\\Delta / { n }  0$ . While experimenting on large graphs, we often observed that the CE loss increases even though the accuracy does not decline (see $\\bar { \\bigtriangledown } \\bar { \\mathbf { B } } )$ . As we can see in $\\mathrm { F i g } . 2 ,$ this is due to CE’s bias towards nodes that have a low confidence score. With CE and a sufficiently small budget $\\Delta \\ll n$ we primarily attack nodes that are already misclassified, which means that the classification margin $\\begin{array} { r } { \\psi = \\operatorname* { m i n } _ { c \\neq c ^ { * } } p _ { c ^ { * } } - p _ { c } } \\end{array}$ is already negative. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/b142ae79437f020539c2b1d475396372ee4a53a99550365f2fb0a368103447f5.jpg",
+        "image_caption": [
+            "Figure 2: Margin $\\psi$ of test nodes vs. attacked nodes, before (“clean”) and after perturbation (“perturbed”). We attack the PubMed graph $\\mathrm { ( T a b l e 1 ) }$ and a single-layer GCN with one percent of edges $\\epsilon = 0 . 0 1$ ) as a budget. In stark contrast to the tanh margin (b), the CE loss (a) spends a lot of its budget on misclassified nodes (i.e. $\\psi < 0$ ). See $\\underline { { \\left\\| \\ S \\ B \\right\\| } }$ for more variants and details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            88,
+            789,
+            203
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Global attack. In contrast to attacking a single image/node, a global attack on a GNN has to (1) keep house with the budget $\\Delta$ and (2) find edges that degrade the overall accuracy maximally (i.e. target “fragile” nodes). Without additional information, intuitively, one would first attack low-confidence nodes close to the decision boundary. Hence, the surrogate loss should have a minimal (maximally negative) gradient at $\\psi \\to 0 ^ { + }$ (i.e. approaching $\\psi \\to 0$ from $\\psi \\geq 0$ ). Moreover, if we solely want to lower the accuracy, then we can stop attacking a node once it is misclassified1: ",
+        "bbox": [
+            173,
+            291,
+            825,
+            376
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 A surrogate loss $\\mathcal { L } ^ { \\prime }$ for global attacks $\\mathbf { \\eta } ^ { ( \\mathbf { I } ) }$ should only incentivize perturbing nodes that are correctly classified: $\\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } \\rvert _ { \\psi < 0 } = 0$ and $\\mathbf { \\Pi } ^ { ( \\mathbf { I I } ) }$ should favour nodes close to the decision boundary: $\\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } | _ { \\psi _ { 0 } } < \\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } | _ { \\psi _ { 1 } }$ for any $0 < \\psi _ { 0 } < \\psi _ { 1 }$ . ",
+        "bbox": [
+            174,
+            386,
+            825,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since $\\boxed { \\mathrm { E q . 1 } }$ is in general a discrete and non-convex optimization problem that is often NP-complete [1, 3, 38, 45], we propose to study the surrogate loss under the subsequent simplifying assumptions. Note that in an actual attack other influences (e.g. node degree) are still considered while solving the optimization problem. Assumption $I$ : The set of attacked nodes is independent (their receptive fields do not overlap). Particularly on large graphs with small budgets, $\\Delta / { n }  0$ , deciding which node to attack becomes an increasingly local decision since the receptive field becomes insignificant in comparison to the rest of the graph. Assumption 2: The budget required to change the prediction of node $i$ depends (only) on the margin: $\\Delta _ { i } = g ( | \\psi _ { i } | )$ for some increasing and non-negative function $g ( \\cdot )$ . That is, the larger the margin $\\psi _ { i }$ , the harder it is to attack node $i$ . As stated in Proposition $^ { 1 , }$ with these assumptions, an optimizer with a surrogate loss compliant with Definition is also optimizing the 0/1 loss $\\mathcal { L } _ { 0 / 1 }$ (for proof see $\\ S \\ B . 4 )$ ",
+        "bbox": [
+            173,
+            440,
+            826,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 Let $\\mathcal { L } ^ { \\prime }$ be the surrogate for the 0/1 loss $\\mathcal { L } _ { 0 / 1 }$ used to attack a node classification algorithm $f _ { \\theta } ( A , X )$ with a global budget $\\Delta$ . Suppose we greedily attack nodes in order of $\\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } ( \\psi _ { 0 } ) \\leq$ $\\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } ( \\psi _ { 1 } ) \\leq \\dots \\leq \\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } ( \\psi _ { l } )$ until the budget is exhausted $\\begin{array} { r } { \\Delta < \\sum _ { i = 0 } ^ { l + 1 } \\Delta _ { i } } \\end{array}$ . Under Assumptions 1 & 2, we then obtain the global optimum of $\\begin{array} { r } { \\operatorname* { m a x } _ { \\tilde { A } s . t . \\| \\tilde { A } - A \\| _ { 0 } < \\Delta } \\mathcal { L } _ { 0 / 1 } ( f _ { \\theta } ( \\tilde { A } , X ) ) } \\end{array}$ if $\\mathcal { L } ^ { \\prime }$ has the properties (I) $\\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } \\rvert _ { \\psi < 0 } = 0$ and $\\left( \\mathbf { I I } \\right) \\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } \\vert _ { \\psi _ { 0 } } < \\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } \\vert _ { \\psi _ { 1 } }$ for any $0 < \\psi _ { 0 } < \\psi _ { 1 }$ . ",
+        "bbox": [
+            173,
+            604,
+            825,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Even under the simplifying Assumptions 1 & 2, the Cross Entropy (CE) is not guaranteed to obtain the global optimum. The (CE) violates property (I) and in the worst case only perturbs nodes that are already misclassified (see $\\operatorname { F i g } . 2 )$ . The Carlini-Wagner (CW) [6, 43] loss $\\mathbf { C W } =$ $\\mathrm { m i n } ( \\mathrm { m a x } _ { c \\neq c ^ { * } } z _ { c } - z _ { c ^ { * } } , 0 )$ violates property (II). It is also not guaranteed to obtain the global optimum, i.e. CW loss lacks focus on nodes close to the decision boundary. In the worst case, an attack with CW spends all budget on confident nodes—without flipping a single one. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose the Masked Cross Entropy $\\begin{array} { r } { \\mathbf { M C E } = 1 / | \\mathbb { V } ^ { + } | \\sum _ { i \\in \\mathbb { V } ^ { + } } - \\log ( p _ { c ^ { * } } ^ { ( i ) } ) } \\end{array}$ which fulfills both properties by only considering correctly classified nodes $\\mathbb { V } ^ { + }$ and, hence, reaches the global optimum under the stated assumptions. Empirically, for a greedy gradient-based attack the MCE comes with gains of more than $200 \\%$ in strength (see $\\overline { { \\mathbb { F } \\mathrm { 1 g . ~ } \\boldsymbol { 6 } } } \\big )$ . Surprisingly, if we apply MCE to a Projected Gradient Descent (PGD) attack, we observe hardly any improvement over CE. We identify two potential reasons for that. The first is due to the learning dynamics of PGD. Suppose a misclassified node does not receive any weight in the gradient update, now if the budget is exceeded after the update it is likely to be down-weighted. This can lead to nodes that oscillate around the decision boundary (for more details see $\\underline { { \\overline { { \\ S \\ : \\bf { B } } } } } )$ . A similar behavior occurs for to the Carlini-Wagner loss in e.g. Fig. B.1 (e). ",
+        "bbox": [
+            173,
+            787,
+            825,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Definition 2, we relax properties $( \\mathrm { I } ) / ( \\mathrm { I I } )$ and propose to overcome these limitations via enforcing confidently misclassified nodes, i.e. we want the attacked nodes to be at a “safe” distance from the decision boundary. We propose the tanh of the margin in logit space, i.e. tanh margin $= \\operatorname { t a n h } ( \\operatorname* { m a x } _ { c \\neq c ^ { * } } z _ { c } - z _ { c ^ { * } } )$ . It obeys Definition 2 and its effectiveness is apparent from Fig. 2. For the empirical evaluation see $\\boxed { \\ S 5 }$ and for more results as well as details on all selected losses see $\\ S \\ \\mathbf { B } .$ In the appendix we also study further losses to deepen the understanding about the required properties. Additionally, in $\\ S \\ \\mathbf { B } . \\bar { 5 } ,$ we give an alternative Proposition 1 for a relaxed Assumption 2 s.t. $\\mathbb { E } [ \\Delta _ { i } | \\psi _ { i } ] = g ( | \\psi _ { i } | )$ ",
+        "bbox": [
+            173,
+            138,
+            826,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 A surrogate loss $\\mathcal { L } ^ { \\prime }$ for global attacks that encourages confident misclassification (A) should saturate $\\scriptstyle \\operatorname* { l i m } _ { \\psi \\to - 1 ^ { + } } \\mathcal { L } ^ { \\prime } < \\infty$ and $\\mathbf { ( B ) }$ should favor points close to the decision boundary: $\\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } | _ { \\psi _ { 0 } } < \\partial \\mathcal { L } ^ { \\prime } / \\partial z _ { c ^ { * } } | _ { \\psi _ { 1 } } < 0$ for any $0 < \\psi _ { 0 } < \\psi _ { 1 } < 1$ or $- 1 < \\psi _ { 1 } < \\psi _ { 0 } < 0 .$ . ",
+        "bbox": [
+            174,
+            258,
+            826,
+            304
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Scalable Attacks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            320,
+            344,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Beginning with $[ 1 4 , 5 0 ]$ , many adversarial attacks on the graph structure have been proposed. As discussed, gradient-based attacks such as [9, 41, 49, 50] aim for lower computational cost by approximating the corresponding discrete optimization problem. However, they optimize all possible entries in the dense adjacency matrix $\\pmb { A }$ which comes with quadratic space complexity $\\Theta ( n ^ { 2 } )$ . Since previous attacks come with limited scalability (e.g. see $\\overline { { \\mathbb { F } \\mathrm { 1 g . ~ } \\mathrm { 1 } } } )$ , GNNs robustness on larger graphs is largely unexplored. First, we propose a family of attacks that does not require a dense adjacency matrix and comes with linear complexity w.r.t. the budget $\\Delta$ . Then, we further improve the complexity of our attack for a scalable GNN called PPRGo [5]. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Related work. Li et al. $\\pmb { \\mathbb { D } } \\pmb { \\ 6 } \\|$ evaluate their local adversarial attack SGA only on a graph with around 200k nodes and SGA is specifically designed for Simplified Graph Convolution (SGC) $\\mathbb { \\left[ \\left| 4 0 \\right| \\right] }$ . Note that a two-layer SGC is identical to Nettack’s surrogate model. We consider arbitrary Graph Neural Networks and we even scale our global attack to a graph ten times larger. With PPRGo we even outscale them by factor 500. Feng et al. $\\mathbb { \\ m }$ partition the graph to lower the attack’s memory footprint but still have a time complexity of $\\mathcal { O } ( n ^ { 2 } )$ . Dai et al. $\\pmb { \\mathbb { I } } \\pmb { \\ 4 } \\|$ scale their reinforcement learning approach to a graph for financial transactions with 2.5 million nodes. In contrast to our work, they scale their local attack only using a tiny budget $\\Delta$ of a single edge deletion and only need to consider the receptive field of a single node. We scale our local attack to 111M nodes and allow large budgets $\\Delta$ . ",
+        "bbox": [
+            173,
+            468,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Large scale optimization. In some big data use cases, the cost to calculate the gradient towards all variables can be prohibitively high. For this reason, coordinate descent has gained importance in machine learning and large-scale optimization $\\mathbb { \\lVert 3 9 \\rVert }$ . Nesterov $\\mathbb { \\left. 2 9 \\right. }$ proposed (and analyzed the convergence of) Randomized Block Coordinate Descent (R-BCD). In R-BCD only a subset (called a block) of variables is optimized at a time and, hence, only the gradients towards those variables are required. In many cases, this allows for a lower memory footprint and in some settings even converges faster than standard methods $\\left[ \\left[ 3 0 \\right] \\right]$ . ",
+        "bbox": [
+            173,
+            599,
+            825,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For clarity, we model the perturbations $P \\in \\{ 0 , 1 \\} ^ { n \\times n }$ explicitly $( P _ { i j } = 1$ denotes an edge flip): ",
+        "bbox": [
+            173,
+            702,
+            803,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/623d8d537bd350af37dfd3c46bb079b699d05cc163f4636a16c632fcda270a37.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { P \\mathrm { ~ s . t . } P \\in \\{ 0 , 1 \\} ^ { n \\times n } , \\sum P \\leq \\Delta } { \\mathcal { L } } ( f _ { \\theta } ( A \\oplus P , X ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            719,
+            648,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\oplus$ stands for an element-wise exclusive or and $\\Delta$ denotes the edge budget (i.e. the number of altered entries in the perturbed adjacency matrix). Naively, applying R-BCD to optimize towards the dense adjacency matrix would only save some computation on obtaining the respective gradient. It still has a space complexity of $\\mathcal { O } ( n ^ { \\bar { 2 } } )$ on top of the complexity of the attacked model because we still have to store up to $\\mathit { \\Pi } _ { n ^ { 2 } }$ parameters. Note that the $L _ { 0 }$ perturbation constraint with limited budget $\\Delta$ implies that the solution will be sparse. We build upon this fact and in each epoch, in a survival-ofthe-fittest manner, we keep that part of the search space which is “promising” and resample the rest. Despite the differences, we simply call our approach Projected Randomized Block Coordinate Descent (PR-BCD) and provide the pseudo code in Algo. $^ 1$ (a preliminary version appeared in $\\mathbb { I m }$ ). On top of the GNN, PR-BCD comes with space complexity of $\\Theta ( b )$ where $b$ is the block size (number of coordinates) since everything can be implemented efficiently with sparse operations. We typically choose $\\Delta$ to be a fraction of $m$ and $b > \\Delta$ , thus, in practice, we have a linear overhead. ",
+        "bbox": [
+            173,
+            746,
+            826,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4072d8b9135dad069022a3968803ce6d367da1929c8458191ba6c8b9a6afcce.jpg",
+        "image_caption": [
+            "Figure 3: Influence of block size $b$ on PR-BCD (dashed $L _ { 0 }$ PGD $\\mathbb { E 3 } \\mathbb { I }$ ) with tanh margin loss and $\\epsilon = 0 . 1$ . (a) shows adv. accuracy with three-sigma error over five seeds. We resample $E _ { \\mathrm { r e s . } } ~ = ~ 5 0$ epochs and then fine-tune 250. (b) shows adv. accuracy over epochs $t$ with $E \\cdot b =$ const. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            490,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Gr. $( A , X )$ , lab. $\\textbf {  { y } }$ , GNN $f _ { \\theta } ( \\cdot )$ , loss $\\mathcal { L }$   \n2: Parameter: budget $\\Delta$ , block size $b$ , epochs $E$   \n& $E _ { \\mathrm { r e s . } }$ , heuristic $\\operatorname { \\bar { \\it h } } ( \\dots )$ , learning rate $\\alpha _ { t }$   \n3: Draw w/o replacement $i _ { 0 } { \\in } \\{ 0 , 1 , { \\ldots } , { n ^ { 2 } } - 1 \\} ^ { b }$   \n4: Initialize zeros for ${ \\pmb p } _ { 0 } \\in \\mathbb { R } ^ { b }$   \n5: for $t \\in \\{ 1 , 2 , \\ldots , E \\}$ do   \n6: $\\hat { \\pmb { y } }  f _ { \\theta } ( \\pmb { A } \\oplus \\pmb { p } _ { t - 1 } , \\pmb { X } )$   \n7: $p _ { t } \\gets p _ { t - 1 } + \\alpha _ { t } \\nabla _ { p _ { t - 1 } [ i _ { t - 1 } ] } \\mathcal { L } ( \\hat { \\pmb { y } } , \\pmb { y } )$   \n8: Projection $p _ { t } \\gets \\Pi _ { \\mathbb { E } [ \\mathrm { B e r n o u l l i } ( { \\pmb p } _ { t } ) ] \\leq \\Delta } ( { \\pmb p } _ { t } )$   \n9: $\\mathbf { \\delta } _ { i _ { t } } \\gets i _ { t - 1 }$   \n10: if t  Eres. then   \n11: $\\mathrm { m a s k } _ { \\mathrm { r e s . } }  h ( \\pmb { p } _ { t } )$   \n12: pt[maskres.] 0   \n13: Resample it[maskres.]   \n14: P ⇠ Bernoulli(pE) s.t. $\\sum P \\leq \\Delta$   \n15: Return A \u0000 P ",
+        "bbox": [
+            519,
+            138,
+            823,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "PR-BCD. For $L _ { 0 }$ -norm PGD we relax the discrete edge perturbations $_ { P }$ from $\\{ 0 , 1 \\} ^ { ( n \\times n ) }$ to $[ 0 , 1 ] ^ { ( n \\times n ) }$ as proposed by $\\mathrm { X u }$ et al. [43]. Each entry of $_ { r }$ denotes the probability for flipping it. In each epoch we only look at a randomly sampled, non-contiguous block of $_ { r }$ of size $b$ (line 3, line 10-13) and additionally ignore the diagonal elements (i.e. self-loops). If using an undirected graph, the potential edges are restricted to the upper/lower triangular $n \\times n$ matrix. In each epoch $t \\in \\{ \\bar { 1 } , \\bar { 2 } , \\dots \\}$ , $\\pmb { p }$ is added to $/$ subtracted from the discrete edge weight (line 6). Note, we overload $\\oplus$ s.t. $\\pmb { A } _ { i j } \\oplus p _ { i j } = A _ { i j } + p _ { i j }$ if $A _ { i j } = 0$ and $A _ { i j } - p _ { i j }$ otherwise. We use $\\pmb { p }$ and $_ { P }$ interchangeably while $\\pmb { p }$ only corresponds to the current subset/block of $\\bar { P } _ { i _ { t } }$ . After each gradient update (line 7), the projection $\\Pi _ { \\mathbb { E } [ \\mathrm { B e r n o u l l i } ( p ) ] \\leq \\Delta } ( p )$ adjusts the probability mass such that $\\begin{array} { r } { \\mathbb { E } [ \\bar { \\mathrm { B e r n o u l l i } } ( \\bar { p } ) ] = \\sum _ { i \\in b } p _ { i } \\le \\bar { \\Delta } } \\end{array}$ and that $\\pmb { p } \\in [ 0 , 1 ]$ (line 8). In the end we draw $b$ sample s.t. $P \\in \\{ 0 , 1 \\} ^ { ( n \\times n ) }$ via $P \\sim \\mathrm { B e r n o u l l i } ( p )$ (line 14). ",
+        "bbox": [
+            173,
+            382,
+            826,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The projection $\\Pi _ { \\mathbb { E } [ \\mathrm { B e r n o u l l i } ( p ) ] \\leq \\Delta } ( p )$ likely results in many zero elements, but is not guaranteed to be sparse (for details see $\\textstyle \\left\\| { \\mathfrak { S } } \\ C . 1 \\right\\|$ . If $\\pmb { p }$ has more than $50 \\%$ non-zero entries, we remove the entries with the lowest probability mass such that $50 \\%$ of the search space is resampled. Otherwise, we resample all zero entries in $\\pmb { p }$ . However, one also might apply a more sophisticated heuristic $h ( p )$ which we leave for future work (see line 11). After $E _ { \\mathrm { r e s . } }$ . epochs we fine-tune $\\pmb { p }$ , i.e. we stop resampling and decay the learning rate as in $\\mathbb { \\lVert \\rVert 3 \\rVert }$ . We also employ early stopping for both stages $t \\leq E _ { \\mathrm { r e s . } }$ and $t > E _ { \\mathrm { r e s } }$ with the epoch $t$ ) such that we take the result of the epoch with highest loss $\\mathcal { L }$ . ",
+        "bbox": [
+            173,
+            531,
+            825,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Block size $b$ . With growing $n$ it is unrealistic that each possible entry of the adjacency matrix was part of at least one random search space of (P)R-BCD. As is apparent, with a constant search space size, the number of mutually exclusive chunks of the perturbation matrix grows with $\\Theta ( n ^ { 2 } )$ and this would imply a quadratic runtime. However, as evident in randomized black-box attacks $ { \\mathbb { B } } 7  { \\mathbb { I } }$ , it is not necessary to test every possible edge to obtain an effective attack. In $\\boxed { \\mathrm { F i g . ~ } 3 }$ (a), we analyze the influence of the block size $b$ on the adversarial accuracy. On small datasets and over a wide range of block sizes $b$ , our method performs comparably (or sometimes even better) to its dense equivalent. For larger graphs, we observe that the block size $b$ has a stronger influence on the adversarial accuracy. However, as shown in $\\left[ \\mathrm { F i g . } \\ 3 \\right] ( \\mathbf { b } )$ , one might increase the number of epochs for an improved attack strength. This indicates that PR-BCD successfully identifies the harmful edges to keep. ",
+        "bbox": [
+            173,
+            635,
+            825,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GR-BCD. As an alternative to PR-BCD, we propose Greedy R-BCD (GR-BCD) which greedily flips the entries with the largest gradient in the block so that after $E$ iterations the budget is met. It is even a little bit more scalable as it does not require $b > \\Delta$ (see $\\textstyle \\left\\| { \\mathfrak { S } } \\mathbf { C } . 2 \\right\\|$ for details such as the pseudo code). ",
+        "bbox": [
+            174,
+            780,
+            821,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Limitations. We solely propose approximate attacks that do not provide any guarantee on how well they approximate the actual optimization problem and, hence, only provide an upper bound on e.g. the adversarial accuracy. We also recommend monitoring the relaxation error. One could use certificates to get the respective lower bound, provided they were scalable enough. Even sparse smoothing [4] might be too slow since we need many forward passes. As our attacks rely on the gradient they also require that the victim model is (approximately) differentiable. Otherwise, the approximation can become inappropriate. Moreover, we are limited by the scalability of the attacked GNN as we discuss next. For the theoretical complexities of all studied attacks, we refer to § E. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Scalable GNNs. Up to now, we implicitly assumed that we have enough memory to obtain the predictions and gradient towards the edges. GNNs that typically process the whole graph “at once”, are inherently limited in their scalability. Our PR-BCD attack is even applicable when operating at those limits (see experiments on Products in $\\textcircled { \\ S 5 }$ . To push the limits further, we now consider more scalable GNNs. Some notable scalable GNNs either sample subgraphs $\\mathbb { Z } \\mathbb { Z } \\mathbb { 3 } \\mathbb { I }$ or, such as PPRGo [5], simplify the message passing operation. Next, we extend our PR-BCD to a local attack on PPRGo with constant complexity including the (Soft Median) PPRGo (we introduce the Soft Median in $\\textcircled { \\ S 4 }$ ",
+        "bbox": [
+            173,
+            125,
+            825,
+            223
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "PPRGo.To scale to massive graphs effectively, we need to obtain sublinear/constant complexity w.r.t. the number of nodes. This severely restricts the possibilities of how one might approach a global attack and is the reason why we now focus on local attacks (i.e. attacking single node $\\romannumeral 1$ ). For an $L$ -layer message passing GNN we need to recursively compute the $L$ -hop neighborhood to obtain the prediction of a single node. This makes it difficult to obtain a sublinear space complexity (here including the GNN)—especially if one considers arbitrary edge insertions. In contrast, PPRGo $\\pmb { \\Vert 5 \\Vert }$ leverages the Personalized Page Rank (PPR) matrix $\\mathbf { I I } \\overset { \\cdot } { = } \\alpha ( \\bar { I } - ( 1 - \\alpha ) D ^ { - 1 } A ) ^ { - 1 }$ (row normalization) to reduce the number of explicit message passing steps to one (with feat. encoder $f _ { \\mathrm { e n c , } }$ ): ",
+        "bbox": [
+            173,
+            228,
+            826,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f4abe8e9dde04e4d004ab35e9ffd5b701785fb3570b9cdfe53d29a21e3d2873.jpg",
+        "text": "$$\np = \\mathrm { s o f t m a x } \\left[ \\mathrm { A G G } \\left\\{ \\left( \\mathbf { H } _ { u v } , f _ { \\mathrm { e n c } } ( \\pmb { x } _ { u } ) \\right) , \\forall u \\in \\mathbb { N } ^ { \\prime } ( v ) \\right\\} \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            347,
+            673,
+            364
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Differentiable PPR Update. For a local attack on PPRGo, we require a differentiable update of the respective PPR Scores for an edge perturbation on a weighted graph. We achieve this using the Sherman-Morrison formula through a closed-form rank-one update of row $i$ of the PPR matrix: ",
+        "bbox": [
+            176,
+            377,
+            825,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b11dab37b3d4c80f86bfd865c93db3b1160a44becf1c8ed43bc1d3f5de92dce.jpg",
+        "text": "$$\n\\tilde { \\Pi } _ { i } = \\alpha \\left( \\Pi _ { i } ^ { \\prime } - \\frac { \\Pi _ { i i } ^ { \\prime } v \\Pi ^ { \\prime } } { 1 + v \\Pi _ { \\ddots i } ^ { \\prime } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            426,
+            593,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { I I ^ { \\prime } } = \\alpha ^ { - 1 } \\mathbf { I I }$ and, with degree matrix $_ { D }$ , $\\pmb { v } = ( \\pmb { D } _ { i i } + \\sum \\pmb { p } ) ^ { - 1 } ( \\pmb { A } _ { i } + \\pmb { p } ) - \\pmb { D } _ { i i } ^ { - 1 } \\pmb { A } _ { i }$ . This suffices to attack incoming edges of a node and since everything is differentiable $( { \\partial \\mathcal { L } ^ { \\prime } } / { \\partial p } )$ we do not need a surrogate model (common practice [26, 36, 50]). In $\\ S \\bar { { \\mathrm C } } . 3 ,$ we give details on the derivation and show how we can leverage the fact that PPRGo uses a top- $\\bar { k }$ -sparsified PPR matrix to obtain constant complexity $\\mathcal O ( b k )$ (assuming $b \\ll n$ and $k \\ll n$ ). With $\\Delta < b$ , our approach comes with no restriction on how we can insert or remove incoming edges of a specific node. Other approaches such as $\\boxed { 1 4 } \\boxed { 2 6 }$ gain scalability via restricting the set of admissible nodes for edge perturbations. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            568
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Scalable Defense ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            344,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To complete the robustness picture we now shift focus to defenses. Unfortunately, we are not aware of any defense that scales to graphs significantly larger than PubMed. Thus, we propose a novel, scalable defense based on a robust message-passing aggregation, relying on recent advancements in differentiable sorting $\\textcircled { \\scriptsize { 1 3 1 } }$ . Our Soft Median not only comes with the best possible breakdown point of 0.5 but also can have a lower error than its hard equivalent for finite perturbations $( \\mathrm { s e e } \\ S \\mathrm { D } . 3 )$ . Moreover, our Soft Median performs similarly to the recent Soft Medoid $\\dot { \\left\\| 1 8 \\right\\| }$ , but comes with better computational complexity w.r.t. the neighborhood size, lower memory footprint, and enables us to scale to bigger graphs. We can also use this aggregation neatly in the PPRGo architecture resulting in the first defense that scales to massive graphs with over 111M nodes (see Eq. 3) ",
+        "bbox": [
+            173,
+            616,
+            826,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Background. We typically have the message passing framework of a GNN: ",
+        "bbox": [
+            174,
+            747,
+            673,
+            763
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb4e13365afcd45658be29694023e13700e1343bea196efde81eae4e078c6eed.jpg",
+        "text": "$$\n\\mathbf { h } _ { v } ^ { ( l ) } = \\sigma ^ { ( l ) } \\left[ \\mathbf { A G G } ^ { ( l ) } \\left\\{ \\left( A _ { v u } , \\mathbf { h } _ { u } ^ { ( l - 1 ) } W ^ { ( l ) } \\right) , \\forall u \\in \\mathbb { N } ^ { \\prime } ( v ) \\right\\} \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            768,
+            694,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with neighborhood $\\mathbb { N } ^ { \\prime } ( v ) = \\mathbb { N } ( v ) \\cup v$ including the node itself, the $l$ -th layer message passing aggregation $\\mathbf { A G G } ^ { ( l ) }$ , embedding $\\mathbf { h } _ { v } ^ { ( l ) }$ , normalized adjacency matrix $\\pmb { A }$ , weights $W ^ { ( l ) }$ , and activation $\\sigma ^ { ( l ) }$ ",
+        "bbox": [
+            176,
+            803,
+            823,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Related Work. Following Günnemann $\\pmb { \\mathbb { D } } \\pmb { \\mathbb { 0 } }$ , we classify defenses into three categories: (1) preprocessing [16, 22, 41], (2) training procedure $\\textcircled { 1 1 0 } , \\textcircled { 4 3 } , \\textcircled { 4 9 } $ , and (3) modifications of the architecture [11, 18, 23, 35, 42, 46–48]. All these previous defenses were not evaluated on graphs substantially larger than PubMed. Note GNNGuard $\\mathbb { H }$ was only evaluated on a subset of arXiv, covering $20 \\%$ of the nodes and $6 \\%$ of the edges. Even though our attacks lend themselves well for adversarial training but we leave it for future work due to the overhead during training. Instead, we build the observation of Geisler et al. [18] that common aggregations (e.g. sum or mean) in $\\mathbb { E } { \\bf q } . 5 ]$ are known to be non-robust. They propose a differentiable robust aggregation for $\\mathbf { A G G } ^ { ( l ) }$ and call it Soft Medoid. It is a continuous relaxation of the Medoid and requires the row/column sum over the distance matrix of the embedding of the nodes in the neighborhood. Hence this operation has a quadratic complexity w.r.t. the neighborhood size and comes with a sizable memory overhead during training and inference. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            176
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Soft Median. Intuitively, the Soft Median is a weighted mean where the weight for each instance is determined based on the distance to the dimension-wise median $\\bar { \\mathbf { x } }$ . This way, instances far from the dimension-wise median are filtered out. We define the Soft Median as ",
+        "bbox": [
+            173,
+            183,
+            825,
+            224
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/543c3bdfc49e0568e6fd8ef14d4e4173cca63c88e8e997b3fdd91f3987137279.jpg",
+        "text": "$$\n\\mu _ { \\operatorname { S o f t M e d i a n } } ( X ) = \\operatorname { s o f t m a x } \\left( - c / T \\sqrt { d } \\right) ^ { \\top } X = s ^ { \\top } X \\approx \\operatorname { a r g m i n } _ { x ^ { \\prime } \\in \\mathbb { X } } \\| \\bar { x } - x ^ { \\prime } \\| ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            224,
+            748,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "with the distances $c _ { v } = \\| \\bar { \\pmb { x } } - \\pmb { X } _ { v , : } \\|$ and number of dimensions $d$ . We use $\\boldsymbol { X }$ as well as $\\mathbb { X }$ interchangeably. For a single dimension, this closely resembles the soft sorting operator as proposed in $\\tilde { \\mathbb { B } } \\tilde { \\mathbb { I } }$ for the central element and can be understood as a soft version of the median. To apply it to multivariate inputs, we rely on the dimension-wise median which can be computed efficiently for practical choices of $d$ . In contrast to the Soft Medoid, we do not require the distances between all input instances which makes the Soft Median much more efficient. Assuming $d$ is sufficiently small, the Soft Median scales linearly with the number of inputs $\\left| \\mathbb { N } ^ { \\prime } ( v ) \\right|$ . ",
+        "bbox": [
+            173,
+            246,
+            825,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The temperature. The temperature parameter $T$ controls the steepness of the weight distribution $\\pmb { s }$ between the neighbors. In the extreme case as $T  0$ we recover the instance which is closest to the dimension-wise Median (i.e. $\\begin{array} { r } { \\arg \\operatorname* { m i n } _ { { \\pmb x } ^ { \\prime } \\in \\mathbb { X } } \\left\\| \\bar { \\pmb x } - { \\pmb x } ^ { \\prime } \\right\\| ) } \\end{array}$ . In the other extreme case $T \\to \\infty$ , the Soft Median is equivalent to the sample mean. We observe a similar empirical behavior as Geisler et al. $\\left[ \\left[ 1 8 \\right] \\right]$ and we decide on a temperature value in our experiments by grid search. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Breakdown point. For any finite $T$ , our proposed Soft Median has the best possible breakdown point of 0.5 as we state formally in Theorem 1 (for proof see $\\mathbb { B } \\underline { { \\mathbf { D . 1 } } } \\underline { { \\mathbf { \\mu } } }$ . Note that despite the lower complexity compared to Soft Medoid, we maintain the same breakdown point: ",
+        "bbox": [
+            173,
+            424,
+            825,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 Let $\\mathbb { X } = \\{ \\mathbf { x } _ { 1 } , \\ldots , \\mathbf { x } _ { n } \\}$ be a collection of points in $\\mathbb { R } ^ { d }$ with finite coordinates and temperature $T \\in [ 0 , \\infty )$ . Then the Soft Median location estimator $( E q . \\ 6 )$ has the finite sample breakdown point of $\\epsilon ^ { * } ( \\bar { \\mu } _ { S o f t M e d i a n } , X ) = { } ^ { 1 } / n \\lfloor ^ { ( n + 1 ) } / 2 \\rfloor$ (asympt. $\\begin{array} { r } { \\operatorname* { l i m } _ { n \\to \\overline { { \\infty } } } \\overline { { \\epsilon ^ { * } ( \\mu } } \\ u { \\hat { s } } \\hat { o } f t M e d i a n , \\boldsymbol { X } ) = 0 . 5 ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            477,
+            826,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We define the weighted Soft Median as ",
+        "bbox": [
+            176,
+            530,
+            433,
+            544
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20c004a7d6f5cc0ad646360714b9b8fcbb96757e7a5999fbb01a848178a1fd36.jpg",
+        "text": "$$\n\\mu _ { \\mathrm { W S M } } ( X , \\mathbf { a } ) = C \\left( \\pmb { \\mathscr { s } } \\circ \\mathbf { \\mathscr { a } } \\right) ^ { \\top } X\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            545,
+            428,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { s }$ is the softmax weight of $\\boxed { \\mathrm { E q . ~ } 6 }$ obtained using the weighted dimension-wise Median, $C$ normalizes s.t. $\\sum s \\circ \\mathbf { a } = \\sum$ a, $\\circ$ is the elementwise multiplication, and a the edges weights. Similarly to $\\pm \\textcircled { 1 8 } \\textcircled { 1 }$ , we recover the message passing operation of a GCN $\\mathbb { \\left[ \\left[ 2 4 \\right] \\right] }$ for $T \\to \\infty$ . ",
+        "bbox": [
+            174,
+            566,
+            486,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Empirical robustness. The optimal breakdown point only assesses worst-case perturbations. Therefore, in Fig. 4, we analyze the $L _ { 2 }$ distance in the latent space after the first message passing operation for a clean vs. perturbed graph. Empirically the Soft Median has a $20 \\%$ lower error than the weighted sum of a GCN (we call ",
+        "bbox": [
+            174,
+            656,
+            485,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd80abed2fc736e5bfe1cc4add2d8eb1e176dfa46084bc917e72a82a445c6492.jpg",
+        "image_caption": [
+            "Figure 4: Empirical bias $B ( \\epsilon )$ for the second layer of a GCN with GDC preproc. $\\lVert 2 5 \\rVert$ network under PGD attack with $L _ { 2 }$ distance. We use $T = 0 . 2$ and a relative budget of $\\epsilon = 0 . 2 5$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            530,
+            823,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "it sum since the weights do not sum up to 1). While here the Soft Medoid seems to be more robust, this is not consistent with the adversarial accuracy values in $\\ S 5 .$ Interestingly, the Soft Median can outperform its hard equivalent in terms of the finite error as we show in $\\underline { { \\overline { { \\ S ~ \\dot { \\bf ~ D . 3 } } } } }$ . ",
+        "bbox": [
+            176,
+            752,
+            823,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Limitations. Our Soft Median has the best possible breakdown point which is a (well-established) indicator for robustness but does not prove adversarial robustness. As for most defenses, ours can provide a false sense of robustness. If possible, use attacks and certification techniques to verify the application-specific efficacy. Similar to the Soft Medoid in $\\mathbb { \\lVert 1 8 \\rVert 3 2 \\rVert }$ , we show that the Soft Median can improve the certified robustness in $| \\ S \\ D . 4 |$ Naturally, our Soft Median also comes with higher cost than e.g. a naïve summation despite having the same asymptotic complexity. Nevertheless, the overhead seems to be reasonable as we show in our experiments and in combination with PPRGo one can mitigate the slightly higher memory requirements with smaller batch size. ",
+        "bbox": [
+            173,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Empirical Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            385,
+            107
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the following, we present our experiments (consisting of approx. 2,500 runs) to show the efficacy and scalability of our methods on the six graphs detailed in Table 1. Attacks: We benchmark our GR-BCD and PR-BCD against PGD [43], greedy FGSM (similar to Dai et al. [14]) as well as DICE [37]. Defenses: Besides regular/vanilla GNNs we compare our Soft Median GDC/PPRGo with Soft Medoid GDC [18], SVD GCN [16], RGCN [48], and Jaccard ",
+        "bbox": [
+            174,
+            121,
+            421,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/43079513277c1e2971a0e676e6eb5f9707b9bb6fb008b4a5d34dd4cb1dfc393a.jpg",
+        "table_caption": [
+            "Table 1: Dataset summary. For the dense adjacency matrix we assume 4 bytes per entry. We represent the sparse (COO) matrix via two 8 byte integer pointers and a 4 bytes float value per edge. We highlight configurations above $3 0 \\mathrm { G B }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>#Nodes n</td><td>Size (dense)</td><td>Size (sparse)</td></tr><tr><td>Cora ML 四</td><td>2.8k</td><td>35.88MB</td><td>168.32 kB</td></tr><tr><td>Citeseer 28</td><td>3.3k</td><td>43.88MB</td><td>94.30kB</td></tr><tr><td>PubMed [33</td><td>19.7k</td><td>1.56 GB</td><td>1.77 MB</td></tr><tr><td>arXiv 2</td><td>169.3 k</td><td>114.71 GB</td><td>23.32MB</td></tr><tr><td>Products [21</td><td>2.4M</td><td>23.99 TB</td><td>2.47 GB</td></tr><tr><td>Papers 100M 四</td><td>111.1 M</td><td>49.34 PB</td><td>32.31 GB</td></tr></table>",
+        "bbox": [
+            436,
+            188,
+            821,
+            287
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "GCN [41]. For the Soft Median, we follow Soft Medoid GDC [18] and diffuse the adjacency matrix with PPR/GDC [25] and use PPRGo’s efficient implementation to calculate the PPR scores. For the OGB datasets we use the public splits and otherwise sample 20 nodes per class for training/validation. We typically report the average over three random seeds/splits and the 3-sigma error of the mean. The full setup and details about baselines are given in $\\mathbb { S } \\mathbb { F } . 1 \\mathbb { J }$ For supplementary material including the code and configuration see https://www.in.tum.de/daml/robustness-of-gnns-at-scale. ",
+        "bbox": [
+            173,
+            300,
+            825,
+            383
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Time and memory cost. We want to stress again that most of the baselines barely scale to PubMed using a common 11GB GeForce GTX 1080 Ti (as we do). We only use a 32GB Tesla V100 for the experiments on Products with a full-batch GNN, since a three-layer GCN requires roughly 30 GB already during training. Extrapolating the overhead on PubMed to the largest dataset, Papers 100M, traditional attacks and defenses would require roughly 1 exabyte $1 0 ^ { 1 8 }$ bytes) while for ours 11 GB suffice. Our attacks and defenses are also reasonably fast. On arXiv ( $1 7 0 \\mathrm { k }$ nodes), we train for 500 epochs and run the global PR-BCD attack for 500 epochs. The whole training and attacking procedure requires less than 2 minutes. Moreover, one epoch on Papers 100M with the local PR-BCD attack takes less than 10 seconds. See $\\ S \\ : \\mathrm { F } . 2$ for further details and $\\mathsf { \\Omega } _ { \\mathbb { S } \\mathbb { E } }$ for theoretical complexities. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            515
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Surrogate Loss. We illustrate the losses in $\\mathrm { F i g . } 5 ,$ where we clustered the losses in three groups. (1) incentivizing low margins: Cross Entropy CE and margin. (2) focusing on high-confidence nodes: Carlini-Wagner CW, the (neg.) CE of the most-likely, non-target class NCE, and ELU Margin. (3) focusing on nodes close to the decision boundary: MCE (ours) and tanh margin (ours). In Fig. 6, we see that the losses of category (3), or equivalently obeying the properties of Definition 1 or Definition 2, are superior to the other losses. For example, with MCE and FGSM the accuracy drops twice as much as with CE. A detailed discussion and mathematical formulation of all losses can be found in $\\boxed { \\ S \\mathrm { ~ B } }$ Additionally, we report further experiments backing our claims and discuss the losses’ properties in more detail. Subsequently, we use MCE for greedy attacks and tanh margin otherwise. ",
+        "bbox": [
+            173,
+            520,
+            826,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Robustness w.r.t. global attacks. In Table 2, we present the experimental results for our proposed global attacks on the small dataset Cora ML since most baselines do not scale much further. Our attacks are as strong as their dense equivalents despite being much more scalable. In Fig. 7, w e compare our PR-BCD attack on all baselines that fit into memory or can be trained within 24 hours on the bigger datasets. On the large products dataset, it suffices to perturb roughly $2 \\%$ of the edges to push the accuracy below $60 \\%$ , i.e. reaching the performance of an MLP $\\dot { \\left[ \\left[ 2 1 \\right] \\right] }$ . We conclude that GNNs on large graphs are indeed not robust (see also $\\ S \\operatorname { F } . S )$ . Our defense Soft Median GDC and Soft Median PPRGo are consistently among the best models tested over all scales. For example with $\\epsilon = 0 . 1$ , the accuracy of a Vanilla GCN drops by an absolute $20 \\%$ while for the Soft Median PPRGo we only lose $5 \\%$ . To fit our Soft Median GDC on Products into memory, we had to reduce the number of hidden dimensions in comparison to its baselines. However, note that even a Vanilla GCN requires almost the entire memory of the 32 GB GPU. Despite the small sacrifice in clean accuracy, we already outperform most baselines for a budget of $\\epsilon > 0 . 0 1$ . We also faced similar scaling limitations for the Soft Medoid GDC baseline on arXiv. This highlights the lower memory requirements for our Soft Median. In $\\mathbb { S } \\xrightarrow { \\mathbb { F } . 3 }$ we present more exhaustive results and adaptive/direct attacks supporting the robustness of our defense but highlighting the importance of adaptiveness. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/be4043791a8d951a507c5b9c9b7b1f89500746ac461fca7e9037255173a9bae2.jpg",
+        "image_caption": [
+            "Figure 5: Losses for the binary case. The losses are grouped via their basic properties (see text). ",
+            "Figure 6: Attacking GCN on Pubmed. The lower the adv. accuracy the better the loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            723,
+            816,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e2af68288894a0be1224d01648bee75071ffbec1bcba39155bcdd5dc6a462062.jpg",
+        "table_caption": [
+            "Table 2: Comparing attacks (transfer from Vanilla GCN) and defenses. We show the adversarial accuracy for $\\epsilon = 0 . 1$ on Cora ML, and the clean test accuracy (last column). We only highlight the strongest defense as the attacks perform similarly. Our approaches are underlined. See § F.3 for more datasets, budgets, and adaptive/direct attacks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>FGSM</td><td>GR-BCD</td><td>PGD</td><td>PR-BCD</td><td>Acc.</td></tr><tr><td>Soft Median GDC</td><td>0.769 ± 0.002</td><td>0.765 ± 0.001</td><td>0.758 ± 0.002</td><td>0.752 ± 0.002</td><td>0.824 ± 0.002</td></tr><tr><td>Soft Median PPRGo</td><td>0.778 ± 0.001</td><td>0.781 ± 0.002</td><td>0.769 ± 0.001</td><td>0.770 ± 0.001</td><td>0.821 ± 0.001</td></tr><tr><td>Vanilla GCN</td><td>0.641 ± 0.003</td><td>0.622 ± 0.003</td><td>0.662 ± 0.003</td><td>0.645 ± 0.002</td><td>0.827 ± 0.003</td></tr><tr><td>Vanilla GDC</td><td>0.672 ± 0.005</td><td>0.677 ± 0.005</td><td>0.679 ± 0.002</td><td>0.674 ± 0.004</td><td>0.842 ± 0.003</td></tr><tr><td>Vanilla PPRGo</td><td>0.724 ± 0.003</td><td>0.726 ± 0.002</td><td>0.704 ± 0.001</td><td>0.700 ± 0.002</td><td>0.826 ± 0.002</td></tr><tr><td>Soft Medoid GDC</td><td>0.773 ± 0.005</td><td>0.775 ± 0.003</td><td>0.759 ± 0.003</td><td>0.761 ± 0.003</td><td>0.819 ± 0.002</td></tr><tr><td>SVD GCN</td><td>0.751 ± 0.007</td><td>0.755 ± 0.006</td><td>0.719 ± 0.005</td><td>0.724 ± 0.006</td><td>0.781 ± 0.005</td></tr><tr><td>Jaccard GCN</td><td>0.661 ± 0.002</td><td>0.664 ± 0.001</td><td>0.673 ± 0.002</td><td>0.667 ± 0.003</td><td>0.818 ± 0.003</td></tr><tr><td>RGCN</td><td>0.654 ± 0.007</td><td>0.665 ± 0.005</td><td>0.671 ± 0.007</td><td>0.664 ± 0.004</td><td>0.819 ± 0.002</td></tr></table>",
+        "bbox": [
+            186,
+            161,
+            812,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb4736d623497e2f9f6638c2ba810b67a7161a18c7ebc029dc506e36788b7092.jpg",
+        "image_caption": [
+            "Figure 7: PR-BCD (DICE dashed) on the large datasets (transfer) where the adversarial accuracy denotes the accuracy after attacking with budget $\\Delta = \\epsilon m$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            321,
+            766,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            577,
+            825,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robustness w.r.t. local attacks. In Fig. 8, we compare the results of our local PR-BCD with Nettack on Cora ML (undirected). We define the budget $\\Delta _ { i } = \\epsilon d _ { i }$ and select the nodes for each budget s.t. $\\Delta _ { i } \\geq 1$ . Similarly to Zügner et al. $ { \\mathbb { I } } ^ {  { 5 } \\mathrm { O I } }$ , we apply the attack only to the 10 nodes with highest confidence, 10 with lowest, and 20 random nodes (all correctly classified). For more datasets and budgets see $\\ S \\ F . 4 .$ Our attack seems to be slightly stronger than Nettack on all architectures and budgets. Nettack and PR-BCD use a different strategy to make the original combinatorial optimization problem feasible (see $\\ S \\ O _ { 1 } )$ . Nettack uses a linearized surrogate model to select the adversarial edges. Evidently, this leads to a weaker attack compared to relaxing the optimization problem as we proposed with PR-BCD. On the large datasets Products and Papers 100M (directed), we outperform the simple DICE baseline substantially. We compare to DICE since Nettack is not scalable enough. In comparison to the small datasets, the Vanilla GCN/PPRGo are extremely fragile and much lower budgets $\\Delta _ { i }$ suffice to flip almost every node’s prediction. Our proposed defense Soft Median PPRGo on the other hand remains similarly robust as on the small datasets. On Papers 100M with $\\Delta _ { i } = 0 . 2 5$ , the Soft Median PPRGo reduces the attacker’s success rate from around $90 \\%$ to just $30 \\%$ $90 \\%$ vs. $1 \\%$ on Products with $\\Delta _ { i } = 0 . 5$ ). ",
+        "bbox": [
+            173,
+            762,
+            825,
+            915
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ca6e66837f776a05c6bbae91c84f98c9055f883f57e9b304e22cb9759881790f.jpg",
+        "table_caption": [
+            "Table 3: Attack success rate of PR-BCD (ours) and SGA $[ \\overline { { 2 6 } } ]$ on a Vanilla GCN and Vanilla SGC [40] The stronger attack is bold. For poisoning we retrain on the perturbed graph of an evasion attack. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Frac. edges ∈,△i= edi</td><td>Attack</td><td colspan=\"3\">PR-BCD</td><td colspan=\"3\">SGA</td></tr><tr><td colspan=\"2\"></td><td></td><td>0.25</td><td>0.50</td><td>1.00</td><td>0.25</td><td>0.50</td><td>1.00</td></tr><tr><td rowspan=\"3\">C eII</td><td rowspan=\"2\">GCN</td><td>evasion</td><td>0.38 ± 0.04</td><td>0.65 ± 0.04</td><td>0.96 ± 0.02</td><td>0.36 ± 0.04</td><td>0.51 ± 0.05</td><td>0.82 ±0.03</td></tr><tr><td>poisoning</td><td>0.46 ± 0.05</td><td>0.79 ± 0.04</td><td>0.97 ± 0.02</td><td>0.47 ± 0.05</td><td>0.64 ± 0.04</td><td>0.95 ± 0.02</td></tr><tr><td>evasion</td><td>0.45 ± 0.05</td><td>0.57± 0.05</td><td>0.97±0.02</td><td>0.37± 0.04</td><td>0.43 ± 0.05</td><td>0.95 ±0.02</td></tr><tr><td rowspan=\"3\">eeeeet</td><td>SGC</td><td>poisoning evasion</td><td>0.50 ± 0.05 0.42 ± 0.05</td><td>0.66 ± 0.04</td><td>0.96 ± 0.02</td><td>0.47 ± 0.05</td><td>0.62 ± 0.04</td><td>0.97 ± 0.01</td></tr><tr><td>GCN</td><td></td><td></td><td>0.66± 0.04</td><td>0.85 ± 0.03</td><td>0.34± 0.04</td><td>0.50± 0.05</td><td>0.72±0.04</td></tr><tr><td></td><td>poisoning evasion</td><td>0.53 ± 0.05 0.39±0.04</td><td>0.78 ± 0.04 0.62 ± 0.04</td><td>0.94 ± 0.02 0.91±0.03</td><td>0.54 ± 0.05</td><td>0.76 ± 0.04</td><td>0.93 ± 0.02</td></tr><tr><td rowspan=\"3\">AIX.Ie</td><td>SGC</td><td>poisoning</td><td>0.49 ± 0.05</td><td>0.77 ± 0.04</td><td>0.92 ± 0.03</td><td>0.35 ± 0.04 0.49 ± 0.05</td><td>0.55 ± 0.05 0.74 ± 0.04</td><td>0.85±0.03 0.97 ± 0.01</td></tr><tr><td>GCN</td><td>evasion</td><td>0.92 ± 0.03</td><td>1.00 ± 0.00</td><td>1.00 ± 0.00</td><td>0.58± 0.05</td><td>0.90±0.03</td><td>0.98 ± 0.01</td></tr><tr><td></td><td>poisoning</td><td>0.82 ± 0.03</td><td>0.99 ± 0.01</td><td>1.00 ± 0.00</td><td>0.52 ± 0.05</td><td>0.82 ± 0.04</td><td>0.98 ± 0.01</td></tr><tr><td rowspan=\"2\"></td><td>SGC</td><td>evasion</td><td>0.91± 0.03</td><td>0.97 ± 0.01</td><td>1.00± 0.00</td><td>0.83± 0.04</td><td>0.94±0.02</td><td>0.94± 0.02</td></tr><tr><td></td><td>poisoning</td><td>0.91 ± 0.03</td><td>0.97 ± 0.01</td><td>1.00 ± 0.00</td><td>0.83 ± 0.04</td><td>0.94 ± 0.02</td><td>0.94 ±0.02</td></tr></table>",
+        "bbox": [
+            176,
+            126,
+            821,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            328,
+            516,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Table 3, we compare to the SGA attack of Li et al. [26] that transfers the attacks from a SGC $\\mathbb { H O }$ surrogate. With our PR-BCD we attack the respective model directly. We follow SGA and obtain a poisoning attack by applying the perturbations of an evasion attack to the graph before training. Our PR-BCD clearly dominates SGA–even on SGC. This demonstrates how generally applicable our PR-BCD is without any modifications. We hypothesize that PR-BCD is stronger since, in contrast to SGA, it does not constrain the edge perturbations to be within a subgraph. Moreover, the large gap for a GCN highlights the importance of adaptive attacks (i.e. no surrogate). Also in terms of scalability, we find PR-BCD to be superior, even though SGA is efficient on graphs up to the size of arXiv. However, on products, we observe that for $s = 3$ SGC message passing steps we sometimes require more than $1 1 \\ \\mathrm { G b }$ and $s \\ : = \\ : 4$ we typically require more than $3 2 \\ \\mathrm { G b }$ . However, our PR-BCD with PPRGo scales to graphs 2 magnitudes larger $\\mathrm { P a } -$ pers100M) and requires less than 11 GB (see $\\overset { \\cdot } { \\vartheta } \\operatorname { F } . 2 )$ ",
+        "bbox": [
+            174,
+            431,
+            517,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c852dbad637cd22f8dfa77d421dada0dae6dd2bc1057ee42d3f1b915a3181b8.jpg",
+        "image_caption": [
+            "Figure 8: Adversarial classification margins $\\tilde { \\psi } _ { i }$ of the attacked nodes. In (a), we compare our local PR-BCD attack with Nettack $ { \\mathbb { I } } ^ {  { \\left[ 5 0 \\right] } }$ on (undirected) Cora ML. In (b), we show the results on the (directed) largescale datasets Products (2.5 million nodes) and Papers 100M (111 million nodes), respectively. Our Soft Medoid PPRGo resists the attacks much better than the baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            539,
+            330,
+            816,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            741,
+            297,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We study the adversarial robustness of GNNs at scale. We tackle all three of the identified challenges: (1) we introduce surrogate losses for global attacks that can double the attack strength, (2) we principally scale first-order attacks that optimize over the quadratic number of possible edges, and (3) we propose a scalable defense using our novel Soft Median which is differentiable as well as provably robust. We show that our attacks and defenses are practical by scaling to graphs of up to 111 million nodes. In some settings our defense reduces the attack’s success rate from around $90 \\%$ to $1 \\%$ . Most importantly, our work enables the assessment of robustness for massive-scale applications with GNNs. ",
+        "bbox": [
+            173,
+            772,
+            517,
+            842
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            843,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by the Helmholtz Association under the joint research school “Munich School for Data Science - MUDS“. ",
+        "bbox": [
+            176,
+            121,
+            825,
+            150
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] M. Andriushchenko and M. Hein. Provably robust boosted decision stumps and trees against adversarial attacks. In Advances in Neural Information Processing Systems. Curran Associates, Inc., 2019.   \n[2] A. Bojchevski and S. Günnemann. Deep Gaussian embedding of graphs: Unsupervised inductive learning via ranking. 6th International Conference on Learning Representations, ICLR, 2018.   \n[3] A. Bojchevski and S. Günnemann. Certifiable Robustness to Graph Perturbations. Neural Information Processing Systems, NeurIPS, 2019.   \n[4] A. Bojchevski, J. Klicpera, and S. Günnemann. Efficient Robustness Certificates for Graph Neural Networks via Sparsity-Aware Randomized Smoothing. 37th International Conference on Machine Learning, ICML, 2020.   \n[5] A. Bojchevski, J. Klicpera, B. Perozzi, A. Kapoor, M. Blais, B. Rózemberczki, M. Lukasik, and S. Günnemann. Scaling Graph Neural Networks with Approximate PageRank. International Conference on Knowledge Discovery and Data Mining, KDD, 2020.   \n[6] N. Carlini and D. Wagner. Towards Evaluating the Robustness of Neural Networks. IEEE Symposium on Security and Privacy, 2017.   \n[7] J. Chen, T. Ma, and C. Xiao. FASTGCN: Fast learning with graph convolutional networks via importance sampling. 6th International Conference on Learning Representations, ICLR, 2018.   \n[8] J. Chen, Y. Wu, X. Xu, Y. Chen, H. Zheng, and Q. Xuan. Fast gradient attack on network embedding. arXiv:1809.02797, 2018.   \n[9] J. Chen, Y. Chen, H. Zheng, S. Shen, S. Yu, D. Zhang, and Q. Xuan. MGA: Momentum Gradient Attack on Network. IEEE Transactions on Computational Social Systems, 2020.   \n[10] J. Chen, X. Lin, H. Xiong, Y. Wu, H. Zheng, and Q. Xuan. Smoothing Adversarial Training for GNN. IEEE Transactions on Computational Social Systems, 2020.   \n[11] L. Chen, J. Li, Q. Peng, Y. Liu, Z. Zheng, and C. Yang. Understanding Structural Vulnerability in Graph Convolutional Networks. In Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, Montreal, Canada, Aug. 2021. International Joint Conferences on Artificial Intelligence Organization.   \n[12] T. Chen, B. Xu, C. Zhang, and C. Guestrin. Training Deep Nets with Sublinear Memory Cost. arXiv preprint arXiv:1604.06174, 2016.   \n[13] W. L. Chiang, Y. Li, X. Liu, S. Bengio, S. Si, and C. J. Hsieh. Cluster-GCN: An efficient algorithm for training deep and large graph convolutional networks. International Conference on Knowledge Discovery and Data Mining, KDD, 2019.   \n[14] H. Dai, H. Li, T. Tian, H. Xin, L. Wang, Z. Jun, and S. Le. Adversarial attack on graph structured data. 35th International Conference on Machine Learning, ICML, 3, 2018.   \n[15] D. Donoho and P. J. Huber. The notion of breakdown point. In A Festschrift For Erich L. Lehmann. Wadsworth Statist./Probab. Ser., Wadsworth, Belmont, CA, 1983, 1983.   \n[16] N. Entezari, S. A. Al-Sayouri, A. Darvishzadeh, and E. E. Papalexakis. All you need is Low (rank): Defending against adversarial attacks on graphs. International Conference on Web Search and Data Mining, WSDM, 2020.   \n[17] B. Feng, Y. Wang, X. Li, and Y. Ding. Scalable Adversarial Attack on Graph Neural Networks with Alternating Direction Method of Multipliers. arXiv:2009.10233 [cs, stat], Sept. 2020. arXiv: 2009.10233.   \n[18] S. Geisler, D. Zügner, and S. Günnemann. Reliable Graph Neural Networks via Robust Aggregation. Neural Information Processing Systems, NeurIPS, (NeurIPS), 2020.   \n[19] S. Geisler, D. Zügner, A. Bojchevski, and S. Günnemann. Attacking Graph Neural Networks at Scale. Deep Learning for Graphs at AAAI Conference on Artificial Intelligence, 2021.   \n[20] S. Günnemann. Graph neural networks: Adversarial robustness. In L. Wu, P. Cui, J. Pei, and L. Zhao, editors, Graph Neural Networks: Foundations, Frontiers, and Applications, chapter 8. Springer, Singapore, 2021.   \n[21] W. Hu, M. Fey, M. Zitnik, Y. Dong, H. Ren, B. Liu, M. Catasta, and J. Leskovec. Open Graph Benchmark: Datasets for Machine Learning on Graphs. 2020.   \n[22] M. Jin, H. Chang, W. Zhu, and S. Sojoudi. Power up! Robust Graph Convolutional Network against Evasion Attacks based on Graph Powering. AAAI Conference on Artificial Intelligence, 2019.   \n[23] W. Jin, T. Derr, Y. Wang, Y. Ma, Z. Liu, and J. Tang. Node Similarity Preserving Graph Convolutional Networks. WSDM 2021 - Proceedings of the 14th ACM International Conference on Web Search and Data Mining, 2021.   \n[24] T. N. Kipf and M. Welling. Semi-supervised classification with graph convolutional networks. 5th International Conference on Learning Representations, ICLR, 2017.   \n[25] J. Klicpera, S. Weißenberger, and S. Günnemann. Diffusion Improves Graph Learning. Neural Information Processing Systems, NeurIPS, 2019.   \n[26] J. Li, T. Xie, L. Chen, F. Xie, X. He, and Z. Zheng. Adversarial attack on large scale graph. IEEE Transactions on Knowledge & Data Engineering, 2021.   \n[27] J. Ma, S. Ding, and Q. Mei. Towards More Practical Adversarial Attacks on Graph Neural Networks. Neural Information Processing Systems, NeurIPS, (NeurIPS), 2020.   \n[28] A. K. McCallum, K. Nigam, J. Rennie, and K. Seymore. Automating the construction of internet portals with machine learning. Information Retrieval, 2000.   \n[29] Y. Nesterov. Efficiency of coordinate descent methods on huge-scale optimization problems. SIAM J. Optim., 22, 2012.   \n[30] Y. Nesterov and S. Stich. Efficiency of accelerated coordinate descent method on structured optimization problems. Siam J. Optim., 27, 2017.   \n[31] S. Prillo and J. Martin Eisenschlos. SoftSort: A Continuous Relaxation for the argsort Operator. 37th International Conference on Machine Learning, ICML, 119, 2020.   \n[32] J. Schuchardt, A. Bojchevski, J. Klicpera, and S. Günnemann. Collective robustness certificates. 9th International Conference on Learning Representations, ICLR, 2021.   \n[33] P. Sen, G. M. Namata, M. Bilgic, L. Getoor, B. Gallagher, and T. Eliassi-Rad. Collective classification in network data. AI Magazine, 2008.   \n[34] O. Shchur, M. Mumme, A. Bojchevski, and S. Günnemann. Pitfalls of Graph Neural Network Evaluation. arXiv:1811.05868 [cs, stat], June 2019. arXiv: 1811.05868.   \n[35] X. Tang, Y. Li, Y. Sun, H. Yao, P. Mitra, and S. Wang. Transferring robustness for graph neural network against poisoning attacks. Conference on Web Search and Data Mining, WSDM, 2020.   \n[36] J. Wang, M. Luo, F. Suya, J. Li, Z. Yang, and Q. Zheng. Scalable attack on graph data by injecting vicious nodes. Data Mining and Knowledge Discovery, 34(5), 2020.   \n[37] M. Waniek, T. P. Michalak, M. J. Wooldridge, and T. Rahwan. Hiding individuals and communities in a social network. Nature Human Behaviour, 2(2), 2018.   \n[38] L. Weng, H. Zhang, H. Chen, Z. Song, C.-J. Hsieh, L. Daniel, D. Boning, and I. Dhillon. Towards Fast Computation of Certified Robustness for ReLU Networks. In 35th International Conference on Machine Learning, ICML, July 2018.   \n[39] S. J. Wright. Coordinate Descent Algorithms. Mathematical Programming, 151, 2015.   \n[40] F. Wu, A. Souza, T. Zhang, C. Fifty, T. Yu, and K. Weinberger. Simplifying Graph Convolutional Networks. In 36th International Conference on Machine Learning, ICML, May 2019.   \n[41] H. Wu, C. Wang, Y. Tyshetskiy, A. Docherty, K. Lu, and L. Zhu. Adversarial examples for graph data: Deep insights into attack and defense. IJCAI International Joint Conference on Artificial Intelligence, 2019-Augus, 2019.   \n[42] T. Wu, H. Ren, P. Li, and J. Leskovec. Graph Information Bottleneck. Neural Information Processing Systems, NeurIPS, (NeurIPS), 2020.   \n[43] K. Xu, H. Chen, S. Liu, P. Y. Chen, T. W. Weng, M. Hong, and X. Lin. Topology attack and defense for graph neural networks: An optimization perspective. IJCAI International Joint Conference on Artificial Intelligence, 2019-Augus, 2019.   \n[44] R. Ying, R. He, K. Chen, P. Eksombatchai, W. L. Hamilton, and J. Leskovec. Graph convolutional neural networks for web-scale recommender systems. International Conference on Knowledge Discovery and Data Mining, KDD, 2018.   \n[45] H. Zhang, T.-W. Weng, P.-Y. Chen, C.-J. Hsieh, and L. Daniel. Efficient Neural Network Robustness Certification with General Activation Functions. In Advances in Neural Information Processing Systems. Curran Associates, Inc., 2018.   \n[46] X. Zhang and M. Zitnik. GNNGuard: Defending Graph Neural Networks against Adversarial Attacks. Neural Information Processing Systems, NeurIPS, (NeurIPS), 2020.   \n[47] Y. Zhang, S. Pal, M. Coates, and D. Ustebay. Bayesian Graph Convolutional Neural Networks for Semi-Supervised Classification. AAAI Conference on Artificial Intelligence, 33, 2019.   \n[48] D. Zhu, P. Cui, Z. Zhang, and W. Zhu. Robust graph convolutional networks against adversarial attacks. International Conference on Knowledge Discovery and Data Mining, KDD, 2019.   \n[49] D. Zügner and S. Günnemann. Adversarial attacks on graph neural networks via meta learning. 7th International Conference on Learning Representations, ICLR, 2019.   \n[50] D. Zügner, A. Akbarnejad, and S. Günnemann. Adversarial attacks on neural networks for graph data. International Conference on Knowledge Discovery and Data Mining, KDD, 2018. ",
+        "bbox": [
+            171,
+            167,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            63,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            826,
+            671
+        ],
+        "page_idx": 12
+    }
+]