Add files using upload-large-folder tool

parse/train/BJe4oxHYPB/BJe4oxHYPB.md

@@ -0,0 +1,287 @@
+# WINNING THE LOTTERY WITH CONTINUOUS SPARSIFICATION
+
+# Anonymous authors
+
+Paper under double-blind review
+
+# ABSTRACT
+
+The Lottery Ticket Hypothesis from Frankle & Carbin (2019) conjectures that, for typically-sized neural networks, it is possible to find small sub-networks which train faster and yield superior performance than their original counterparts. The proposed algorithm to search for “winning tickets”, Iterative Magnitude Pruning, consistently finds sub-networks with $9 0 - 9 5 \%$ less parameters which train faster and better than the overparameterized models they were extracted from, creating potential applications to problems such as transfer learning.
+
+In this paper, we propose Continuous Sparsification, a new algorithm to search for winning tickets which continuously removes parameters from a network during training, and learns the sub-network’s structure with gradient-based methods instead of relying on pruning strategies. We show empirically that our method is capable of finding tickets that outperforms the ones learned by Iterative Magnitude Pruning, and at the same time providing faster search, when measured in number of training epochs or wall-clock time.
+
+# 1 INTRODUCTION
+
+Although deep neural networks have become ubiquitous in fields such as computer vision and natural language processing, extreme overparameterization is typically required to achieve state-ofthe-art results (Xie et al., 2017; Devlin et al., 2018), causing higher training costs and hindering applications where memory or inference time are constrained. Recent theoretical work suggest that overparameterization plays a key role in both the capacity and generalization of a network (Neyshabur et al., 2018), and in training dynamics (Allen-Zhu et al., 2019). However, it remains unclear whether overparameterization is truly necessary to train networks to state-of-the-art performance.
+
+At the same time, empirical approaches have been successful in finding less overparameterized neural networks, either by reducing the network after training (Han et al., 2015; 2016) or through more efficient architectures that can be trained from scratch (Iandola et al., 2016). Recently, the combination of these two approaches lead to new methods which discover efficient architectures through optimization instead of design (Liu et al., 2019; Savarese & Maire, 2019). Nonetheless, parameter efficiency is typically maximized by pruning an already trained network.
+
+The fact that pruned networks are hard to train from scratch (Han et al., 2015; 2016) suggests that, while overparameterization is not necessary for a model’s capacity, it might be required for successful network training. Recently, this idea has been put into question by Frankle & Carbin (2019), where heavily pruned networks are trained faster than their original counterparts, often yielding superior performance.
+
+A key finding is that the same parameter initialization should be used when re-training the pruned network. A winning ticket, defined by a sub-network and a setting of randomly-initialized parameters, is quickly trainable and has already found applications in, for example, transfer learning (Morcos et al., 2019; Mehta, 2019; Soelen & Sheppard, 2019), making the search for winning tickets a problem of independent interest.
+
+Currently, the standard algorithm to find winning tickets is Iterative Magnitude Pruning (IMP) (Frankle & Carbin, 2019; Frankle et al., 2019), which consists of a repeating a 2-stage procedure that alternates between parameter optimization and pruning. As a result, IMP relies on a sensible choice for pruning strategy, and is time-consuming: finding a winning ticket with $1 \%$ of the original parameters in a 6-layer CNN requires over 20 rounds of training followed by pruning, totalling over 1000 epochs (Frankle & Carbin, 2019). Choosing a parameter’s magnitude as pruning criterion has also shown to be sub-optimal in some settings (Zhou et al., 2019), leading to the question of whether better winning tickets can be found by different pruning methods. Moreover, at each iteration, IMP resets the parameters of the network back to initialization, hence considerable time is spent on re-training similar networks with different sparsities.
+
+With the goal of speeding up the search for winning tickets in deep neural networks, we design a novel method, Continuous Sparsification, which continuously removes weights from a network during training, instead of following a strategy to prune parameters at discrete time intervals. Unlike IMP, our method approaches the search for sparse networks as a $\ell _ { 0 }$ -regularized optimization problem (Louizos et al., 2017), resulting in a method that can be fully described in the optimization framework. To approximate $\ell _ { 0 }$ -regularization, we propose a smooth re-parameterization, allowing for the subnetwork’s structure to be directly learned with gradient-based methods. Unlike previous works, our re-parameterization is deterministic, proving more convenient for the tasks of pruning and ticket search, while also yielding faster training times.
+
+Experimentally, our method offers superior performance when pruning VGG to extreme regimes, and is capable of finding winning tickets in Residual Networks trained on CIFAR-10 at a fraction of time taken by Iterative Magnitude Pruning. In particular, Continuous Sparsification successfully finds tickets in under 5 iterations, compared to 20 iterations required by Iterative Magnitude Pruning in the same setting. To further speed up the search for sub-networks, our method abdicates parameter rewinding, a key ingredient of Iterative Magnitude Pruning. By showing superior results without rewinding, our experiments offer insights on how ticket search should be performed.
+
+# 2 RELATED WORK
+
+# 2.1 LOTTERY TICKET HYPOTHESIS
+
+The Lottery Ticket Hypothesis (Frankle & Carbin, 2019) states that for a network $f ( x ; w )$ , $w \in \mathbb { R } ^ { d }$ , and randomly-initialized parameters $w _ { 0 } \sim \mathcal { D }$ , there exists a sparse sub-network, defined by a configuration $m \in \{ 0 , 1 \} ^ { d }$ , $\| m \| _ { 0 } \ll d$ , that, when trained from scratch, achieves higher performance than $f ( x ; w )$ while requiring fewer training iterations. The authors support this conjecture experimentally, showing that such sub-networks indeed exist: in particular, they can be discovered by repeatedly training, pruning, and re-initializing the network, through a procedure named Iterative Magnitude Pruning (IMP; Algorithm 1) (Frankle et al., 2019). More specifically, IMP alternates between: (1) training the weights $w$ of a network, (2) removing a fixed fraction of the weights with the smallest magnitude (pruning), and (3) rewinding: setting the remaining weights back to their original initialization $w _ { 0 }$ .
+
+The sub-networks found by IMP, which indeed train faster and outperform their original, dense networks, are called winning tickets, and can generalize across datasets (Mehta, 2019; Soelen & Sheppard, 2019) and training methods (Morcos et al., 2019). In this sense, IMP can be a promising tool in applications that involve knowledge transfer, such as transfer or meta learning.
+
+Zhou et al. (2019) perform extensive experiments to re-evaluate and better understand the Lottery Ticket Hypothesis. Relevant to this work is the fact that the authors propose a method to learn the binary mask $m$ in an end-to-end manner through SGD, instead of relying on magnitude-based pruning. The authors show that learning only the binary mask and not the weights is sufficient to achieve competitive performance, confirming that the learned masks are highly dependent on the initialized values $w _ { 0 }$ , and are also capable of encoding substantial information about a problem’s solution.
+
+# 2.2 SPARSE NETWORKS
+
+The core aspect of searching for a winning ticket is finding a sparse sub-network that attains high performance relative to its dense counterpart. One way to achieve this is through pruning methods (LeCun et al., 1990), which follow a strategy to remove weights from a trained network while minimizing negative impacts on its performance. In Han et al. (2015), a network is iteratively trained and pruned using parameter magnitudes as criterion: this iterative, two-stage algorithm is shown to outperform “one-shot pruning”: training and pruning the network only once.
+
+Other methods attempt to approximate $\ell _ { 0 }$ regularization on the weights of a network, yielding onestage procedures that can be fully described in the optimization framework. In order to find a sparse
+
+# Algorithm 1 Iterative Magnitude Pruning (Frankle et al., 2019)
+
+1: Initialize $w  w _ { 0 } \sim \mathcal { D }$ and $m \gets \vec { 1 } ^ { d }$   
+2: Minimize $L ( f ( x ; m \odot w ) )$ until $w _ { T }$ is produced   
+3: Set $m _ { i } = 0$ for the active weights with smallest magnitudes $\langle \vert w _ { T , i } \vert \le \tau$ and $m _ { i } = 1$ )   
+4: If satisfied, output ticket $f ( x ; m \odot w _ { k } )$   
+5: Otherwise, set $w  w _ { k }$ and go back to step 2
+
+# Algorithm 2 Iterative Stochastic Sparsification (inspired by Zhou et al. (2019))
+
+1: Initialize $w  w _ { 0 } \sim \mathcal { D }$ , $s  { \vec { s } } _ { 0 }$   
+2: Minimize $\mathbb { E } _ { m \sim \mathrm { B e r } ( \sigma ( s ) ) } \left[ L ( f ( x ; m \odot w ) ) \right] + \lambda \left\| \sigma ( s ) \right\| _ { 1 }$ until $w _ { T }$ and $s _ { T }$ are produced   
+3: If satisfied, output ticket $f ( x ; m \odot w _ { k } )$ , $m \sim \operatorname { B e r } ( \sigma ( s _ { T } ) )$   
+4: Otherwise, set $w  w _ { k }$ , $s _ { i } \gets - \infty$ for $s _ { i , T } < s _ { i , 0 }$ , and go back to step 2
+
+setting $m \in \{ 0 , 1 \} ^ { d }$ of a network $f ( x ; m \odot w )$ , Srinivas et al. (2016) and Louizos et al. (2017) use a stochastic re-parameterization $m \sim \mathrm { B e r n o u l l i } ( g ( s ) )$ with $s \in \mathbb { R } ^ { d }$ and $g : \mathbb { R }  [ 0 , 1 ]$ applied element-wise. First-order methods, coupled with gradient estimators, are then used to train both $w$ and $s$ to minimize the expected loss. This approach performs continuous parameter removal during training in an automatic fashion: any component $s _ { i }$ of $s$ that assumes a value during training where $g ( s _ { i } ) \bar { = } 0$ effectively removes $w _ { i }$ from the network. Moreover, approximating $\ell _ { 0 }$ regularization has the advantage of not requiring a pruning strategy, which might be arbitrarily complex.
+
+# 3 METHOD
+
+Designing a method to quickly find winning tickets requires an efficient way to sparsify networks: ideally, sparsification should be done as early as possible in training, and the number of removed parameters should be maximized without harming the model’s performance. In other words, sparsification must be continuously maximized following a trade-off with the performance of the network. This goal is not met by Iterative Magnitude Pruning: sparsification is done at discrete time steps, only after fully training the network, and optimal pruning rates likely depend on the model’s performance and current sparsity: factors which are typically not accounted for – note that these are inherent characteristics of magnitude-based pruning.
+
+In light of this, we turn to $\ell _ { 0 }$ -regularization methods for learning sparse networks, which consist of optimizing a clear trade-off between sparsity and performance. As we will see, performing sparsification continuously is not only straightforward, but done automatically by the optimizer.
+
+# 3.1 CONTINUOUS SPARSIFICATION BY LEARNING DETERMINISTIC MASKS
+
+We first frame the search for sparse networks as a loss minimization problem with $\ell _ { 0 }$ regularization (Louizos et al., 2017; Srinivas et al., 2016):
+
+$$
+\operatorname* { m i n } _ { w \in \mathbb { R } ^ { d } } L ( f ( x ; w ) ) + \lambda \cdot \| w \| _ { 0 }
+$$
+
+where $\lambda \geq 0$ controls the sparsity of the solution, and, with a slight abuse of notation, $L ( f ( x ; w ) )$ denotes the loss incurred by the network $f ( x ; w )$ (e.g., the cross-entropy loss over a training set). As $\ell _ { 0 }$ regularization is typically intractable, we re-state the above minimization problem as:
+
+$$
+\operatorname* { m i n } _ { w \in \mathbb { R } ^ { d } } L ( f ( x ; m \odot w ) ) + \lambda \cdot \| m \| _ { 1 }
+$$
+
+which uses the fact that, for $m \in \{ 0 , 1 \} ^ { d }$ , $\left\| m \right\| _ { 0 } = \left\| m \right\| _ { 1 }$ . The $\ell _ { 1 }$ term can be minimized with subgradient descent, however the $m \in \{ 0 , 1 \} ^ { d }$ constraint makes the above problem combinatorial and poorly suited for local search methods like SGD.
+
+# Algorithm 3 Continuous Sparsification
+
+1: Initialize $w  w _ { 0 } \sim \mathcal { D }$ , $s  s _ { 0 }$ , $\beta  \beta _ { 0 }$   
+2: Minimize $L ( f ( x ; \sigma ( \boldsymbol { \beta } \cdot \boldsymbol { s } ) \odot w ) ) + \lambda \| \sigma ( \boldsymbol { \beta } \boldsymbol { s } ) \| _ { 1 }$ while increasing $\beta$ , producing $w _ { T } , s _ { T }$ , and $\beta _ { T }$   
+3: If satisfied, output ticket $f ( x ; b ( s _ { T } ) \odot w _ { k } )$   
+4: Otherwise, set $s \gets \operatorname* { m i n } ( \beta _ { T } \cdot s _ { T } , s _ { 0 } )$ , $\beta \gets \beta _ { 0 }$ , (optionally, $w  w _ { 0 }$ ), and go back to step 2
+
+![](images/373e0fadcc41f3b2199e6a7d6c67db0a7b3584468985a49668a5e449fd898738.jpg)  
+Figure 1: Illustration of our proposed re-parameterization $m = \sigma ( \beta s )$ , where $\begin{array} { r } { \sigma ( z ) = \frac { 1 } { 1 + e ^ { - z } } } \end{array}$ is the sigmoid function and $\beta$ acts as a temperature. As $\beta$ increases, $\sigma ( \beta z )$ approaches $b ( z )$ , which can can be used to frame a $\ell _ { 0 }$ -regularized problem (Equation 4). Note that the gradients of $\overset { \cdot } { \sigma } ( \beta s )$ vanish as $\beta$ increases, suggesting that $\beta$ should be annealed slowly during training.
+
+We can avoid the binary constraint $m \in \{ 0 , 1 \} ^ { d }$ by re-parameterizing $m$ as a function of a newlyintroduced variable $s \in \mathbf { \overline { { \mathbb { R } } } } ^ { d }$ . For example, Louizos et al. (2017) propose a stochastic mapping $s \mapsto m$ and use gradient methods to minimize the expected total loss, while using estimators for the gradients of $s$ (since $m$ is still binary). Having a stochastic mask (or, equivalently, a distribution over subnetworks) poses an immediate challenge for the task of finding tickets, as it is not clear which ticket should be chosen once a distribution over $m$ is learned. Moreover, relying on gradient estimators often causes gradients to have high variance, requirwe consider a deterministic parameterization $\bar { m } = \bar { b ( s ) }$ training, where $s \in \mathbb { R } _ { \neq 0 } ^ { d }$ optiand $b : \bar { \mathbb { R } } _ { \neq 0 }  \{ 0 , 1 \}$ ly,is applied element-wise:
+
+$$
+b ( z ) = { \left\{ \begin{array} { l l } { 1 , { \mathrm { i f ~ } } z > 0 } \\ { 0 , { \mathrm { i f ~ } } z < 0 } \end{array} \right. }
+$$
+
+Applying this re-parameterization to Equation 2 yields:
+
+$$
+\operatorname* { m i n } _ { w \in \mathbb { R } ^ { d } \atop s \in \mathbb { R } _ { \neq 0 } ^ { d } } L ( f ( x ; b ( s ) \odot w ) ) + \lambda \cdot \| b ( s ) \| _ { 1 }
+$$
+
+Clearly, the above problem is again intractable, as it is still equivalent to the original $\ell _ { 0 }$ problem in Equation 1. More specifically, the step function $b ( z )$ is non-convex, and having zero gradients make gradient-based optimization ineffective. Instead, we consider the following smooth relaxation of $b ( \cdot )$ :
+
+$$
+m : = \sigma ( \beta \cdot s )
+$$
+
+where $\beta \in \mathbb { R } _ { > 0 }$ , and $\sigma$ is the sigmoid function $\begin{array} { r } { \sigma ( z ) = \frac { 1 } { 1 + e ^ { - z } } } \end{array}$ , applied element-wise. By controlling $\beta$ , which acts as a temperature parameter, we effectively interpolate between $\sigma ( s )$ , a smooth function well-suited for SGD, and $\begin{array} { r } { \operatorname* { l i m } _ { \beta \to \infty } \sigma ( \beta \cdot s ) = b ( z ) } \end{array}$ , our original goal, which brings computational hardness to the problem. Figure 1 illustrates this behavior. Note that, if $L ( f ( x ; w ) )$ is continuous in $w$ , then:
+
+$$
+\operatorname* { m i n } _ { w \in \mathbb { R } _ { \neq 0 } ^ { d } } \operatorname* { l i m } _ { \beta \to \infty } L ( f ( x ; \sigma ( \beta s ) \odot w ) ) + \lambda \cdot \| \sigma ( \beta s ) \| _ { 1 } = \operatorname* { m i n } _ { w \in \mathbb { R } _ { \neq 0 } ^ { d } } L ( f ( x ; b ( s ) \odot w ) ) + \lambda \cdot \| b ( s ) \| _ { 1 }
+$$
+
+Although gradient methods will become ineffective as $\beta \to \infty$ due to vanishing gradients of $s$ , we can increase $\beta$ while optimizing $s$ and $w$ with gradient descent. That is, our loss at each iteration will be a function of $\beta$ as follows:
+
+$$
+L _ { \beta } ( w , s ) = L ( f ( x ; \sigma ( \beta s ) \odot w ) ) + \lambda \cdot \| \sigma ( \beta \cdot s ) \| _ { 1 }
+$$
+
+How does the soft mask $m = \sigma ( \beta \cdot s )$ behave as we minimize ${ \cal L } _ { \beta } ( w , s )$ while increasing $\beta ?$ As $\beta \to \infty$ , every negative component of $s$ will be mapped to 0, effectively removing its correspondent weight parameter from the network. While analytically the weights will never truly be zeroed-out, limited numerical precision has the fortunate side-effect of causing actual sparsification to the network during training, as long as $\beta$ is increased to a large enough value.
+
+In a nutshell, we learn sparse networks by minimizing $\boldsymbol { L _ { \beta } } ( \boldsymbol { w } , s )$ for $T$ parameter updates with gradient descent while jointly annealing $\beta$ : producing $w _ { T }$ , $s _ { T }$ and $\beta _ { T }$ , which is ideally large enough such that, numerically 1, $\sigma ( \vec { \beta _ { T } } \cdot s _ { T } ) = \bar { b } ( s _ { T } )$ . In case $m$ is truly required to be binary (as in the task of finding tickets), the dependence on numerical imprecision can be avoided by directly outputting $m = b ( s _ { T } )$ at the end of training.
+
+Finally, note that minimizing $L _ { \beta }$ while increasing $\beta$ is not generally equivalent to minimizing the original $\ell _ { 0 }$ -regularized problem. Informally, the former aims to solve $\begin{array} { r } { \operatorname* { l i m } _ { \beta \to \infty } \operatorname* { m i n } _ { w , s } L _ { \beta } ( w , s ) } \end{array}$ , while the $\ell _ { 0 }$ problem is $\mathrm { \bar { m i n } } _ { w , s } \operatorname* { l i m } _ { \substack { \beta \to \infty } } L _ { \beta } \mathrm { \bar { ( } } w , s )$ .
+
+# 3.2 TICKET SEARCH THROUGH CONTINUOUS SPARSIFICATION
+
+The method presented above offers a direct alternative to magnitude-based pruning when performing ticket search, but a few considerations must follow. Most importantly, when searching for winning tickets, there is a strict constraint that the learned mask $m$ be binary: otherwise, one can also learn the magnitude of the weights, defeating the purpose of finding sub-networks that can be trained from scratch. To guarantee that the output mask satisfies this constraint regardless of numerical precision, we always output $b ( s _ { T } )$ instead of $\sigma ( \beta _ { T } \cdot s _ { T } )$ .
+
+Additionally, we also incorporate two techniques from successful methods for learning sparse networks and searching for winning tickets. First, motivated by Han et al. (2015), where it is shown that iteratively pruning a network yields improved sparsity compared to pruning it only once, we enable “kept” weights – those whose corresponding component of $s$ is positive after many iterations – to be removed from the network at a later stage. More specifically, when $\beta$ becomes large after $T$ gradient descent updates, the gradients of $s$ vanish and weights will no longer be removed from the network. To avoid this, we set $s \gets \operatorname* { m i n } ( \beta _ { T } \cdot s _ { T } , s _ { 0 } )$ , effectively resetting the soft mask parameters for the remaining weights while at the same time not interfering with weights that have been removed. This is followed by a reset on the temperature, $\beta  \beta _ { 0 }$ , to allow training of $s$ once again.
+
+Second, we perform parameter rewinding, following Frankle $\&$ Carbin (2019), which is a key component of Iterative Magnitude Pruning. More specifically, after $T$ gradient descent steps, we reset the weight values back to an earlier stage $w  w _ { k }$ , where $k \ll T$ . Even though experimental results in Frankle & Carbin (2019) suggest that rewinding is necessary for successful ticket search, we leave rewinding as an optinal component of our algorithm: as we will see empirically, it turns out that ticket search is possible without rewinding weights. Our proposed algorithm to find winning tickets is presented as Algorithm 3, and referred simply as “Continuous Sparsification”.
+
+# 4 EXPERIMENTS
+
+Our experiments aim at comparing different methods on the task of finding winning tickets in neural networks, hence our evaluation focuses on the generalization performance of each ticket (sub-network) when trained from scratch (or from an iterate in early-training). Additionally, we measure the cost of the search procedure: the number of training epochs to find tickets with varying performance and sparsity.
+
+Besides comparing our proposed method to Iterative Magnitude Pruning (Algorithm 1), we also design a baseline method, Iterative Stochastic Sparsification (ISS, Algorithm 2), motivated by the procedure in Zhou et al. (2019) to find a binary mask $m$ with gradient descent in an end-to-end fashion. More specifically, ISS uses a stochastic re-parameterization $m \sim$ Bernoulli $( \sigma ( s ) )$ with $s \in \mathbb { R } ^ { d }$ , and trains $w$ and $s$ jointly with gradient descent and the straight-through estimator (Bengio et al., 2013). When ran for multiple iterations, all components of the mask parameters $s$ which have decreased in value from initialization are set to $- \infty$ , such that the corresponding weight is permanently removed from the network. While this might look arbitrary, we observed empirically that ISS was unable to remove weights quickly without this step unless $\lambda$ was chosen to be large – in which case the model’s performance decrease in exchange for sparsity. The hyperparameters used in this section were chosen based on analysis presented in Appendix (...), where we study how the pruning rate affects IMP, and how $\lambda , s _ { 0 }$ and $\beta _ { T }$ interact in CS.
+
+# 4.1 CONVOLUTIONAL NEURAL NETWORKS
+
+We train a neural network with 6 convolutional layers on the CIFAR-10 dataset (Krizhevsky, 2009), following Frankle & Carbin (2019). The network consists of 3 blocks of 2 resolution-preserving convolutional layers followed by $2 \times 2$ max-pooling, where convolutions in each block have 64, 128 and 256 channels, a $3 \times 3$ kernel, and are immediately followed by ReLU activations. The blocks are followed by fully-connected layers with 256, 256 and 10 neurons, with ReLUs in between. The network is trained with Adam (Kingma & Ba, 2015) with a learning rate of 0.0003 and a batch size of 60.
+
+Learning a Supermask: As a first baseline, we consider the task of learning a “supermask” (Zhou et al., 2019): a binary mask $m$ that, when applied to a network with randomly initialized weights, yields performance competitive to that of training its weights. This task is equivalent to pruning a randomly-initialized network, or learning an architecture that performs well prior to training with a fixed initialization. We compare ISS and CS , where each method is run for a single iteration composed of 100 epochs. When ran for a single iteration, ISS is equivalent to the algorithm proposed in Zhou et al. (2019) to learn a supermask, referred here as simply Stochastic Sparsification. We control the sparsity of the learned masks by varying $s _ { 0 }$ between $- 5$ and 5 for Stochastic Sparsification (which showed to be more effective than varying $\lambda$ ), while for Continuous Sparsification we vary $\lambda$ between $1 0 ^ { - 1 1 }$ and $1 0 ^ { - 7 }$ (which results in stable and consistent training, unlike varying $s _ { 0 }$ ). SS uses SGD with a learning rate of 100 to learn its mask parameters, while CS uses Adam with $\mathrm { \ddot { 3 } } \times 1 0 ^ { - 4 }$ .
+
+Results are presented in Figure 2: CS outperforms SS in terms of both training speed and the quality of the learned mask. In particular, CS finds masks with over $7 5 \%$ sparsity that yield over $7 5 \%$ test accuracy, while the performance of masks found by SS decrease when sparsity is over $5 0 \%$ . Moreover, CS makes faster progress in training, showing that optimizing a deterministic mask is indeed faster than learning a distribution over masks through stochastic re-parameterizations.
+
+Finding Winning Tickets: We run IMP and ISS for a total of 30 iterations, each consisting of 40 epochs. Parameters are trained with Adam (Kingma & Ba, 2015) with a learning rate of $3 \times 1 0 ^ { - 4 }$ , following Frankle & Carbin (2019). For IMP, we use pruning rates of $1 5 \% / 2 0 \%$ for convolutional/dense layers. We initialize the Bernoulli parameters of ISS with $s _ { 0 } = \vec { 1 }$ , and train them with SGD and a learning rate of 20, along with a $\ell _ { 1 }$ regularization of $\lambda = 1 0 ^ { - 8 }$ . For CS , we anneal the temperature from $\beta _ { 0 } = 1$ to $\beta _ { 0 } = 2 5 0$ following an exponential schedule $( \beta _ { t } = 2 5 0 ^ { \frac { t } { T } } )$ ), training both the weights and the mask with Adam and a learning rate of $3 \times 1 0 ^ { - 4 }$ .
+
+To test whether our method is capable of finding winning tickets in a limited amount of time, we limit each run of CS to 4 iterations only, in contrast with IMP and ISS which are run for 30. We perform 6 runs of CS , each with a different value for the mask initialization $s _ { 0 } \colon - 0 . 0 5 , - 0 . 0 3 , - 0 . \bar { 0 2 } , - 0 . 0 1 ,$ $- 0 . 0 0 5 , 0$ , keeping $\lambda = 1 0 ^ { - 1 0 }$ , such that sparsification is not enforced during training, but heavily biased at initialization. In order to evaluate how consistent our method is, we repeat each run with 3 different random seeds so that error bars can be computed.
+
+![](images/38737692412099085fa17d05de3bd18d9b6b97f461d31e86023b5d386cf0a1f0.jpg)  
+Figure 2: Learning a binary mask with weights frozen at initialization with Stochastic Sparsification (SS, Algorithm 2 with one iteration) and Continuous Sparsification (CS), on a 6-layer CNN on CIFAR10. Left: Training curves with hyperparameters for which masks learned by SS and CS were both approximately $5 0 \%$ sparse. CS learns the mask significantly faster while attaining similar early-stop performance. Right: Sparsity and test accuracy of masks learned with different settings for SS and CS: our method learns sparser masks while maintaining test performance, while SS is unable to successfully learn masks with over $5 0 \%$ sparsity.
+
+![](images/9bec91a4d6d0bcd418f1f6cf5fbd413ee833db063e1e6916fdac26b186cbeaaa.jpg)  
+Figure 3: Test accuracy of tickets found by different methods on CIFAR-10. Error bars depict variance across 3 runs. Left: Performance of tickets found on a 6-layer CNN, when trained from scratch. Right: Performance of tickets found on a ResNet 20, when rewinded to the second training epoch. In both experiments, tickets found by CS outperform ones found by IMP. In most cases, CS successfully finds winning tickets in 2 iterations (purple curves).
+
+Figure 3 (left) presents the quality of tickets found by each method, measured by their test accuracy when trained from scratch. To illustrate the quality of the tickets that can be found by Continuous Sparsification, we plot the Pareto curve (green) of the tickets founds with the 6 different values for $s _ { 0 }$ . With $s _ { 0 } = - 0 . 0 3$ , in only 2 iterations CS finds a ticket with over $7 7 \%$ sparsity (first marker of purple curve) which outperforms every ticket found by IMP in its 30 iterations. The Pareto curve of CS strictly dominates IMP for tickets with more less than $9 7 \%$ sparsity, where ticket performance is superior or similar to the original dense network.
+
+In terms of computational time, the total cost to run CS with the 6 different values for $s _ { 0 }$ is lower than performing a single run of IMP for 30 iterations, even though CS takes $1 5 \%$ extra time per epoch due to the mask parameters. This shows the potential of our model even in the setting where a specific sparsity is desired for the tickets. When run in parallel, CS takes less wall-clock time to find all tickets in the Pareto curve than to run IMP for 5 iterations.
+
+4.2 FINDING WINNING TICKETS IN RESIDUAL NETWORKS WITHOUT REWINDING
+
+Searching for tickets in realistic models is not as straightforward as finding tickets in a small CNN, and might require new strategies. Frankle et al. (2019) show that IMP fails at finding winning tickets in ResNets (He et al., 2016) unless the learning rate is smaller than the recommended value, leading to worse overall performance and defeating the purpose of ticket search. However, the authors propose a slight modification to IMP that enables search for winning tickets to be successful on complex networks: instead of training from scratch, tickets are initialized with weights from early training.
+
+With this in mind, we evaluate how Continuous Sparsification performs in the time-consuming task of finding winning tickets in a ResNet- $2 0 ^ { 2 }$ (He et al., 2016) trained on CIFAR-10: a setting where IMP might take over 10 iterations (850 epochs) to succeed. We follow the setup in Frankle & Carbin (2019) and Frankle et al. (2019): in each iteration, the network is trained with SGD, a learning rate of 0.1, and a momentum of 0.9 for a total of 85 epochs, using a batch size of 128. The learning rate is decayed by a factor of 10 at epochs 56 and 71, and a weight decay of 0.0001 is applied to the weights (for CS , we do not apply weight decay to the mask parameters $s$ ). The two skip-connections that perform $1 \times 1$ convolutions and the output layer are not removable: for IMP, their parameters are not pruned, while for CS their weights do not have a correspondent mask $m$ nor mask parameters $s$ .
+
+When training the returned tickets in order to evaluate their performance, we initialize their weights with the iterates from the end of epoch 2 (780 parameter updates), similarly to Frankle et al. (2019). Unlike when searching for winning tickets in the 6-layer CNN, IMP performs global pruning, removing $2 0 \%$ of the remaining parameters with smallest magnitude, ranked globally (across different layers). IMP runs for a total of 30 iterations, while CS is limited to only 5 iterations for each run. The sparsity of the tickets found by CS is controlled by varying the mask initialization $s _ { 0 } \in$ $\{ - 0 . 3 , - 0 . 2 , - 0 . 1 , - 0 . 0 5 , - 0 . 0 3 , 0 , 0 . 0 3 , 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 3 \}$ (a total of 11 values). To allow for even faster ticket search, we run CS without parameter rewinding: that is, the weights $w$ are transferred from one iteration to another, removing the need to re-train the network as the method progresses through iterations. For both CS and IMP, each run is repeated with 3 different random seeds.
+
+The results presented in Figure 3 (right) show that CS is able to successfully find winning tickets with varying sparsity in under 5 iterations. Once again, the Pareto curve strictly dominates IMP, and variance across runs is smaller than IMP’s. Most notably, CS is capable of quickly sparsifying the network in a single iteration (first marker of each purple curve), and typically finds better tickets than IMP after only 2 rounds (compare blue curve and second marker of each purple curve), regardless of sparsity. When run in parallel, 2 iterations suffice for CS to find tickets that outperform the ones found by IMP.
+
+We observed that not performing rewinding caused the performance of tickets with high sparsity to quickly degrade after 2 or more iterations of CS. We speculate that, when rewinding is not performed between iterations, the distance between $w _ { k }$ and the parameter iterates produced by gradient descent $w _ { t }$ increase significantly with the number of iterations. This in turn can result in the learned mask $m _ { T }$ to be highly sub-optimal for weight values $w _ { k }$ $k \ll T$ ) which are used to re-train the ticket. This suggests that in order to avoid re-training the network and hence make the search for winning tickets more efficient, rewinding should not be performed between iterations. In this case, the search must complete quickly, before performance degradation occurs due to “overtraining”, requiring optimal ways to perform sparsification without negatively impacting the model’s performance.
+
+# 4.3 PRUNING VGG
+
+Our experiments show that Continuous Sparsification is capable of finding tickets quickly and consistently, and we attribute its success to its deterministic re-parameterization of the binary mask. Here, we evaluate our method a pruning technique, to better assess whether our proposed re-parameterization is advantageous only in terms of training time, or also in respect to the quality of the learned masks.
+
+For this task, we train a VGG (Simonyan & Zisserman, 2015) on the CIFAR-10 dataset, following the protocol in Frankle & Carbin (2019): the network is trained with SGD and an initial learning rate of 0.1, which is decayed by a factor of 10 at epochs 80 and 120. After 160 training epochs, the network is sparsified and then fine-tuned for 40 epochs with a learning rate of 0.001. We evaluate previously described methods when executed for a single iteration (one-shot pruning): Continuous Sparsification, Magnitude Pruning (IMP with 1 iteration) (Han et al., 2015), and Stochastic Sparsification (ISS with 1 iteration), which is similar to methods in Zhou et al. (2019), Srinivas et al. (2016), and Louizos et al. (2017).
+
+At the sparsification step, IMP performs global pruning, ISS fixes the binary mask $m$ to be the maximum likelihood one under $\operatorname { B e r } ( \sigma ( s ) )$ (which performed better than sampling from the distribution), and CS changes the parameterization of the mask from $\sigma ( \beta s )$ to $b ( s )$ (or, equivalently, weights $w _ { i }$ where $s _ { i } < 0$ are removed). We use a momentum of 0.9, a weight decay of 0.0001 (not applied to s), and a batch-size of 64. Following Frankle & Carbin (2019), sparsification is not applied to batch normalization nor the final linear layer.
+
+To evaluate each method when finding masks with different sparsity levels, we run IMP with global pruning rates $5 0 \%$ , $7 5 \%$ , $8 0 \%$ , $8 5 \%$ , ${ \bar { 9 } } 0 \%$ , $9 \hat { 5 } \%$ , $9 7 . 5 \%$ , $9 8 \%$ , $9 8 . 5 \%$ , $9 9 \%$ , $9 9 . 5 \%$ , $9 9 . 7 5 \%$ , and ISS and CS with initial mask values $- 0 . 3$ , $- 0 . 2 5$ , $- 0 . 2$ , $- 0 . 1 5$ , $- 0 . 1$ , $- 0 . 0 5$ $- 0 . 0 1$ , $- 0 . 0 0 5$ , $- 0 . 0 0 1$ , 0. Results are shown in Figure 4: both magnitude pruning and stochastic $\ell _ { 0 }$ regularization (Stochastic Sparsifi
+
+![](images/b21e02a334c93b267ef966b4139eeb497f15c3cfc8a4b4250deebf600cd38422.jpg)  
+Figure 4: Performance of different methods when performing one-shot pruning on VGG. CS maintains over $9 0 \%$ test accuracy after removing $9 9 . 7 \%$ of the weights, while other methods fail to successfully remove more than $9 8 \%$ of the parameters.
+
+cation) fail at removing over $9 8 \%$ of the weights without severely degrading the performance of the model. On the other hand, Continuous Sparsification successfully removes ${ \bar { 9 } } 9 . 7 \%$ of the parameters in the convolutional layers while still yielding over $9 0 \%$ test accuracy. When taken to the extreme, our method is capable of removing $9 9 . 8 5 \%$ of the weights and still yield over $8 3 \%$ accuracy.
+
+The dramatic performance difference between stochastic and continuous sparsification shows that our proposed deterministic re-parameterization is key to achieve superior results in both network pruning and ticket search. The fact that it outperforms magnitude pruning, a standard technique in the pruning literature, suggests that further exploration of $\ell _ { 0 }$ -based methods could yield significant advances in pruning techniques.
+
+# 5 DISCUSSION
+
+With Frankle & Carbin (2019), we now realize that sparse sub-networks can indeed be successfully trained from scratch, putting in question the belief that overparameterization is required for proper optimization of neural networks. Such sub-networks, called winning tickets, can be potentially used to significantly decrease the required resources for training deep networks, as they are shown to transfer between different, but similar, tasks (Mehta, 2019; Soelen & Sheppard, 2019).
+
+Currently, the search for winning tickets is a poorly explored problem, where Iterative Magnitude Pruning (Frankle & Carbin, 2019) stands as the only algorithm suited for this task, and it is unclear whether its key ingredients – post-training magnitude pruning and parameter rewinding – are the correct choices for the task. Here, we approach the problem of finding sparse sub-networks as an $\ell _ { 0 }$ -regularized optimization problem, which we approximate through a smooth, parameterized relaxation of the step function. Our proposed algorithm for finding winning tickets, Continuous Sparsification, removes parameters automatically and continuously during training, and can be fully described by the optimization framework. We show empirically that, indeed, post-training pruning might not be a sensible choice for finding winning tickets, raising questions on how the search for tickets differs from standard network compression. With this work, we hope to further motivate the problem of quickly finding tickets in overparameterized networks, as recent work suggests that the task might be highly relevant to transfer learning and mobile applications.
+
+# REFERENCES
+
+Zeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. A convergence theory for deep learning via overparameterization. In ICML, 2019.
+
+Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or Propagating Gradients Through Stochastic Neurons for Conditional Computation. arXiv e-prints, art. arXiv:1308.3432, 2013.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv e-prints, art. arXiv:1810.04805, 2018.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR, 2019.
+
+Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M. Roy, and Michael Carbin. Stabilizing the Lottery Ticket Hypothesis. arXiv e-prints, art. arXiv:1903.01611, 2019.
+
+Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural networks. NIPS’15, 2015.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. ICLR, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016.
+
+Forrest N. Iandola, Matthew W. Moskewicz, Khalid Ashraf, Song Han, William J. Dally, and Kurt Keutzer. SqueezeNet: AlexNet-level accuracy with $5 0 \mathrm { x }$ fewer parameters and ${ < } 1 \mathbf { M } \mathbf { B }$ model size. arXiv:1602.07360, 2016.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In NIPS. 1990.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. ICLR, 2019.
+
+Christos Louizos, Max Welling, and Diederik P. Kingma. Learning Sparse Neural Networks through $L _ { 0 }$ Regularization. arXiv e-prints, art. arXiv:1712.01312, 2017.
+
+Rahul Mehta. Sparse Transfer Learning via Winning Lottery Tickets. arXiv e-prints, art. arXiv:1905.07785, 2019.
+
+Ari S. Morcos, Haonan Yu, Michela Paganini, and Yuand ong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. arXiv e-prints, art. arXiv:1906.02773, 2019.
+
+Behnam Neyshabur, Zhiyuan Li, Srinadh Bhojanapalli, Yann LeCun, and Nathan Srebro. Towards Understanding the Role of Over-Parametrization in Generalization of Neural Networks. arXiv e-prints, art. arXiv:1805.12076, 2018.
+
+Pedro Savarese and Michael Maire. Learning implicitly recurrent CNNs through parameter sharing. In ICLR, 2019.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. ICLR, 2015.
+
+Ryan Van Soelen and John W. Sheppard. Using winning lottery tickets in transfer learning for convolutional neural networks. In IJCNN, 2019.
+
+Suraj Srinivas, Akshayvarun Subramanya, and R. Venkatesh Babu. Training Sparse Neural Networks. arXiv e-prints, art. arXiv:1611.06694, 2016.
+
+Saining Xie, Ross B. Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. CVPR, 2017.
+
+Hattie Zhou, Janice Lan, Rosanne Liu, and Jason Yosinski. Deconstructing lottery tickets: Zeros, signs, and the supermask. ArXiv, abs/1905.01067, 2019.
+
+# APPENDIX
+
+# A HYPERPARAMETER ANALYSIS
+
+# A.1 CONTINUOUS SPARSIFICATION
+
+In this section, we study how the hyperparameters of Continuous Sparsification affect its performance in terms of sparsity and performance of the found tickets. More specifically, we consider the following hyperparameters:
+
+• Final temperature $\beta _ { T }$ : the final value for $\beta$ , which controls how smooth the parameterization $m = \sigma ( \bar { \beta } s )$ is.   
+• $\ell _ { 1 }$ penalty $\lambda$ : the strength of the $\ell _ { 1 }$ regularization applied to the soft mask $\sigma ( \beta s )$ , which promotes sparsity.   
+• Mask initial value $s _ { 0 }$ : the value used to initialize all components of the soft mask $m = \sigma ( \beta s )$ , where smaller values promote sparsity.
+
+Our setup is as follows: to analyze how each of the 3 hyperparameters impact the performance of Continuous Sparsification, we train a ResNet 20 on CIFAR-10 (following the same protocol from Section 4.2), varying one hyperparameter while keeping the other two fixed. To capture how hyperparameters interact with each other, we repeat the described experiment with different settings for the fixed hyperparameters.
+
+Since different hyperparameter settings naturally yield vastly distinct sparsity and performance for the found tickets, we report relative changes in accuracy and in sparsity.
+
+In Figure 5, we vary $\lambda$ between 0 and $1 0 ^ { - 8 }$ for three different $( s _ { 0 } , \beta _ { T } )$ settings: $\stackrel { \prime } { s } _ { 0 } = - 0 . 2 , \beta _ { T } =$ 100), $( s _ { 0 } = 0 . 0 5 , \mathring { \beta _ { t } } = 2 0 0 )$ , and $( s _ { 0 } = - 0 . 3 , \beta _ { T } = 1 0 0 )$ . As we can see, there is little impact on either the performance or the sparsity of the found ticket, except for the case where $s _ { 0 } = 0 . 0 5$ and $\beta _ { T } = 2 0 0$ , for which $\lambda = 1 0 ^ { - 8 }$ yields slightly increased sparsity.
+
+![](images/e56a29401e70aaf2ec3f8cc9a42a882496ee4aa389ac344c91494ade8c1c4d17.jpg)  
+Figure 5: Impact on relative test accuracy and sparsity of tickets found in a ResNet 20 trained on CIFAR-10, for different values of $\lambda$ and fixed settings for $\beta _ { T }$ and $s _ { 0 }$ .
+
+Next, we consider the fixed settings $( s _ { 0 } = - 0 . 2 , \lambda = 1 0 ^ { - 1 0 } ,$ ), $( s _ { 0 } = 0 . 0 5 , \lambda = 1 0 ^ { - 1 2 } )$ ), $( s _ { 0 } =$ $- 0 . 3 , \lambda = 1 0 ^ { - 8 } ,$ , and proceed to vary the final temperature $\beta _ { T }$ between 50 and 200. Figure 6 shows the results: in all cases, a larger temperature of 200 yielded better accuracy. However, it decreased sparsity compared to smaller temperature values for the settings $( s _ { 0 } = - 0 . 2 , \lambda = 1 0 ^ { - 1 0 }$ ) and $\stackrel { \prime } { s } _ { 0 } = \bar { - } 0 . 3 , \stackrel { . } { \lambda } = 1 \bar { 0 } ^ { - 8 } ,$ ), while at the same time increasing sparsity for $\begin{array} { r } { { ' s _ { 0 } } = 0 . 0 5 , \lambda = 1 0 ^ { - 1 2 } . } \end{array}$ ). While larger temperatures appear beneficial and might suggest that even higher values should be used, note that, the larger $\beta _ { T }$ is, the earlier in training the gradients of $s$ will vanish, at which point training of the mask will stop. Since the performance for temperatures between 100 and 200 does not change significantly, we recommend values around 150 or 200 when either pruning or performing ticket search.
+
+![](images/7f92ae1a277e9c86b70bb810e1a1eed680f5ceb6bfb8b3ebe0e80fc52e996fe9.jpg)  
+Figure 6: Impact on relative test accuracy and sparsity of tickets found in a ResNet 20 trained on CIFAR-10, for different values of $\beta _ { T }$ and fixed settings for $\lambda$ and $s _ { 0 }$ .
+
+![](images/f4ad948bda3f8fc2a7596868bdcc729344371972624a4ac99e0c23ab352ca461.jpg)  
+Figure 7: Impact on relative test accuracy and sparsity of tickets found in a ResNet 20 trained on CIFAR-10, for different values of $s _ { 0 }$ and fixed settings for $\beta _ { T }$ and $\lambda$ .
+
+Lastly, we vary the initial mask value $s _ { 0 }$ between $- 0 . 3$ and $+ 0 . 3$ , with hyperpameter settings $( \beta _ { T } \doteq 1 0 0 , \lambda \doteq 1 0 ^ { - 1 0 } )$ , $( \beta _ { T } = 2 0 0 , \lambda = 1 0 ^ { - 1 2 } )$ ), and $\langle \beta _ { T } = 1 0 0 , \lambda = 1 0 ^ { - 8 } \rangle$ ). Results are given in Figure 7: unlike the exploration on $\lambda$ and $\beta _ { T }$ , we can see that $s _ { 0 }$ has a strong and consistent effect on the sparsity of the found tickets. For this reason, we suggest proper tuning of $s _ { 0 }$ when the goal is to achieve a specific sparsity value. Since the percentage of remaining weights is monotonically increasing with $s _ { 0 }$ , we can perform binary search over values for $s _ { 0 }$ to achieve any desired sparsity level. In terms of performance, lower values for $s _ { 0 }$ naturally lead to performance degradation, since sparsity quickly increases as $s _ { 0 }$ becomes more negative.
+
+![](images/28ffb9049096008e4c9629d6536fd2b0184a9f1c90eb72d731f4af1bb6bdb1df.jpg)  
+Figure 8: Performance of tickets found by Iterative Magnitude Pruning in a ResNet 20 trained on CIFAR, for different pruning rates.
+
+# A.2 ITERATIVE MAGNITUDE PRUNING
+
+Here, we assess whether the running time of Iterative Magnitude Pruning can be improved by increasing the amount of parameters pruned at each iteration. The goal of this experiment is to evaluate if Continuous Sparsification offers faster ticket search only because it prunes the network more aggressively than IMP, or because it is truly more effective in how parameters are chosen to be removed.
+
+Following the same setup as the previous section, we train a ResNet 20 on CIFAR-10. We run IMP for 30 iterations, performing global pruning with different pruning rates at the end of each iteration. Figure 8 shows that the performance of tickets found by IMP decays when the pruning rate is increased to $4 0 \%$ . In particular, the final performance of found tickets is mostly monotonically decreasing with the number of remaining parameters, suggesting that, in order to find tickets which outperform the original network, IMP is not compatible with more aggressive pruning rates.

parse/train/BJe4oxHYPB/BJe4oxHYPB_content_list.json

@@ -0,0 +1,1500 @@
+[
+    {
+        "type": "text",
+        "text": "WINNING THE LOTTERY WITH CONTINUOUS SPARSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            789,
+            118
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            143,
+            326,
+            156
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Paper under double-blind review ",
+        "bbox": [
+            184,
+            157,
+            398,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            207,
+            544,
+            222
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The Lottery Ticket Hypothesis from Frankle & Carbin (2019) conjectures that, for typically-sized neural networks, it is possible to find small sub-networks which train faster and yield superior performance than their original counterparts. The proposed algorithm to search for “winning tickets”, Iterative Magnitude Pruning, consistently finds sub-networks with $9 0 - 9 5 \\%$ less parameters which train faster and better than the overparameterized models they were extracted from, creating potential applications to problems such as transfer learning. ",
+        "bbox": [
+            233,
+            238,
+            766,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose Continuous Sparsification, a new algorithm to search for winning tickets which continuously removes parameters from a network during training, and learns the sub-network’s structure with gradient-based methods instead of relying on pruning strategies. We show empirically that our method is capable of finding tickets that outperforms the ones learned by Iterative Magnitude Pruning, and at the same time providing faster search, when measured in number of training epochs or wall-clock time. ",
+        "bbox": [
+            233,
+            337,
+            764,
+            434
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            336,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although deep neural networks have become ubiquitous in fields such as computer vision and natural language processing, extreme overparameterization is typically required to achieve state-ofthe-art results (Xie et al., 2017; Devlin et al., 2018), causing higher training costs and hindering applications where memory or inference time are constrained. Recent theoretical work suggest that overparameterization plays a key role in both the capacity and generalization of a network (Neyshabur et al., 2018), and in training dynamics (Allen-Zhu et al., 2019). However, it remains unclear whether overparameterization is truly necessary to train networks to state-of-the-art performance. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "At the same time, empirical approaches have been successful in finding less overparameterized neural networks, either by reducing the network after training (Han et al., 2015; 2016) or through more efficient architectures that can be trained from scratch (Iandola et al., 2016). Recently, the combination of these two approaches lead to new methods which discover efficient architectures through optimization instead of design (Liu et al., 2019; Savarese & Maire, 2019). Nonetheless, parameter efficiency is typically maximized by pruning an already trained network. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            680
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The fact that pruned networks are hard to train from scratch (Han et al., 2015; 2016) suggests that, while overparameterization is not necessary for a model’s capacity, it might be required for successful network training. Recently, this idea has been put into question by Frankle & Carbin (2019), where heavily pruned networks are trained faster than their original counterparts, often yielding superior performance. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A key finding is that the same parameter initialization should be used when re-training the pruned network. A winning ticket, defined by a sub-network and a setting of randomly-initialized parameters, is quickly trainable and has already found applications in, for example, transfer learning (Morcos et al., 2019; Mehta, 2019; Soelen & Sheppard, 2019), making the search for winning tickets a problem of independent interest. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Currently, the standard algorithm to find winning tickets is Iterative Magnitude Pruning (IMP) (Frankle & Carbin, 2019; Frankle et al., 2019), which consists of a repeating a 2-stage procedure that alternates between parameter optimization and pruning. As a result, IMP relies on a sensible choice for pruning strategy, and is time-consuming: finding a winning ticket with $1 \\%$ of the original parameters in a 6-layer CNN requires over 20 rounds of training followed by pruning, totalling over 1000 epochs (Frankle & Carbin, 2019). Choosing a parameter’s magnitude as pruning criterion has also shown to be sub-optimal in some settings (Zhou et al., 2019), leading to the question of whether better winning tickets can be found by different pruning methods. Moreover, at each iteration, IMP resets the parameters of the network back to initialization, hence considerable time is spent on re-training similar networks with different sparsities. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "With the goal of speeding up the search for winning tickets in deep neural networks, we design a novel method, Continuous Sparsification, which continuously removes weights from a network during training, instead of following a strategy to prune parameters at discrete time intervals. Unlike IMP, our method approaches the search for sparse networks as a $\\ell _ { 0 }$ -regularized optimization problem (Louizos et al., 2017), resulting in a method that can be fully described in the optimization framework. To approximate $\\ell _ { 0 }$ -regularization, we propose a smooth re-parameterization, allowing for the subnetwork’s structure to be directly learned with gradient-based methods. Unlike previous works, our re-parameterization is deterministic, proving more convenient for the tasks of pruning and ticket search, while also yielding faster training times. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Experimentally, our method offers superior performance when pruning VGG to extreme regimes, and is capable of finding winning tickets in Residual Networks trained on CIFAR-10 at a fraction of time taken by Iterative Magnitude Pruning. In particular, Continuous Sparsification successfully finds tickets in under 5 iterations, compared to 20 iterations required by Iterative Magnitude Pruning in the same setting. To further speed up the search for sub-networks, our method abdicates parameter rewinding, a key ingredient of Iterative Magnitude Pruning. By showing superior results without rewinding, our experiments offer insights on how ticket search should be performed. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            419,
+            344,
+            435
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LOTTERY TICKET HYPOTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            431,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Lottery Ticket Hypothesis (Frankle & Carbin, 2019) states that for a network $f ( x ; w )$ , $w \\in \\mathbb { R } ^ { d }$ , and randomly-initialized parameters $w _ { 0 } \\sim \\mathcal { D }$ , there exists a sparse sub-network, defined by a configuration $m \\in \\{ 0 , 1 \\} ^ { d }$ , $\\| m \\| _ { 0 } \\ll d$ , that, when trained from scratch, achieves higher performance than $f ( x ; w )$ while requiring fewer training iterations. The authors support this conjecture experimentally, showing that such sub-networks indeed exist: in particular, they can be discovered by repeatedly training, pruning, and re-initializing the network, through a procedure named Iterative Magnitude Pruning (IMP; Algorithm 1) (Frankle et al., 2019). More specifically, IMP alternates between: (1) training the weights $w$ of a network, (2) removing a fixed fraction of the weights with the smallest magnitude (pruning), and (3) rewinding: setting the remaining weights back to their original initialization $w _ { 0 }$ . ",
+        "bbox": [
+            174,
+            479,
+            825,
+            604
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The sub-networks found by IMP, which indeed train faster and outperform their original, dense networks, are called winning tickets, and can generalize across datasets (Mehta, 2019; Soelen & Sheppard, 2019) and training methods (Morcos et al., 2019). In this sense, IMP can be a promising tool in applications that involve knowledge transfer, such as transfer or meta learning. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Zhou et al. (2019) perform extensive experiments to re-evaluate and better understand the Lottery Ticket Hypothesis. Relevant to this work is the fact that the authors propose a method to learn the binary mask $m$ in an end-to-end manner through SGD, instead of relying on magnitude-based pruning. The authors show that learning only the binary mask and not the weights is sufficient to achieve competitive performance, confirming that the learned masks are highly dependent on the initialized values $w _ { 0 }$ , and are also capable of encoding substantial information about a problem’s solution. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            758
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 SPARSE NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            777,
+            352,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The core aspect of searching for a winning ticket is finding a sparse sub-network that attains high performance relative to its dense counterpart. One way to achieve this is through pruning methods (LeCun et al., 1990), which follow a strategy to remove weights from a trained network while minimizing negative impacts on its performance. In Han et al. (2015), a network is iteratively trained and pruned using parameter magnitudes as criterion: this iterative, two-stage algorithm is shown to outperform “one-shot pruning”: training and pruning the network only once. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other methods attempt to approximate $\\ell _ { 0 }$ regularization on the weights of a network, yielding onestage procedures that can be fully described in the optimization framework. In order to find a sparse ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Iterative Magnitude Pruning (Frankle et al., 2019) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            591,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize $w  w _ { 0 } \\sim \\mathcal { D }$ and $m \\gets \\vec { 1 } ^ { d }$   \n2: Minimize $L ( f ( x ; m \\odot w ) )$ until $w _ { T }$ is produced   \n3: Set $m _ { i } = 0$ for the active weights with smallest magnitudes $\\langle \\vert w _ { T , i } \\vert \\le \\tau$ and $m _ { i } = 1$ )   \n4: If satisfied, output ticket $f ( x ; m \\odot w _ { k } )$   \n5: Otherwise, set $w  w _ { k }$ and go back to step 2 ",
+        "bbox": [
+            179,
+            123,
+            758,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Iterative Stochastic Sparsification (inspired by Zhou et al. (2019)) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            217,
+            691,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize $w  w _ { 0 } \\sim \\mathcal { D }$ , $s  { \\vec { s } } _ { 0 }$   \n2: Minimize $\\mathbb { E } _ { m \\sim \\mathrm { B e r } ( \\sigma ( s ) ) } \\left[ L ( f ( x ; m \\odot w ) ) \\right] + \\lambda \\left\\| \\sigma ( s ) \\right\\| _ { 1 }$ until $w _ { T }$ and $s _ { T }$ are produced   \n3: If satisfied, output ticket $f ( x ; m \\odot w _ { k } )$ , $m \\sim \\operatorname { B e r } ( \\sigma ( s _ { T } ) )$   \n4: Otherwise, set $w  w _ { k }$ , $s _ { i } \\gets - \\infty$ for $s _ { i , T } < s _ { i , 0 }$ , and go back to step 2 ",
+        "bbox": [
+            181,
+            237,
+            761,
+            296
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "setting $m \\in \\{ 0 , 1 \\} ^ { d }$ of a network $f ( x ; m \\odot w )$ , Srinivas et al. (2016) and Louizos et al. (2017) use a stochastic re-parameterization $m \\sim \\mathrm { B e r n o u l l i } ( g ( s ) )$ with $s \\in \\mathbb { R } ^ { d }$ and $g : \\mathbb { R }  [ 0 , 1 ]$ applied element-wise. First-order methods, coupled with gradient estimators, are then used to train both $w$ and $s$ to minimize the expected loss. This approach performs continuous parameter removal during training in an automatic fashion: any component $s _ { i }$ of $s$ that assumes a value during training where $g ( s _ { i } ) \\bar { = } 0$ effectively removes $w _ { i }$ from the network. Moreover, approximating $\\ell _ { 0 }$ regularization has the advantage of not requiring a pruning strategy, which might be arbitrarily complex. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            426
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            445,
+            282,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Designing a method to quickly find winning tickets requires an efficient way to sparsify networks: ideally, sparsification should be done as early as possible in training, and the number of removed parameters should be maximized without harming the model’s performance. In other words, sparsification must be continuously maximized following a trade-off with the performance of the network. This goal is not met by Iterative Magnitude Pruning: sparsification is done at discrete time steps, only after fully training the network, and optimal pruning rates likely depend on the model’s performance and current sparsity: factors which are typically not accounted for – note that these are inherent characteristics of magnitude-based pruning. ",
+        "bbox": [
+            174,
+            477,
+            826,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In light of this, we turn to $\\ell _ { 0 }$ -regularization methods for learning sparse networks, which consist of optimizing a clear trade-off between sparsity and performance. As we will see, performing sparsification continuously is not only straightforward, but done automatically by the optimizer. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 CONTINUOUS SPARSIFICATION BY LEARNING DETERMINISTIC MASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            705,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first frame the search for sparse networks as a loss minimization problem with $\\ell _ { 0 }$ regularization (Louizos et al., 2017; Srinivas et al., 2016): ",
+        "bbox": [
+            173,
+            681,
+            821,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a299b1026efe4caafd227f7cb001f603c02e3fb243ce146f13958849d157505.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w \\in \\mathbb { R } ^ { d } } L ( f ( x ; w ) ) + \\lambda \\cdot \\| w \\| _ { 0 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            729,
+            596,
+            755
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda \\geq 0$ controls the sparsity of the solution, and, with a slight abuse of notation, $L ( f ( x ; w ) )$ denotes the loss incurred by the network $f ( x ; w )$ (e.g., the cross-entropy loss over a training set). As $\\ell _ { 0 }$ regularization is typically intractable, we re-state the above minimization problem as: ",
+        "bbox": [
+            174,
+            766,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/658db95338a3f71f039b17a6530186b951ed843776f314d2a572a6bf64ecdcac.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w \\in \\mathbb { R } ^ { d } } L ( f ( x ; m \\odot w ) ) + \\lambda \\cdot \\| m \\| _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            828,
+            627,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which uses the fact that, for $m \\in \\{ 0 , 1 \\} ^ { d }$ , $\\left\\| m \\right\\| _ { 0 } = \\left\\| m \\right\\| _ { 1 }$ . The $\\ell _ { 1 }$ term can be minimized with subgradient descent, however the $m \\in \\{ 0 , 1 \\} ^ { d }$ constraint makes the above problem combinatorial and poorly suited for local search methods like SGD. ",
+        "bbox": [
+            176,
+            878,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Continuous Sparsification ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            433,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize $w  w _ { 0 } \\sim \\mathcal { D }$ , $s  s _ { 0 }$ , $\\beta  \\beta _ { 0 }$   \n2: Minimize $L ( f ( x ; \\sigma ( \\boldsymbol { \\beta } \\cdot \\boldsymbol { s } ) \\odot w ) ) + \\lambda \\| \\sigma ( \\boldsymbol { \\beta } \\boldsymbol { s } ) \\| _ { 1 }$ while increasing $\\beta$ , producing $w _ { T } , s _ { T }$ , and $\\beta _ { T }$   \n3: If satisfied, output ticket $f ( x ; b ( s _ { T } ) \\odot w _ { k } )$   \n4: Otherwise, set $s \\gets \\operatorname* { m i n } ( \\beta _ { T } \\cdot s _ { T } , s _ { 0 } )$ , $\\beta \\gets \\beta _ { 0 }$ , (optionally, $w  w _ { 0 }$ ), and go back to step 2 ",
+        "bbox": [
+            179,
+            122,
+            821,
+            181
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/373e0fadcc41f3b2199e6a7d6c67db0a7b3584468985a49668a5e449fd898738.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of our proposed re-parameterization $m = \\sigma ( \\beta s )$ , where $\\begin{array} { r } { \\sigma ( z ) = \\frac { 1 } { 1 + e ^ { - z } } } \\end{array}$ is the sigmoid function and $\\beta$ acts as a temperature. As $\\beta$ increases, $\\sigma ( \\beta z )$ approaches $b ( z )$ , which can can be used to frame a $\\ell _ { 0 }$ -regularized problem (Equation 4). Note that the gradients of $\\overset { \\cdot } { \\sigma } ( \\beta s )$ vanish as $\\beta$ increases, suggesting that $\\beta$ should be annealed slowly during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            199,
+            807,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can avoid the binary constraint $m \\in \\{ 0 , 1 \\} ^ { d }$ by re-parameterizing $m$ as a function of a newlyintroduced variable $s \\in \\mathbf { \\overline { { \\mathbb { R } } } } ^ { d }$ . For example, Louizos et al. (2017) propose a stochastic mapping $s \\mapsto m$ and use gradient methods to minimize the expected total loss, while using estimators for the gradients of $s$ (since $m$ is still binary). Having a stochastic mask (or, equivalently, a distribution over subnetworks) poses an immediate challenge for the task of finding tickets, as it is not clear which ticket should be chosen once a distribution over $m$ is learned. Moreover, relying on gradient estimators often causes gradients to have high variance, requirwe consider a deterministic parameterization $\\bar { m } = \\bar { b ( s ) }$ training, where $s \\in \\mathbb { R } _ { \\neq 0 } ^ { d }$ optiand $b : \\bar { \\mathbb { R } } _ { \\neq 0 }  \\{ 0 , 1 \\}$ ly,is applied element-wise: ",
+        "bbox": [
+            173,
+            489,
+            826,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6133c8a48d268a2bd71f7b13ba44b7ea51b40f101d65736b040d35c0f54b3599.jpg",
+        "text": "$$\nb ( z ) = { \\left\\{ \\begin{array} { l l } { 1 , { \\mathrm { i f ~ } } z > 0 } \\\\ { 0 , { \\mathrm { i f ~ } } z < 0 } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            619,
+            562,
+            655
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Applying this re-parameterization to Equation 2 yields: ",
+        "bbox": [
+            173,
+            661,
+            535,
+            678
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c767b5598bcd1f3a926f6ab9e4a3153755a4e3e5519ab2f407da747f926b2e2.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w \\in \\mathbb { R } ^ { d } \\atop s \\in \\mathbb { R } _ { \\neq 0 } ^ { d } } L ( f ( x ; b ( s ) \\odot w ) ) + \\lambda \\cdot \\| b ( s ) \\| _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            699,
+            629,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Clearly, the above problem is again intractable, as it is still equivalent to the original $\\ell _ { 0 }$ problem in Equation 1. More specifically, the step function $b ( z )$ is non-convex, and having zero gradients make gradient-based optimization ineffective. Instead, we consider the following smooth relaxation of $b ( \\cdot )$ : ",
+        "bbox": [
+            174,
+            753,
+            825,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b42fcc57ff60f376bfc9950174f0ea48f606e9e8093b778f4adc5a93e15bdfa.jpg",
+        "text": "$$\nm : = \\sigma ( \\beta \\cdot s )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            450,
+            819,
+            547,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta \\in \\mathbb { R } _ { > 0 }$ , and $\\sigma$ is the sigmoid function $\\begin{array} { r } { \\sigma ( z ) = \\frac { 1 } { 1 + e ^ { - z } } } \\end{array}$ , applied element-wise. By controlling $\\beta$ , which acts as a temperature parameter, we effectively interpolate between $\\sigma ( s )$ , a smooth function well-suited for SGD, and $\\begin{array} { r } { \\operatorname* { l i m } _ { \\beta \\to \\infty } \\sigma ( \\beta \\cdot s ) = b ( z ) } \\end{array}$ , our original goal, which brings computational hardness to the problem. Figure 1 illustrates this behavior. Note that, if $L ( f ( x ; w ) )$ is continuous in $w$ , then: ",
+        "bbox": [
+            173,
+            849,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/058cc44242c6e30f68691610423d3fa3327634198515a0f4a9ad5c9321b029bb.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w \\in \\mathbb { R } _ { \\neq 0 } ^ { d } } \\operatorname* { l i m } _ { \\beta \\to \\infty } L ( f ( x ; \\sigma ( \\beta s ) \\odot w ) ) + \\lambda \\cdot \\| \\sigma ( \\beta s ) \\| _ { 1 } = \\operatorname* { m i n } _ { w \\in \\mathbb { R } _ { \\neq 0 } ^ { d } } L ( f ( x ; b ( s ) \\odot w ) ) + \\lambda \\cdot \\| b ( s ) \\| _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            126,
+            787,
+            166
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although gradient methods will become ineffective as $\\beta \\to \\infty$ due to vanishing gradients of $s$ , we can increase $\\beta$ while optimizing $s$ and $w$ with gradient descent. That is, our loss at each iteration will be a function of $\\beta$ as follows: ",
+        "bbox": [
+            174,
+            184,
+            823,
+            227
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93aa304b253a038647efb4207531290cd527d908a51e20781364c49ec3183d53.jpg",
+        "text": "$$\nL _ { \\beta } ( w , s ) = L ( f ( x ; \\sigma ( \\beta s ) \\odot w ) ) + \\lambda \\cdot \\| \\sigma ( \\beta \\cdot s ) \\| _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            260,
+            668,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "How does the soft mask $m = \\sigma ( \\beta \\cdot s )$ behave as we minimize ${ \\cal L } _ { \\beta } ( w , s )$ while increasing $\\beta ?$ As $\\beta \\to \\infty$ , every negative component of $s$ will be mapped to 0, effectively removing its correspondent weight parameter from the network. While analytically the weights will never truly be zeroed-out, limited numerical precision has the fortunate side-effect of causing actual sparsification to the network during training, as long as $\\beta$ is increased to a large enough value. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In a nutshell, we learn sparse networks by minimizing $\\boldsymbol { L _ { \\beta } } ( \\boldsymbol { w } , s )$ for $T$ parameter updates with gradient descent while jointly annealing $\\beta$ : producing $w _ { T }$ , $s _ { T }$ and $\\beta _ { T }$ , which is ideally large enough such that, numerically 1, $\\sigma ( \\vec { \\beta _ { T } } \\cdot s _ { T } ) = \\bar { b } ( s _ { T } )$ . In case $m$ is truly required to be binary (as in the task of finding tickets), the dependence on numerical imprecision can be avoided by directly outputting $m = b ( s _ { T } )$ at the end of training. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, note that minimizing $L _ { \\beta }$ while increasing $\\beta$ is not generally equivalent to minimizing the original $\\ell _ { 0 }$ -regularized problem. Informally, the former aims to solve $\\begin{array} { r } { \\operatorname* { l i m } _ { \\beta \\to \\infty } \\operatorname* { m i n } _ { w , s } L _ { \\beta } ( w , s ) } \\end{array}$ , while the $\\ell _ { 0 }$ problem is $\\mathrm { \\bar { m i n } } _ { w , s } \\operatorname* { l i m } _ { \\substack { \\beta \\to \\infty } } L _ { \\beta } \\mathrm { \\bar { ( } } w , s )$ . ",
+        "bbox": [
+            173,
+            452,
+            825,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 TICKET SEARCH THROUGH CONTINUOUS SPARSIFICATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            620,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The method presented above offers a direct alternative to magnitude-based pruning when performing ticket search, but a few considerations must follow. Most importantly, when searching for winning tickets, there is a strict constraint that the learned mask $m$ be binary: otherwise, one can also learn the magnitude of the weights, defeating the purpose of finding sub-networks that can be trained from scratch. To guarantee that the output mask satisfies this constraint regardless of numerical precision, we always output $b ( s _ { T } )$ instead of $\\sigma ( \\beta _ { T } \\cdot s _ { T } )$ . ",
+        "bbox": [
+            173,
+            545,
+            825,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we also incorporate two techniques from successful methods for learning sparse networks and searching for winning tickets. First, motivated by Han et al. (2015), where it is shown that iteratively pruning a network yields improved sparsity compared to pruning it only once, we enable “kept” weights – those whose corresponding component of $s$ is positive after many iterations – to be removed from the network at a later stage. More specifically, when $\\beta$ becomes large after $T$ gradient descent updates, the gradients of $s$ vanish and weights will no longer be removed from the network. To avoid this, we set $s \\gets \\operatorname* { m i n } ( \\beta _ { T } \\cdot s _ { T } , s _ { 0 } )$ , effectively resetting the soft mask parameters for the remaining weights while at the same time not interfering with weights that have been removed. This is followed by a reset on the temperature, $\\beta  \\beta _ { 0 }$ , to allow training of $s$ once again. ",
+        "bbox": [
+            174,
+            636,
+            826,
+            761
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Second, we perform parameter rewinding, following Frankle $\\&$ Carbin (2019), which is a key component of Iterative Magnitude Pruning. More specifically, after $T$ gradient descent steps, we reset the weight values back to an earlier stage $w  w _ { k }$ , where $k \\ll T$ . Even though experimental results in Frankle & Carbin (2019) suggest that rewinding is necessary for successful ticket search, we leave rewinding as an optinal component of our algorithm: as we will see empirically, it turns out that ticket search is possible without rewinding weights. Our proposed algorithm to find winning tickets is presented as Algorithm 3, and referred simply as “Continuous Sparsification”. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            866
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our experiments aim at comparing different methods on the task of finding winning tickets in neural networks, hence our evaluation focuses on the generalization performance of each ticket (sub-network) when trained from scratch (or from an iterate in early-training). Additionally, we measure the cost of the search procedure: the number of training epochs to find tickets with varying performance and sparsity. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            203
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Besides comparing our proposed method to Iterative Magnitude Pruning (Algorithm 1), we also design a baseline method, Iterative Stochastic Sparsification (ISS, Algorithm 2), motivated by the procedure in Zhou et al. (2019) to find a binary mask $m$ with gradient descent in an end-to-end fashion. More specifically, ISS uses a stochastic re-parameterization $m \\sim$ Bernoulli $( \\sigma ( s ) )$ with $s \\in \\mathbb { R } ^ { d }$ , and trains $w$ and $s$ jointly with gradient descent and the straight-through estimator (Bengio et al., 2013). When ran for multiple iterations, all components of the mask parameters $s$ which have decreased in value from initialization are set to $- \\infty$ , such that the corresponding weight is permanently removed from the network. While this might look arbitrary, we observed empirically that ISS was unable to remove weights quickly without this step unless $\\lambda$ was chosen to be large – in which case the model’s performance decrease in exchange for sparsity. The hyperparameters used in this section were chosen based on analysis presented in Appendix (...), where we study how the pruning rate affects IMP, and how $\\lambda , s _ { 0 }$ and $\\beta _ { T }$ interact in CS. ",
+        "bbox": [
+            174,
+            209,
+            825,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 CONVOLUTIONAL NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            488,
+            406
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train a neural network with 6 convolutional layers on the CIFAR-10 dataset (Krizhevsky, 2009), following Frankle & Carbin (2019). The network consists of 3 blocks of 2 resolution-preserving convolutional layers followed by $2 \\times 2$ max-pooling, where convolutions in each block have 64, 128 and 256 channels, a $3 \\times 3$ kernel, and are immediately followed by ReLU activations. The blocks are followed by fully-connected layers with 256, 256 and 10 neurons, with ReLUs in between. The network is trained with Adam (Kingma & Ba, 2015) with a learning rate of 0.0003 and a batch size of 60. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Learning a Supermask: As a first baseline, we consider the task of learning a “supermask” (Zhou et al., 2019): a binary mask $m$ that, when applied to a network with randomly initialized weights, yields performance competitive to that of training its weights. This task is equivalent to pruning a randomly-initialized network, or learning an architecture that performs well prior to training with a fixed initialization. We compare ISS and CS , where each method is run for a single iteration composed of 100 epochs. When ran for a single iteration, ISS is equivalent to the algorithm proposed in Zhou et al. (2019) to learn a supermask, referred here as simply Stochastic Sparsification. We control the sparsity of the learned masks by varying $s _ { 0 }$ between $- 5$ and 5 for Stochastic Sparsification (which showed to be more effective than varying $\\lambda$ ), while for Continuous Sparsification we vary $\\lambda$ between $1 0 ^ { - 1 1 }$ and $1 0 ^ { - 7 }$ (which results in stable and consistent training, unlike varying $s _ { 0 }$ ). SS uses SGD with a learning rate of 100 to learn its mask parameters, while CS uses Adam with $\\mathrm { \\ddot { 3 } } \\times 1 0 ^ { - 4 }$ . ",
+        "bbox": [
+            173,
+            522,
+            825,
+            675
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results are presented in Figure 2: CS outperforms SS in terms of both training speed and the quality of the learned mask. In particular, CS finds masks with over $7 5 \\%$ sparsity that yield over $7 5 \\%$ test accuracy, while the performance of masks found by SS decrease when sparsity is over $5 0 \\%$ . Moreover, CS makes faster progress in training, showing that optimizing a deterministic mask is indeed faster than learning a distribution over masks through stochastic re-parameterizations. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finding Winning Tickets: We run IMP and ISS for a total of 30 iterations, each consisting of 40 epochs. Parameters are trained with Adam (Kingma & Ba, 2015) with a learning rate of $3 \\times 1 0 ^ { - 4 }$ , following Frankle & Carbin (2019). For IMP, we use pruning rates of $1 5 \\% / 2 0 \\%$ for convolutional/dense layers. We initialize the Bernoulli parameters of ISS with $s _ { 0 } = \\vec { 1 }$ , and train them with SGD and a learning rate of 20, along with a $\\ell _ { 1 }$ regularization of $\\lambda = 1 0 ^ { - 8 }$ . For CS , we anneal the temperature from $\\beta _ { 0 } = 1$ to $\\beta _ { 0 } = 2 5 0$ following an exponential schedule $( \\beta _ { t } = 2 5 0 ^ { \\frac { t } { T } } )$ ), training both the weights and the mask with Adam and a learning rate of $3 \\times 1 0 ^ { - 4 }$ . ",
+        "bbox": [
+            174,
+            758,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To test whether our method is capable of finding winning tickets in a limited amount of time, we limit each run of CS to 4 iterations only, in contrast with IMP and ISS which are run for 30. We perform 6 runs of CS , each with a different value for the mask initialization $s _ { 0 } \\colon - 0 . 0 5 , - 0 . 0 3 , - 0 . \\bar { 0 2 } , - 0 . 0 1 ,$ $- 0 . 0 0 5 , 0$ , keeping $\\lambda = 1 0 ^ { - 1 0 }$ , such that sparsification is not enforced during training, but heavily biased at initialization. In order to evaluate how consistent our method is, we repeat each run with 3 different random seeds so that error bars can be computed. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/38737692412099085fa17d05de3bd18d9b6b97f461d31e86023b5d386cf0a1f0.jpg",
+        "image_caption": [
+            "Figure 2: Learning a binary mask with weights frozen at initialization with Stochastic Sparsification (SS, Algorithm 2 with one iteration) and Continuous Sparsification (CS), on a 6-layer CNN on CIFAR10. Left: Training curves with hyperparameters for which masks learned by SS and CS were both approximately $5 0 \\%$ sparse. CS learns the mask significantly faster while attaining similar early-stop performance. Right: Sparsity and test accuracy of masks learned with different settings for SS and CS: our method learns sparser masks while maintaining test performance, while SS is unable to successfully learn masks with over $5 0 \\%$ sparsity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            818,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9bec91a4d6d0bcd418f1f6cf5fbd413ee833db063e1e6916fdac26b186cbeaaa.jpg",
+        "image_caption": [
+            "Figure 3: Test accuracy of tickets found by different methods on CIFAR-10. Error bars depict variance across 3 runs. Left: Performance of tickets found on a 6-layer CNN, when trained from scratch. Right: Performance of tickets found on a ResNet 20, when rewinded to the second training epoch. In both experiments, tickets found by CS outperform ones found by IMP. In most cases, CS successfully finds winning tickets in 2 iterations (purple curves). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            417,
+            816,
+            592
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 (left) presents the quality of tickets found by each method, measured by their test accuracy when trained from scratch. To illustrate the quality of the tickets that can be found by Continuous Sparsification, we plot the Pareto curve (green) of the tickets founds with the 6 different values for $s _ { 0 }$ . With $s _ { 0 } = - 0 . 0 3$ , in only 2 iterations CS finds a ticket with over $7 7 \\%$ sparsity (first marker of purple curve) which outperforms every ticket found by IMP in its 30 iterations. The Pareto curve of CS strictly dominates IMP for tickets with more less than $9 7 \\%$ sparsity, where ticket performance is superior or similar to the original dense network. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In terms of computational time, the total cost to run CS with the 6 different values for $s _ { 0 }$ is lower than performing a single run of IMP for 30 iterations, even though CS takes $1 5 \\%$ extra time per epoch due to the mask parameters. This shows the potential of our model even in the setting where a specific sparsity is desired for the tickets. When run in parallel, CS takes less wall-clock time to find all tickets in the Pareto curve than to run IMP for 5 iterations. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 FINDING WINNING TICKETS IN RESIDUAL NETWORKS WITHOUT REWINDING ",
+        "bbox": [
+            173,
+            103,
+            753,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Searching for tickets in realistic models is not as straightforward as finding tickets in a small CNN, and might require new strategies. Frankle et al. (2019) show that IMP fails at finding winning tickets in ResNets (He et al., 2016) unless the learning rate is smaller than the recommended value, leading to worse overall performance and defeating the purpose of ticket search. However, the authors propose a slight modification to IMP that enables search for winning tickets to be successful on complex networks: instead of training from scratch, tickets are initialized with weights from early training. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "With this in mind, we evaluate how Continuous Sparsification performs in the time-consuming task of finding winning tickets in a ResNet- $2 0 ^ { 2 }$ (He et al., 2016) trained on CIFAR-10: a setting where IMP might take over 10 iterations (850 epochs) to succeed. We follow the setup in Frankle & Carbin (2019) and Frankle et al. (2019): in each iteration, the network is trained with SGD, a learning rate of 0.1, and a momentum of 0.9 for a total of 85 epochs, using a batch size of 128. The learning rate is decayed by a factor of 10 at epochs 56 and 71, and a weight decay of 0.0001 is applied to the weights (for CS , we do not apply weight decay to the mask parameters $s$ ). The two skip-connections that perform $1 \\times 1$ convolutions and the output layer are not removable: for IMP, their parameters are not pruned, while for CS their weights do not have a correspondent mask $m$ nor mask parameters $s$ . ",
+        "bbox": [
+            173,
+            219,
+            825,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When training the returned tickets in order to evaluate their performance, we initialize their weights with the iterates from the end of epoch 2 (780 parameter updates), similarly to Frankle et al. (2019). Unlike when searching for winning tickets in the 6-layer CNN, IMP performs global pruning, removing $2 0 \\%$ of the remaining parameters with smallest magnitude, ranked globally (across different layers). IMP runs for a total of 30 iterations, while CS is limited to only 5 iterations for each run. The sparsity of the tickets found by CS is controlled by varying the mask initialization $s _ { 0 } \\in$ $\\{ - 0 . 3 , - 0 . 2 , - 0 . 1 , - 0 . 0 5 , - 0 . 0 3 , 0 , 0 . 0 3 , 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 3 \\}$ (a total of 11 values). To allow for even faster ticket search, we run CS without parameter rewinding: that is, the weights $w$ are transferred from one iteration to another, removing the need to re-train the network as the method progresses through iterations. For both CS and IMP, each run is repeated with 3 different random seeds. ",
+        "bbox": [
+            174,
+            352,
+            825,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results presented in Figure 3 (right) show that CS is able to successfully find winning tickets with varying sparsity in under 5 iterations. Once again, the Pareto curve strictly dominates IMP, and variance across runs is smaller than IMP’s. Most notably, CS is capable of quickly sparsifying the network in a single iteration (first marker of each purple curve), and typically finds better tickets than IMP after only 2 rounds (compare blue curve and second marker of each purple curve), regardless of sparsity. When run in parallel, 2 iterations suffice for CS to find tickets that outperform the ones found by IMP. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observed that not performing rewinding caused the performance of tickets with high sparsity to quickly degrade after 2 or more iterations of CS. We speculate that, when rewinding is not performed between iterations, the distance between $w _ { k }$ and the parameter iterates produced by gradient descent $w _ { t }$ increase significantly with the number of iterations. This in turn can result in the learned mask $m _ { T }$ to be highly sub-optimal for weight values $w _ { k }$ $k \\ll T$ ) which are used to re-train the ticket. This suggests that in order to avoid re-training the network and hence make the search for winning tickets more efficient, rewinding should not be performed between iterations. In this case, the search must complete quickly, before performance degradation occurs due to “overtraining”, requiring optimal ways to perform sparsification without negatively impacting the model’s performance. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 PRUNING VGG ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            321,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our experiments show that Continuous Sparsification is capable of finding tickets quickly and consistently, and we attribute its success to its deterministic re-parameterization of the binary mask. Here, we evaluate our method a pruning technique, to better assess whether our proposed re-parameterization is advantageous only in terms of training time, or also in respect to the quality of the learned masks. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            840
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For this task, we train a VGG (Simonyan & Zisserman, 2015) on the CIFAR-10 dataset, following the protocol in Frankle & Carbin (2019): the network is trained with SGD and an initial learning rate of 0.1, which is decayed by a factor of 10 at epochs 80 and 120. After 160 training epochs, the network is sparsified and then fine-tuned for 40 epochs with a learning rate of 0.001. We evaluate previously described methods when executed for a single iteration (one-shot pruning): Continuous Sparsification, Magnitude Pruning (IMP with 1 iteration) (Han et al., 2015), and Stochastic Sparsification (ISS with 1 iteration), which is similar to methods in Zhou et al. (2019), Srinivas et al. (2016), and Louizos et al. (2017). ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            826,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "At the sparsification step, IMP performs global pruning, ISS fixes the binary mask $m$ to be the maximum likelihood one under $\\operatorname { B e r } ( \\sigma ( s ) )$ (which performed better than sampling from the distribution), and CS changes the parameterization of the mask from $\\sigma ( \\beta s )$ to $b ( s )$ (or, equivalently, weights $w _ { i }$ where $s _ { i } < 0$ are removed). We use a momentum of 0.9, a weight decay of 0.0001 (not applied to s), and a batch-size of 64. Following Frankle & Carbin (2019), sparsification is not applied to batch normalization nor the final linear layer. ",
+        "bbox": [
+            174,
+            181,
+            485,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To evaluate each method when finding masks with different sparsity levels, we run IMP with global pruning rates $5 0 \\%$ , $7 5 \\%$ , $8 0 \\%$ , $8 5 \\%$ , ${ \\bar { 9 } } 0 \\%$ , $9 \\hat { 5 } \\%$ , $9 7 . 5 \\%$ , $9 8 \\%$ , $9 8 . 5 \\%$ , $9 9 \\%$ , $9 9 . 5 \\%$ , $9 9 . 7 5 \\%$ , and ISS and CS with initial mask values $- 0 . 3$ , $- 0 . 2 5$ , $- 0 . 2$ , $- 0 . 1 5$ , $- 0 . 1$ , $- 0 . 0 5$ $- 0 . 0 1$ , $- 0 . 0 0 5$ , $- 0 . 0 0 1$ , 0. Results are shown in Figure 4: both magnitude pruning and stochastic $\\ell _ { 0 }$ regularization (Stochastic Sparsifi",
+        "bbox": [
+            174,
+            354,
+            485,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b21e02a334c93b267ef966b4139eeb497f15c3cfc8a4b4250deebf600cd38422.jpg",
+        "image_caption": [
+            "Figure 4: Performance of different methods when performing one-shot pruning on VGG. CS maintains over $9 0 \\%$ test accuracy after removing $9 9 . 7 \\%$ of the weights, while other methods fail to successfully remove more than $9 8 \\%$ of the parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            205,
+            810,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "cation) fail at removing over $9 8 \\%$ of the weights without severely degrading the performance of the model. On the other hand, Continuous Sparsification successfully removes ${ \\bar { 9 } } 9 . 7 \\%$ of the parameters in the convolutional layers while still yielding over $9 0 \\%$ test accuracy. When taken to the extreme, our method is capable of removing $9 9 . 8 5 \\%$ of the weights and still yield over $8 3 \\%$ accuracy. ",
+        "bbox": [
+            174,
+            479,
+            826,
+            535
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The dramatic performance difference between stochastic and continuous sparsification shows that our proposed deterministic re-parameterization is key to achieve superior results in both network pruning and ticket search. The fact that it outperforms magnitude pruning, a standard technique in the pruning literature, suggests that further exploration of $\\ell _ { 0 }$ -based methods could yield significant advances in pruning techniques. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            611
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            642,
+            310,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "With Frankle & Carbin (2019), we now realize that sparse sub-networks can indeed be successfully trained from scratch, putting in question the belief that overparameterization is required for proper optimization of neural networks. Such sub-networks, called winning tickets, can be potentially used to significantly decrease the required resources for training deep networks, as they are shown to transfer between different, but similar, tasks (Mehta, 2019; Soelen & Sheppard, 2019). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Currently, the search for winning tickets is a poorly explored problem, where Iterative Magnitude Pruning (Frankle & Carbin, 2019) stands as the only algorithm suited for this task, and it is unclear whether its key ingredients – post-training magnitude pruning and parameter rewinding – are the correct choices for the task. Here, we approach the problem of finding sparse sub-networks as an $\\ell _ { 0 }$ -regularized optimization problem, which we approximate through a smooth, parameterized relaxation of the step function. Our proposed algorithm for finding winning tickets, Continuous Sparsification, removes parameters automatically and continuously during training, and can be fully described by the optimization framework. We show empirically that, indeed, post-training pruning might not be a sensible choice for finding winning tickets, raising questions on how the search for tickets differs from standard network compression. With this work, we hope to further motivate the problem of quickly finding tickets in overparameterized networks, as recent work suggests that the task might be highly relevant to transfer learning and mobile applications. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. A convergence theory for deep learning via overparameterization. In ICML, 2019. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or Propagating Gradients Through Stochastic Neurons for Conditional Computation. arXiv e-prints, art. arXiv:1308.3432, 2013. ",
+        "bbox": [
+            176,
+            161,
+            823,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv e-prints, art. arXiv:1810.04805, 2018. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR, 2019. ",
+        "bbox": [
+            171,
+            263,
+            825,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M. Roy, and Michael Carbin. Stabilizing the Lottery Ticket Hypothesis. arXiv e-prints, art. arXiv:1903.01611, 2019. ",
+        "bbox": [
+            173,
+            301,
+            823,
+            330
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural networks. NIPS’15, 2015. ",
+        "bbox": [
+            174,
+            338,
+            823,
+            367
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. ICLR, 2016. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            405
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016. ",
+        "bbox": [
+            173,
+            412,
+            823,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Forrest N. Iandola, Matthew W. Moskewicz, Khalid Ashraf, Song Han, William J. Dally, and Kurt Keutzer. SqueezeNet: AlexNet-level accuracy with $5 0 \\mathrm { x }$ fewer parameters and ${ < } 1 \\mathbf { M } \\mathbf { B }$ model size. arXiv:1602.07360, 2016. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015. ",
+        "bbox": [
+            171,
+            501,
+            795,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            169,
+            523,
+            803,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In NIPS. 1990. ",
+        "bbox": [
+            171,
+            547,
+            753,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. ICLR, 2019. ",
+        "bbox": [
+            173,
+            570,
+            823,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Max Welling, and Diederik P. Kingma. Learning Sparse Neural Networks through $L _ { 0 }$ Regularization. arXiv e-prints, art. arXiv:1712.01312, 2017. ",
+        "bbox": [
+            173,
+            607,
+            823,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rahul Mehta. Sparse Transfer Learning via Winning Lottery Tickets. arXiv e-prints, art. arXiv:1905.07785, 2019. ",
+        "bbox": [
+            173,
+            643,
+            823,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ari S. Morcos, Haonan Yu, Michela Paganini, and Yuand ong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. arXiv e-prints, art. arXiv:1906.02773, 2019. ",
+        "bbox": [
+            173,
+            681,
+            825,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Behnam Neyshabur, Zhiyuan Li, Srinadh Bhojanapalli, Yann LeCun, and Nathan Srebro. Towards Understanding the Role of Over-Parametrization in Generalization of Neural Networks. arXiv e-prints, art. arXiv:1805.12076, 2018. ",
+        "bbox": [
+            173,
+            733,
+            826,
+            776
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pedro Savarese and Michael Maire. Learning implicitly recurrent CNNs through parameter sharing. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            784,
+            823,
+            814
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. ICLR, 2015. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan Van Soelen and John W. Sheppard. Using winning lottery tickets in transfer learning for convolutional neural networks. In IJCNN, 2019. ",
+        "bbox": [
+            171,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Suraj Srinivas, Akshayvarun Subramanya, and R. Venkatesh Babu. Training Sparse Neural Networks. arXiv e-prints, art. arXiv:1611.06694, 2016. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Ross B. Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. CVPR, 2017. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hattie Zhou, Janice Lan, Rosanne Liu, and Jason Yosinski. Deconstructing lottery tickets: Zeros, signs, and the supermask. ArXiv, abs/1905.01067, 2019. ",
+        "bbox": [
+            174,
+            141,
+            825,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            263,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A HYPERPARAMETER ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            135,
+            460,
+            151
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 CONTINUOUS SPARSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            165,
+            433,
+            180
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study how the hyperparameters of Continuous Sparsification affect its performance in terms of sparsity and performance of the found tickets. More specifically, we consider the following hyperparameters: ",
+        "bbox": [
+            176,
+            190,
+            825,
+            233
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Final temperature $\\beta _ { T }$ : the final value for $\\beta$ , which controls how smooth the parameterization $m = \\sigma ( \\bar { \\beta } s )$ is.   \n• $\\ell _ { 1 }$ penalty $\\lambda$ : the strength of the $\\ell _ { 1 }$ regularization applied to the soft mask $\\sigma ( \\beta s )$ , which promotes sparsity.   \n• Mask initial value $s _ { 0 }$ : the value used to initialize all components of the soft mask $m = \\sigma ( \\beta s )$ , where smaller values promote sparsity. ",
+        "bbox": [
+            214,
+            244,
+            825,
+            337
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our setup is as follows: to analyze how each of the 3 hyperparameters impact the performance of Continuous Sparsification, we train a ResNet 20 on CIFAR-10 (following the same protocol from Section 4.2), varying one hyperparameter while keeping the other two fixed. To capture how hyperparameters interact with each other, we repeat the described experiment with different settings for the fixed hyperparameters. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            416
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Since different hyperparameter settings naturally yield vastly distinct sparsity and performance for the found tickets, we report relative changes in accuracy and in sparsity. ",
+        "bbox": [
+            174,
+            424,
+            823,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, we vary $\\lambda$ between 0 and $1 0 ^ { - 8 }$ for three different $( s _ { 0 } , \\beta _ { T } )$ settings: $\\stackrel { \\prime } { s } _ { 0 } = - 0 . 2 , \\beta _ { T } =$ 100), $( s _ { 0 } = 0 . 0 5 , \\mathring { \\beta _ { t } } = 2 0 0 )$ , and $( s _ { 0 } = - 0 . 3 , \\beta _ { T } = 1 0 0 )$ . As we can see, there is little impact on either the performance or the sparsity of the found ticket, except for the case where $s _ { 0 } = 0 . 0 5$ and $\\beta _ { T } = 2 0 0$ , for which $\\lambda = 1 0 ^ { - 8 }$ yields slightly increased sparsity. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/e56a29401e70aaf2ec3f8cc9a42a882496ee4aa389ac344c91494ade8c1c4d17.jpg",
+        "image_caption": [
+            "Figure 5: Impact on relative test accuracy and sparsity of tickets found in a ResNet 20 trained on CIFAR-10, for different values of $\\lambda$ and fixed settings for $\\beta _ { T }$ and $s _ { 0 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            530,
+            818,
+            728
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider the fixed settings $( s _ { 0 } = - 0 . 2 , \\lambda = 1 0 ^ { - 1 0 } ,$ ), $( s _ { 0 } = 0 . 0 5 , \\lambda = 1 0 ^ { - 1 2 } )$ ), $( s _ { 0 } =$ $- 0 . 3 , \\lambda = 1 0 ^ { - 8 } ,$ , and proceed to vary the final temperature $\\beta _ { T }$ between 50 and 200. Figure 6 shows the results: in all cases, a larger temperature of 200 yielded better accuracy. However, it decreased sparsity compared to smaller temperature values for the settings $( s _ { 0 } = - 0 . 2 , \\lambda = 1 0 ^ { - 1 0 }$ ) and $\\stackrel { \\prime } { s } _ { 0 } = \\bar { - } 0 . 3 , \\stackrel { . } { \\lambda } = 1 \\bar { 0 } ^ { - 8 } ,$ ), while at the same time increasing sparsity for $\\begin{array} { r } { { ' s _ { 0 } } = 0 . 0 5 , \\lambda = 1 0 ^ { - 1 2 } . } \\end{array}$ ). While larger temperatures appear beneficial and might suggest that even higher values should be used, note that, the larger $\\beta _ { T }$ is, the earlier in training the gradients of $s$ will vanish, at which point training of the mask will stop. Since the performance for temperatures between 100 and 200 does not change significantly, we recommend values around 150 or 200 when either pruning or performing ticket search. ",
+        "bbox": [
+            173,
+            784,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/7f92ae1a277e9c86b70bb810e1a1eed680f5ceb6bfb8b3ebe0e80fc52e996fe9.jpg",
+        "image_caption": [
+            "Figure 6: Impact on relative test accuracy and sparsity of tickets found in a ResNet 20 trained on CIFAR-10, for different values of $\\beta _ { T }$ and fixed settings for $\\lambda$ and $s _ { 0 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            816,
+            300
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/f4ad948bda3f8fc2a7596868bdcc729344371972624a4ac99e0c23ab352ca461.jpg",
+        "image_caption": [
+            "Figure 7: Impact on relative test accuracy and sparsity of tickets found in a ResNet 20 trained on CIFAR-10, for different values of $s _ { 0 }$ and fixed settings for $\\beta _ { T }$ and $\\lambda$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            359,
+            818,
+            559
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we vary the initial mask value $s _ { 0 }$ between $- 0 . 3$ and $+ 0 . 3$ , with hyperpameter settings $( \\beta _ { T } \\doteq 1 0 0 , \\lambda \\doteq 1 0 ^ { - 1 0 } )$ , $( \\beta _ { T } = 2 0 0 , \\lambda = 1 0 ^ { - 1 2 } )$ ), and $\\langle \\beta _ { T } = 1 0 0 , \\lambda = 1 0 ^ { - 8 } \\rangle$ ). Results are given in Figure 7: unlike the exploration on $\\lambda$ and $\\beta _ { T }$ , we can see that $s _ { 0 }$ has a strong and consistent effect on the sparsity of the found tickets. For this reason, we suggest proper tuning of $s _ { 0 }$ when the goal is to achieve a specific sparsity value. Since the percentage of remaining weights is monotonically increasing with $s _ { 0 }$ , we can perform binary search over values for $s _ { 0 }$ to achieve any desired sparsity level. In terms of performance, lower values for $s _ { 0 }$ naturally lead to performance degradation, since sparsity quickly increases as $s _ { 0 }$ becomes more negative. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            739
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/28ffb9049096008e4c9629d6536fd2b0184a9f1c90eb72d731f4af1bb6bdb1df.jpg",
+        "image_caption": [
+            "Figure 8: Performance of tickets found by Iterative Magnitude Pruning in a ResNet 20 trained on CIFAR, for different pruning rates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            308,
+            104,
+            684,
+            310
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 ITERATIVE MAGNITUDE PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            381,
+            454,
+            395
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here, we assess whether the running time of Iterative Magnitude Pruning can be improved by increasing the amount of parameters pruned at each iteration. The goal of this experiment is to evaluate if Continuous Sparsification offers faster ticket search only because it prunes the network more aggressively than IMP, or because it is truly more effective in how parameters are chosen to be removed. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            476
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Following the same setup as the previous section, we train a ResNet 20 on CIFAR-10. We run IMP for 30 iterations, performing global pruning with different pruning rates at the end of each iteration. Figure 8 shows that the performance of tickets found by IMP decays when the pruning rate is increased to $4 0 \\%$ . In particular, the final performance of found tickets is mostly monotonically decreasing with the number of remaining parameters, suggesting that, in order to find tickets which outperform the original network, IMP is not compatible with more aggressive pruning rates. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            568
+        ],
+        "page_idx": 13
+    }
+]

parse/train/BJleph4KvS/BJleph4KvS.md

@@ -0,0 +1,455 @@
+# HAARPOOLING: GRAPH POOLING WITH COMPRESSIVE HAAR BASIS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep Graph Neural Networks (GNNs) are instrumental in graph classification and graph-based regression tasks. In these tasks, graph pooling is a critical ingredient by which GNNs adapt to input graphs of varying size and structure. We propose a new graph pooling operation based on compressive Haar transforms, called HaarPooling. HaarPooling is computed by following a chain of sequential clusterings of the input graph. The input of each pooling layer is transformed by the compressive Haar basis of the corresponding clustering. HaarPooling operates in the frequency domain by the synthesis of nodes in the same cluster and filters out fine detail information by compressive Haar transforms. Such transforms provide an effective characterization of the data and preserve the structure information of the input graph. By the sparsity of the Haar basis, the computation of HaarPooling is of linear complexity. The GNN with HaarPooling and existing graph convolution layers achieves state-of-the-art performance on diverse graph classification problems.
+
+# 1 INTRODUCTION
+
+Graph Neural Networks (GNNs) have demonstrated excellent performance in node classification tasks and are very promising in graph classification and regression (Bronstein et al., 2017; Battaglia et al., 2018; Zhang et al., 2018b; Zhou et al., 2018; Wu et al., 2019). In node classification, the input is a single graph with missing node labels that are to be predicted from the known node labels. In this problem, GNNs with appropriate graph convolutions can be trained based on the single graph that is provided, and achieve state-of-the-art performance (Defferrard et al., 2016; Kipf & Welling, 2017; Ma et al., 2019b). Different from node classification, graph classification is a task where the label of any given graph-structured sample is to be predicted based on a training set of labeled graph-structured samples. This is similar to the image classification task tackled by traditional deep convolutional neural networks. The major difference is that here each input sample may have an arbitrary adjacency structure, instead of the fixed regular grids that are used in images. An example of graph-structured data are the molecules of different sizes shown in Figure 1. This raises two important challenges: 1) How can GNNs exploit the graph structure information of the input data? 2) How can GNNs handle input graphs with varying number of nodes and connectivity structures?
+
+Figure 1: Graph-structured data: two molecules with atoms as nodes and bonds as edges. Each molecule has a different number of nodes and molecular structure. In graph classification (and regression), each input datum is an individual graph with features defined on the graph nodes (e.g., indicating the chemical element).
+
+These problems have motivated the design of proper graph convolution and graph pooling to allow GNNs to capture the geometric information of each data sample (Zhang et al., 2018a; Ying et al., 2018; Cangea et al., 2018; Gao & Ji, 2019; Knyazev et al., 2019; Ma et al., 2019a; Lee et al., 2019). Graph convolution plays an important role especially in question 1).
+
+![](images/b759d6ca4fb8aa82ce8e4c286194881fb22e760fe87df7bbfedd48213ab3706c.jpg)  
+Figure 2: Computational flow of a Graph Neural Network consisting of three blocks of GCN graph convolutional and HaarPooling layers, followed by an MLP. In this example, the output feature of the last pooling layer has dimension 4, which is the number of input units of the MLP.
+
+The following graph convolution, as proposed by Kipf & Welling (2017), is a widely accepted example:
+
+$$
+X ^ { \mathrm { o u t } } = \widehat { A } X ^ { \mathrm { i n } } W .
+$$
+
+Here $\widehat { A } = \widetilde { D } ^ { - 1 / 2 } ( A + I ) \widetilde { D } ^ { - 1 / 2 } \in \mathbb { R } ^ { N \times N }$ is a normalized version of the adjacency matrix $A$ of the input graph, where $I$ is the identity matrix and $\widetilde { D }$ is the degree diagonal matrix for $A + I$ . Further, $X ^ { \mathbf { \bar { i } n } } \in \mathbb { R } ^ { \mathbf { \bar { N } } \times d }$ is the array of $d$ e-dimensional features on the $N$ nodes of the graph, and $W \in \mathbb { R } ^ { d \times m }$ is the filter parameter matrix. The graph convolution in equation 1 captures the structural information of the input in terms of $A$ (or $\widehat { A }$ ), and $W$ transforms the feature dimension from $d$ to $m$ . The filter size $d \times m$ does not depend on the graph size, which allows a fixed network architecture to process input graphs of varying size. However, the GCN convolution preserves the number of nodes and hence the output dimension of the network is not unique. Graph pooling provides an effective way to overcome this obstacle. Among several approaches that have been proposed, only EigenPooling (Ma et al., 2019a) incorporates both features and graph structure. However, this is based on eigenpairs of graph Laplacian and suffers from a high computational cost. We provide an overview of this and other graph pooling methods in Section 2.
+
+In this paper, we propose a new graph pooling strategy based on a sparse Haar representation of the data, which we call HaarPooling. This is based on the Haar basis (Li et al., 2019), which incorporates graph structure and features, and is computationally efficient. Suppose we have an input $X ^ { \mathrm { i n } } \in \breve { \mathbb R } ^ { N \times d }$ . HaarPooling is then defined as
+
+$$
+X ^ { \mathrm { o u t } } = \Phi ^ { T } X ^ { \mathrm { i n } } ,
+$$
+
+where $\Phi \in \mathbb { R } ^ { N \times N _ { 1 } }$ , $N _ { 1 } < N$ . Each column of $\Phi$ is a compressive Haar basis vector. By applying HaarPooling in equation 2, the number of nodes is compressed from $N$ to $N _ { 1 }$ . The Haar basis provides a sparse representation which distills graph structural information. Cascading pooling layers we can obtain an output of a fixed dimension, regardless of the size of the inputs. The sparsity of the Haar basis matrix ensures that the computation of HaarPooling is efficient. Generating the Haar basis and computing the Haar transform has a computational cost $\mathcal { O } ( N )$ (up to a log term of $N$ ) for input graphs with $N$ nodes. Experiments in Section 5 demonstrate that GNNs with HaarPooling achieve state-of-the-art performance on various graph classification tasks.
+
+This paper is organized as follows. Section 2 gives an overview of existing work on graph pooling. Section 3 details the components and computational flow for HaarPooling. Section 4 provides the mathematical details on HaarPooling, including the compressive Haar basis, compressive Haar transforms, and efficient implementations. Section 5 reports our experimental results on benchmark graph classification tasks compared with existing graph pooling methods. Section 6 concludes the paper. Proofs and implementation details are deferred to the appendix.
+
+Graph pooling is a necessary step when building a GNN model for graph classification, as one needs a unified graph-level rather than node-level representation for graph inputs for which size and topology are changing. The most direct pooling method takes the global mean and sum of node representations obtained by the graph convolutional layer (Duvenaud et al., 2015) as a simple graph-level representation. However, this pooling operation treats all the nodes equally and ignores the global geometry of the graph. ChebNet (Defferrard et al., 2016) uses a graph coarsening procedure to build the pooling module, which requires graph clustering algorithms to obtain subgraphs. One drawback of this topology-based strategy is that it does not incorporate the node features in the pooling. Global pooling methods consider the information of node embeddings to obtain the entire graph representation. As a general framework for graph classification problems, MPNN (Gilmer et al., 2017) uses the Set2Set method (Vinyals et al., 2015) to obtain graph-level representations. Zhang et al. (2018a) proposed a SortPool method that sorts feature representation of nodes before feeding them into traditional 1-D convolutional and dense layers. But these global pooling techniques cannot guarantee hierarchical graph representations that may contain useful information in the graph structure. A prominent recent idea is to build a differentiable and data-dependent pooling layer with learnable operations/parameters, which has brought substantial improvements on graph classification tasks. Ying et al. (2018) proposed a differentiable pooling layer (DiffPool) that learns a cluster assignment matrix over the nodes using the output of a GNN model. One common problem with DiffPool is its huge storage complexity, which results from the computation of the soft clustering assignments. Cangea et al. (2018); Gao & Ji (2019); Knyazev et al. (2019) used a Top-K pooling method that samples a subset of important nodes by employing a trainable projection vector. Lee et al. (2019) introduced Self-Attention Graph Pooling (SAGPool) by replacing the way node scores are computed in Top-K pooling by a GCN module. These hierarchical pooling methods technically still employ mean/max pooling procedures to aggregate the feature representation of super-nodes, which would lead to information loss. Diehl et al. (2019) proposed EdgePool which is a scheme which considers edge contraction and thus takes into account of graph structure in pooling.
+
+There are also spectral-based pooling methods that take account of both the graph structure and its node features. Noutahi et al. (2019) proposed the Laplacian Pooling (LaPool) method that dynamically selects centroid nodes and their corresponding follower nodes by an attention mechanism that uses the graph Laplacian. Ma et al. (2019a) introduced EigenPool which uses local graph Fourier transform to extract subgraph information utilizing both node features and structure of the subgraph. Its potential drawback lies in the inherent bottleneck of computing Laplacian-based graph Fourier transform, given the huge cost in the eigendecomposition of the graph Laplacian. This shortcoming partially motivates our present work.
+
+# 3 HAARPOOLING
+
+In this section we give an overview of the proposed HaarPooling framework. First we define the pooling architecture in terms of a chain, i.e., a sequence of graphs $\left( \mathcal { G } _ { 0 } , \mathcal { G } _ { 1 } , \ldots , \mathcal { G } _ { K } \right)$ , where the nodes of each $\mathcal { G } _ { j + 1 }$ correspond to clusters of nodes of $\mathcal { G } _ { j + 1 }$ , $j = 0 , \ldots , K - 1$ . Each layer in the chain determines which sets of nodes are pooled together. Then we construct the compressive Haar transform, which compresses the dimension of the features.
+
+Chain of coarse-grained graphs for pooling Graph pooling amounts to defining a sequence of coarse-grained graphs. In our chain, each graph is an induced graph that arises from grouping (clustering) certain subsets of nodes from the previous graph. We use clustering algorithms to generate the groupings of nodes. There are many good candidates, such as spectral clustering (Shi & Malik, 2000), $k$ -means clustering (Pakhira, 2014), DBSCAN (Ester et al., 1996), OPTICS (Ankerst et al., 1999) and METIS (Karypis & Kumar, 1998). Any of these will work with HaarPooling.
+
+Figure 3 shows an example of a chain with 3 levels, for an input graph $\mathcal { G } _ { 0 }$ .
+
+Compressive Haar transforms on chain For each layer of the chain, we will have a feature representation. We define these in terms of the Haar basis. Haar basis represents graph-structured data by low and high frequency Haar coefficients in frequency domain. The low frequency coefficients contain the coarse information of the original data while the high frequency coefficients contain the fine details. In the HaarPooing, the data is pooled (or compressed) by discarding fine detail information.
+
+![](images/ebcc57a74cea276f9027d11b9ce8cf8eed8e5f480c7f1cadd80fec3edd65a1b4.jpg)  
+Figure 3: A coarse-grained chain of graphs, where the input has 8 nodes, the second level has 3 nodes, and the top level has single node.
+
+The Haar basis can be compressed in each layer. Consider a chain where at level $j$ the two subsequent graphs have $N _ { j + 1 }$ and $N _ { j }$ nodes, $N _ { j + 1 } < N _ { j }$ . For each of these graphs, we can create a Haar basis with $N _ { j + 1 }$ and $N _ { j }$ elements, respectively. The elements of the smaller layer are obtained by compressing a subset of the elements from the other layer. These new vectors form the matrix $\Phi _ { j }$ of size $N _ { j + 1 } \times N _ { j }$ . We call $\Phi _ { j }$ compressive Haar basis matrix for this particular $j$ th layer. This then defines the compressive Haar transform $\Phi _ { j } ^ { T } X ^ { \mathrm { i n } }$ for feature $X ^ { \mathrm { i n } }$ with size $N _ { j } \times d$ .
+
+Computational strategy of HaarPooling The HaarPooling is then defined as follows.
+
+Definition 1 (HaarPooling). The HaarPooling for a graph neural network with $K$ pooling layers is defined as
+
+$$
+X _ { j } ^ { \mathrm { o u t } } = \Phi _ { j } ^ { T } X _ { j } ^ { \mathrm { i n } } , \quad j = 0 , 1 , \ldots , K - 1 ,
+$$
+
+where $N _ { j } > N _ { j + 1 }$ and $N _ { K } = 1$ , $\Phi _ { j }$ or $\Phi _ { N _ { j } \times N _ { j + 1 } } ^ { ( j ) }$ is the $N _ { j } \times N _ { j + 1 }$ compressive Haar basis matrix for the jth layer, $X _ { j } ^ { \mathrm { i n } } \in \mathbb { R } ^ { N _ { j } \times d _ { j } }$ is the input feature array, and $X _ { j } ^ { \mathrm { o u t } } \in \mathbb { R } ^ { N _ { j + 1 } \times d _ { j } }$ feature array. The corresponding layer is called HaarPooling layer.
+
+HaarPooling has following key properties.
+
+• The HaarPooling reduces layer by layer the first dimension of input feature. In the last pooling layer, the output feature is compressed as a vector with length $d _ { K - 1 }$ and each original input sample would generate such a vector with the same length. This then makes it possible to deal with input graph-structured data with different size and structure.   
+• The HaarPooling uses the sparse Haar representation on chain structure. In each HaarPooling layer, the representation then combines the features of input $X _ { j } ^ { \mathrm { i n } }$ with the geometric information of the graphs of the $j$ th and $( j + 1 )$ th layers of the chain.   
+• By the property of Haar basis, the HaarPooling only drops the high frequency (or detailed) information of the input data. The $X _ { j } ^ { \mathrm { o u t } }$ has good approximation to $X _ { j } ^ { \mathrm { i n } }$ . Thus, the major data information (i.e. the low frequency coefficients) is preserved in the pooling, and the loss of the information is small.   
+Since the Haar basis matrix is very sparse, HaarPooling can be computed very fast, with near linear computational complexity.
+
+Example Figure 4 shows the computational details of the HaarPooling associated with the chain is transformed by the compressvectors of the full Haar basis from Figure 3. There are two HaarPooling layers. In the first layer, the input aar basis matrix in (a), and out $\Phi _ { 8 \times 3 } ^ { ( 0 ) }$ w a nsists ofmatrix $X _ { 1 } ^ { \mathrm { i n } }$ with size rst three column. In the second $8 \times d _ { 1 }$ $\Phi _ { 8 \times 8 } ^ { ( 0 ) }$ $3 \times d _ { 1 }$ $X _ { 1 } ^ { \mathrm { o u t } }$ layer, the input $X _ { 2 } ^ { \mathrm { i n } }$ with size $3 \times d _ { 2 }$ (usually $X _ { 1 } ^ { \mathrm { o u t } }$ followed by convolution) is transformed by the compressive Haar matrix $\Phi _ { 3 \times 1 } ^ { ( 1 ) }$ which is the first column vector of the full Haar basis matrix $\Phi _ { 3 \times 3 } ^ { ( 1 ) }$ in (b). By the construction of the Haar basis in relation to the chain (details in Appendix B), each of the first three column vectors $\phi _ { 1 } ^ { ( 0 ) } , \phi _ { 2 } ^ { ( 0 ) }$ and $\phi _ { 3 } ^ { ( 0 ) }$ of $\Phi _ { 8 \times 3 } ^ { ( 0 ) }$ has only up to three different values. This bound is exactly the number of nodes of $\mathcal { G } _ { 1 }$ . For each column $\phi _ { \ell } ^ { ( 0 ) }$ , all nodes with the same parent take the same value. Similarly, the $3 \times 1$ vector $\phi _ { 1 } ^ { ( 1 ) }$ is constant. This means that the HaarPooling
+
+(a) First HaarPooling Layer for $\mathcal { G } _ { 0 }  \mathcal { G } _ { 1 }$
+
+![](images/48e28b8ff7510c6076983245f06e8d85fcd8c28a2b3a73ab5e477f9295cd2b28.jpg)  
+Figure 4: Computational strategy of HaarPooling. We use the chain in Figure 3 and then there are two HaarPooling layers in the network from $\mathcal { G } _ { 0 }  \mathcal { G } _ { 1 }$ and $\mathcal { G } _ { 1 }  \mathcal { G } _ { 2 }$ respectively. The input of each layer is pooled by the compressive Haar transform for each layer: in the first layer input $X _ { 1 } ^ { \mathrm { i n } } = ( x _ { i , j } ) \in \mathbb { R } ^ { 8 \times d _ { 1 } }$ is transformed by the compressive Haar basis matrix $\Phi _ { 8 \times 3 } ^ { ( 0 ) }$ with size $8 \times 3$ formed by the first three column vectors, and the output is a feature array with size $3 \times d _ { 1 }$ ; in the second layer $X _ { 2 } ^ { \mathrm { i n } } = ( y _ { i , j } ) \in \mathbb { R } ^ { 3 \times d _ { 2 } }$ is transformed by the first column vector $\Phi _ { 3 \times 1 } ^ { ( 1 ) }$ and the output is a feature vector with size $1 \times d _ { 2 }$ . In the plots of Haar basis matrix, the colors indicate the value of the entries of the Haar basis matrix.
+
+synthesizes the node feature by adding the same weight to the nodes that are in the same cluster of the coarser layer, and in this way, pools the feature using the graph clustering information.
+
+# 4 MATHEMATICS AND COMPUTATION FOR HAARPOOLING
+
+Chain of graphs by clustering For a graph $\mathcal { G } = ( V , E , w )$ , where $V , E , w$ are the vertices, edges, and weights on edges, a graph $\mathcal { G } ^ { \mathrm { c g } } : = ( V ^ { \mathrm { c g } } , E ^ { \mathrm { c g } } , w ^ { \mathrm { c g } } )$ is a coarse-grained graph of $\mathcal { G }$ if $| V ^ { \mathrm { c g } } | \leq | V |$ and each node of $\mathcal { G }$ has only one parent node in ${ \mathcal { G } } ^ { \mathrm { c g } }$ associated with it. Each node of $\mathcal G ^ { \mathrm { c g } }$ is called a cluster of $\mathcal { G }$ . For integers $J > 0$ , a coarse-grained chain for $\mathcal { G }$ is a sequence of graphs $\mathcal { G } _ { 0  J } : =$ $( \mathcal { G } _ { 0 } , \mathcal { G } _ { 1 } , \ldots , \mathcal { G } _ { J } )$ with $\mathcal { G } _ { 0 } = \mathcal { G }$ and such that $\mathcal { G } _ { j + 1 }$ is a coarse-grained graph of $\mathcal { G } _ { j } = ( V _ { j } , E _ { j } , w _ { j } )$ for each $j = 0 , 1 , \ldots , J - 1$ , and $\mathcal { G } _ { J }$ has only one node. Here, we call the graph $\dot { \mathcal { G } } _ { J }$ the top level or the coarsest level and $\mathcal { G } _ { 0 }$ the bottom level or the finest level. The chain $\mathcal { G } _ { 0  J }$ hierarchically coarsens graph $\mathcal { G }$ . We use the notation $J + 1$ for the number of layers of the chain to distinguish the number $K$ of layers for pooling. The chain for graph $\mathcal { G }$ can be created by any clustering method. For details about graphs and chains, we refer the reader to the examples by Chung & Graham (1997); Hammond et al. (2011); Chui et al. (2015; 2018); Wang & Zhuang (2018; 2019).
+
+# 4.1 COMPRESSIVE HAAR TRANSFORMS
+
+Haar basis The construction of Haar basis is rooted in the theory of Haar wavelet basis which was first introduced by Haar (1910). It is a special example of the more general Daubechies wavelets (Daubechies, 1992). Haar basis is later constructed on graph by Belkin et al. (2006), and also Chui et al. (2015); Wang & Zhuang (2018; 2019). The construction of the Haar basis is based on a chain of the graph. If the topology of the graph is well reflected by the clustering of the chain, then the Haar basis contains the crucial geometric information of the graph. For a chain $\mathcal { G } _ { 0  J }$ , on the $j$ th-layer graph $\mathcal { G } _ { j }$ , $j = 0 , \dots , J$ , there is a basis $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 0 } ^ { N _ { j } }$ defined on , where is the size of $\mathcal { G } _ { j }$ and $N _ { j + 1 } < N _ { j }$ $j = 0 , \ldots , J - 1$ . Suppose two consecutive layers $j , j + 1$ . The first $N _ { j + 1 }$ members of $\phi _ { \ell } ^ { ( j ) }$ , $\ell = 1 , \ldots , N _ { j + 1 }$ , are defined on the finer layer $j + 1$ , and can be reduced into the $\phi _ { \ell } ^ { ( j + 1 ) }$ , $\ell = 1 , \dots , N _ { j + 1 }$ , as follows. For first $\ell = 1 , \dots , N _ { j + 1 }$ $\phi _ { \ell } ^ { ( j ) } ( v ) = \phi _ { \ell } ^ { ( j + 1 ) } ( P a _ { \mathcal { G } } ( v ) ) / \sqrt { | P a _ { \mathcal { G } } ( v ) | }$ , i.e. the value of the $\phi _ { \ell } ^ { ( j ) } ( v )$ is equal to the scaled $\phi _ { \ell } ^ { ( j + 1 ) }$ at the parent $P a _ { \cal G } ( v )$ of $v$ and the scaled factor is one on square root of the number of nodes in the cluster which $v$ lies in. It means that $\phi _ { \ell } ^ { ( j ) } ( v )$ for $v$ sharing the parent have the same value. This property is critical to pooling as $\phi _ { \ell } ^ { ( j ) } ( v )$ can then be treated as weights for the graph $\mathcal { G } _ { j }$ on which the input feature defined, and the nodes gain the same weight if they are in the same cluster. On the other hand, the remaining Haar basis vectors $\phi _ { \ell } ^ { ( j ) }$ for $\ell = N _ { j + 1 } { + } 1 , \ldots , N _ { j }$ are constructed to reflect the high-frequency information in the Haar wavelet decomposition. This property is exploited by the compressive Haar basis which then pools the input feature into a lower (first) dimension output feature. The construction and its pseudo-codes for algorithmic implementation of the full Haar basis is detailed in Li et al. (2019); Wang & Zhuang (2019), which we also attach in the appendix. Let {φ(j)\` }Nj\`=1, $j = 0 , \dots , J$ , be the sequence of Haar bases associated with the layers of chain $\mathcal { G } _ { 0  J }$ of a graph $\mathcal { G }$ . For $j = 0 , \dots , J$ , we let the matrix $\widetilde { \Phi } _ { j } = ( \phi _ { 1 } ^ { ( j ) } , \dots , \phi _ { N _ { j } } ^ { ( j ) } ) \in \mathbb { R } ^ { N _ { j } \times N _ { j } }$ and call the matrix $\widetilde { \Phi } _ { j }$ Haar transform matrix for layer $j$ .
+
+Orthogonality For each level $j = 0 , \dots , J$ , the sequence $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 1 } ^ { N _ { j } }$ , with $N _ { j } : = | V _ { j } |$ , is an for the sp. For each c, $l _ { 2 } ( \mathcal { G } _ { j } )$ f square-summable sequences on theis the Haar basis system for the chain . $\mathcal { G } _ { j }$ , so that $( \phi _ { \ell } ^ { ( j ) } ) ^ { T } \phi _ { \ell ^ { \prime } } ^ { ( j ) } = \delta _ { \ell , \ell ^ { \prime } }$ $j$ $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 1 } ^ { N _ { j } }$ $\mathcal { G } _ { j  J }$
+
+Locality Let $\mathcal { G } _ { 0  J }$ be a coarse-grained chain for $\mathcal { G }$ . If each parent of level $\mathcal { G } _ { j }$ , $j = 1 , \dotsc , J$ , contains at least two children, the number of different scalar values of the components of a Haar basis vector $\phi _ { \ell } ^ { ( j ) }$ , $\ell = 1 , \ldots , N _ { j }$ , is bounded by a constant independent of $j$ .
+
+In Figure 4, the Haar basis is created based on the coarse-grained chain $\mathcal { G } _ { 0 \to 2 } : = ( \mathcal { G } _ { 0 } , \mathcal { G } _ { 1 } , \mathcal { G } _ { 2 } )$ , where $\mathcal { G } _ { 0 } , \mathcal { G } _ { 1 } , \mathcal { G } _ { 2 }$ are graphs with $8 , 3 , 1$ nodes. The two colorful matrices show two Haar bases for the layers 0 and 1 in the chain $\mathcal { G } _ { 0  2 }$ . There are in total 8 vectors of the Haar basis for $\mathcal { G } _ { 0 }$ each with length 8, and 3 vectors of the Haar basis for $\mathcal { G } _ { 1 }$ each with length 3. Haar basis matrix for each level of the chain has up to 3 different values in each column as indicated by colors in each matrix. For $j = 0 , 1$ , each node of $\mathcal { G } _ { j }$ is a cluster of nodes in $\mathcal { G } _ { j + 1 }$ . Each column of the matrix is a member of the Haar basis on the individual layer of the chain. The first three column vectors of $\widetilde { \Phi } _ { 1 }$ can be reduced as an orthonormal basis of $\mathcal { G } _ { 1 }$ and the first column vector of $\mathcal { G } _ { 1 }$ can be compressed to the constant basis for $\mathcal { G } _ { 2 }$ . This connection ensures that the compressive Haar transform for HaarPooling is feasible and would allow fast algorithms of HaarPooling (see Section 4.2 below).
+
+Adjoint and forward Haar transforms We use adjoint Haar transforms for HaarPooling, which as the sparsity of the Haar basis matrix, the transform is fast implementable. The adjoint Haar transform for the signal $f$ on $\mathcal { G } _ { j }$ is defined as
+
+$$
+( \widetilde { \Phi } _ { j } ) ^ { T } f = \left( \sum _ { v \in V } \phi _ { 1 } ^ { ( j ) } ( v ) f ( v ) , \ldots , \sum _ { v \in V } \phi _ { N _ { j } } ^ { ( j ) } ( v ) f ( v ) \right) \in \mathbb { R } ^ { N _ { j } } ,
+$$
+
+and the forward Haar transform for (coefficients) vector $c : = ( c _ { 1 } , \ldots , c _ { N _ { j } } ) \in \mathbb { R } ^ { N _ { j } }$ .
+
+$$
+( \widetilde { \Phi } _ { j } c ) ( v ) = \sum _ { \ell = 1 } ^ { N _ { j } } \phi _ { \ell } ^ { ( j ) } ( v ) c _ { \ell } , \quad v \in V _ { j } .
+$$
+
+We call the components of $( \widetilde { \Phi } _ { j } ) ^ { T } f$ the Haar (wavelet) coefficients for $f$ . The adjoint Haar transform represents the signal in Haar wavelet domain by computing the Haar coefficients for graph signal. Here the adjoint and forward Haar transforms can be extended to a feature data with size $N _ { j } \times d _ { j }$ by replacing the column vector $f$ by the feature array.
+
+Proposition 2. The adjoint and forward Haar Transforms are invertible in that for $j = 0 , \dots , J$ and vector $f$ on graph $\mathcal { G } _ { j }$ ,
+
+$$
+f = \widetilde { \Phi } _ { j } ( \widetilde { \Phi } _ { j } ) ^ { T } f .
+$$
+
+Proposition 2 shows that the forward Haar transform can recover the graph signal $f$ from the adjoint Haar transform $( \widetilde { \Phi } _ { j } ) ^ { T } f$ . This means that adjoint and forward Haar transforms have zero-loss in graph signal transmission.
+
+Compressive Haar transforms Now for a graph neural network, suppose we want to use $K$ pooling layers. We associate the chain $\mathscr { G } _ { 0 \to K }$ of an input graph with the pooling by linking the $j$ th layer of pooling with the $j$ th layer of the chain. Then, we can use the Haar basis system on the chain to define the pooling operation. By the property of Haar basis, in the Haar transforms for layer $j$ , $0 \leq$ $j \le K - 1$ , of the $N _ { j }$ Haar coefficients, the first $N _ { j + 1 }$ coefficients are low-frequency coefficients, which reflect the approximation to the original data, and the other $\left( N _ { j } - N _ { j + 1 } \right)$ coefficients are in high frequency, which contain fine details of the Haar wavelet decomposition. To define pooling, we remove the high-frequency coefficients in Haar wavelet representation and obtain the compressive Haar transforms for the feature $X _ { j } ^ { \mathrm { i n } }$ at layers $j = 0 , \ldots , K - 1$ , which then gives the HaarPooling in Definition 1.
+
+As shown in the following formula, the compressive Haar transform synthesizes the neighbourhood information of the signal $f$ as compared to the full Haar transform. Thus, HaarPooling takes the average information of the data $f$ over nodes in the same cluster.
+
+$$
+\big \lVert \Phi _ { j } ^ { T } X _ { j } ^ { \mathrm { i n } } \big \rVert ^ { 2 } = \sum _ { p \in \mathcal { G } _ { j + 1 } } \frac { 1 } { | P a ( v ) | } \Big | \sum _ { p = P a ( v ) } X _ { j } ^ { \mathrm { i n } } ( v ) \Big | ^ { 2 } , \quad \Big \lVert \tilde { \Phi } _ { j } ^ { T } X _ { j } ^ { \mathrm { i n } } \Big \rVert ^ { 2 } = \sum _ { p \in \mathcal { G } _ { j + 1 } } \sum _ { p = P a ( v ) } \Big | X _ { j } ^ { \mathrm { i n } } ( v ) \Big | ^ { 2 } ,
+$$
+
+where $\widetilde { \Phi } _ { j }$ is the full Haar basis matrix at the $j$ th layer and $| P a g ( v ) |$ means the number of nodes in the cluster which $v$ lies in. Here, in the first equation, $1 / \sqrt { | P a _ { \mathcal { G } } ( v ) | }$ can be taken out of summation as $P a ( v )$ is in fact a set of nodes. We show the derivation of formula in equation 5 in Appendix D.
+
+In HaarPooling, the compression or pooling occurs in the Haar wavelet domain. HaarPooling transforms the features on the nodes to the Haar wavelet domain and discards the high-frequency coefficients in the sparse Haar wavelet representation. Figure 4 shows a two-layer HaarPooling strategy. The first layer pools the input $X _ { 0 } ^ { \mathrm { i n } }$ by the compressive Haar basis matrix $\Phi _ { 8 \times 3 } ^ { ( 0 ) }$ to the output $X _ { 0 } ^ { \mathrm { o u t } }$ with lower first dimension. The second layer pools the input $X _ { 1 } ^ { \mathrm { i n } }$ by the $\Phi _ { 3 \times 1 } ^ { ( 1 ) }$ to the output $X _ { 1 } ^ { \mathrm { o u t } }$ which first dimension drops to one.
+
+# 4.2 FAST COMPUTATION OF HAARPOOLING
+
+For the HaarPooling introduced in Definition 1, we can develop a fast computational strategy by virtue of fast adjoint Haar transforms. Let $\mathscr { G } _ { 0 \to K }$ be a coarse-grained chain of the graph $\mathcal { G } _ { 0 }$ . For convenience, we label the vertices of the level- $j$ graph $\mathcal { G } _ { j }$ by $V _ { j } : = \{ v _ { 1 } ^ { ( j ) } , \ldots , v _ { N _ { j } } ^ { ( j ) } \}$ .
+
+Fast algorithm for HaarPooling The HaarPooling in equation 3 can be computed fast by using the hierarchical structure of the chain, as we introduce as follows. For $j = 1 , \ldots , K$ , let $c _ { k } ^ { ( j ) }$ be the number of children of $v _ { k } ^ { ( j ) }$ , i.e. the number of vertices of $\mathcal { G } _ { j - 1 }$ which belongs to the cluster $v _ { k } ^ { ( j ) }$ for $k = 1 , \ldots , N _ { j }$ . For $j = 0$ , we let $c _ { k } ^ { ( 0 ) } \equiv 1$ for $k = 1 , \ldots , N _ { 0 }$ . Now, for $j = 0 , \ldots , K$ and $k = 1 , \dots , N _ { j }$ , define the weight for the node $v _ { k } ^ { ( j ) }$ of layer $j$ by
+
+$$
+w _ { k } ^ { ( j ) } : = \frac { 1 } { \sqrt { c _ { k } ^ { ( j ) } } } .
+$$
+
+Let $W _ { 0 \to K } : = \{ w _ { k } ^ { ( j ) } | j = 0 , \dots , K , k = 1 , \dots , N _ { j } \}$ . Then, for $j = 0 , \ldots , K$ , the weighted chain $( \mathscr { G } _ { j \to K } , W _ { j \to K } )$ becomes a filtration if each parent of the chain $\mathscr { G } _ { j  K }$ has at least two children. See e.g. (Chui et al., 2015, Definition 2.3).
+
+Let $j = 0 , \ldots , K$ . For the $j$ th HaarPooling layer, let $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 1 } ^ { N _ { j } }$ be the Haar basis for the $j$ th layer, which we also call the Haar basis for the filtration $( \mathscr { G } _ { j \to K } , W _ { j \to K } )$ $k = 1 , \dots , N _ { j }$ we let $X ( v _ { k } ^ { ( j ) } ) = X ( v _ { k } ^ { ( j ) } , \cdot ) \in \mathbb { R } ^ { d _ { j } }$ the feature vector at node $v _ { k } ^ { ( j ) }$ . We define the weighted sum for feature $X \in \mathbb { R } ^ { N _ { j } \times d _ { j } }$ for $d _ { j } \geq 1$ by
+
+$$
+\begin{array} { r } { S ^ { ( j ) } \big ( X , v _ { k } ^ { ( j ) } \big ) : = X ( v _ { k } ^ { ( j ) } ) , \quad v _ { k } ^ { ( j ) } \in \mathcal { G } _ { j } , } \end{array}
+$$
+
+Input: Input feature $X _ { j } ^ { \mathrm { i n } }$ for the $j$ th pooling layer given $j = 0 , \ldots , K - 1$ in a GNN with total $K$ HaarPooling layers; the chain $\mathscr { G } _ { j  K }$ associated with the HaarPooling; numbers $N _ { i }$ of nodes for layers $i = j , \ldots , K$ .
+
+Output: $\Phi _ { j } ^ { T } X _ { j } ^ { \mathrm { i n } }$ from Definition 1.
+
+Step 1: Evaluate the sums for $i = j , \dots , K$ recursively, using equation 7 and equation 8: $\bar { S } ^ { ( i ) } ( X _ { j } ^ { \mathrm { i n } } , v _ { k } ^ { ( i ) } ) \quad \forall v _ { k } ^ { ( i ) } \in V _ { i }$ .
+
+# Step 2:
+
+# end for
+
+and recursively, for $i = j + 1 , \dots , K$ and $v _ { k } ^ { ( i ) } \in \mathcal G _ { i }$
+
+$$
+\mathcal { S } ^ { ( i ) } \big ( X , v _ { k } ^ { ( i ) } \big ) : = \sum _ { v _ { k ^ { \prime } } ^ { ( i - 1 ) } \in v _ { k } ^ { ( i ) } } w _ { k ^ { \prime } } ^ { ( i - 1 ) } \mathcal { S } ^ { ( i - 1 ) } \big ( X , v _ { k ^ { \prime } } ^ { ( i - 1 ) } \big ) .
+$$
+
+For each vertex $v _ { k } ^ { ( i ) }$ of $\mathcal { G } _ { i }$ , the $S ^ { ( i ) } \big ( X , v _ { k } ^ { ( i ) } \big )$ is the weighted sum of the $\begin{array} { r l } {  { S ^ { ( i - 1 ) } \big ( X , v _ { k ^ { \prime } } ^ { ( i - 1 ) } \big ) } } \end{array}$ at the level $i - 1$ for those vertices $v _ { k ^ { \prime } } ^ { ( i - 1 ) }$ of $\mathcal { G } _ { i - 1 }$ whose parent is $v _ { k } ^ { ( i ) }$ .
+
+Theorem 3. For $0 \leq j \leq K - 1 _ { \mathrm { { \cdot } } }$ let $\{ \phi _ { \ell } ^ { ( i ) } \} _ { \ell = 1 } ^ { N _ { i } }$ for $i = j + 1 , . . . , K$ be the Haar bases for the $( \mathscr { G } _ { j \to K } , W _ { j \to K } )$ at layer $i$ . Then, the compressive Haar transform for the jth HaarPooling layer can be computed by, for the feature $X \in \mathbb { R } ^ { N _ { j } \times d _ { j } }$ and $\ell = 1 , \ldots , N _ { j }$ ,
+
+$$
+\left( \Phi _ { j } ^ { T } X \right) _ { \ell } = \sum _ { k = 1 } ^ { N _ { i } } \mathcal { S } ^ { ( i ) } \big ( X , v _ { k } ^ { ( i ) } \big ) w _ { k } ^ { ( i ) } \phi _ { \ell } ^ { ( i ) } ( v _ { k } ^ { ( i ) } ) ,
+$$
+
+where i is the largest possible number in $\{ j + 1 , \ldots , K \}$ such that $\phi _ { \ell } ^ { ( i ) }$ is the \`th member of the orthonormal basis $\{ { \phi } _ { \ell } ^ { ( i ) } \} _ { \ell = 1 } ^ { N _ { i } } f o r l _ { 2 } ( \mathcal { G } _ { i } ) _ { \ell }$ , $v _ { k } ^ { ( i ) }$ are the vertices of $\mathcal { G } _ { i }$ \`and the weights $w _ { k } ^ { ( i ) }$ are given by
+
+We give the algorithmic implementation of Theorem 3 in Algorithm 1, which provides a fast algorithm for HaarPooling at each layer.
+
+Computational complexity With increasing graph size, the sparsity of the Haar basis matrix $\widetilde { \Phi } _ { j }$ becomes more pronounced (Li et al., 2019). This sparsity implies fast computation for HaarPooling. The computational complexity of HaarPooling is determined by the adjoint Haar transforms. In the first step of Algorithm 1, the total number of summations for all elements of Step 1 is no more than $\textstyle \sum _ { i = 0 } ^ { j - 1 } { \bar { N } } _ { i + 1 }$ ; In the second step, by the locality of the Haar basis, the total number of multiplication and summation operations is at most $\begin{array} { r } { 2 \sum _ { \ell = 1 } ^ { N _ { j } } C = \mathcal { O } ( N _ { j } ) } \end{array}$ . Here $C$ is the constant which bounds the number of different values of the Haar basis vector. Thus, the computational cost of Algorithm 1 is $\mathcal { O } ( N _ { j } )$ .
+
+We run an experiment to evaluate the CPU computational time of HaarPooling by Algorithm 1 against the direct matrix product. We use randomly generated graphs and features with size ranging from 2 to 5000. As shown in Figure 5, the fast HaarPooling has computational cost nearly proportional to the number of nodes $N$ , while the ordinary matrix product incurs a cost close to order $\overset { \cdot } { \mathcal { O } } ( N ^ { 2 } )$ . These results are consistent with the computational complexity analysis given above.
+
+![](images/e73b5b95324181e7c129072fc4b2e2927730608cd35c2da06e5499cc3a0e0a7f.jpg)  
+Figure 5: Comparison for fast computation and direct matrix product for HaarPooling for input feature array with up to 5000 nodes. The cost of HaarPooling has near linear computational complexity. The cost of direct matrix product grows at $\mathcal { O } ( N ^ { 2 . 1 } )$ .
+
+# 5 EXPERIMENTS
+
+Data sets To verify whether the proposed framework can hierarchically learn good graph representations for classification, we evaluate HaarPooling on five widely used benchmark data sets for graph classification (Kersting et al., 2016), including one protein graph data set PROTEINS (Borgwardt et al., 2005; Dobson & Doig, 2003); two mutagen data sets MUTAG (Debnath et al., 1991; Kriege & Mutzel, 2012) and MUTAGEN (Riesen & Bunke, 2008; Kazius et al., 2005) (full name Mutagenicity); and two data sets that consist of chemical compounds screened for activity against non-small cell lung cancer and ovarian cancer cell lines, NCI1 and NCI109 (Wale et al., 2008). We include data sets from different domains, sample and graph sizes to give a comprehensive understanding of how HaarPooling performs with data sets in various scenarios. A summary information of the data sets is given in Table 1, which shows the data sets containing graphs with different sizes and structures: the number of data samples ranges from 188 to 4,337, the average number of nodes is from 17.93 to 39.06 and the average number of edges is from 19.79 to 72.82.
+
+Table 1: Summary statistics of the data sets used in our experiments   
+
+<table><tr><td>Data Set</td><td>MUTAG</td><td>PROTEINS</td><td>NCI1</td><td>NCI109</td><td>MUTAGEN</td></tr><tr><td>max #nodes</td><td>28</td><td>620</td><td>111</td><td>111</td><td>417</td></tr><tr><td>min #nodes</td><td>10</td><td>4</td><td>3</td><td>4</td><td>4</td></tr><tr><td>avg #nodes</td><td>17.93</td><td>39.06</td><td>29.87</td><td>29.68</td><td>30.32</td></tr><tr><td>avg #edges</td><td>19.79</td><td>72.82</td><td>32.30</td><td>32.13</td><td>30.77</td></tr><tr><td>#graphs</td><td>188</td><td>1,113</td><td>4,110</td><td>4,127</td><td>4,337</td></tr><tr><td>#classes</td><td>2</td><td>2</td><td>2</td><td>2</td><td>2</td></tr></table>
+
+Baselines and running environment We compare HaarPool with SortPool (Zhang et al., 2018a), DiffPool (Ying et al., 2018), gPool (Gao & Ji, 2019), SAGPool (Lee et al., 2019), EigenPool (Ma et al., 2019a), CSM (Kriege & Mutzel, 2012) and GIN (Xu et al., 2019) on the above data sets. The experiments use PyTorch Geometric1 (Fey & Lenssen, 2019) and were run in Google Cloud using 4 Nvidia Telsa T4 with 2560 CUDA cores, compute 7.5, 16GB GDDR6 VRAM.
+
+Training procedures In experiments, we use a GNN with at most 3 GCN (Kipf & Welling, 2017) convolutional layers plus one HaarPooling layer, followed by three fully connected layers. The hyperparameters of the network are adjusted case by case. We use spectral clustering, which exploits the eigenvalues of the graph Laplacian, to generate a chain with the number of layers given. Spectral clustering has shown good performance in coarsening a variety of data patterns and can handle isolated nodes.
+
+We use random shuffling of the data set, which we split into training, validation, and test sets with proportions $8 0 \%$ , $1 0 \%$ and $1 0 \%$ respectively. We use the Adam optimizer (Kingma & Ba, 2015), early stopping criterion, patience. The specific values are provided in the appendix. The early stopping criterion was that the validation loss does not improve for 50 epochs, with a maximum of 150 epochs, as suggested by Shchur et al. (2018).
+
+Results The classification test accuracy is reported in Table 6. GNNs with HaarPooling have excellent performance on all data sets. In 4 out of 5 datasets, it achieved top accuracy. This shows that HaarPooling with appropriate graph convolution, can achieve top performance on a variety of graph classification tasks, and in some cases improve state of the art by a few percent points.
+
+Table 2: Performance comparison for graph classification tasks (test accuracy in percent, showing the standard deviation over 10 repetitions of the experiment).   
+
+<table><tr><td>Method</td><td>MUTAG</td><td>PROTEINS</td><td>NCI1</td><td>NCI109</td><td>MUTAGEN</td></tr><tr><td>CSM</td><td>85.4</td><td>1</td><td>1</td><td>1</td><td></td></tr><tr><td>GIN</td><td>89.4</td><td>76.2</td><td>82.7</td><td>1</td><td>1 1</td></tr><tr><td>SortPool</td><td>85.8</td><td>75.5</td><td>74.4</td><td>72.3*</td><td>78.8*</td></tr><tr><td>DiffPool</td><td>1</td><td>76.3</td><td>76.0*</td><td>74.1*</td><td>80.6*</td></tr><tr><td>gPool</td><td>1</td><td>77.7</td><td>1</td><td>1</td><td>1</td></tr><tr><td>SAGPool</td><td>1</td><td>72.1</td><td>74.2</td><td>74.1</td><td>1</td></tr><tr><td>EigenPool</td><td>二</td><td>76.6</td><td>77.0</td><td>74.9</td><td>79.5</td></tr><tr><td>HaarPool</td><td>90.0±3.6</td><td>80.4±1.8</td><td>78.6±0.5</td><td>75.6±1.2</td><td>80.9±1.5</td></tr></table>
+
+‘\*’ means that the records are retrieved from EigenPool (Ma et al., 2019a), ‘–’ means that there is no public records for the corresponding method on the data set, and the bold number indicates the best performance in the list.
+
+# 6 CONCLUSION
+
+We introduced a new graph pooling method called HaarPooling. HaarPooling has a mathematical formalism derived from compressive Haar transforms. Unlike existing graph pooling methods, HaarPooling takes into account both the graph structure and also the features over the nodes of the graph-structured input data, to compute a coarsened representation. As an individual unit, HaarPooling can be applied in conjunction with any type of graph convolution in GNNs. We show in experiments that HaarPooling reaches state of the art in several benchmark graph classification tasks. Moreover, having only linear computational complexity in the size of the inputs, HaarPooling is a very fast pooling method.
+
+# REFERENCES
+
+Mihael Ankerst, Markus M Breunig, Hans-Peter Kriegel, and Jorg Sander. Optics: ordering points¨ to identify the clustering structure. In ACM Sigmod Record, volume 28, pp. 49–60. ACM, 1999.
+
+Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.
+
+Mikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. Journal of Machine Learning Research, 7(Nov):2399–2434, 2006.
+
+Karsten M Borgwardt, Cheng Soon Ong, Stefan Schonauer, SVN Vishwanathan, Alex J Smola, and ¨ Hans-Peter Kriegel. Protein function prediction via graph kernels. Bioinformatics, 21(suppl 1): i47–i56, 2005.
+
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.
+
+Cat˘ alina Cangea, Petar Veli ˘ ckovi ˇ c, Nikola Jovanovi ´ c, Thomas Kipf, and Pietro Li ´ o. Towards sparse \` hierarchical graph classifiers. In Workshop on Relational Representation Learning, NeurIPS, 2018.
+
+C. K. Chui, H.N. Mhaskar, and X. Zhuang. Representation of functions on big data associated with directed graphs. Applied and Computational Harmonic Analysis, 44(1):165 – 188, 2018. ISSN 1063-5203. doi: https://doi.org/10.1016/j.acha.2016.12.005.
+
+C.K. Chui, F. Filbir, and H.N. Mhaskar. Representation of functions on big data: graphs and trees. Applied and Computational Harmonic Analysis, 38(3):489 – 509, 2015.
+
+Fan RK Chung and Fan Chung Graham. Spectral graph theory. American Mathematical Society, 1997.
+
+Ingrid Daubechies. Ten lectures on wavelets. SIAM, 1992.
+
+Asim Kumar Debnath, Rosa L. Lopez de Compadre, Gargi Debnath, Alan J. Shusterman, and Corwin Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds. correlation with molecular orbital energies and hydrophobicity. Journal of Medicinal Chemistry, 34(2):786–797, 1991. doi: 10.1021/jm00106a046.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In NIPS, pp. 3844–3852, 2016.
+
+Frederik Diehl, Thomas Brunner, Michael Truong Le, and Alois Knoll. Towards graph pooling by edge contraction. In ICML 2019 Workshop on Learning and Reasoning with Graph-Structured Data, 2019.
+
+Paul D Dobson and Andrew J Doig. Distinguishing enzyme structures from non-enzymes without alignments. Journal of Molecular Biology, 330(4):771–783, 2003.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´ Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In NIPS, pp. 2224–2232, 2015.
+
+Martin Ester, Hans-Peter Kriegel, Jorg Sander, Xiaowei Xu, et al. A density-based algorithm for ¨ discovering clusters in large spatial databases with noise. In KDD, volume 96, pp. 226–231, 1996.
+
+Matthias Fey and Jan Eric Lenssen. Fast graph representation learning with pytorch geometric. In Workshop on Representation Learning on Graphs and Manifolds, ICLR, 2019.
+
+Hongyang Gao and Shuiwang Ji. Graph U-Nets. ICML, pp. 2083–2092, 2019.
+
+Matan Gavish, Boaz Nadler, and Ronald R Coifman. Multiscale wavelets on trees, graphs and high dimensional data: theory and applications to semi supervised learning. In ICML, pp. 367–374, 2010.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In ICML, pp. 1263–1272, 2017.
+
+Alfred Haar. Zur theorie der orthogonalen funktionensysteme. Mathematische Annalen, 69(3): 331–371, 1910.
+
+David K Hammond, Pierre Vandergheynst, and Remi Gribonval. Wavelets on graphs via spectral ´ graph theory. Applied and Computational Harmonic Analysis, 30(2):129–150, 2011.
+
+George Karypis and Vipin Kumar. A fast and high quality multilevel scheme for partitioning irregular graphs. SIAM Journal on Scientific Computing, 20(1):359–392, 1998.
+
+Jeroen Kazius, Ross McGuire, and Roberta Bursi. Derivation and validation of toxicophores for mutagenicity prediction. Journal of Medicinal Chemistry, 48(1):312–320, 2005.
+
+Kristian Kersting, Nils M. Kriege, Christopher Morris, Petra Mutzel, and Marion Neumann. Benchmark data sets for graph kernels, 2016. URL http://graphkernels.cs.tu-dortmund. de.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Boris Knyazev, Graham W. Taylor, and Mohamed R. Amer. Understanding attention and generalization in graph neural networks. In NeurIPS, 2019.
+
+Nils Kriege and Petra Mutzel. Subgraph matching kernels for attributed graphs. In ICML, pp. 291–298, 2012.
+
+Junhyun Lee, Inyeop Lee, and Jaewoo Kang. Self-attention graph pooling. In ICML, pp. 3734–3743, 2019.
+
+Ming Li, Zheng Ma, Yu Guang Wang, and Xiaosheng Zhuang. Fast Haar transforms for graph neural networks. arXiv preprint arXiv:1907.04786, 2019.
+
+Yao Ma, Suhang Wang, Charu C. Aggarwal, and Jiliang Tang. Graph convolutional networks with EigenPooling. In KDD, pp. 723–731, 2019a.
+
+Zheng Ma, Ming Li, and Yu Guang Wang. PAN: Path integral based convolution for deep graph neural networks. In Workshop on Learning and Reasoning with Graph-Structured Representation. ICML, 2019b.
+
+Emmanuel Noutahi, Dominique Beani, Julien Horwood, and Prudencio Tossou. Towards interpretable sparse graph representation learning with Laplacian pooling. arXiv preprint arXiv:1905.11577, 2019.
+
+M. K. Pakhira. A linear time-complexity k-means algorithm using cluster shifting. In 2014 International Conference on Computational Intelligence and Communication Networks, pp. 1047–1051, 2014. doi: 10.1109/CICN.2014.220.
+
+Kaspar Riesen and Horst Bunke. IAM graph database repository for graph based pattern recognition and machine learning. In Joint IAPR International Workshops on Statistical Techniques in Pattern Recognition (SPR) and Structural and Syntactic Pattern Recognition (SSPR), pp. 287–297. Springer, 2008.
+
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pit- ¨ falls of graph neural network evaluation. In Workshop on Relational Representation Learning, NeurIPS, 2018.
+
+Jianbo Shi and Jitendra Malik. Normalized cuts and image segmentation. Departmental Papers (CIS), pp. 107, 2000.
+
+Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. In ICLR, 2015.
+
+Nikil Wale, Ian A Watson, and George Karypis. Comparison of descriptor spaces for chemical compound retrieval and classification. Knowledge and Information Systems, 14(3):347–375, 2008.
+
+Yu Guang Wang and Xiaosheng Zhuang. Tight framelets and fast framelet filter bank transforms on manifolds. Applied and Computational Harmonic Analysis, 2018. doi: 10.1016/j.acha.2018.02. 001.
+
+Yu Guang Wang and Xiaosheng Zhuang. Tight framelets on graphs for multiscale analysis. In Wavelets and Sparsity XVIII, SPIE Proc., pp. 11138–11, 2019.
+
+Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and Philip S Yu. A comprehensive survey on graph neural networks. arXiv preprint arXiv:1901.00596, 2019.   
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In ICLR, 2019.   
+Zhitao Ying, Jiaxuan You, Christopher Morris, Xiang Ren, Will Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. In NeurIPS, pp. 4800–4810, 2018.   
+Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018a.   
+Ziwei Zhang, Peng Cui, and Wenwu Zhu. Deep learning on graphs: A survey. arXiv preprint arXiv:1812.04202, 2018b.   
+Jie Zhou, Ganqu Cui, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Graph neural networks: A review of methods and applications. arXiv preprint arXiv:1812.08434, 2018.
+
+# A GRAPH CLASSIFICATION
+
+Graph classification This task is to categorize graph-structured data into several classes. The training set consists of $M$ pairs of samples $\mathbf { \bar { \Psi } } ( x _ { i } , \mathcal { G } _ { i } ) , \mathbf { \bar { y } } _ { i } )$ , $i = 1 , \dots , M$ . For the ith sample, $\mathcal { G } _ { i } =$ $( V _ { i } , E _ { i } , W _ { i } )$ is a graph with vertex set $V _ { i }$ of size $| V _ { i } | = N _ { i }$ (also called nodes), and edge set $E _ { i }$ with weights $W _ { i }$ . The feature $x _ { i } \in \mathbb { R } ^ { N _ { i } \times d }$ is an array of $d$ features per vertex, i.e., an $\mathbb { R } ^ { d }$ -valued function over $V _ { i }$ . The label $y _ { i }$ is an integer from a finite set indicating which class the input sample $( x _ { i } , \mathcal { G } _ { i } )$ lies in. The number of nodes $N _ { i }$ and the graph structure $E _ { i } , W _ { i }$ usually vary over the different input samples.
+
+Graph neural networks Deep graph neural networks (GNNs) are designed to work with graphstructured inputs of the form $( x _ { i } , \mathcal { G } _ { i } )$ described above. A GNN is typically composed of multiple graph convolution layers, graph pooling layers, and fully connected layers. A (graph) convolutional layer extracts an array of features from the previous array. It changes the dimension $d$ of the feature array but does not change the number of nodes $N _ { i }$ . Since the number of nodes of different inputs is variable, the number of nodes of the corresponding outputs is also variable. This raises new challenges in comparison with traditional image classification tasks, where the local structure connecting pixels is always fixed (even if the number of pixels might be variable).
+
+Graph pooling In GNNs, one uses graph pooling to reduce the first dimension $N$ of the feature arrays, and more importantly, to obtain outputs of uniform dimension (commonly followed by fully connected layers). A general architecture uses a cascade of convolutional and pooling layers. Figure 2 illustrates such an architecture with three blocks of graph convolutional and pooling layers, followed by a multi-layer perceptron (MLP) with three fully connected layers. In practice, each block can include several convolutional layers but use only one pooling layer at most. The exact architecture of GNNs with combined convolutional and pooling layers is mainly dependent upon the particular problem and the data set and is designed case by case.
+
+# B CONSTRUCTION OF HAAR BASIS
+
+Construction of Haar basis. With a chain of the graph, one can generate a Haar basis for $l _ { 2 } ( \mathcal { G } )$ following Chui et al. (2015), see also Gavish et al. (2010). We show the construction of Haar basis on $\mathcal { G }$ , as follows.
+
+Step 1. Let $\mathcal { G } ^ { \mathrm { c g } } = ( V ^ { \mathrm { c g } } , E ^ { \mathrm { c g } } , w ^ { \mathrm { c g } } )$ be a coarse-grained graph of $\mathcal { G } = ( V , E , w )$ with $N ^ { \mathrm { c g } } : = | V ^ { \mathrm { c g } } |$ . ∈   degrees of vertices or weights of vertices, as Each vertex $v ^ { \mathrm { c g } } \in V ^ { \mathrm { c g } }$ is a cluster $v ^ { \mathrm { c g } } = \{ v \ \bar { } \in \ V \vert v$ $V ^ { \mathrm { c g } } = \{ v _ { 1 } ^ { \mathrm { c g } } , \ldots , v _ { N ^ { \mathrm { c g } } } ^ { \mathrm { c g } } \}$ has parent $v ^ { \mathrm { c g } } \}$ } G. We define of . Order $N ^ { \mathrm { c g } }$ vectors , e.g., by $\phi _ { \ell } ^ { \mathrm { c g } }$ on ${ \mathcal { G } } ^ { \mathrm { c g } }$ by
+
+$$
+\phi _ { 1 } ^ { \mathrm { c g } } ( v ^ { \mathrm { c g } } ) : = \frac { 1 } { \sqrt { N ^ { \mathrm { c g } } } } , \quad v ^ { \mathrm { c g } } \in V ^ { \mathrm { c g } } ,
+$$
+
+and for $\ell = 2 , \ldots , N ^ { \mathrm { c g } }$ ,
+
+$$
+\phi _ { \ell } ^ { \mathrm { c g } } : = \sqrt { \frac { N ^ { \mathrm { c g } } - \ell + 1 } { N ^ { \mathrm { c g } } - \ell + 2 } } \left( \chi _ { \ell - 1 } ^ { \mathrm { c g } } - \frac { \sum _ { j = \ell } ^ { N ^ { \mathrm { c g } } } \chi _ { j } ^ { \mathrm { c g } } } { N ^ { \mathrm { c g } } - \ell + 1 } \right) ,
+$$
+
+where $\chi _ { j } ^ { \mathrm { c g } }$ is the indicator function for the $j$ th vertex $v _ { j } ^ { \mathrm { c g } } \in V ^ { \mathrm { c g } }$ on $\mathcal { G }$ given by
+
+$$
+\begin{array} { r } { \chi _ { j } ^ { \mathrm { c g } } ( v ^ { \mathrm { c g } } ) : = \left\{ \begin{array} { l l } { 1 , } & { v ^ { \mathrm { c g } } = v _ { j } ^ { \mathrm { c g } } , } \\ { 0 , } & { v ^ { \mathrm { c g } } \in V ^ { \mathrm { c g } } \backslash \{ v _ { j } ^ { \mathrm { c g } } \} . } \end{array} \right. } \end{array}
+$$
+
+Then, one can show that $\{ \phi _ { \ell } ^ { \mathrm { c g } } \} _ { \ell = 1 } ^ { N ^ { \mathrm { c g } } }$ forms an orthonormal basis for $l _ { 2 } ( \mathcal { G } ^ { \mathrm { c g } } )$ .
+
+Note that each $v \in V$ belongs to exactly one cluster $v ^ { \mathrm { c g } } \in V ^ { \mathrm { c g } }$ . In view of this, for each $\ell =$ $1 , \ldots , N ^ { \mathrm { c g } }$ , we can extend the vector $\phi _ { \ell } ^ { \mathrm { c g } }$ on ${ \mathcal { G } } ^ { \mathrm { c g } }$ to a vector $\phi _ { \ell , 1 }$ on $\mathcal { G }$ by
+
+$$
+\phi _ { \ell , 1 } ( v ) : = \frac { \phi _ { \ell } ^ { \mathrm { c g } } ( v ^ { \mathrm { c g } } ) } { \sqrt { | v ^ { \mathrm { c g } } | } } , \quad v \in v ^ { \mathrm { c g } } ,
+$$
+
+here $| v ^ { \mathrm { c g } } | : = k _ { \ell }$ is the size of the cluster $v ^ { \mathrm { c g } }$ , i.e., the number of vertices in $\mathcal { G }$ whose common parent is $v ^ { \mathrm { c g } }$ . We order the cluster $v _ { \ell } ^ { \mathrm { c g } }$ , e.g., by degrees of vertices, as
+
+$$
+v _ { \ell } ^ { \mathrm { c g } } = \{ v _ { \ell , 1 } , \ldots , v _ { \ell , k _ { \ell } } \} \subseteq V .
+$$
+
+For $k = 2 , \ldots , k _ { \ell }$ , similar to equation 11, define
+
+$$
+\phi _ { \ell , k } = \sqrt { \frac { k _ { \ell } - k + 1 } { k _ { \ell } - k + 2 } } \left( \chi _ { \ell , k - 1 } - \frac { \sum _ { j = k } ^ { k _ { \ell } } \chi _ { \ell , j } } { k _ { \ell } - k + 1 } \right) .
+$$
+
+where for $j = 1 , \ldots , k _ { \ell } , \chi _ { \ell , j }$ is given by
+
+$$
+\chi _ { \ell , j } ( v ) : = \{ \boldsymbol { 1 } , \quad v = v _ { \ell , j } , \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad 
+$$
+
+One can show that the resulting $\{ \phi _ { \ell , k } : \ell = 1 , \ldots , N ^ { \mathrm { c g } } , k = 1 , \ldots , k _ { \ell } \}$ is an orthonormal basis for $l _ { 2 } ( \mathcal { G } )$ .
+
+Step 2. Let $\mathcal { G } _ { 0  J }$ be a coarse-grained chain for the graph $\mathcal { G }$ . An orthonormal basis $\{ \phi _ { \ell } ^ { ( J ) } \} _ { \ell = 1 } ^ { N _ { J } }$ $j = 0 , \dots , J - 1$ rated using equation 10 and equati, we generate an orthonormal basis $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 1 } ^ { N _ { j } }$ e thefor $l _ { 2 } ( \mathcal { G } _ { j } )$ atedly use Step 1: forfrom the orthonormal basis $\{ { \phi } _ { \ell } ^ { ( j + 1 ) } \} _ { \ell = 1 } ^ { N _ { j + 1 } }$ for the coarse-grained graph $\mathcal { G } _ { j + 1 }$ that was derived in the previous steps. We call the sequence {φ\` := φ(0)\` }N0\`=1 o f vectors at the finest level, the Haar global orthonormal basis or for , s for is ca $\mathcal { G }$ associated with the chain d the associated (orthonor $\mathcal { G } _ { 0  J }$ . The orthonormal basbasis for the Haar basis $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 1 } ^ { N _ { j } }$ $l _ { 2 } ( \mathcal { G } _ { j } )$ $j = 1 , \dots , J$ $\{ \phi _ { \ell } \} _ { \ell = 1 } ^ { N }$
+
+Besides the orthogonality, the Haar basis has the locality which is critical to the fast computation of HaarPooling.
+
+Comlayer ssive Haar of the chain Suppose we have constructed the (ful. The compressive Haar basis for layer His $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 0 } ^ { N _ { j } }$ for each $\mathcal { G } _ { j }$ $\mathscr { G } _ { 0 \to K }$ $j$ $\{ \phi _ { \ell } ^ { ( j ) } \} _ { \ell = 0 } ^ { N _ { j + 1 } }$
+
+# C FAST COMPUTATION FOR HAARPOOLING
+
+Let $\mathscr { G } _ { 0 \to K }$ be a coarse-grained chain of the graph $\mathcal { G } _ { 0 }$ . For convenience, we label the vertices of the level- $j$ graph $\mathcal { G } _ { j }$ by $V _ { j } : = \{ v _ { 1 } ^ { ( j ) } , \ldots , v _ { N _ { j } } ^ { ( j ) } \}$ .
+
+Fast algorithm for HaarPooling The HaarPooling in equation 3 can be computed fast by using the hierarchical structure of the chain, as we introduce as follows. For $j = 1 , \ldots , K$ , let $c _ { k } ^ { ( j ) }$ be the for number of children of $k = 1 , \ldots , N _ { j }$ . For $v _ { k } ^ { ( j ) }$ $j = 0$ , i.e. the number of vertices of , we let $c _ { k } ^ { ( 0 ) } \equiv 1$ for $k = 1 , \ldots , N _ { 0 }$ $\mathcal { G } _ { j - 1 }$ which belongs to the cluster . Now, for $j = 0 , \ldots , K$ $v _ { k } ^ { ( j ) }$ kand , $k = 1 , \dots , N _ { j }$ , define the weight for the node $v _ { k } ^ { ( j ) }$ of layer $j$ by
+
+$$
+w _ { k } ^ { ( j ) } : = \frac { 1 } { \sqrt { c _ { k } ^ { ( j ) } } } .
+$$
+
+$W _ { 0 \to K } : = \{ w _ { k } ^ { ( j ) } | j = 0 , \ldots , K , k = 1 , \ldots , N _ { j } \}$ . Then, f the chain $j = 0 , \ldots , K$ , the weighted chainast two children. See $( \mathscr { G } _ { j \to K } , W _ { j \to K } )$ $\mathscr { G } _ { j  K }$ e.g. (Chui et al., 2015, Definition 2.3).
+
+# D PROOFS
+
+Proof for equation $5$ . We only need to prove the first formula. The second is obtained by definition. To simplify notation, we let $\bar { \boldsymbol { f } } =  { \boldsymbol { X } } _ { j } ^ { \mathrm { i n } }$ . By construction of Haar basis, for some layer $j$ , the first $N _ { j + 1 }$ basis vectors
+
+$$
+\phi _ { \ell } ^ { ( j ) } ( v ) = \phi _ { \ell } ^ { ( j + 1 ) } ( p ) / \sqrt { | P a _ { \mathcal { G } } ( v ) | } , \quad \mathrm { f o r } p = P a _ { \mathcal { G } } ( v ) .
+$$
+
+Then, the Fourier coefficient of $f$ for the \`th basis vector is the inner product
+
+$$
+\begin{array} { l } { \left. f , \phi _ { \ell } ^ { ( j ) } \right. = \displaystyle \sum _ { v \in \mathcal { G } _ { j } } f ( v ) \overline { { \phi _ { \ell } ^ { ( j ) } ( v ) } } } \\ { = \displaystyle \sum _ { p \in \mathcal { G } _ { j + 1 } } \sum _ { p = P a _ { \mathcal { G } } ( v ) } f ( v ) \overline { { \phi _ { \ell } ^ { ( j + 1 ) } ( p ) } } / \sqrt { | P a _ { \mathcal { G } } ( v ) | } } \\ { = \displaystyle \sum _ { p \in \mathcal { G } _ { j + 1 } } \widetilde { f } ( p ) \overline { { \phi _ { \ell } ^ { ( j + 1 ) } ( p ) } } } \\ { = \left. \widetilde { f } , \phi _ { \ell } ^ { ( j + 1 ) } \right. } \end{array}
+$$
+
+where we have let
+
+$$
+\widetilde { f } ( p ) : = \frac { 1 } { \sqrt { \left| P a _ { \mathcal { G } } ( v ) \right| } } \sum _ { p = P a _ { \mathcal { G } } ( v ) } f ( v ) .
+$$
+
+This then gives
+
+$$
+\sum _ { \ell = 1 } ^ { N _ { j + 1 } } \left| \left. f , \phi _ { \ell } ^ { ( j ) } \right. \right| ^ { 2 } = \sum _ { \ell = 1 } ^ { N _ { j + 1 } } \left| \left. \widetilde { f } , \phi _ { \ell } ^ { ( j + 1 ) } \right. \right| ^ { 2 } .
+$$
+
+Since {φ\`}Nj+1\`=1 forms an orthonormal basis on $\ell _ { 2 } ( \mathcal { G } _ { j + 1 } )$ ,
+
+$$
+\begin{array} { l } { \displaystyle \left\| \Phi _ { j } ^ { T } f \right\| ^ { 2 } = \sum _ { \ell = 1 } ^ { N _ { j + 1 } } \left| \left. \widetilde f , \phi _ { \ell } ^ { ( j + 1 ) } \right. \right| ^ { 2 } = \left\| \widetilde f \right\| ^ { 2 } = \sum _ { p \in \mathcal { G } _ { j + 1 } } \left| \widetilde f ( p ) \right| ^ { 2 } } \\ { \displaystyle \qquad = \sum _ { p \in \mathcal { G } _ { j + 1 } } \left| \frac { 1 } { \sqrt { \left| P a _ { \mathcal { G } } ( v ) \right| } } \sum _ { p = P a _ { \mathcal { G } } ( v ) } f ( v ) \right| ^ { 2 } . } \end{array}
+$$
+
+This proves the left formula in equation 5.
+
+Proof of Theorem 3. By the relation between $\phi _ { \ell } ^ { ( i ) }$ and $\phi _ { \ell } ^ { ( j ) }$ , for $i \ = \ j + 1 , \ldots , K$ and $\ell \ =$ $1 , \ldots , N _ { j + 1 }$ ,
+
+$$
+\begin{array} { r l } { \langle \theta ^ { \dagger } \rangle ^ { * } \mathcal { X } _ { i } \rangle _ { i } = } & { \frac { \nu _ { 0 } } { \lambda _ { 0 } } \mathcal { X } _ { i } ^ { ( \nu _ { 0 } ) } \frac { \partial } { \partial \alpha _ { i } } \langle \theta ^ { \dagger } \rangle _ { i \alpha } ^ { * } } \\ & { = \frac { \nu _ { 0 } } { \lambda _ { 0 } } \left( \underbrace { \sum _ { i = 1 } ^ { N } \frac { \partial \left( \theta ^ { \dagger } \right) ^ { * } } { \partial \alpha _ { i } } \sum _ { \alpha = 1 } ^ { N } \lambda _ { 0 } \langle \theta ^ { \dagger } \rangle _ { i \alpha } } _ { \displaystyle \left\{ \begin{array} { l } { 1 , \dots , N } } \\ { \frac { \partial } { \partial \alpha _ { i } } \sum _ { \alpha = 1 } ^ { N } \lambda _ { i } \Big [ \epsilon _ { i } \partial _ { i } ^ { \alpha } \epsilon _ { i } ^ { \alpha } } \end{array}  ^ { * } } \right. } \\\right\ & \right]{ = \frac { \nu _ { 0 } } { \lambda _ { 0 } } \left( \underbrace { \sum _ { i = 1 } ^ { N } \frac { \partial \left( \theta ^ { \dagger } \right) ^ { * } } { \partial \alpha _ { i } } \sum _ { \alpha = 1 } ^ { N } \lambda _ { 0 } \left( \frac { \partial \theta ^ { \dagger } } { \partial \alpha _ { i } } \right) ^ { * } } _ { \displaystyle \left\{ \begin{array} { l } { 1 , \dots , N } } \\ { \frac { \partial } { \partial \alpha _ { i } } \sum _ { \alpha = 1 } ^ { N } \lambda _ { i } \Big [ \epsilon _ { i } \partial _ { i } ^ { \alpha } \epsilon _ { i } ^ { \alpha } } \end{array}  } \frac { \par\right\tial ^ { 2 } \alpha ^ { 2 } \sigma ^ { 2 } \sigma ^ { 2 } \sigma ^ { 2 } \sigma ^ { 2 } \sigma ^ { 2 } } { \partial \alpha _ { i } ^ { 2 } } \left( \epsilon _ { i } ^ { 2 } \partial _ { i } ^ { \alpha } \epsilon _ { i } ^ { \alpha } \right) } \\ & \right) = \frac { \nu _ { 0 } } { \lambda _ { 0 } ^ { 2 } \sigma ^ { 2 } } \left( \underbrace  \sum _ { i = 1 } ^ { N } \frac { \partial \left( \theta ^ { \dagger } \right) ^ { * } } { \partial \alpha _ { i } ^ { 2 } } \partial _ { i } ^ { \alpha } \partial _ { i } ^ { \alpha } \epsilon  \end{array}
+$$
+
+where $v _ { k ^ { \prime } } ^ { ( j + 1 ) }$ is the parent of $v _ { k } ^ { ( j ) }$ and $v _ { k ^ { \prime \prime } } ^ { ( j + 2 ) }$ is the parent of $v _ { k } ^ { ( j + 1 ) }$ , and we recursively compute the summation to obtain the last equality, thus completing the proof.
+
+# E EXPERIMENTAL SETTING
+
+The architecture of GNN is identified by the layer type and the number of hidden nodes at each layer. For example, we denote 3GC256-HP-2FC256-FC128 to represent a GNN architecture with 3 GCNConv layers each with 256 hidden nodes plus one HaarPooling layer followed by 2 fully connected layers each with 256 hidden nodes and 1 fully connected layer with 128 hidden nodes. The architecture for each data set is shown by Table 3.
+
+The hyperparameters include batch size; learning rate, weight decay rate (these two for optimization); maximum number of epochs; patience for early stopping. The choice of hyperparameters in each data set is shown in Table 4.
+
+Table 3: Network architecture   
+
+<table><tr><td>Data Set</td><td>Layers and #Hidden Nodes</td></tr><tr><td>MUTAG</td><td>GC60-HP-FC60-FC180-FC60</td></tr><tr><td>PROTEINS</td><td>2GC128-HP-2GC128-HP-2GC128-HP-GC128-2FC128-FC64</td></tr><tr><td>NCI1</td><td>2GC256-HP-FC256-FC1024-FC2048</td></tr><tr><td>NCI109</td><td>3GC256-HP-2FC256-FC128</td></tr><tr><td>MUTAGEN</td><td>3GC256-HP-2FC256-FC128</td></tr></table>
+
+# F GNN WITH HAARPOOLING ON TRIANGLES
+
+We test GNN with HaarPooling on graph data set Triangles (Knyazev et al., 2019). Triangles is a 10 classification problem with 45000 graphs. The average numbers of nodes and edges of graphs are
+
+Table 4: Hyperparameter setting   
+
+<table><tr><td>Data Set</td><td>MUTAG</td><td>PROTEINS</td><td>NCI1</td><td>NCI109</td><td>MUTAGEN</td></tr><tr><td>batch size</td><td>60</td><td>50</td><td>100</td><td>100</td><td>100</td></tr><tr><td>max #epochs</td><td>30</td><td>20</td><td>150</td><td>150</td><td>50</td></tr><tr><td>early stopping</td><td>15</td><td>20</td><td>50</td><td>50</td><td>50</td></tr><tr><td>learning rate</td><td>0.01</td><td>0.001</td><td>0.001</td><td>0.01</td><td>0.01</td></tr><tr><td>weight decay</td><td>0.0005</td><td>0.0005</td><td>0.0005</td><td>0.0001</td><td>0.0005</td></tr></table>
+
+20.85 and 32.74 respectively. In the experiments, the network uses GIN convolution (Xu et al., 2019) as graph convolution and with HaarPooling or SAGPooling (Lee et al., 2019). With SAGPooling, the network architecture uses two combined layers of GIN convolution and SAGPooling followed by combined layers of GIN convolution and global max pooling, denoted by GIN-SP-GIN-SP-GIN-MP, where SP means the SAGPooling and MP means global max pooling. With HaarPooling, we test with two architectures: GIN-HP-GIN-HP-GIN-MP and GIN-HP-GIN-GIN-MP, where HP means HaarPooling. The data for training, validation and test are 35000, 5000 and 10000 respectively. The hidden nodes in convoluational layers is 64, batch size is 60 and learning rate is 0.001.
+
+Table 5 shows the test accuracy of the three networks. It illustrates that both networks with HaarPooling outperform that with the SAGPooling.
+
+Table 5: Training, validation and test accuracies on Triangles   
+
+<table><tr><td rowspan="2">Architecture</td><td colspan="3">Accuracy (%)</td></tr><tr><td>Training</td><td>Validation</td><td>Test</td></tr><tr><td>GIN-SP-GIN-SP-GIN-MP</td><td>45.6</td><td>45.3</td><td>44.0</td></tr><tr><td>GIN-HP-GIN-HP-GIN-MP</td><td>47.5</td><td>46.3</td><td>46.1</td></tr><tr><td>GIN-HP-GIN-GIN-MP</td><td>47.3</td><td>45.8</td><td>45.5</td></tr></table>
+
+# G PROPERTY COMPARISON OF POOLING METHODS
+
+Here we provide a comparison of the properties of HaarPooling with existing pooling methods. The properties in comparison includes time complexity and space complexity, and whether involving the clustering, hierarchical pooling (which is then not a global pooling), spectral-based, node feature or graph structure and sparse representation. We compare HaarPooling (denoted by HaarPool in the table) to other methods (SortPool, DiffPool, gPool, SAGPool and EigenPool). The SortPool (i.e. SortPooling) is a global pooling which uses node signature (i.e. Weisfeiler-Lehman color of vertex) sorts all vertices by the values of the channels of the input data. Thus, the time complexity (worst case) of SortPool is $\mathcal { O } ( | V | ^ { 2 } )$ and space complexity is $\mathcal { O } ( | V | )$ . Other pooling methods are all hierarchical pooling. DiffPool and gPool both use the node feature and have time complexity $\mathcal { O } ( | V | ^ { 2 } )$ The DiffPool learns the assignment matrices in end-to-end manner and has space complexity ${ \dot { \mathcal { O } } } ( k | V | ^ { 2 } )$ for pooling ratio $k$ . The $\mathrm { \ g P o o l }$ projects all nodes to a learnable vector to generate scores for nodes, and then sorts the nodes by the projection scores; the space complexity is $\mathsf { \tilde { O } } ( | V | + | E | )$ . SAGPool uses the graph convolution to calculate the attention scores of nodes and then selects top ranked nodes for pooling. The time complexity of SAGPool is $\mathcal { O } ( | E | )$ and the space complexity is $\mathcal { O } ( \left| V \right| + \left| E \right| )$ due to the sparsity of the pooling matrix. EigenPool, which considers both the node feature and graph structure, uses the eigedecomposition of subgraphs (from clustering) of the input graph, and pools the input data by Fourier transforms of the assembled basis matrix. Due to eigendecomposition, the time complexity of EigenPool is $\mathcal { O } ( | V | ^ { 2 } )$ and space complexity is $\mathcal { O } ( | V | ^ { 2 } )$ . HaarPool which uses the sparse representation of data by compressive Haar basis has linear time complexity $\mathcal { O } ( | V | )$ (up to a $\log | V |$ term), and the space complexity is $\mathcal { O } ( | V | ^ { 2 } \epsilon )$ , where $\epsilon$ is the sparsity of the compressive Haar transform matrix and is usually very small. From the table, we can observe the HaarPool is the only pooling method which has time complexity proportional to the number of nodes, and thus has faster implementation.
+
+Table 6: Property comparison for pooling methods.   
+
+<table><tr><td>Method</td><td>Time Complexity</td><td>Space Complexity</td><td>Clustering- based</td><td>based</td><td>Spectral- Hierarchical Use Node Pooling</td><td>Feature</td><td>Use Graph Structure</td><td>Sparse Repre- ：sentation</td></tr><tr><td>SortPool</td><td>0(IV12)</td><td>O(IVI)</td><td></td><td></td><td></td><td>&lt;</td><td></td><td></td></tr><tr><td>DiffPool</td><td>0(ivi2)</td><td>O(k|V|2)</td><td></td><td></td><td>√</td><td></td><td></td><td></td></tr><tr><td>gPool</td><td>0(ivi2)</td><td>O(IV|+|EI)</td><td></td><td></td><td>√</td><td>√</td><td></td><td></td></tr><tr><td>SAGPool</td><td>O(EI）</td><td>O(ivi+jEI)</td><td></td><td></td><td>√</td><td>√</td><td>√</td><td></td></tr><tr><td>EigenPool</td><td>0(iv12)</td><td>0(IV12)</td><td>√</td><td></td><td>√</td><td>√</td><td>√</td><td></td></tr><tr><td>HaarPool</td><td>0(IVI)</td><td>0(IV1²e)</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr></table>
+
+$| \overline { { V | } } ^ { \star }$ is the number of vertices of the input graph; $\overline { { \cdot | E | } } ^ { | }$ is the number of edges of the input graph; $\overline { { \cdot \epsilon ^ { * } } }$ in HaarPooling is the sparsity of the compressive Haar transform matrix; $\cdot _ { k } ,$ in the DiffPool is the pooling ratio.

parse/train/H1lJws05K7/H1lJws05K7.md

@@ -0,0 +1,610 @@
+# ON THE SELECTION OF INITIALIZATION AND ACTIVATION FUNCTION FOR DEEP NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The weight initialization and the activation function of deep neural networks have a crucial impact on the performance of the training procedure. An inappropriate selection can lead to the loss of information of the input during forward propagation and the exponential vanishing/exploding of gradients during back-propagation. Understanding the theoretical properties of untrained random networks is key to identifying which deep networks may be trained successfully as recently demonstrated by Schoenholz et al. (2017) who showed that for deep feedforward neural networks only a specific choice of hyperparameters known as the ‘edge of chaos’ can lead to good performance. We complete this analysis by providing quantitative results showing that, for a class of ReLU-like activation functions, the information propagates indeed deeper for an initialization at the edge of chaos. By further extending this analysis, we identify a class of activation functions that improve the information propagation over ReLU-like functions. This class includes the Swish activation, $\phi _ { s w i s h } ( x ) = x \cdot \mathrm { s i g m o i d } ( x )$ , used in Hendrycks & Gimpel (2016), Elfwing et al. (2017) and Ramachandran et al. (2017). This provides a theoretical grounding for the excellent empirical performance of $\phi _ { s w i s h }$ observed in these contributions. We complement those previous results by illustrating the benefit of using a random initialization on the edge of chaos in this context.
+
+# 1 INTRODUCTION
+
+Deep neural networks have become extremely popular as they achieve state-of-the-art performance on a variety of important applications including language processing and computer vision; see, e.g., LeCun et al. (1998). The success of these models has motivated the use of increasingly deep networks and stimulated a large body of work to understand their theoretical properties. It is impossible to provide here a comprehensive summary of the large number of contributions within this field. To cite a few results relevant to our contributions, Montufar et al. (2014) have shown that neural networks have exponential expressive power with respect to the depth while Poole et al. (2016) obtained similar results using a topological measure of expressiveness.
+
+We follow here the approach of Poole et al. (2016) and Schoenholz et al. (2017) by investigating the behaviour of random networks in the infinite-width and finite-variance i.i.d. weights context where they can be approximated by a Gaussian process as established by Matthews et al. (2018) and Lee et al. (2018).
+
+In this paper, our contribution is two-fold. Firstly, we provide an analysis complementing the results of Poole et al. (2016) and Schoenholz et al. (2017) and show that initializing a network with a specific choice of hyperparameters known as the ‘edge of chaos’ is linked to a deeper propagation of the information through the network. In particular, we establish that for a class of ReLU-like activation functions, the exponential depth scale introduced in Schoenholz et al. (2017) is replaced by a polynomial depth scale. This implies that the information can propagate deeper when the network is initialized on the edge of chaos. Secondly, we outline the limitations of ReLU-like activation functions by showing that, even on the edge of chaos, the limiting Gaussian Process admits a degenerate kernel as the number of layers goes to infinity. Our main result (4) gives sufficient conditions for activation functions to allow a good ‘information flow’ through the network (Proposition 4) (in addition to being non-polynomial and not suffering from the exploding/vanishing gradient problem). These conditions are satisfied by the Swish activation $\phi _ { s w i s h } ( x ) = x$ · sigmoid $( x )$ used in Hendrycks & Gimpel (2016),
+
+Elfwing et al. (2017) and Ramachandran et al. (2017). In recent work, Ramachandran et al. (2017) used automated search techniques to identify new activation functions and found experimentally that functions of the form $\phi ( x ) = \overset { \cdot } { x } \cdot \mathrm { s i g m o i d } ( \overset { \cdot } { \beta } x )$ appear to perform indeed better than many alternative functions, including ReLU. Our paper provides a theoretical grounding for these results. We also complement previous empirical results by illustrating the benefits of an initialization on the edge of chaos in this context. All proofs are given in the Supplementary Material.
+
+# 2 ON GAUSSIAN PROCESS APPROXIMATIONS OF NEURAL NETWORKS AND THEIR STABILITY
+
+# 2.1 SETUP AND NOTATIONS
+
+We use similar notations to those of Poole et al. (2016) and Lee et al. (2018). Consider a fully connected random neural network of depth $L$ , widths $( N _ { l } ) _ { 1 \leq l \leq L }$ , weights $\begin{array} { r } { { W _ { i j } ^ { l } } \stackrel { i i d } { \sim } \mathcal { N } ( 0 , \frac { { \sigma _ { w } ^ { 2 } } } { { N _ { l - 1 } } } ) } \end{array}$ and bias $B _ { i } ^ { l } \stackrel { i i d } { \sim } \mathcal { N } ( 0 , \sigma _ { b } ^ { 2 } )$ , where ${ \mathcal { N } } ( \mu , \sigma ^ { 2 } )$ denotes the normal distribution of mean $\mu$ and variance $\sigma ^ { 2 }$ . For some input $a \in \mathbb { R } ^ { d }$ , the propagation of this input through the network is given for an activation function $\phi : \mathbb { R }  \mathbb { R }$ by
+
+$$
+y _ { i } ^ { 1 } ( a ) = \sum _ { j = 1 } ^ { d } W _ { i j } ^ { 1 } a _ { j } + B _ { i } ^ { 1 } , \quad y _ { i } ^ { l } ( a ) = \sum _ { j = 1 } ^ { N _ { l - 1 } } W _ { i j } ^ { l } \phi ( y _ { j } ^ { l - 1 } ( a ) ) + B _ { i } ^ { l } , \quad \mathrm { f o r } l \ge 2 .
+$$
+
+Throughout the paper we assume that for all $l$ the processes $y _ { i } ^ { l } ( . )$ are independent (across $i$ ) centred Gaussian processes with covariance kernels $\kappa ^ { l }$ and write accordingly $y _ { i } ^ { l } \overset { i n d } { \sim } g \mathcal { P } ( 0 , \kappa ^ { l } )$ . This is an idealized version of the true processes corresponding to choosing $N _ { l - 1 } = + \infty$ (which implies, using Central Limit Theorem, that $y _ { i } ^ { l } ( a )$ is a Gaussian variable for any input $a$ ). The approximation of $y _ { i } ^ { l } ( . )$ by a Gaussian process was first proposed by Neal (1995) in the single layer case and has been recently extended to the multiple layer case by Lee et al. (2018) and Matthews et al. (2018). We recall here the expressions of the limiting Gaussian process kernels. For any input $a \in \mathbb { R } ^ { d }$ , $\mathbb { E } [ y _ { i } ^ { l } ( a ) ] = 0$ so that for any inputs $a , b \in \mathbb { R } ^ { d }$
+
+$$
+\begin{array} { r l } & { \kappa ^ { l } ( a , b ) = \mathbb { E } [ y _ { i } ^ { l } ( a ) y _ { i } ^ { l } ( b ) ] = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } _ { y _ { i } ^ { l - 1 } \sim G P ( 0 , \kappa ^ { l - 1 } ) } [ \phi ( y _ { i } ^ { l - 1 } ( a ) ) \phi ( y _ { i } ^ { l - 1 } ( b ) ) ] } \\ & { \quad \quad \quad \quad \quad \quad = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } F _ { \phi } ( \kappa ^ { l - 1 } ( a , a ) , \kappa ^ { l - 1 } ( a , b ) , \kappa ^ { l - 1 } ( b , b ) ) , } \end{array}
+$$
+
+where $F _ { \phi }$ is a function that depends only on $\phi$ . This gives a recursion to calculate the kernel $\kappa ^ { l }$ ; see, e.g., Lee et al. (2018) for more details. We can also express the kernel $\kappa ^ { l }$ in terms of the correlation $c _ { a b } ^ { l ^ { - } }$ in the ${ l ^ { t h } }$ layer used in the rest of this paper
+
+q $\mathbf \Lambda _ { a b } ^ { l } : = \kappa ^ { l } ( a , b ) = \mathbb { E } [ y _ { i } ^ { l } ( a ) y _ { i } ^ { l } ( b ) ] = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( \sqrt { q _ { a } ^ { l - 1 } } Z _ { 1 } ) \phi ( \sqrt { q _ { b } ^ { l - 1 } } ( c _ { a b } ^ { l - 1 } Z _ { 1 } + \sqrt { 1 - ( c _ { a b } ^ { l - 1 } ) ^ { 2 } } Z _ { 2 } ) ) ]$ where $q _ { a } ^ { l - 1 } : = q _ { a a } ^ { l - 1 }$ , resp. $c _ { a b } ^ { l - 1 } : = q _ { a b } ^ { l - 1 } / \sqrt { q _ { a } ^ { l - 1 } q _ { b } ^ { l - 1 } }$ , is the variance, resp. correlation, in the $( l - 1 ) ^ { t h }$ layer and $Z _ { 1 } , Z _ { 2 }$ are independent standard Gaussian random variables. when it propagates through the network. $q _ { a } ^ { l }$ is updated through the layers by the recursive formula $q _ { a } ^ { l } = F ( q _ { a } ^ { l - 1 } )$ , where $F$ is the ‘variance function’ given by
+
+$$
+F ( x ) = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( { \sqrt { x } } Z ) ^ { 2 } ] , \quad { \mathrm { w h e r e } } \quad Z \sim { \mathcal { N } } ( 0 , 1 ) .
+$$
+
+Throughout the paper, $Z , Z _ { 1 } , Z _ { 2 }$ will always denote independent standard Gaussian variables.
+
+# 2.2 LIMITING BEHAVIOUR OF THE VARIANCE AND COVARIANCE OPERATORS
+
+We analyze here the limiting behaviour of $q _ { a } ^ { L }$ and $c _ { a , b } ^ { L }$ as the network depth $L$ goes to infinity under the assumption that $\phi$ has a second derivative at least in the distribution sense1. From now onwards, we will also assume without loss of generality that $c _ { a b } ^ { 1 } \geq 0$ (similar results can be obtained straightforwardly when $c _ { a b } ^ { 1 } \leq 0 .$ ). We first need to define the Domains of Convergence associated with an activation function $\phi$ .
+
+![](images/67ba9471ecfa4d946636702278bad8657163cc6c2c83d792308784273a4ce982.jpg)  
+Figure 1: Two draws of outputs for ReLU and Tanh networks with $( \sigma _ { b } , \sigma _ { w } ) = ( 1 , 1 ) \in D _ { \phi , v a r } \cap$ $D _ { \phi , c o r r }$ . The output functions are almost constant.
+
+Definition 1. Let $\phi$ be an activation function, $( \sigma _ { b } , \sigma _ { w } ) \in ( \mathbb R ^ { + } ) ^ { 2 }$ (i) ${ \mathrm { ~ , ~ } } ( \sigma _ { b } , \sigma _ { w } )$ is in $D _ { \phi , v a r }$ (domain of convergence for the variance) if there exists $K > 0 , q \ge 0$ such that for any input a with $q _ { a } ^ { 1 } \leq K$ , $\begin{array} { r } { \operatorname* { l i m } _ { l \to \infty } q _ { a } ^ { l } = q } \end{array}$ . We denote by $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } )$ the maximal $K$ satisfying this condition.
+
+(ii) $\left( \sigma _ { b } , \sigma _ { w } \right)$ is in $D _ { \phi , c o r r }$ (domain of convergence for the correlation) if there exists $K > 0$ such that for any two inputs $a , b$ with $q _ { a } ^ { 1 } , q _ { b } ^ { 1 } \leq K$ , $\begin{array} { r } { \operatorname* { l i m } _ { l \to \infty } c _ { a b } ^ { l } = 1 } \end{array}$ . We denote by $K _ { \phi , c o r r } ( \sigma _ { b } , \sigma _ { w } )$ the maximal $K$ satisfying this condition.
+
+Remark : Typically, $q$ in Definition 1 is a fixed point of the variance function defined in equation 2. Therefore, it is easy to see that for any $\left( \sigma _ { b } , \sigma _ { w } \right)$ such that $F$ is increasing and admits at least one fixed point, we have $K _ { \phi , c o r r } ( \sigma _ { b } , \sigma _ { w } ) \ge q$ where $q$ is the minimal fixed point; i.e. $q : = \operatorname* { m i n } \{ x : F ( x ) = x \}$ . Thus, if we re-scale the input data to have $q _ { a } ^ { 1 } \leq q$ , the variance $q _ { a } ^ { l }$ converges to $q$ . We can also re-scale the variance $\sigma _ { w }$ of the first layer (only) to assume that $q _ { a } ^ { 1 } \leq q$ for all inputs $a$ .
+
+The next result gives sufficient conditions on $\left( \sigma _ { b } , \sigma _ { w } \right)$ to be in the domains of convergence of $\phi$ .
+
+Proposition 1. Let $\begin{array} { r } { M _ { \phi } : = \mathrm { s u p } _ { x \geq 0 } \mathbb { E } [ | \phi ^ { \prime 2 } ( x Z ) + \phi ^ { \prime \prime } ( x Z ) \phi ( x Z ) | ] } \end{array}$ . Assume $M _ { \phi } < \infty$ , then for $\begin{array} { r } { \sigma _ { w } ^ { 2 } < \frac { 1 } { M _ { \phi } } } \end{array}$ and any $\sigma _ { b }$ , we have $( \sigma _ { b } , \sigma _ { w } ) \in D _ { \phi , v a r }$ and $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$
+
+Let $\begin{array} { r } { C _ { \phi , \delta } : = \operatorname* { s u p } _ { x , y \geq 0 , | x - y | \leq \delta , c \in [ 0 , 1 ] } \mathbb { E } [ | \phi ^ { \prime } ( x Z _ { 1 } ) \phi ^ { \prime } ( y ( c Z _ { 1 } + \sqrt { 1 - c ^ { 2 } } Z _ { 2 } ) | ] } \end{array}$ . Assume $C _ { \phi , \delta } < \infty$ for some $\delta > 0$ , then for $\begin{array} { r } { \sigma _ { w } ^ { 2 } < \operatorname* { m i n } ( \frac { 1 } { M _ { \phi } } , \frac { 1 } { C _ { \phi } } ) } \end{array}$ and any $\sigma _ { b }$ , we have $( \sigma _ { b } , \sigma _ { w } ) \in D _ { \phi , v a r } \cap D _ { \phi , c o r r }$ and $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = K _ { \phi , c o r r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$ .
+
+The proof of Proposition 1 is straightforward. We prove that $\operatorname* { s u p } F ^ { \prime } ( x ) = \sigma _ { w } ^ { 2 } M _ { \phi }$ and then apply the Banach fixed point theorem; similar ideas are used for $C _ { \phi , \delta }$ .
+
+Example : For ReLU activation function, we have $M _ { R e L U } = 2$ and $C _ { R e L U , \delta } \leq 1$ for any $\delta > 0$
+
+In the domain of convergence $D _ { \phi , v a r } \cap D _ { \phi , c o r r }$ , for all $a , b \in \mathbb { R } ^ { d }$ , $y _ { i } ^ { \infty } ( a ) = y _ { i } ^ { \infty } ( b )$ almost surely and the outputs of the network are constant functions. Figure 1 illustrates this behaviour for $d = 2$ for ReLU and Tanh using a network of depth $L = 1 0$ with $N _ { l } = 1 0 0$ neurons per layer. The draws of outputs of these networks are indeed almost constant.
+
+To refine this convergence analysis, Schoenholz et al. (2017) established the existence of $\epsilon _ { q }$ and $\epsilon _ { c }$ such that $| q _ { a } ^ { l } - q | \sim e ^ { - l / \epsilon _ { q } }$ and $| c _ { a b } ^ { l } - 1 | \sim e ^ { - l / \epsilon _ { c } }$ when fixed points exist. The quantities $\epsilon _ { q }$ and $\epsilon _ { c }$ are called ‘depth scales’ since they represent the depth to which the variance and correlation can propagate without being exponentially close to their limits. More precisely, if we write $\chi _ { 1 } = \sigma _ { w } ^ { 2 } \mathbb { E } [ \bar { \phi ^ { \prime } } ( \bar { \sqrt { q } } \bar { Z } ) ^ { 2 } ]$ and $\alpha = \chi _ { 1 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime \prime } ( \sqrt { q } Z ) \phi ( \sqrt { q } Z ) ]$ then the depth scales are given by $\epsilon _ { r } = - \log ( \alpha ) ^ { - 1 }$ and $\epsilon _ { c } = - \log ( \chi _ { 1 } ) ^ { - 1 }$ . The equation $\chi _ { 1 } = 1$ corresponds to an infinite depth scale of the correlation. It is called the edge of chaos as it separates two phases: an ordered phase where the correlation converges to 1 if $\chi _ { 1 } < 1$ and a chaotic phase where $\chi _ { 1 } > 1$ and the correlations do not converge to 1. In this chaotic regime, it has been observed in Schoenholz et al. (2017) that the correlations converge to some random value $c < 1$ when $\phi ( x ) = \mathrm { T a n h } ( x )$ and that $c$ is independent of the correlation between the inputs. This means that very close inputs (in terms of correlation) lead to very different outputs. Therefore, in the chaotic phase, the output function of the neural network is non-continuous everywhere.
+
+Definition 2. For $( \sigma _ { b } , \sigma _ { w } ) \in D _ { \phi , v a r }$ , let q be the limiting variance2. The Edge of Chaos, hereafter EOC, is the set of values of $\left( \sigma _ { b } , \sigma _ { w } \right)$ satisfying $\chi _ { 1 } = \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime } ( \sqrt { q } Z ) ^ { 2 } ] = 1$ .
+
+To further study the EOC regime, the next lemma introduces a function $f$ called the ‘correlation function’ simplifying the analysis of the correlations. It states that the correlations have the same asymptotic behaviour as the time-homogeneous dynamical system $c _ { a b } ^ { l + 1 } = f ( c _ { a b } ^ { l } )$ .
+
+Lemma 1. Let $( \sigma _ { b } , \sigma _ { w } ) \in D _ { \phi , v a r } \cap D _ { \phi , c o r r }$ such that $q > 0$ , $a , b \in \mathbb { R } ^ { d }$ and $\phi$ an activation function such that $\begin{array} { r } { \operatorname* { s u p } _ { x \in S } \mathbb { E } [ \phi ( x Z ) ^ { 2 } ] < \infty } \end{array}$ for all compact sets √ $S$ . Define $f _ { l }$ by $c _ { a b } ^ { l + 1 } = f _ { l } ( c _ { a b } ^ { l } )$ and $f$ by $\begin{array} { r } { f ( x ) = \frac { \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( \sqrt { q } Z _ { 1 } ) \phi ( \sqrt { q } ( x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } ) ) } { q } } \end{array}$ . Then $\begin{array} { r } { \operatorname* { l i m } _ { l  \infty } \operatorname* { s u p } _ { x \in [ 0 , 1 ] } | f _ { l } ( x ) - f ( x ) | = 0 . } \end{array}$
+
+The condition on $\phi$ in Lemma 1 is violated only by activation functions with exponential growth (which are not used in practice), so from now onwards, we use this approximation in our analysis. Note that being on the EOC is equivalent to $( \sigma _ { b } , \sigma _ { w } )$ satisfying $f ^ { \prime } ( 1 ) = 1$ . In the next section, we analyze this phase transition carefully for a large class of activation functions.
+
+# 3 EDGE OF CHAOS
+
+To illustrate the effect of the initialization on the EOC, we plot in Figure 2 the output of a ReLU neural network with 20 layers and 100 neurons per layer with parameters $( \sigma _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( \mathsf { \bar { 0 } } , 2 )$ (as we will see later $\mathrm { E O C } = \{ ( 0 , \sqrt { 2 } ) \}$ for ReLU). Unlike the output in Figure 1, this output displays much more variability. However, we will prove here that the correlations still converges to 1 even in the EOC regime, albeit at a slower rate.
+
+# 3.1 RELU-LIKE ACTIVATION FUNCTIONS
+
+![](images/227bb801e09b15a5209fdb1053b023bb8f21040bdf297f460a1bf93f25faa361.jpg)  
+Figure 2: A draw from the output function of a ReLu network with 20 layers, 100 neurons per layer, $( \sigma _ { b } ^ { 2 } , \bar { \sigma _ { w } ^ { 2 } } ) = ( 0 , 2 )$ (edge of chaos)
+
+We consider activation functions $\phi$ of the form: $\phi ( x ) = \lambda x$ if $x > 0$ and $\phi ( x ) = \beta x$ if $x \leq 0$ . ReLU corresponds to $\lambda = 1$ and $\beta = 0$ . For this class of activation functions, we see (Proposition 2) that the variance is unchanged $( q _ { a } ^ { l } = q _ { a } ^ { 1 } )$ on the EOC, so that $q$ does not formally exist in the sense that the limit of $q _ { a } ^ { l }$ depends on $a$ . However, this does not impact the analysis of the correlations.
+
+Proposition 2. Let $\phi$ be a ReLU-like function with $\lambda$ and $\beta$ defined above. Then for any $\begin{array} { r } { \sigma _ { w } < \sqrt { \frac { 2 } { \lambda ^ { 2 } + \beta ^ { 2 } } } } \end{array}$ and $\sigma _ { b } \geq 0$ , we have $( \sigma _ { b } , \sigma _ { w } ) \in D _ { \phi , v a r }$ with $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$ . Moreover $\begin{array} { r } { E O C = \{ ( 0 , \frac { 1 } { \sqrt { \mathbb { E } [ \phi ^ { \prime } ( Z ) ^ { 2 } ] } } ) \} } \end{array}$ , √ 1E[φ0(Z)2] )} and, on the EOC, F (x) = x for any $x \geq 0$ .
+
+This class of activation functions has the interesting property of preserving the variance across layers when the network is initialized on the EOC. However, we show in Proposition 3 below that, even in the EOC regime, the correlations converge to 1 but at a slower rate. We only present the result for ReLU but the generalization to the whole class is straightforward.
+
+Example : ReLU: The EOC is reduced to the singleton $( \sigma _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( 0 , 2 )$ , which means we should initialize a ReLU network with the parameters $( \bar { \sigma } _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( \bar { 0 } , 2 )$ . This result coincides with the recommendation of He et al. (2015) whose objective was to make the variance constant as the input propagates but did not analyze the propagation of the correlations. Klambauer et al. (2017) also performed a similar analysis by using the "Scaled Exponential Linear Unit" activation (SELU) that makes it possible to center the mean and normalize the variance of the post-activation $\phi ( y )$ . The propagation of the correlation was not discussed therein either. In the next result, we present the correlation function corresponding to ReLU networks. This was first obtained in Cho & Saul (2009). We present an alternative derivation of this result and further show that the correlations converge to 1 at a polynomial rate of $1 / l ^ { 2 }$ instead of an exponential rate.
+
+![](images/b561b5a725551310ac9febadaa8763a49c33b898c38663d2947bf188813e15c1.jpg)  
+Figure 3: Impact of the initialization on the EOC for a ReLU network
+
+Proposition 3 (ReLU kernel). Consider a ReLU network with parameters $( \sigma _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( 0 , 2 )$ on the EOC.We have
+
+Figure 3 displays the correlation function $f$ with two different sets of parameters $( \sigma _ { b } , \sigma _ { w } )$ . The red graph corresponds to the EOC $( \sigma _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( 0 , 2 )$ , and the blue one corresponds to an ordered phase $( \bar { \sigma } _ { b } , \bar { \sigma } _ { w } ) = ( \bar { 1 } , 1 )$ . In unreported experiments, we observed that numerical convergence towards 1 for $l \geq 5 0$ on the EOC. As the variance $q _ { a } ^ { l }$ is preserved by the network $( q _ { a } ^ { l } = q _ { a } ^ { 1 } = 2 \| a \| ^ { 2 } / d )$ and the correlations $c _ { a b } ^ { l }$ converge to 1 as $l$ increases, the output function is of the form $C \cdot \| a \|$ for a constant $C$ (notice that in Figure 2, we start observing this effect for depth 20).
+
+# 3.2 A BETTER CLASS OF ACTIVATION FUNCTIONS
+
+We now introduce a set of sufficient conditions for activation functions which ensures that it is then possible to tune $\left( \sigma _ { b } , \sigma _ { w } \right)$ to slow the convergence of the correlations to 1. This is achieved by making the correlation function $f$ sufficiently close to the identity function.
+
+Proposition 4 (Main Result). Let $\phi$ be an activation function. Assume that   
+(i) $\phi ( 0 ) = 0$ , and $\phi$ has right and left derivatives in zero and $\phi ^ { \prime } ( 0 ^ { + } ) \neq 0$ or $\phi ^ { \prime } ( 0 ^ { - } ) \neq 0$ , and there exists $k > 0$ such that $\big | \frac { \phi ( x ) } { x } \big | \leq k$ .   
+(ii) There exists $A > 0$ such that for any $\sigma _ { b } \in [ 0 , A ]$ , there exists $\sigma _ { w } > 0$ such that $( \sigma _ { b } , \sigma _ { w } ) \in E O C$ . (iii) For any $\sigma _ { b } \in [ 0 , A ]$ , the function $F$ with parameters $( \sigma _ { b } , \sigma _ { w } ) \in E O C$ is non-decreasing and $\scriptstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q = 0$ where $q$ is the minimal fixed point of $F$ , $q : = \operatorname* { i n f } \{ x : F ( x ) = x \}$ .   
+$( i \nu )$ For any $\sigma _ { b } \in [ 0 , A ]$ , the correlation function $f$ with parameters $( \sigma _ { b } , \sigma _ { w } ) \in E O C$ introduced in Lemma $^ { l }$ is convex.
+
+Then, for any $\sigma _ { b } \in [ 0 , A ]$ , we have $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) \ge q$ , and
+
+$$
+\operatorname* { l i m } _ { \sigma _ { b } \to 0 } \operatorname* { s u p } _ { x \in [ 0 , 1 ] } | f ( x ) - x | = 0 .
+$$
+
+Note that ReLU does not satisfy the condition $( i i )$ since the EOC in this case is the singleton $( \sigma _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( 0 , 2 )$ . The result of Proposition 4 states that we can make $f ( x )$ close to $x$ by considering $\sigma _ { b } \  \ 0$ . However, this is under condition $( i i i )$ which states that $\textstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q \ = \ 0$ . Therefore, practically, we cannot take $\sigma _ { b }$ too small. One might wonder whether condition $( i i i )$ is necessary for this result to hold. The next lemma shows that removing this condition results in a useless class of activation functions.
+
+![](images/2c52e8ca7c9650fb6981180040517400bd14ed471e430e501603d0e81e0fd882.jpg)
+
+(a) The correlation function $f$ of a Swish network for different values of $\sigma _ { b }$
+
+![](images/4fddc8b8d1192b827546854ef5e42088eb4844a2a488f6e319586405c4f4307b.jpg)  
+(b) A draw from the output function of a Swish network with depth 30 and width 100 on the edge of chaos for   
+Figure 4: Correlation function and a draw of the output for a Swish network
+
+Lemma 2. Under the conditions of Proposition 4, the only change being $\textstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q > 0$ , the result of Proposition 4 holds if only if the activation function is linear.
+
+The next proposition gives sufficient conditions for bounded activation functions to satisfy all the conditions of Proposition 4.
+
+Proposition 5. Let $\phi$ be a bounded function such that $\phi ( 0 ) = 0$ , $\phi ^ { \prime } ( 0 ) > 0$ , $\phi ^ { \prime } ( x ) \geq 0$ , $\phi ( - x ) =$ $- \phi ( x )$ , $x \phi ( x ) > 0$ and $x \phi ^ { \prime \prime } ( x ) < 0$ for $x \neq 0$ , and $\phi$ satisfies (ii) in Proposition 4. Then, $\phi$ satisfies all the conditions of Proposition 4.
+
+The conditions in Proposition 5 are easy to verify and are, for example, satisfied by Tanh and Arctan. We can also replace the assumption " $" \phi$ satisfies (ii) in Proposition $4 "$ by a sufficient condition (see Proposition 7 in the Supplementary Material). Tanh-like activation functions provide better information flow in deep networks compared to ReLU-like functions. However, these functions suffer from the vanishing gradient problem during back-propagation; see, e.g., Pascanu et al. (2013) and Kolen & Kremer (2001). Thus, an activation function that satisfies the conditions of Proposition 4 (in order to have a good ’information flow’) and does not suffer from the vanishing gradient issue is expected to perform better than ReLU. Swish is a good candidate.
+
+Proposition 6. The Swish activation function $\begin{array} { r } { \phi _ { s w i s h } ( x ) = x \cdot s i g m o i d ( x ) = \frac { x } { 1 + e ^ { - x } } } \end{array}$ satisfies all the conditions of Proposition 4.
+
+It is clear that Swish does not suffer from the vanishing gradient problem as it has a gradient close to 1 for large inputs like ReLU. Figure 4 (a) displays $f$ for Swish for different values of $\sigma _ { b }$ . We see that $f$ is indeed approaching the identity function when $\sigma _ { b }$ is small, preventing the correlations from converging to 1. Figure 4(b) displays a draw of the output of a neural network of depth 30 and width 100 with Swish activation, and $\sigma _ { b } = 0 . 2$ . The outputs displays much more variability than the ones of the ReLU network with the same architecture. We present in Table 1 some values of $\left( \sigma _ { b } , \sigma _ { w } \right)$ on the EOC as well as the corresponding limiting variance for Swish. As condition $( i i i )$ of Proposition 4 is satisfied, the limiting variance $q$ decreases with $\sigma _ { b }$ .
+
+Table 1: Values of $\left( \sigma _ { b } , \sigma _ { w } \right)$ on the EOC and limiting variance $q$ for Swish   
+
+<table><tr><td>Jb</td><td>0.1</td><td>0.2</td><td>0.3</td><td>0.4</td><td>0.5</td></tr><tr><td>w</td><td>1.845</td><td>1.718</td><td>1.616</td><td>1.537</td><td>1.485</td></tr><tr><td>q</td><td>0.14</td><td>0.44</td><td>0.61</td><td>1.01</td><td>2.13</td></tr></table>
+
+Other activation functions that have been shown to outperform empirically ReLU such as ELU (Clevert et al. (2016)), SELU (Klambauer et al. (2017)) and Softplus also satisfy the conditions of Proposition 4 (see Supplementary Material for ELU). The comparison of activation functions satisfying the conditions of Proposition 4 remains an open question.
+
+# 4 EXPERIMENTAL RESULTS
+
+We demonstrate empirically our results on the MNIST dataset. In all the figures below, we compare the learning speed (test accuracy with respect to the number of epochs/iterations) for different activation functions and initialization parameters. We use the Adam optimizer with learning rate $\mathbf { l r } = 0 . 0 0 1$ . The Python code to reproduce all the experiments will be made available on-line.
+
+Initialization on the Edge of Chaos We initialize randomly the deep network by sampling $W _ { i j } ^ { l } \stackrel { i i d } { \sim }$ $\mathcal { N } ( 0 , \sigma _ { w } ^ { 2 } / N _ { l - 1 } )$ and $B _ { i } ^ { l } \overset { i i d } { \sim } \mathcal { N } ( 0 , \sigma _ { b } ^ { 2 } )$ . In Figure 5, we compare the learning speed of a Swish network for different choices of random initialization. Any initialization other than on the edge of chaos results in the optimization algorithm being stuck eventually at a very poor test accuracy of $\sim 0 . 1$ as the depth $L$ increases (equivalent to selecting the output uniformly at random). To understand what is happening in this case, let us recall how the optimization algorithm works. Let $\{ ( X _ { i } , Y _ { i } ) , 1 \leq i \leq N \}$ be the MNIST dataset. The loss we optimize is given by $\begin{array} { r } { \mathcal { L } ( w , b ) = \sum _ { i = 1 } ^ { N } \ell ( y ^ { L } ( X _ { i } ) , Y _ { i } ) / N } \end{array}$ where $y ^ { L } ( x )$ is the output of the network, and $\ell$ is the categorical cross-entropy loss. In the ordered phase, we know that the output converges exponentially to a fixed value (same value for all $X _ { i }$ ), thus a small change in $w$ and $b$ will not change significantly the value of the loss function, therefore the gradient is approximately zero and the gradient descent algorithm will be stuck around the initial value.
+
+![](images/efaa881563f0962ee53a7d2dd5064e0ba71fe98dcd7e8d5cbe738619d65835cc.jpg)  
+Figure 5: Impact of the initialization on the edge of chaos for Swish network
+
+ReLU versus Tanh We proved in Section 3.2 that the Tanh activation guarantees better information propagation through the network when initialized on the EOC. However, Tanh suffers
+
+![](images/90b381d8088acb02fa69f71a50ef1959e721d6fe23d7e8eb3e19ccb898a5bc83.jpg)  
+Figure 6: Comparaison of ReLu and Tanh learning curves for different widths and depths
+
+from the vanishing gradient problem. Consequently, we expect Tanh to perform better than ReLU for shallow networks as opposed to deep networks, where the problem of the vanishing gradient is not encountered. Numerical results confirm this fact. Figure 6 shows curves of validation accuracy with confidence interval $9 0 \%$ (30 simulations). For depth 5, the learning algorithm converges faster for Tanh compared to ReLu. However, for deeper networks $L \geq 4 0 ) ,$ ), Tanh is stuck at a very low test accuracy, this is due to the fact that a lot of parameters remain essentially unchanged because the gradient is very small.
+
+ReLU versus Swish As established in Section 3.2, Swish, like Tanh, propagates the information better than ReLU and, contrary to Tanh, it does not suffer from the vanishing gradient problem. Hence our results suggest that Swish should perform better than ReLU, especially for deep architectures. Numerical results confirm this fact. Figure 7 shows curves of validation accuracy with confidence interval $9 0 \%$ (30 simulations). Swish performs clearly better than ReLU especially for depth 40. A comparative study of final accuracy is shown in Table 2. We observe a clear advantage for Swish, especially for large depths. Additional simulations results on diverse datasets demonstrating better performance of Swish over many other activation functions can be found in Ramachandran et al. (2017) (Notice that these authors have already implemented Swish in Tensorflow).
+
+![](images/979885afdba59d50b929b7fd51a2d90a3bfd77ad0071b79dd3be779dcf9f0384.jpg)  
+Figure 7: Convergence across iterations of the learning algorithm for ReLU and Swish networks
+
+Table 2: Accuracy on test set for different values of (width, depth)   
+
+<table><tr><td></td><td>(10,5)</td><td>(20,10)</td><td>(40,30)</td><td>(60,40)</td></tr><tr><td>ReLU</td><td>94.01</td><td>96.01</td><td>96.51</td><td>91.45</td></tr><tr><td>Swish</td><td>94.46</td><td>96.34</td><td>97.09</td><td>97.14</td></tr></table>
+
+# 5 CONCLUSION AND DISCUSSION
+
+We have complemented here the analysis of Schoenholz et al. (2017) which shows that initializing networks on the EOC provides a better propagation of information across layers. In the ReLU case, such an initialization corresponds to the popular approach proposed in He et al. (2015). However, even on the EOC, the correlations still converge to 1 at a polynomial rate for ReLU networks. We have obtained a set of sufficient conditions for activation functions which further improve information propagation when the parameters $\left( \sigma _ { b } , \sigma _ { w } \right)$ are on the EOC. The Tanh activation satisfied those conditions but, more interestingly, other functions which do not suffer from the vanishing/exploding gradient problems also verify them. This includes the Swish function used in Hendrycks & Gimpel (2016), Elfwing et al. (2017) and promoted in Ramachandran et al. (2017) but also ELU Clevert et al. (2016).
+
+Our results have also interesting implications for Bayesian neural networks which have received renewed attention lately; see, e.g., Hernandez-Lobato $\&$ Adams (2015) and Lee et al. (2018). They show that if one assigns i.i.d. Gaussian prior distributions to the weights and biases, the resulting prior distribution will be concentrated on close to constant functions even on the EOC for ReLU-like activation functions. To obtain much richer priors, our results indicate that we need to select not only parameters $\left( \sigma _ { b } , \sigma _ { w } \right)$ on the EOC but also an activation function satisfying Proposition 4.
+
+# REFERENCES
+
+Y. Cho and L.K. Saul. Kernel methods for deep learning. Advances in Neural Information Processing Systems, 22:342–350, 2009.   
+D.A. Clevert, T. Unterthiner, and S. Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). International Conference on Learning Representations, 2016.   
+S. Elfwing, E. Uchibe, and K. Doya. Sigmoid-weighted linear units for neural network function approximation in reinforcement learning. arXiv:1702.03118, 2017.   
+K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. ICCV, 2015.   
+D.. Hendrycks and K. Gimpel. Bridging nonlinearities and stochastic regularizers with gaussian error linear units. arXiv:1606.08415, 2016.   
+J. M. Hernandez-Lobato and R.P. Adams. Probabilistic backpropagation for scalable learning of bayesian neural networks. ICML, 2015.   
+G. Klambauer, T. Unterthiner, and A. Mayr. Self-normalizing neural networks. Advances in Neural Information Processing Systems, 30, 2017.   
+J.F. Kolen and S.C. Kremer. Gradient flow in recurrent nets: The difficulty of learning longterm dependencies. A Field Guide to Dynamical Recurrent Network, Wiley-IEEE Press, pp. 464–, 2001.   
+Y. LeCun, L. Bottou, G. Orr, and K. Muller. Efficient backprop. Neural Networks: Tricks of the trade, Springer, 1998.   
+J. Lee, Y. Bahri, R. Novak, S.S. Schoenholz, J. Pennington, and J. Sohl-Dickstein. Deep neural networks as gaussian processes. 6th International Conference on Learning Representations, 2018.   
+A.G. Matthews, J. Hron, M. Rowland, R.E. Turner, and Z. Ghahramani. Gaussian process behaviour in wide deep neural networks. 6th International Conference on Learning Representations, 2018.   
+G.F. Montufar, R. Pascanu, K. Cho, and Y. Bengio. On the number of linear regions of deep neural networks. Advances in Neural Information Processing Systems, 27:2924–2932, 2014.   
+R.M. Neal. Bayesian learning for neural networks. Springer Science & Business Media, 118, 1995.   
+R. Pascanu, T. Mikolov, and Y. Bengio. On the difficulty of training recurrent neural networks. Proceedings of the 30th International Conference on Machine Learning, 28:1310–1318, 2013.   
+B. Poole, S. Lahiri, M. Raghu, J. Sohl-Dickstein, and S. Ganguli. Exponential expressivity in deep neural networks through transient chaos. 30th Conference on Neural Information Processing Systems, 2016.   
+P. Ramachandran, B. Zoph, and Q.V. Le. Searching for activation functions. arXiv e-print 1710.05941, 2017.   
+S.S. Schoenholz, J. Gilmer, S. Ganguli, and J. Sohl-Dickstein. Deep information propagation. 5th International Conference on Learning Representations, 2017.
+
+# A PROOFS
+
+We provide in the supplementary material the proofs of the propositions presented in the main document, and we give additive theoretical and experimental results. For the sake of clarity we recall the propositions before giving their proofs.
+
+# A.1 CONVERGENCE TO THE FIXED POINT: PROPOSITION 1
+
+Proposition 1. Let $\begin{array} { r } { M _ { \phi } : = \operatorname* { s u p } _ { x \ge 0 } \mathbb { E } [ | \phi ^ { \prime 2 } ( x Z ) + \phi ^ { \prime \prime } ( x Z ) \phi ( x Z ) | ] } \end{array}$ . Suppose $M _ { \phi } < \infty$ , then for $\begin{array} { r } { \sigma _ { w } ^ { 2 } < \frac { 1 } { M _ { \phi } } } \end{array}$ and any $\sigma _ { b }$ , we have $( \sigma _ { b } , \sigma _ { w } ) \in D _ { \phi , v a r }$ and $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$
+
+Moreover, let $\begin{array} { r l r } { C _ { \phi , \delta } } & { : = } & { \operatorname* { s u p } _ { x , y \geq 0 , | x - y | \leq \delta , c \in [ 0 , 1 ] } \mathbb { E } [ | \phi ^ { \prime } ( x Z _ { 1 } ) \phi ^ { \prime } ( y ( c Z _ { 1 } + \sqrt { 1 - c ^ { 2 } } Z _ { 2 } ) | ] } \end{array}$ ]. Suppose $C _ { \phi , \delta } \ < \ \infty$ for some positive $\delta$ , then for $\begin{array} { r } { \sigma _ { w } ^ { 2 } \ < \ \operatorname* { m i n } ( \frac { 1 } { M _ { \phi } } , \frac { 1 } { C _ { \phi } } ) } \end{array}$ and any $\sigma _ { b }$ , we have $( \sigma _ { b } , \sigma _ { w } ) \in$ $D _ { \phi , v a r } \cap D _ { \phi , c o r r }$ and $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = K _ { \phi , c o r r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$ .
+
+Proof. To abbreviate the notation, we use $\boldsymbol { q } ^ { l } : = \boldsymbol { q } _ { a } ^ { l }$ for some fixed input a.
+
+Convergence of the variances: We first consider the asymptotic behaviour of $q ^ { l } = q _ { a } ^ { l }$ . Recall that $q ^ { l } = F \tilde { ( q ^ { l - 1 } ) }$ where,
+
+$$
+F ( x ) = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( { \sqrt { x } } Z ) ^ { 2 } ] .
+$$
+
+The first derivative of this function is given by:
+
+$$
+F ^ { \prime } ( x ) = \sigma _ { w } ^ { 2 } \mathbb { E } [ \frac { Z } { \sqrt { x } } \phi ^ { \prime } ( \sqrt { x } Z ) \phi ( \sqrt { x } Z ) ] = \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime } ( \sqrt { x } Z ) ^ { 2 } + \phi ^ { \prime \prime } ( \sqrt { x } Z ) \phi ( \sqrt { x } Z ) ]
+$$
+
+where we used Gaussian integration by parts $\mathbb { E } [ Z G ( Z ) ] = \mathbb { E } [ G ^ { \prime } ( Z ) ]$ , an identify satisfied by any function $G$ such that $\mathbb { E } [ | G ^ { \prime } ( Z ) | ] < \infty$ .
+
+Using the condition on $\phi$ , we see that for $\begin{array} { r } { \sigma _ { w } ^ { 2 } \ < \ \frac { 1 } { M _ { \phi } } } \end{array}$ , the function $F$ is a contraction mapping, and the Banach fixed-point theorem guarantees the existence of a unique fixed point $q$ of $F$ , with $\textstyle \operatorname* { l i m } _ { l \to + \infty } q ^ { l } = q$ . Note that this fixed point depends only on $F$ , therefore, this is true for any input $a$ , and $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$ .
+
+Convergence of the covariances: Since $M _ { \phi } < \infty$ , then for all $a , b \in \mathbb { R } ^ { d }$ there exists $l _ { 0 }$ such that, for all $l > l _ { 0 } , | \sqrt { q _ { a } ^ { l } } - \sqrt { q _ { b } ^ { l } } | < \delta$ . Let $l > l _ { 0 }$ , using Gaussian integration by parts, we have
+
+$$
+\frac { d c _ { a b } ^ { l + 1 } } { d c _ { a b } ^ { l } } = \sigma _ { w } ^ { 2 } \mathbb { E } [ | \phi ^ { \prime } ( \sqrt { q _ { a } ^ { l } } Z _ { 1 } ) \phi ^ { \prime } ( \sqrt { q _ { b } ^ { l } } ( c _ { a b } ^ { l } Z _ { 1 } + \sqrt { 1 - ( c _ { a b } ^ { l } ) ^ { 2 } } Z _ { 2 } ) | ] .
+$$
+
+We cannot use the Banach fixed point theorem directly because the integrated function here depends on $l$ through $q ^ { l }$ . For ease of notation, we write $c ^ { l } : = \dot { c } _ { a b } ^ { l }$ , we have
+
+$$
+| c ^ { l + 1 } - c ^ { l } | = | \int _ { c ^ { l - 1 } } ^ { c ^ { l } } \frac { d c ^ { l + 1 } } { d c ^ { l } } ( x ) d x | \le \sigma _ { w } ^ { 2 } C _ { \phi } | c ^ { l } - c ^ { l - 1 } | .
+$$
+
+Therefore, for $\begin{array} { r } { \sigma _ { w } ^ { 2 } < \operatorname* { m i n } \bigl ( \frac { 1 } { M _ { \phi } } , \frac { 1 } { C _ { \phi } } \bigr ) , } \end{array}$ $c ^ { l }$ is a Cauchy sequence and it converges to a limit $c \in [ 0 , 1 ]$ At the limit
+
+$$
+c = f ( c ) = \frac { \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( \sqrt { q } z _ { 1 } ) \phi ( \sqrt { q } ( c z _ { 1 } + \sqrt { 1 - c ^ { 2 } } z _ { 2 } ) ) ) ] } { q } ,
+$$
+
+The derivative of this function is given by
+
+$$
+f ^ { \prime } ( x ) = \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime } ( { \sqrt { q } } Z _ { 1 } ) \phi ^ { \prime } ( { \sqrt { q } } ( x Z _ { 1 } + { \sqrt { 1 - x } } Z _ { 2 } ) ]
+$$
+
+By assumption on $\phi$ and the choice of $\sigma _ { w }$ , we have $\begin{array} { r } { \operatorname* { s u p } _ { x } | f ^ { \prime } ( x ) | < 1 } \end{array}$ , so that $f$ is a contraction, and has a unique fixed point. Since $f ( 1 ) = 1$ , $c = 1$ . The above result is true for any $a , b$ , therefore, $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = \bar { K } _ { \phi , c o r r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$ . □
+
+As an illustration we plot in Figure 12 the variance for three different inputs with $( \sigma _ { b } , \sigma _ { w } ) = ( 1 , 1 )$ , as a function of the layer l. In this example, the convergence for Tanh is faster than that of ReLU.
+
+![](images/2a659e3f248b7002f1d1f26a057bc37f97be473666bff9d2326a11970e0e601b.jpg)  
+Figure 8: Convergence of the variance for three different inputs with $( \sigma _ { b } , \sigma _ { w } ) = ( 1 , 1 )$
+
+Lemma 1. Let $( \sigma _ { b } , \sigma _ { w } ) \in D _ { \phi , v a r } \cap D _ { \phi , c o r r }$ such that $q > 0$ , $a , b \in \mathbb { R } ^ { d }$ and $\phi$ an activation function such that $\begin{array} { r } { \operatorname* { s u p } _ { x \in K } \mathbb { E } [ \phi ( x Z ) ^ { 2 } ] < \infty } \end{array}$ for all compact sets $K$ . Define $f _ { l }$ by $c _ { a , b } ^ { l + 1 } = f _ { l } ( c _ { a , b } ^ { l } )$ and $f$ by $\begin{array} { r } { f ( x ) = \frac { \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( \sqrt { q } Z _ { 1 } ) \phi ( \sqrt { q } ( x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } ) ) } { q } } \end{array}$ . Then $\begin{array} { r } { \operatorname* { l i m } _ { l  \infty } \operatorname* { s u p } _ { x \in [ 0 , 1 ] } | f _ { l } ( x ) - f ( x ) | = 0 . } \end{array}$ .
+
+Proof. For $x \in [ 0 , 1 ]$ , we have
+
+$$
+\begin{array} { l } { \displaystyle f _ { l } ( x ) - f ( x ) = \big ( \frac { 1 } { \sqrt { q _ { a } ^ { l } q _ { b } ^ { l } } } - \frac { 1 } { q } \big ) \big ( \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi \big ( \sqrt { q _ { a } ^ { l } } Z _ { 1 } \big ) \phi \big ( \sqrt { q _ { b } ^ { l } } u _ { 2 } ( x ) \big ) ] \big ) } \\ { \displaystyle \qquad + \frac { \sigma _ { w } ^ { 2 } } { q } \big ( \mathbb { E } [ \phi \big ( \sqrt { q _ { a } ^ { l } } Z _ { 1 } \big ) \phi \big ( \sqrt { q _ { b } ^ { l } } u _ { 2 } ( x ) \big ) ] - \mathbb { E } [ \phi \big ( \sqrt { q } Z _ { 1 } \big ) \phi ( \sqrt { q } u _ { 2 } ( x ) \big ) ] \big ) , } \end{array}
+$$
+
+where $u _ { 2 } ( x ) : = x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 }$ . The first term goes to zero uniformly in $x$ using the condition on $\phi$ and Cauchy-Schwartz inequality. As for the second term, it can be written as
+
+$$
+\mathbb { E } [ ( \phi ( \sqrt { q _ { a } ^ { l } } Z _ { 1 } ) - \phi ( \sqrt { q } Z _ { 1 } ) ) \phi ( \sqrt { q _ { b } ^ { l } } u _ { 2 } ( x ) ) ] + \mathbb { E } [ \phi ( \sqrt { q } Z _ { 1 } ) ( \phi ( \sqrt { q _ { b } ^ { l } } u _ { 2 } ( x ) ) - \phi ( \sqrt { q } u _ { 2 } ( x ) ) ) ]
+$$
+
+again, using Cauchy-Schwartz and the condition on $\phi$ , both terms can be controlled uniformly in $x$ by an integrable upper bound. We conclude using the Dominated convergence. □
+
+A.2 RESULTS FOR RELU-LIKE ACTIVATION FUNCTIONS: PROOF OF PROPOSITIONS 2 AND 3
+
+Proposition 2. Let $\phi$ be a ReLU-like function with $\lambda$ and $\beta$ defined above. Then for any $\sigma _ { w } \ <$ q 2λ2+β2 and σb ≥ 0, we have (σb, σw) ∈ Dφ,var with Kφ,var(σb, σw) = ∞. Moreover EOC = $\big \{ ( 0 , \frac { 1 } { \sqrt { \mathbb { E } [ \phi ^ { \prime } ( Z ) ^ { 2 } ] } } ) \big \}$ and, on the EOC, $F ( x ) = x$ for any $x \geq 0$ .
+
+Proof. We write $q ^ { l } = q _ { a } ^ { l }$ throughout the proof. Note first that the variance satisfies the recursion:
+
+$$
+q ^ { l + 1 } = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( Z ) ^ { 2 } ] q ^ { l } = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \frac { \lambda ^ { 2 } + \beta ^ { 2 } } { 2 } q ^ { l } .
+$$
+
+For all $\begin{array} { r } { \sigma _ { w } < \sqrt { \frac { 2 } { \lambda ^ { 2 } + \beta ^ { 2 } } } } \end{array}$ , $q = \sigma _ { b } ^ { 2 } \left( 1 - \sigma _ { w } ^ { 2 } ( \lambda ^ { 2 } + \beta ^ { 2 } ) / 2 \right) ^ { - 1 }$ is a fixed point. This is true for any input, therefore $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) = \infty$ and (i) is proved.
+
+Now, the EOC equation is given by $\begin{array} { r } { \chi _ { 1 } = \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime } ( Z ) ^ { 2 } ] = \sigma _ { w } ^ { 2 } \frac { \lambda ^ { 2 } + \beta ^ { 2 } } { 2 } } \end{array}$ . Therefore, σ2w $\begin{array} { r } { \sigma _ { w } ^ { 2 } = \frac { 2 } { \lambda ^ { 2 } + \beta ^ { 2 } } } \end{array}$ . Replacing $\sigma _ { w } ^ { 2 }$ by its critical value in equation 4 yields
+
+$$
+\begin{array} { r } { q ^ { l + 1 } = \sigma _ { b } ^ { 2 } + q ^ { l } . } \end{array}
+$$
+
+Thus $q = \sigma _ { b } ^ { 2 } + q$ if and only if $\sigma _ { b } = 0$ , otherwise $q ^ { l }$ diverges to infinity. So the frontier is reduced to a single point $( \sigma _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( \bar { 0 } , \mathbb { E } [ \phi ^ { \prime } ( Z ) ^ { 2 } ] ^ { - 1 } )$ , and the variance does not depend on $l$ .
+
+Proposition 3 (ReLU kernel). Consider a ReLU network with parameters $( \sigma _ { b } ^ { 2 } , \sigma _ { w } ^ { 2 } ) = ( 0 , 2 )$ on the EOC.We have
+
+(i) for $x \in [ 0 , 1 ]$ , $\begin{array} { r } { f ( x ) = \frac { 1 } { \pi } x \arcsin ( x ) + \frac { 1 } { \pi } \sqrt { 1 - x ^ { 2 } } + \frac { 1 } { 2 } x , } \end{array}$ , ii) for any $( a , b )$ , $\begin{array} { r } { \operatorname* { l i m } _ { l \to \infty } c _ { a b } ^ { l } = 1 } \end{array}$ and $\begin{array} { r } { 1 - c _ { a b } ^ { l } \sim \frac { 9 \pi ^ { 2 } } { 2 l ^ { 2 } } } \end{array}$ 9π22l2 as l → ∞.
+
+Proof. In this case the correlation function $f$ is given by $f ( x ) = 2 \mathbb { E } [ ( Z _ { 1 } ) _ { + } ( x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } ) _ { + } ]$ where $( x ) _ { + } : = x 1 _ { x > 0 }$ .
+
+• Let $x \in [ 0 , 1 ]$ , note that $f$ is differentiable and satisfies,
+
+$$
+\begin{array} { r } { f ^ { \prime } ( x ) = 2 \mathbb { E } [ 1 _ { Z _ { 1 } > 0 } 1 _ { x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } > 0 } ] , } \end{array}
+$$
+
+which is also differentiable. Simple algebra leads to
+
+$$
+f ^ { " } \left( x \right) = { \frac { 1 } { \pi { \sqrt { 1 - x ^ { 2 } } } } } .
+$$
+
+Since $\begin{array} { r } { \arcsin ^ { \prime } ( x ) = \frac { 1 } { \sqrt { 1 - x ^ { 2 } } } } \end{array}$ and $f ^ { \prime } ( 0 ) = 1 / 2$
+
+$$
+f ^ { \prime } ( x ) = { \frac { 1 } { \pi } } \arcsin ( x ) + { \frac { 1 } { 2 } } .
+$$
+
+We conclude using the fact that $\textstyle { \int \arcsin } = x \arcsin + { \sqrt { 1 - x ^ { 2 } } }$ and $f ( 1 ) = 1$ .
+
+• We first derive a Taylor expansion of $f$ near 1. Consider the change of variable $x = 1 - t ^ { 2 }$ with $t$ close to 0, then
+
+$$
+\arcsin ( 1 - t ^ { 2 } ) = { \frac { \pi } { 2 } } - { \sqrt { 2 } } t - { \frac { \sqrt { 2 } } { 1 2 } } t ^ { 3 } + O ( t ^ { 5 } ) ,
+$$
+
+so that
+
+$$
+\arcsin ( x ) = { \frac { \pi } { 2 } } - { \sqrt { 2 } } ( 1 - x ) ^ { 1 / 2 } - { \frac { \sqrt { 2 } } { 1 2 } } ( 1 - x ) ^ { 3 / 2 } + O ( ( 1 - x ) ^ { 5 / 2 } ) ,
+$$
+
+and
+
+$$
+x \arcsin ( x ) = { \frac { \pi } { 2 } } - { \sqrt { 2 } } ( 1 - x ) ^ { 1 / 2 } + { \frac { 1 1 { \sqrt { 2 } } } { 1 2 } } ( 1 - x ) ^ { 3 / 2 } + O ( ( 1 - x ) ^ { 5 / 2 } ) .
+$$
+
+Since
+
+$$
+\sqrt { 1 - x ^ { 2 } } = \sqrt { 2 } ( 1 - x ) ^ { 1 / 2 } - \frac { \sqrt { 2 } } { 4 } ( 1 - x ) ^ { 3 / 2 } + O ( ( 1 - x ) ^ { 5 / 2 } ) ,
+$$
+
+we obtain that
+
+$$
+f ( x ) \mathop = _ { x \to 1 - } x + \frac { 2 \sqrt { 2 } } { 3 \pi } ( 1 - x ) ^ { 3 / 2 } + O ( ( 1 - x ) ^ { 5 / 2 } ) .
+$$
+
+Since $\begin{array} { r } { ( f ( x ) - x ) ^ { \prime } = \frac { 1 } { \pi } ( \arcsin ( x ) - \frac { \pi } { 2 } ) < 0 } \end{array}$ and $f ( 1 ) = 1$ , for all $x \in [ 0 , 1 [ , f ( x ) > x $ If $c ^ { l } < c ^ { l + 1 }$ then by taking the image by $f$ (which is increasing because $f ^ { \prime } \geq 0 .$ ) we have that $c ^ { l + 1 } < c ^ { l + 2 }$ , and we know that $c ^ { 1 } = f ( c ^ { 0 } ) \geq c ^ { 0 }$ , so by induction the sequence $c ^ { l }$ is increasing, and therefore it converges (because it is bounded) to the fixed point of $f$ which is 1.
+
+Nowthat $\gamma _ { l } : = 1 - c _ { a b } ^ { l }$ $a , b$ d. We note  so that $\begin{array} { r } { s = \frac { 2 \sqrt { 2 } } { 3 \pi } } \end{array}$ , from the series expansion we have $\gamma _ { l + 1 } = \gamma _ { l } - s \gamma _ { l } ^ { 3 / 2 } + O ( \gamma _ { l } ^ { 5 / 2 } )$
+
+$$
+\begin{array} { l } { { \gamma _ { l + 1 } ^ { - 1 / 2 } = \gamma _ { l } ^ { - 1 / 2 } ( 1 - s \gamma _ { l } ^ { 1 / 2 } + O ( \gamma _ { l } ^ { 3 / 2 } ) ) ^ { - 1 / 2 } = \gamma _ { l } ^ { - 1 / 2 } ( 1 + \frac { s } { 2 } \gamma _ { l } ^ { 1 / 2 } + O ( \gamma _ { l } ^ { 3 / 2 } ) ) } } \\ { { \nonumber } } \\ { { \qquad = \gamma _ { l } ^ { - 1 / 2 } + \frac { s } { 2 } + O ( \gamma _ { l } ) . } } \end{array}
+$$
+
+Thus, as $l$ goes to infinity
+
+$$
+\gamma _ { l + 1 } ^ { - 1 / 2 } - \gamma _ { l } ^ { - 1 / 2 } \sim \frac { s } { 2 }
+$$
+
+and by summing and equivalence of positive divergent series
+
+$$
+\gamma _ { l } ^ { - 1 / 2 } \sim \frac { s } { 2 } l ,
+$$
+
+which terminates the proof.
+
+A.3 A BETTER CLASS OF ACTIVATION FUNCTIONS: PROOFS OF PROPOSITIONS 4, 5, 6 AND LEMMA 2
+
+Proposition 4 (main result). Let √ $\phi$ be an activation function. Recall the definition of the variance function $F ( x ) : = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( { \sqrt { x } } Z ) ^ { 2 } ]$ . Assume that   
+(i) $\phi ( 0 ) = 0$ , and $\phi$ has right and left derivatives in zero and at least one of them is different from zero $( \phi ^ { \prime } ( 0 ^ { + } ) \neq 0$ or $\phi ^ { \prime } ( 0 ^ { - } ) \neq 0 ,$ ), and there exists $K > 0$ such that $\textstyle | { \frac { \phi ( x ) } { x } } | \leq K$ .   
+(ii) There exists $A > 0$ such that for any $\sigma _ { b } \in [ 0 , A ]$ , there exists $\sigma _ { w , E O C } > 0$ such that $( \sigma _ { b } , \sigma _ { w , E O C } ) \in$ EOC.   
+(iii) For any $\sigma _ { b } ~ \in ~ [ 0 , A ]$ , the function $F$ with parameters $( \sigma _ { b } , \sigma _ { w , E O C } )$ is non-decreasing and $\scriptstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q = 0$ where $q$ is the minimal fixed point of $F$ , $q : = \operatorname* { i n f } \{ x : F ( x ) = x \} .$ ).   
+$( i \nu )$ For any $\sigma _ { b } \in [ 0 , A ]$ , the correlation function $f$ with parameters $( \sigma _ { b } , \sigma _ { w , E O C } )$ introduced in Lemma $^ { l }$ is convex.
+
+Then, for any $\sigma _ { b } \in [ 0 , A ]$ , we have $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) \ge q$ , and
+
+$$
+\operatorname* { l i m } _ { \sigma _ { b } \to 0 } \operatorname* { s u p } _ { x \in [ 0 , 1 ] } | f ( x ) - x | = 0 .
+$$
+
+Proof. We first prove that $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) \ge q$ . We assume that $\sigma _ { b } > 0$ , the case $\sigma _ { b } = 0$ is trivial since in this case $q = 0$ (the output of the network is zero in this case).
+
+Since $F$ is continuous and $F ( 0 ) = \sigma _ { b } ^ { 2 } > 0$ , we have $x \leq F ( x ) \leq q$ for all $x \in [ 0 , q ]$ . Using the fact that $F$ is non-decreasing for any input $a$ such that $q _ { a } ^ { 1 } \leq q$ , we have $q ^ { l }$ is increasing and converges to the fixed point $q$ . Therefore $K _ { \phi , v a r } ( \sigma _ { b } , \sigma _ { w } ) \ge q$ .
+
+Now we prove that on the edge of chaos, we have
+
+$$
+\operatorname* { l i m } _ { \sigma _ { b } \to 0 } \frac { \sigma _ { b } ^ { 2 } } { q } = 0 .
+$$
+
+The EOC equation is given by $\sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime } ( { \sqrt { q } } Z ) ^ { 2 } ] = 1$ . By taking the limit $\sigma _ { b }  0$ on the edge of chaos, and using the fact that $\scriptstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q = 0$ , we have $\begin{array} { r } { \sigma _ { w } ^ { 2 } \frac { \phi ^ { \prime } ( 0 ^ { + } ) ^ { 2 } + \phi ^ { \prime } ( 0 ^ { - } ) ^ { 2 } } { 2 } = 1 . } \end{array}$ . Moreover $q$ verifies
+
+$$
+\frac { F ( q ) } { q } = 1 = \frac { \sigma _ { b } ^ { 2 } } { q } + \sigma _ { w } ^ { 2 } \mathbb { E } [ ( \frac { \phi ( \sqrt { q } Z ) } { \sqrt { q } } ) ^ { 2 } ] ,
+$$
+
+so that by taking the limit $\sigma _ { b }  0$ , and using the dominated convergence theorem, we have that $\begin{array} { r } { 1 = \operatorname* { l i m } _ { \sigma _ { b } \to 0 } \frac { \sigma _ { b } ^ { 2 } } { q } + \sigma _ { w } ^ { 2 } \frac { \phi ^ { \prime } ( 0 ^ { + } ) ^ { 2 } + \phi ^ { \prime } ( 0 ^ { - } ) ^ { 2 } } { 2 } = \operatorname* { l i m } _ { \sigma _ { b } \to 0 } \frac { \sigma _ { b } ^ { 2 } } { q } + 1 } \end{array}$ and equation 6 holds.
+
+Finally since $f$ is strictly convex, for all $x \in [ 0 , 1 ] f ^ { \prime } ( x ) \leq f ^ { \prime } ( 1 ) = 1$ if $( \sigma _ { b } , \sigma _ { w } ) \in E O C$ . Therefore $\begin{array} { r } { 0 \le f ( x ) - x \le f ( 0 ) = \frac { \sigma _ { b } ^ { 2 } } { q } } \end{array}$ σ 2b , we conclude using the fact that limσb→0 $\begin{array} { r } { \operatorname* { l i m } _ { \sigma _ { b } \to 0 } \frac { \sigma _ { b } ^ { 2 } } { q } = 0 } \end{array}$ .
+
+Note however that for all $\sigma _ { b } > 0$ , if $( \sigma _ { b } , \sigma _ { w } ) \in E O C$ , for any inputs $a , b$ , we have $\begin{array} { r } { \operatorname* { l i m } _ { l  \infty } c _ { a , b } ^ { l } = 1 } \end{array}$ Indeed, since $f$ is usually strictly convex (otherwise, $f$ would be equal to identity on at least a segment of $[ 0 , 1 ] \rangle$ ) and $f ^ { \prime } ( 1 ) = 1$ , we have that $f$ is a contraction (because $f ^ { \prime } \geq 0 \mathrm { \ : \ : }$ ), therefore the correlation converges to the unique fixed point of $f$ which is 1. Therefore, in most of the cases, the result of Proposition 4 should be seen as a way of slowing down the convergence of the correlation to 1.
+
+Lemma 2. Under the conditions of Proposition 4, the only change being $\textstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q > 0$ , the result of Proposition 4 holds only if the activation function is linear.
+
+Proof. Using the convexity of $f$ and the result of Proposition 4, we have in the limit $\sigma _ { b }  0$ , $f ^ { \prime } ( 0 ) ~ = ~ f ^ { \prime } ( 1 ) ~ = ~ 1$ , which is equivalent to $\mathbb { E } [ \phi ^ { \prime } ( \sqrt { q } \bar { Z } ) ^ { 2 } ] = \mathbb { E } [ \phi ^ { \prime } ( \sqrt { q } Z ) ] ^ { 2 }$ which implies that $\mathrm { v a r } ( \phi ^ { \prime } ( { \sqrt { q } } Z ) ) = 0$ . Therefore there exists a constant $a _ { 1 }$ such that $\phi ^ { \prime } ( { \sqrt { q } } { \dot { Z } } ) = a _ { 1 }$ almost surely. This implies $\phi ^ { \prime } = a _ { 1 }$ almost everywhere. □
+
+Proposition 5. Let $\phi$ be a bounded function such that $\phi ( 0 ) = 0$ , $\phi ^ { \prime } ( 0 ) > 0$ , $\phi ^ { \prime } ( x ) \geq 0$ , $\phi ( - x ) =$ $- \phi ( x )$ , $x \phi ( x ) > 0$ and $x \phi ^ { \prime \prime } ( x ) < 0$ for $x \neq 0$ , and $\phi$ satisfies (ii) in Proposition 4. Then, $\phi$ satisfies all the conditions of Proposition 4.
+
+Proof. Let $\phi$ be an activation function that satisfies the conditions of Proposition 5.
+
+(i) we have $\phi ( 0 ) = 0$ and $\phi ^ { \prime } ( 0 ) > 0$ . Since $\phi$ is bounded and $0 < \phi ^ { \prime } ( 0 ) < \infty$ , then there exists $K$ such that $\textstyle \left| { \frac { \phi ( x ) } { x } } \right| \leq K$ .
+
+(ii) The condition (ii) is satisfied by assumption.
+
+(iii) Let $\sigma _ { b } > 0$ and $\sigma _ { w } > 0$ . Using equation 3 together with $\phi ^ { \prime } > 0$ , we have $F ^ { \prime } ( x ) \geq 0$ so that F is non-decreasing. Moreover, we have ${ \cal F } ( \mathbb { R } ^ { + } ) \subset \mathbf { \bar { \sigma } } [ B , C ] : = [ \sigma _ { b } ^ { 2 } , \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } M ^ { 2 } ]$ , therefore any fixed point of $F$ should be in $[ B , C ]$ . We have $F ( B ) \geq B$ and $F ( C ) \leq C$ and $\mathrm { F }$ is strictly increasing, therefore, there exists a fixed point $q$ of $F$ in $[ B , C ]$ . Now we prove that $\scriptstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q \ = \ 0$ . Using the EOC equation, q satisfies the equation q = σ2b + E[φ( qZ)2]E[φ0(√qZ)2] . Now let’s prove that the function $\begin{array} { r } { e ( x ) : = x - \frac { \mathbb { E } [ \phi ( \sqrt { x } Z ) ^ { 2 } ] } { \mathbb { E } [ \phi ^ { \prime } ( \sqrt { x } Z ) ^ { 2 } ] } } \end{array}$ is increasing near 0 which means it is an injection near 0, this is sufficient to conclude (because we take $q$ to be the minimal fixed point). After some calculus, we have
+
+$$
+\begin{array} { r } { e ^ { \prime } ( x ) = - \frac { \mathbb { E } [ \phi ^ { \prime \prime } ( \sqrt { x } Z ) ( \phi ( \sqrt { x } Z ) \mathbb { E } [ \phi ^ { \prime } ( \sqrt { x } Z ) ^ { 2 } ] - \frac { Z } { \sqrt { x } } \phi ^ { \prime } ( \sqrt { x } Z ) \mathbb { E } [ \phi ( \sqrt { x } Z ) ^ { 2 } ] ) ] } { \mathbb { E } [ \phi ^ { \prime } ( \sqrt { x } Z ) ^ { 2 } ] } } \end{array}
+$$
+
+Using Taylor expansion near 0, after a detailed but unenlightening calculation the numerator is equal√ to $- \bar { 2 } \phi ^ { \prime } ( \bar { 0 } ) ^ { 2 } \phi ^ { \prime \prime \prime } \bar { ( 0 ) } ^ { 2 } x \sqrt { x } + O ( x ^ { 2 } )$ , therefore the function $e$ is increasing near 0.
+
+(iv) Finally, using the notations $U _ { 1 } : = \sqrt { q } Z _ { 1 }$ and $U _ { 2 } ( x ) = \sqrt { q } ( x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } )$ , the first and second derivatives of the correlation function are given by
+
+$$
+f ^ { \prime } ( x ) = \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime } ( U _ { 1 } ) \phi ^ { \prime } ( U _ { 2 } ( x ) ) ] , \quad f ^ { \prime \prime } ( x ) = \sigma _ { w } ^ { 2 } q \mathbb { E } [ \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ]
+$$
+
+where we used Gaussian integration by parts. Let $x > 0$ , we have that
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ] = \mathbb { E } [ 1 _ { \{ U _ { 1 } \geq 0 \} } \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ] + \mathbb { E } [ 1 _ { \{ U _ { 1 } \leq 0 \} } \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ] } \\ & { \qquad = 2 \mathbb { E } [ 1 _ { \{ U _ { 1 } \geq 0 \} } \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ] } \end{array}
+$$
+
+where we used the fact that $\left( Z _ { 1 } , Z _ { 2 } \right) = \left( - Z _ { 1 } , - Z _ { 2 } \right)$ (in distribution) and $\phi ^ { \prime \prime } ( - y ) = - \phi ^ { \prime \prime } ( y )$ for any $y$ .   
+Using $x \phi ^ { \prime \prime } ( x ) \leq 0$ , we have $1 _ { \{ u _ { 1 } \geq 0 \} } \phi ^ { \prime \prime } ( u _ { 1 } ) \leq 0$ . We also have for all $y > 0$ , $\mathbb { E } [ \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) | U _ { 1 } =$ $y ] < 0$ , this is a consequence of the fact that $\phi ^ { \prime \prime }$ is an odd function and that for $x > 0$ and $y > 0$ , the mapping $z _ { 2 }  x y + \sqrt { 1 - x ^ { 2 } } z _ { 2 }$ moves the center of the Gaussian distribution to a strictly positive number, we conclude that $f ^ { \prime \prime } ( x ) > 0$ almost everywhere and assumption (iii) of Proposition 4 is verified.
+
+Proposition 6. The Swish activation function $\begin{array} { r } { \phi _ { s w i s h } ( x ) = x \cdot s i g m o i d ( x ) = \frac { x } { 1 + e ^ { - x } } } \end{array}$ satisfies all the conditions of Proposition 4.
+
+![](images/7cb72ac0c8eeec0a795011e97ce394bfeee00941378fbd8c9788dccdd18301cc.jpg)  
+Figure 9: Graphs of ReLU and Swish
+
+Proof. To abbreviate notation, we note $\phi : = \phi _ { S w i s h } = x e ^ { x } / ( 1 + e ^ { x } )$ and $h : = e ^ { x } / ( 1 + e ^ { x } )$ is the Sigmoid function. This proof should be seen as a sketch of the ideas and not a rigourous proof.
+
+• we have $\phi ( 0 ) = 0$ and $\begin{array} { r } { \phi ^ { \prime } ( 0 ) = \frac { 1 } { 2 } } \end{array}$ and $\begin{array} { r } { | \frac { \phi ( x ) } { x } | \leq 1 } \end{array}$ • As illustrated in Table 1 in the main text, it is easy to see numerically that (ii) is satisfied. Moreover, we observe that $\scriptstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q = 0$ , which proves the second part of the (iii).
+
+• Now we prove that $F ^ { \prime } > 0$ , we note $g ( x ) : = x \phi ^ { \prime } ( x ) \phi ( x )$ . We have
+
+$$
+g ( x ) = x ^ { 2 } { \frac { ( 1 + e ^ { - x } + x e ^ { - x } ) } { ( 1 + e ^ { - x } ) ^ { 3 } } }
+$$
+
+Define $G$ by
+
+$$
+G ( x ) = { \left\{ \begin{array} { l l } { g ( x ) } & { { \mathrm { i f ~ } } x \leq 0 } \\ { - g ( - x ) } & { { \mathrm { i f ~ } } x > 0 } \end{array} \right. }
+$$
+
+so that $G ( - x ) = - G ( x )$ for all $x \in \mathbb { R }$ and $g ( x ) \geq G ( x )$ for all $x \leq 0$ . Let $x > 0$ , then
+
+$$
+g ( x ) > G ( x ) \Longleftrightarrow 1 + e ^ { - x } + x e ^ { - x } \geq e ^ { - 3 x } ( - 1 - e ^ { x } + x e ^ { x } )
+$$
+
+which holds true for any positive number $x$ . We thus have $g ( x ) > G ( x )$ for all real numbers $x$ . Therefore $\mathbb { E } [ g ( { \sqrt { x } } { \dot { Z } } ) ] > 0$ almost everywhere and $F ^ { \prime } > 0$ . The second part of (iii) was already proven above.
+
+• Let $\sigma _ { b } > 0$ and $\sigma _ { w } > 0$ such that $q$ exists. Recall that
+
+$$
+f ^ { \prime \prime } ( x ) = \sigma _ { w } ^ { 2 } q \mathbb { E } [ \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ]
+$$
+
+In Figure 10, we show the graph of $\mathbb { E } [ \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ]$ for different values of $q$ (from 0.1 to 10, the darkest line being for $q = 1 0$ ). A rigorous proof can be done but is omitted here.
+
+![](images/50125c94bb1f7692afb5f4c010aa22cd23ce249a6ff6240301bffbeed8c11ec8.jpg)  
+Figure 10: graphs of $\mathbb { E } [ \phi ^ { \prime \prime } ( U _ { 1 } ) \phi ^ { \prime \prime } ( U _ { 2 } ( x ) ) ]$ for different values of $q$ $\mathrm { f r o m } 0 . 1$ to 10, the darkest line corresponds to $q = 1 0$ )
+
+We observe that $f ^ { \prime \prime }$ has very small values when $q$ is large, this is a result of the fact that $\phi ^ { \prime \prime }$ is concentrated around 0.
+
+Remark : On the edge of chaos, we have $\sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime } ( \sqrt { q } Z ) ^ { 2 } ] = 1$ . Recall that $F ^ { \prime }$ can also be expressed
+
+as
+
+$$
+F ^ { \prime } ( x ) = \sigma _ { w } ^ { 2 } ( \mathbb { E } [ \phi ^ { \prime } ( { \sqrt { x } } Z ) ^ { 2 } ] + \mathbb { E } [ \phi ^ { \prime \prime } ( { \sqrt { x } } Z ) \phi ( { \sqrt { x } } Z ) ] ) ,
+$$
+
+this yields
+
+$$
+F ^ { \prime } ( q ) = 1 + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ^ { \prime \prime } ( { \sqrt { q } } Z ) \phi ( { \sqrt { q } } Z ) ] .
+$$
+
+The term $\mathbb { E } [ \phi ^ { \prime \prime } ( { \sqrt { q } } Z ) \phi ( { \sqrt { q } } Z ) ]$ is very small compared to 1 $( \sim 0 . 0 1 )$ , therefore $F ^ { \prime } ( q ) \approx 1$ .
+
+Notice also that the theoretical results corresponds to the equivalent Gaussian process, which is just an approximation of the neural network. Thus, using a value of $\left( \sigma _ { b } , \sigma _ { w } \right)$ close to the $E O C$ should not essentially change the quality of the result. □
+
+# B SUPPLEMENTARY THEORETICAL RESULTS
+
+# B.1 SUFFICIENT CONDITIONS FOR BOUNDED ACTIVATION FUNCTIONS
+
+We can replace the conditions $" \phi$ satisfies (ii)" in Proposition 5 by a sufficient condition. However, this condition is not satisfied by Tanh.
+
+Proposition 7. Let $\phi$ be a bounded function such that $\phi ( 0 ) = 0$ , $\phi ^ { \prime } ( 0 ) > 0$ , $\phi ^ { \prime } ( x ) \geq 0$ , $\phi ( - x ) =$ $- \phi ( x )$ , $x \phi ( x ) > 0$ and $x \phi ^ { \prime \prime } ( x ) < \bar { 0 }$ for $x \neq 0$ , and $| \mathbb { E } \phi ^ { \prime } ( x Z ) ^ { 2 } | \gtrsim | x | ^ { - 2 \beta }$ for large $x$ and some $\beta \in ( 0 , 1 )$ . Then, $\phi$ satisfies all the conditions of Proposition 4.
+
+Proof. Let $\phi$ be an activation function that satisfies the conditions of Proposition 7. The proof is similar to the one of 5, we only need to show that having $| \mathbb { E } \phi ^ { \prime } ( x Z ) ^ { 2 } | \gtrsim | x | ^ { \frac { \cdot } { - 2 \beta } }$ for large $x$ and some $\beta \in ( 0 , 1 )$ implies that (ii) of 4 is verified.
+
+We have that $\sigma _ { w } ^ { 2 } | \mathbb { E } \phi ^ { \prime } ( \sqrt { q } Z ) ^ { 2 } | \gtrsim \sigma _ { w } ^ { 2 } q ^ { - 2 \beta } = \sigma _ { w } ^ { 2 } ( \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( \sqrt { q } Z ) ^ { 2 } ] ) ^ { - \beta }$ , so that we can make the term $\sigma _ { w } ^ { 2 } | \mathbb { E } \phi ^ { \prime } ( { \sqrt { q } } Z ) ^ { 2 } |$ take any value between 0 and $\infty$ . Therefore, there exists $\sigma _ { w }$ such that $( \sigma _ { b } , \sigma _ { w } ) \in E O C$ , and assumption (ii) of Proposition 4 holds.
+
+# B.2 IMPACT OF SMOOTHNESS
+
+In the proof of Proposition 5, we used the condition on $\phi ^ { \prime \prime }$ (odd function) to prove that $f ^ { \prime \prime } > 0$ however, in some cases when we can explicitly calculate $f$ , we do not need $\phi ^ { \prime \prime }$ to be defined. This is the case for Hard-Tanh, which is a piecewise-linear version of Tanh. We give an explicit calculation
+
+of $f ^ { \prime \prime }$ for the Hard-Tanh activation function which we note $H T$ in what follows. We compare the performance of $H T$ and Tanh based on a metric which we will define later.
+
+$H T$ is given by
+
+$$
+H T ( x ) = { \left\{ \begin{array} { l l } { - 1 } & { { \mathrm { i f ~ } } x < - 1 } \\ { x } & { { \mathrm { i f ~ } } - 1 \leq x \leq 1 } \\ { 1 } & { { \mathrm { i f ~ } } x > 1 } \end{array} \right. }
+$$
+
+Recall the propagation of the variance $q ^ { l }$
+
+$$
+q ^ { l + 1 } = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } ( H T ( { \sqrt { q ^ { l } } } Z ) ^ { 2 } )
+$$
+
+where $H T$ is the Hard-Tanh function. We have
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } ( H T ( \sqrt { q ^ { l } } Z ) ^ { 2 } ) = \mathbb { E } ( 1 _ { Z < - \frac { 1 } { \sqrt { q ^ { l } } } } ) + \mathbb { E } ( 1 _ { - 1 / \sqrt { q ^ { l } } < Z < 1 / \sqrt { q ^ { l } } } Z ^ { 2 } ) + \mathbb { E } ( 1 _ { Z > 1 / \sqrt { q ^ { l } } } ) } \\ { \displaystyle = 1 - \frac { 2 } { \sqrt { q ^ { l } } } \frac { \exp ( - \frac { 1 } { 2 q ^ { l } } ) } { \sqrt { 2 \pi } } } \end{array}
+$$
+
+This yields
+
+$$
+q ^ { l + 1 } = g ( q ^ { l } )
+$$
+
+where
+
+$$
+g ( x ) = \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } ( 1 - \frac { 2 } { \sqrt { x } } \frac { \exp ( - \frac { 1 } { x } ) } { \sqrt { 2 \pi } } )
+$$
+
+- EDGE OF CHAOS :
+
+To study the correlation behaviour, we will assume that the variance converges to . We have $\begin{array} { r } { \mathbb { E } ( H T ^ { \prime } ( \sqrt { q } Z ) ^ { 2 } ) = \mathbb { E } ( 1 _ { - \frac { 1 } { \sqrt { q } } < Z < \frac { 1 } { \sqrt { q } } } ) = 2 \Psi ( \frac { 1 } { \sqrt { q } } ) - 1 } \end{array}$ (where $\Psi$ is the cumulative distribution function of a standard normal variable). The edge of chaos is then given by the equation $\begin{array} { r } { \sigma _ { w } ^ { 2 } ( 2 \Psi ( \frac { 1 } { \sqrt { q } } ) - 1 ) = 1 } \end{array}$ We fix $\sigma _ { w }$ to its value on the edge.
+
+Now let $a$ and $b$ be any two inputs. We have
+
+$$
+c ^ { l + 1 } = f ( c ^ { l } )
+$$
+
+where
+
+$$
+f ( x ) = \frac { \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \mathbb { E } [ \phi ( U _ { 1 } ) \phi ( U _ { 2 } ( x ) ) ] } { q }
+$$
+
+with $U _ { 1 } : = \sqrt { q } Z _ { 1 }$ , and $U _ { 2 } ( x ) : = \sqrt { q } ( x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } )$ .
+
+Lemma 3. Suppose $q ^ { l }$ converges to a fixed point $q > 0$ . Then,
+
+$$
+\forall x \in [ 0 , 1 ] , f ^ { \prime \prime } ( x ) = { \frac { \sigma _ { w } ^ { 2 } } { \pi { \sqrt { 1 - x ^ { 2 } } } } } ( e ^ { - { \frac { 1 } { q ( 1 + x ) } } } - e ^ { - { \frac { 1 } { q ( 1 - x ) } } } )
+$$
+
+Proof. We note $\alpha : = 1 / \sqrt { q }$ . For $x \in [ 0 , 1 [$ , we have that :
+
+$$
+\begin{array} { r l } & { f ^ { \prime } ( x ) = \sigma _ { w } ^ { 2 } \mathbb { E } [ 1 _ { - \alpha < Z _ { 1 } < \alpha } \times 1 _ { - \alpha < x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } < \alpha } ] } \\ & { \qquad = \sigma _ { w } ^ { 2 } \mathbb { E } [ 1 _ { - \alpha < Z _ { 1 } < \alpha } \times ( 1 _ { - \alpha < x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } } - 1 _ { \alpha < x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } } ) ] } \end{array}
+$$
+
+![](images/9195e7216aa5aee30204de1ad9c55360e68b56e23eef8522af62ddbb65e5d2c6.jpg)  
+Figure 11: The correlation function on the edge of order-to-chaos for a Tanh network with small values of $\sigma _ { b }$
+
+We deal with the first part $f _ { 1 } ( x ) = \sigma _ { w } ^ { 2 } \mathbb { E } [ 1 _ { - \alpha < Z _ { 1 } < \alpha } \times 1 _ { - \alpha < x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } } ]$ , we have that :
+
+$$
+\begin{array} { l } { { f _ { 1 } ^ { \prime } ( x ) = \displaystyle \sigma _ { w } ^ { 2 } \mathbb { E } [ 1 _ { - \alpha < Z _ { 1 } < \alpha } \times \frac { 1 } { \sqrt { 1 - x ^ { 2 } } } ( Z _ { 1 } - \frac { x } { \sqrt { 1 - x ^ { 2 } } } Z _ { 2 } ) \delta _ { - \alpha = x Z _ { 1 } + \sqrt { 1 - x ^ { 2 } } Z _ { 2 } } ] } } \\ { { \displaystyle \quad = \frac { \sigma _ { w } ^ { 2 } } { \sqrt { 2 \pi } } \mathbb { E } [ 1 _ { - \alpha < Z _ { 1 } < \alpha } \times \frac { 1 } { \sqrt { 1 - x ^ { 2 } } } \frac { Z _ { 1 } + x \alpha } { 1 - x ^ { 2 } } \exp ( - \frac { ( x Z _ { 1 } + \alpha ) ^ { 2 } } { 2 ( 1 - x ^ { 2 } ) } ) ] } } \\ { { \displaystyle \quad = \frac { \sigma _ { w } ^ { 2 } } { 2 \pi \sqrt { 1 - x ^ { 2 } } } \int _ { - \alpha } ^ { \alpha } \frac { z _ { 1 } + x \alpha } { 1 - x ^ { 2 } } \exp ( - \frac { z _ { 1 } ^ { 2 } + 2 x \alpha z _ { 1 } + \alpha ^ { 2 } } { 2 ( 1 - x ^ { 2 } ) } ) d z _ { 1 } } } \\ { { \displaystyle \quad = \frac { \sigma _ { w } ^ { 2 } } { 2 \pi \sqrt { 1 - x ^ { 2 } } } ( e ^ { - \frac { \alpha ^ { 2 } } { 1 + x } } - e ^ { - \frac { \alpha ^ { 2 } } { 1 - x } } ) } } \end{array}
+$$
+
+we show a similar result for the second part and we conclude.
+
+We proved that $f ^ { \prime \prime } > 0$ for Hard-Tanh, all other conditions of proposition 5 (excluding the conditions on $\phi ^ { \prime \prime }$ since those were only used to prove $f ^ { \prime \prime } > 0 _ { , }$ ) are verified, therefore the result of Proposition 4 holds for Hard-Tanh. we want to compare Tanh and Hard-Tanh when $\sigma _ { b }$ is small since this is the important case. The proof of Proposition 4 gives us an idea on how to compare them, the ratio $\frac { \sigma _ { b } ^ { 2 } } { q }$ controls the quality of approximation of f by the identity function, so a smaller ratio means a better approximation. Figure 2 shows that Tanh outperforms Hard-Tanh in this sense. This also means that for the same quality of approximation, we have bigger $q$ (bigger output variance) with Tanh compared to Hard-Tanh. This can particularly be due to the nonsmoothness of Hard-Tanh, which slows down the dominated convergence in the proof of Proposition 4.
+
+# C SUPPLEMENTARY EXPERIMENTAL RESULTS
+
+# C.1 ELU ACTIVATION
+
+We show numerically that the activation function ELU defined by $\phi ( x ) = ( e ^ { x } - 1 ) 1 _ { x < 0 } + x 1 _ { x \geq 0 }$ satisfies the conditions of Proposition 4. We have $\phi ( x ) = 0 , \phi ^ { \prime } ( 0 ^ { + } ) = 1 , \phi ^ { \prime } ( 0 ^ { - } ) = 1$ and $\begin{array} { r } { | \frac { \phi ( x ) } { x } | \leq 1 } \end{array}$ . Other conditions of Proposition 4 are shown numerically in graphs below.
+
+![](images/e8fdfc29a4c81a85c4c20fee31bad891ca54cd1a44f746e1d4086e6d4a8c2bb4.jpg)  
+Figure 12: Experimental results for ELU activation
+
+Figure 12a shows the EOC curve (condition (ii) is satisfied). Figure 12b shows that is non-decreasing and Figure 12d illustrates the fact that $\scriptstyle \operatorname* { l i m } _ { \sigma _ { b } \to 0 } q = 0$ . Finally, Figure 12c shows that function $f$ is convex. Although the figures of $F$ and $f$ are shown just for one value of $\left( \sigma _ { b } , \sigma _ { w } \right)$ , the results are true for any value of $\left( \sigma _ { b } , \sigma _ { w } \right)$ on the EOC.
+
+# C.2 WHAT HAPPENS WHEN THE DEPTH IS LARGER THAN THE WIDTH?
+
+Table 2 presents a comparative analysis of the validation accuracy of ReLU and Swish when the depth is larger than the width, in which case the approximation by a Gaussian process is not accurate (notice that in the approximation of a neural network by a Gaussian process, we first let $N _ { l } \to \infty$ , then we consider the limit of large $L$ ). ReLU tends to outperforms Swish when the width is smaller than the depth and both are small, however, we still observe a clear advantage of Swish for deeper architectures.
+
+Table 3: Validation accuracy for different values of (width, depth)   
+
+<table><tr><td></td><td>(5,10)</td><td>(10,20)</td><td>(30,40)</td><td>(40,50)</td></tr><tr><td>ReLU</td><td>86.65</td><td>93.76</td><td>93.59</td><td>90.77</td></tr><tr><td>Swish</td><td>86.56</td><td>93.21</td><td>96.78</td><td>97.08</td></tr></table>

parse/train/H1rRWl-Cb/H1rRWl-Cb.md

@@ -0,0 +1,510 @@
+# AN INFORMATION-THEORETIC ANALYSIS OF DEEP LATENT-VARIABLE MODELS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present an information-theoretic framework for understanding trade-offs in unsupervised learning of deep latent-variables models using variational inference. This framework emphasizes the need to consider latent-variable models along two dimensions: the ability to reconstruct inputs (distortion) and the communication cost (rate). We derive the optimal frontier of generative models in the two-dimensional rate-distortion plane, and show how the standard evidence lower bound objective is insufficient to select between points along this frontier. However, by performing targeted optimization to learn generative models with different rates, we are able to learn many models that can achieve similar generative performance but make vastly different trade-offs in terms of the usage of the latent variable. Through experiments on MNIST and Omniglot with a variety of architectures, we show how our framework sheds light on many recent proposed extensions to the variational autoencoder family.
+
+# 1 INTRODUCTION
+
+Deep learning has led to tremendous advances in supervised learning (Szegedy et al., 2017; Huang et al., 2017; Vaswani et al., 2017); however, unsupervised learning remains a challenging area. Recent advances in variational inference (VI) (Kingma & Welling, 2014; Rezende et al., 2014), have led to an explosion of research in the area of deep latent-variable models and breakthroughs in our ability to model natural high-dimensional data. This class of models typically optimize a lower bound on the log-likelihood of the data known as the evidence lower bound (ELBO), and leverage the “reparameterization trick” to make large-scale training feasible.
+
+However, a number of papers have observed that VAEs trained with powerful decoders can learn to ignore the latent variables (Chen et al., 2017; Tomczak & Welling, 2017; Bowman et al., 2016). We demonstrate this empirically and explain the issue theoretically by deriving the ELBO in terms of the mutual information between $X$ , the data, and $Z$ , the latent variables. Having done so, we show that the previously-described $\beta$ -VAE objective (Higgins et al., 2017) has a theoretical justification in terms of a Legendre-transformation of a constrained optimization of the mutual information. This leads to the core point of this paper, which is that the optimal rate of information in a model is taskdependent, and optimizing the ELBO directly makes the selection of that rate purely a function of architectural choices, whereas by using $\beta$ -VAE or other constrained optimization objectives, practitioners can learn models with optimal rates for their particular task without having to do extensive architectural search.
+
+Mutual information provides a reparameterization-independent measure of dependence between two random variables. Computing mutual information exactly in high dimensions is problematic (Paninski, 2003; Gao et al., 2017), so we turn to recently developed tools in variational inference to approximate it. We find that a natural lower and upper bound on the mutual information between the input and latent variable can be simply related to the ELBO, and understood in terms of two terms: (1) a lower bound that depends on the distortion, or how well an input can be reconstructed through the encoder and decoder, and (2) an upper bound that measures the rate, or how much information is retained about the input. Together these terms provide a unifying perspective on the set of optimal models given a dataset, and show that there exists a continuum of models that make very different trade-offs in terms of rate and distortion.
+
+By leveraging additional information about the amount of information contained in the latent variable, we show that we can recover the ground-truth generative model used to create the data in a toy model. We perform extensive experiments on MNIST and Omniglot using a variety of encoder, decoder, and prior architectures and demonstrate how our framework provides a simple and intuitive mechanism for understanding the trade-offs made by these models. We further show that we can control this tradeoff directly by optimizing the $\beta$ -VAE objective, rather than the ELBO. By varying $\beta$ , we can learn many models with the same architecture and comparable generative performance (in terms of marginal data log likelihood), but that exhibit qualitatively different behavior in terms of the usage of the latent variable and variability of the decoder.
+
+# 2 FRAMEWORK
+
+Unsupervised Representation Learning Depending on the task, there are many desiderata for a good representation. Here we focus on one aspect of a learned representation: the amount of information that the latent variable contains about the input. In the absence of additional knowledge of a “downstream” task, we focus on the ability to recover or reconstruct the input from the representation. Given a set of samples from a true data distribution $p ^ { * } ( x )$ , our goal is to learn a representation that contains a particular amount of information and from which the input can be reconstructed as well as possible.
+
+We will convert each observed data vector $x$ into a latent representation $z$ using any stochastic encoder $e ( z | x )$ of our choosing. This then induces the joint distribution $p _ { e } ( x , z ) \bar { } = \bar { p } ^ { * } ( x ) e ( z | x )$ and the corresponding marginal $\begin{array} { r } { p _ { e } ( z ) = \int d x p ^ { * } ( x ) e ( z | \bar { x } ) } \end{array}$ (the “aggregated posterior” in Makhzani et al. (2016); Tomczak $\&$ Welling (2017)) and conditional $p _ { e } ( x | z ) \bar { = } p _ { e } ( x , \bar { z } ) / p _ { e } ( z )$ .
+
+A good representation $Z$ must contain information about the input $X$ which we define as follows:
+
+$$
+\mathrm { I _ { r e p } } ( X ; Z ) = \iint d x d z p _ { e } ( x , z ) \log \frac { p _ { e } ( x , z ) } { p ^ { * } ( x ) p _ { e } ( z ) } .
+$$
+
+We will call this the representational mutual information, to distinguish it from the generative mutual information we discuss in Appendix C. Equation 1 is hard to compute, since we do not have access to the true data density $p ^ { * } ( x )$ , and computing the marginal $\begin{array} { r } { p _ { e } ( \dot { z } ) = \int d x p _ { e } ( x , z ) } \end{array}$ can be challenging. As demonstrated in Barber $\&$ Agakov (2003); Agakov (2006); Alemi et al. (2017) there exist useful, tractable variational bounds on mutual information. The detailed derivation for this case is included in Appendices B.1 and B.2 for completeness. These yield the following lower and upper bounds:
+
+$$
+\int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \frac { d ( x | z ) } { p ^ { * } ( x ) } \leq \mathrm { I } _ { \mathrm { r e p } } ( X ; Z ) \leq \underbrace { \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \frac { e ( z | x ) } { m ( z ) } } _ { \qquad }
+$$
+
+where $d ( x | z )$ (the “decoder”) is a variational approximation to $p _ { e } ( x | z )$ , $m ( z )$ (the “marginal”) i a variational approximation to $p _ { e } ( z )$ , and all the integrals can be approximated using Monte Carl given a finite sample of data from $p ^ { * } ( x )$ , as we discuss below.
+
+In connection with rate-distortion theory, we can interpret the upper bound as the rate $R$ of our representation (Tishby & Zaslavsky, 2015). This rate term measures the average number of additional nats necessary to encode samples from the encoder using an entropic code constructed from the marginal, being an average KL divergence. Unlike most rate-distortion work (Cover $\&$ Thomas, 2012), where the marginal is assumed a fixed property of the channel, here the marginal is a completely general distribution, which we assume is learnable. Similarly, we can interpret the lower bound as the data entropy $H$ , which measures the complexity of the dataset (a fixed but unknown constant), minus the distortion $D$ , which measures our ability to accurately reconstruct samples:
+
+$$
+\underbrace { \left( - \int d x p ^ { * } ( x ) \log p ^ { * } ( x ) \right) } _ { \mathrm { d a t a } \ : \mathrm { e n t r o p y } ( H ) } - \underbrace { \left( - \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log d ( x | z ) \right) } _ { \mathrm { d i s t o r i o n } ( D ) } \le \mathrm { I } _ { \mathrm { r e p } } \ .
+$$
+
+This distortion term is defined in terms of an arbitrary decoding distribution $d ( x | z )$ , which we consider a learnable distribution. This contrasts with most of the compression literature where distortion is typically measured using a fixed perceptual loss (Balle et al., 2017). Combining these equations, ´ we get the “sandwich equation” $H - D \leq \operatorname { I } _ { \mathrm { r e p } } \leq R$ . Notice that $\mathrm { E L B O } = - D - R$ .
+
+Phase Diagram From the sandwich equation, we see that $H - D - R \leq 0$ . This is a bound that must hold for any set of four distributions $p ^ { * } ( x ) , e ( z | x ) , d ( x | z ) , m ( z )$ . The inequality places strict limits on which values of rate and distortion are achievable, and allows us to reason about all possible solutions in a two dimensional $R D$ -plane. A sketch of this phase diagram is shown in Figure 1.
+
+First, we consider the data entropy term. For discrete data1, all probabilities in $X$ are bounded above by one and both the data entropy and distortion are non-negative $( H \ge 0 , D \ge 0 )$ . The rate is also non-negative $R \geq 0 )$ , because it is an average KL divergence, for either continuous or discrete $Z$ . The positivity constraints and the sandwich equation separate the $R D$ -plane into feasible and infeasible regions, visualized in Figure 1. The boundary between these regions is a convex curve (thick black line). Even given complete freedom in specifying the encoder ${ \dot { \mathbf { \rho } } } _ { e } ( z | x )$ , decoder $d ( x | z )$ and marginal approximation $m ( z )$ , and infinite data, we can never cross this bounding line.
+
+![](images/5039c658b9b008b9d56fd4229a6f4de05493e97dbafa4577a525677e39a59629.jpg)  
+Figure 1: Schematic representation of the phase diagram in the $R D$ -plane. The distortion $( D )$ axis measures the reconstruction error of the samples in the training set. The rate $( R )$ axis measures the relative KL divergence between the encoder and our own marginal approximation. The thick black lines denote the feasible boundary in the infinite model capacity limit.
+
+We now explain qualitatively what the different areas of this diagram correspond to. For simplicity, we will consider the infinite model family limit, where we have complete freedom in specifying $e ( z | x ) , d ( x | z )$ and $m ( z )$ but consider the data distribution $p ^ { * } ( x )$ fixed.
+
+The bottom horizontal line corresponds to the zero distortion setting, which implies that we can perfectly encode and decode our data; we call this the auto-encoding limit. The lowest possible rate is given by $H$ , the entropy of the data. This corresponds to the point $\mathit { \Omega } ^ { \prime } R = H , D = 0 ,$ ). (In this case, our lower bound is tight, and hence $d ( x | z ) = p _ { e } ( x | z )$ .) We can obtain higher rates at fixed distortion by making the marginal approximation $m ( z )$ a weaker approximation to $p _ { e } ( z )$ , since only the rate and not the distortion depends on $m ( z )$ .
+
+The left vertical line corresponds to the zero rate setting. Since $R = 0 \implies e ( z | x ) = m ( z )$ , we see that our encoding distribution $e ( z | x )$ must itself be independent of $x$ . Thus the latent representation is not encoding any information about the input and we have failed to create a useful learned representation. However, by using a suitably powerful decoder, $d ( x | z )$ , that is able to capture correlations between the components of $x$ (e.g., an autoregressive model, such as pixelCNN (Salimans et al., 2017), or an acausal MRF model, such as (Dai et al., 2015)), we can still reduce the distortion to the lower bound of $H$ , thus achieving the point $( R = 0 , D = H )$ ; we call this the auto-decoding limit. Hence we see that we can do density estimation without learning a good representation, as we will verify empirically in Section 4. (Note that since $R$ is an upper bound on the mutual information, in the limit that $R = 0$ , the bound must be tight, which guarantees that $m ( z ) = p _ { e } ( z )$ .) We can achieve solutions further up on the $D$ -axis, while keeping the rate fixed, simply by making the decoder worse, since only the distortion and not the rate depends on $d ( x | z )$ .
+
+Finally, we discuss solutions along the diagonal line. Such points satisfy $D = H - R$ , and hence both of our bounds are tight, so $m ( z ) = p _ { e } ( z )$ and $d ( x | z ) = p _ { e } ( x | z )$ . (Proofs of these claims are given in Sections B.3 and B.4 respectively.)
+
+So far, we have considered the infinite model family limit. If we have only finite parametric families for each of $d ( x | z ) , m ( z ) , e ( z | x )$ , we expect in general that our bounds will not be tight. Any failure of the approximate marginal $m ( z )$ to model the true marginal $p _ { e } ( z )$ , or the decoder $d ( x | z )$ to model the true likelihood $p _ { e } ( x | z )$ , will lead to a gap with respect to the optimal black surface. However, it will still be the case that ${ \dot { H } } - D - R \leq 0$ . This suggests that there will still be a one dimensional optimal surface, $D ( R )$ , or $R ( D )$ where optimality is defined to be the tightest achievable sandwiched bound within the parametric family. We will use the term $R D$ curve to refer to this optimal surface in the rate-distortion $( R D )$ plane. Since the data entropy $H$ is outside our control, this surface can be found by means of constrained optimization, either minimizing the distortion at some fixed rate, or minimizing the rate at some fixed distortion, as we show below. Furthermore, by the same arguments as above, this surface should be monotonic in both $R$ and $D$ , since for any solution, with only very mild assumptions on the form of the parametric families, we should always be able to make $m ( z )$ less accurate in order to increase the rate at fixed distortion (see shift from red curve to blue curve in fig. 1), or make the decoder $d ( x | z )$ less accurate to increase the distortion at fixed rate (see shift from red curve to green curve in fig. 1).
+
+Optimization In this section, we discuss how we can find models that target a given point on the $R D$ curve. Recall that the rate $R$ and distortion $D$ are given by
+
+$$
+\begin{array} { l } { { R \equiv \displaystyle \int d x p ^ { \ast } ( x ) \int d z e ( z | x ) \log \frac { e ( z | x ) } { m ( z ) } } } \\ { { { \cal D } \equiv \displaystyle - \int d x p ^ { \ast } ( x ) \int d z e ( z | x ) \log d ( x | z ) } } \end{array}
+$$
+
+These can both be approximated using a Monte Carlo sample from our training set. We also require that the terms $\log d ( x | z )$ , $\log m ( z )$ and $\log e ( z | x )$ be efficient to compute, and that $e ( z | x )$ be efficient to sample from. In Section 4, we will describe the modeling choices we made for our experiments.
+
+In order to explore the qualitatively different optimal solutions along the frontier, we need to explore different rate-distortion trade-offs. One way to do this would be to perform some form of constrained optimization at fixed rate. Alternatively, instead of considering the rate as fixed, and tracing out the optimal distortion as a function of the rate $D ( R )$ , we can perform the Legendre transformation and can find the optimal rate and distortion for a fixed $\begin{array} { r } { \beta = \frac { \partial D } { \partial R } } \end{array}$ , by minimizing $\begin{array} { r l } { \operatorname* { m i n } _ { e ( z | x ) , m ( z ) , d ( x | z ) } D + } \end{array}$ $\beta R$ . Writing this objective out in full, we get
+
+$$
+\operatorname* { m i n } _ { e ( z | x ) , m ( z ) , d ( x | z ) } \int d x p ^ { * } ( x ) \int d z e ( z | x ) \left[ - \log d ( x | z ) + \beta \log \frac { e ( z | x ) } { m ( z ) } \right] .
+$$
+
+If we set $\beta = 1$ , this matches the ELBO objective used when training a VAE (Kingma & Welling, 2014), with the distortion term matching the reconstruction loss, and the rate term matching the “KL term”. Note, however, that this objective does not distinguish between any of the points along the diagonal of the optimal $R D$ curve, all of which have $\beta = 1$ and the same ELBO. Thus the ELBO objective alone (and the marginal likelihood) cannot distinguish between models that make no use of the latent variable (autodecoders) versus models that make large use of the latent variable and learn useful representations for reconstruction (autoencoders). This is demonstrated experimentally in Section 4.
+
+If we allow a general $\beta \geq 0$ , we get the $\beta$ -VAE objective used in (Higgins et al., 2017; Alemi et al., 2017). This allows us to smoothly interpolate between auto-encoding behavior ( $\beta = 0$ ), where the distortion is low but the rate is high, to auto-decoding behavior $\beta = \infty$ ), where the distortion is high but the rate is low, all without having to change the model architecture. However, unlike Higgins et al. (2017); Alemi et al. (2017), we additionally optimize over the marginal $m ( z )$ and compare across a variety of architectures, thus exploring a much larger solution space, which we illustrate empirically in Section 4.
+
+# 3 RELATED WORK
+
+Here we present an overview of the most closely related work. A more detailed treatment can be found in Appendix D.
+
+Model families for unsupervised learning with neural networks. There are two broad areas of active research in deep latent-variable models with neural networks: methods based on the variational autoencoder (VAE), introduced by Kingma & Welling (2014); Rezende et al. (2014), and methods based on generative adversarial networks (GANs), introduced by Goodfellow et al. (2014). In this paper, we focus on the VAE family of models. In particular, we consider recent variants using inverse autoregressive flow (IAF) (Kingma et al., 2016), masked autoregressive flow (MAF) (Papamakarios et al., 2017), PixelCNN $^ { + + }$ (Salimans et al., 2017), and the VampPrior (Tomczak & Welling, 2017), as well as common Conv/Deconv encoders and decoders.
+
+Information Theory and machine learning. Barber & Agakov (2003) was the first to introduce tractable variational bounds on mutual information, and made close analogies and comparisons to maximum likelihood learning and variational autoencoders. The information bottleneck framework (Tishby et al., 1999; Shamir et al., 2010; Tishby & Zaslavsky, 2015; Alemi et al., 2017; Achille & Soatto, 2016; 2017) allows a model to smoothly trade off the minimality of the learned representation $( Z )$ from data $( X )$ by minimizing their mutual information, $I ( X ; Z )$ , against the informativeness of the representation for the task at hand $( Y )$ by maximizing their mutual information, $I ( Z ; Y )$ . This constrained optimization problem is rephrased with the Lagrange multiplier, $\beta$ , to the unconstrained optimization of $I ( X ; Z ) - \beta I ( Z ; Y )$ . Tishby & Zaslavsky (2015) plot an RD curve similar to the one in this paper, but they only consider the supervised setting, and they do not consider the information content that is implicit in powerful stochastic decoders. Higgins et al. (2017) proposed the $\beta$ -VAE for unsupervised learning, which is a generalization of the original VAE in which the KL term is scaled by $\beta$ , similar to this paper. However, they only considered $\beta > 1$ . In this paper, we show that when using powerful autoregressive decoders, using $\beta \geq 1$ results in the model ignoring the latent code, so it is necessary to use $\beta < 1$ .
+
+Generative Models and Compression. Much recent work has explored the use of latent-variable generative models for image compression. Balle et al. (2017) studies the problem explicitly in terms ´ of the rate/distortion plane, adjusting a Lagrange multiplier on the distortion term to explore the convex hull of a model’s optimal performance. Johnston et al. (2017) uses a recurrent VAE architecture to achieve state-of-the-art image compression rates, posing the loss as minimizing distortion at a fixed rate. Theis et al. (2017) writes the VAE loss as $R + \beta D$ . Rippel & Bourdev (2017) shows that a GAN optimization procedure can also be applied to the problem of compression. All of these efforts focus on rate/distortion tradeoffs for individual models, but don’t explore how the selection of the model itself affects the rate/distortion curve. Because we explore many combinations of modeling choices, we are able to more deeply understand how model selection impacts the rate/distortion curve, and to point out the area where all current models are lacking – the auto-encoding limit. Generative compression models also have to work with both quantized latent spaces and approximately fixed decoder model families trained with perceptual losses such as MS-SSIM (Wang et al., 2003), which constrain the form of the learned distribution. Our work does not assume either of these constraints are present for the tasks of interest.
+
+# 4 EXPERIMENTS
+
+Toy Model In this section, we empirically show a case where the usual ELBO objective can learn a model which perfectly captures the true data distribution, $p ^ { * } ( x )$ , but which fails to learn a useful latent representation. However, by training the same model such that we minimize the distortion, subject to achieving a desired target rate $R ^ { * }$ , we can recover a latent representation that closely matches the true generative process (up to a reparameterization), while also perfectly capturing the true data distribution.
+
+We create a simple data generating process that consists of a true latent variable $Z ^ { * } = \{ z _ { 0 } , z _ { 1 } \} \sim$ $\mathrm { B e r } ( 0 . 7 )$ with added Gaussian noise and discretization. The magnitude of the noise was chosen so that the true generative model had $\operatorname { I } ( x ; z ^ { * } ) = 0 . 5$ nats of mutual information between the observations and the latent. We additionally choose a model family with sufficient power to perfectly autoencode or autodecode. See Appendix $\mathrm { E }$ for more detail on the data generation and model.
+
+Figure 2 shows various distributions computed using three models. For the left column, we use a hand-engineered encoder $e ( z | x )$ , decoder $d ( x | z )$ , and marginal $m ( z )$ constructed with knowledge of the true data generating mechanism to illustrate an optimal model. For the middle and right columns, we learn $e ( z | x ) , d ( x | z )$ , and $m ( z )$ using effectively infinite data sampled from $p ^ { * } ( x )$ directly. The middle column is trained with ELBO. The right column is trained by targeting $R = 0 . 5$ while minimizing $D$ .2 In both cases, we see that $p ^ { * } ( x ) \approx g ( x ) \approx d ( x )$ for both trained models, indicating that optimization found the global optimum of the respective objectives. However, the VAE fails to learn a useful representation, only yielding a rate of $R = 0 . 0 0 0 2$ nats,3 while the Target Rate model achieves $R = 0 . 4 9 9 9$ nats. Additionally, it nearly perfectly reproduces the true generative process, as can be seen by comparing the yellow and purple regions in the z-space plots (middle row) – both the optimal model and the Target Rate model have two clusters, one with about $70 \%$ of the probability mass, corresponding to class 0 (purple shaded region), and the other with about $30 \%$ of the mass (yellow shaded region) corresponding to class 1. In contrast, the z-space of the VAE completely mixes the yellow and purple regions, only learning a single cluster. Note that we reproduced essentially identical results with dozens of different random initializations for both the VAE and the Target Rate model – these results are not cherry-picked.
+
+![](images/f8546b332e8ea9663ccea8849802dd75309ce6cd218f4e9336e930d6c8afa282.jpg)  
+Figure 2: Toy Model illustrating the difference between fitting a model by maximizing ELBO (middle column) vs minimizing distortion for a fixed rate (right column). Top: Three distributions in data space: the true data distribution, $\boldsymbol { p } ^ { * } ( \boldsymbol { x } )$ , the model’s generative distribution, $\begin{array} { r } { g ( x ) { \stackrel { - } { = } } \sum _ { z } m ( z ) d ( x | z ) } \end{array}$ , and the empirical data reconstruction distribution, $\begin{array} { r } { d ( x ) = \bar { \sum _ { x ^ { \prime } } \sum _ { z } \hat { p } ( x ^ { \prime } ) e ( z | x ^ { \prime } ) \bar { d ( } \hat { x | z } ) } } \end{array}$ . Middle: Four distributions in latent space: the learned (or computed) marginal $m ( z )$ , the empirical induced marginal $\begin{array} { r } { e ( z ) = \sum _ { x } \hat { p } ( x ) e ( z | x ) } \end{array}$ , the empirical distribution over $z$ values for data vectors in the set $\mathcal { X } _ { 0 } = \{ x _ { n } : z _ { n } = 0 \}$ , which we denote by $e ( z _ { 0 } )$ in purple, and the empirical distribution over $z$ values for data vectors in the set $\mathcal { X } _ { 1 } = \{ x _ { n } : z _ { n } = 1 \}$ , which we denote by $e ( z _ { 1 } )$ in yellow. Bottom: Three $K \times K$ distributions: $e ( z | x ) , d ( x | z )$ and $\begin{array} { r } { \dot { p } ( x ^ { \prime } | x ) = \dot { \sum _ { z } } e ( z | x ) d ( x ^ { \prime } | z ) } \end{array}$ .
+
+MNIST. In this section, we show how comparing models in terms of rate and distortion separately is more useful than simply observing marginal log likelihoods. We examine several VAE model architectures that have been proposed in the literature. We use the static binary MNIST dataset originally produced for (Larochelle & Murray, 2011)4. In appendix A, we show analogous results for the Omniglot dataset (Lake et al., 2015).
+
+We will consider simple and complex variants for the encoder and decoder, and three different types of marginal. The simple encoder is a CNN with a fully factored 64 dimensional Gaussian for $e ( z | x )$ ; the more complex encoder is similar, but followed by 4 steps of mean-only Gaussian inverse autoregressive flow (Kingma et al., 2016), with each step implemented as a 3 hidden layer MADE (Germain et al., 2015) with 640 units in each hidden layer. The simple decoder is a multilayer deconvolutional network; the more powerful decoder is a PixelCNN $^ { + + }$ (Salimans et al., 2017) model. The simple marginal is a fixed isotropic Gaussian, as is commonly used with VAEs; the more complicated version has a 4 step 3 layer MADE (Germain et al., 2015) mean-only Gaussian autoregressive flow (Papamakarios et al., 2017). We also consider the setting in which the marginal uses the VampPrior from (Tomczak & Welling, 2017). We will denote the particular model combination by the tuple $( + / - , + / - , + / - / v )$ , depending on whether we use a simple $( - )$ or complex $( + )$ (or $( v )$ VampPrior) version for the (encoder, decoder, marginal) respectively. In total we consider $2 \times 2 \times 3 = 1 2$ models. We train them all to minimize the objective in Equation 4. Full details can be found in Appendix F. Runs were performed at various values of $\beta$ ranging from 0.1 to 10.0, both with and without KL annealing (Bowman et al., 2016).
+
+![](images/dd93f683b94956de4b50cb0f2ccacebec615e217372eeab7e7477ba522f7c08d.jpg)  
+Figure 3: Results on MNIST. (a) The best achieved rate distortion value for each run plotted on the $R D$ - plane. We denote the particular model combination by the tuple $( + / - , + / - , + / - / v )$ , depending on whether we use a simple $( - )$ or complex $( + )$ (or $( v )$ VampPrior) version for the (encoder, decoder, marginal) respectively. (b) The same data, but on the skew axes of $\mathrm { E L B O } = R + D$ versus $R$ .
+
+RD curve. Figure 3a show the $R D$ plot for 12 models on the MNIST dataset. Dashed lines represent the best achieved test ELBO of 80.2 nats, which then sets an upper bound on the true data entropy $H$ for the static MNIST dataset. This implies that any $R D$ value above the dashed line is in principle achievable in a powerful enough model. The stepwise black curves show the monotonic Pareto frontier of achieved $R D$ points across all model families. Points participating in this curve are denoted with a $\times$ on the right. The grey solid line shows the corresponding convex hull, which we approach closely across all rates. Strong decoder model families dominate at the lowest and highest rates. Weak decoder models dominate at intermediate rates. Strong marginal models dominate strong encoder models at most rates. Across our model families we appear to be pushing up against an approximately smooth $R D$ curve. The 12 model families we considered here, arguably a representation of the classes of models considered in the VAE literature, in general perform much worse in the auto-encoding limit (bottom right corner) of the $R D$ plane. This is likely due to a lack of power in our current marginal approximations.
+
+Figure 3b shows the same raw data, but where we plot $\scriptstyle \mathrm { E L B O } = R + D$ versus $R$ . Here some of the differences between individual model families performances are more easily resolved. Broadly, models with a deconvolutional decoder perform well at intermediate $\sim 2 2$ nat rates, but quickly suffer large distortion penalties as they move away from that point. This is perhaps unsurprising considering we trained on the binary MNIST dataset, for which the measured pixel level sampling entropy on the test set is approximately 22 nats.
+
+Models with a powerful autoregressive decoder perform well at low rates, but for values of $\beta \geq 1$ tend to collapse to pure autodecoding models. With the use of the VampPrior and KL annealing however, $\beta = 1$ models can exist at finite rates of around 8 nats. Our framework helps explain the observed difficulties in the literature of training a useful VAE with a powerful decoder, and the observed utility of techniques like “free bits” (Kingma et al., 2016), “soft free bits” (Chen et al., 2017) and $\mathrm { K L }$ annealing (Bowman et al., 2016). Each of these effectively trains at a reduced $\beta$ , moving up along the $R D$ curve. Without any additional modifications, simply training at reduced $\beta$ is a simpler way to achieve nonvanishing rates, without additional architectual adjustments like in the variational lossy autoencoder (Chen et al., 2017).
+
+![](images/82a5e4757a36c88166bea170a5a272fa6a25ffe39c8c1c985da0e45b4d80bcce.jpg)  
+Figure 4: We can smoothly move between pure autodecoding and autoencoding behavior in a single model family by tuning $\beta$ . (a) Sampled reconstructions from the $\mathbf { - + v }$ model family trained at given $\beta$ values. Pairs of columns show a single reconstruction and the mean of 5 reconstructions. The first column shows the input samples. (b) Generated images from the same set of models. The pairs of columns are single samples and the mean of 5 samples. See text for discussion.
+
+Analyzing model performance using the $R D$ curve gives a much more insightful comparison of relative model performance than simply comparing marginal data log likelihoods. In particular, we managed to achieve models with five-sample IWAE (Burda et al., 2015) estimates below 82 nats (a competitive rate for single layer latent variable models (Tomczak & Welling, 2017)) for rates spanning from $1 0 ^ { - 4 }$ to 30 nats. While all of those models have competitive ELBOs or marginal log likelihood, they differ substantially in the tradeoffs they make between rate and distortion, and those differences result in qualitatively different model behavior, as illustrated in Figure 4.
+
+The interaction between latent variables and powerful decoders. Within any particular model family, we can smoothly move between and explore its performance at varying rates. An illustrative example is shown in Fig. 4, where we study the effect of changing $\beta$ (using KL annealing from low to high) on the same $\mathbf { - } + \mathbf { V }$ model, corresponding to a VAE with a simple encoder, a powerful PixelCNN++ decoder, and a powerful VampPrior marginal.
+
+In Fig. 4a we assess how well the models do at reconstructing their inputs. We pick an image $x$ at random, encode it using $z \sim e ( z | x )$ , and then reconstruct it using $\hat { x } \sim d ( x \bar { | } z )$ . When $\beta =$ 1.10 (left column), the model obtains $R = 0 . 0 0 0 4 , D = 8 0 . 6 , { \mathrm { E L B O } } = 8 0 . 6$ nats. The tiny rate indicates that the decoder ignores its latent code, and hence the reconstructions are independent of the input $x$ . For example, when the input is $x \ = \ 8$ , the reconstruction is $\hat { x } = 3$ . However, the generated images sampled from the decoder look good (this is an example of an autodecoder). At the other extreme, when $\beta \ : = \ : 0 . 0 5$ (right column), the model obtains $R = 1 5 6 , D = 4 . 8$ , $\mathrm { E L B O } { = } 1 6 1$ nats. Here the model does an excellent job of auto-encoding, generating nearly pixel perfect reconstructions. However, samples from this model’s prior, as shown on the right, are of very poor quality, reflected in the worse ELBO and IWAE values. At intermediate values, such as $\beta = 1 . 0$ , $( R = 6 . 2 , D = 7 4 . 1$ , $\mathrm { E L B O } { = } 8 0 . 3$ ) the model seems to retain semantically meaningful information about the input, such as its class and width of the strokes, but maintains variation in the individual reconstructions. In particular, notice that the individual $" 2 "$ sent in is reconstructed as a similar “2” but with a visible loop at the bottom. This model also has very good generated samples. This intermediate rate encoding arguably typifies what we want to achieve in unsupervised learning: we have learned a highly compressed representation that retains salient features of the data. In the third column, the $\beta \ : = \ : 0 . 1 5$ model $( R = 1 2 0 . 3 , D = 8 . 1$ , $\mathrm { E L B O } { = } 1 2 8$ ) we have very good reconstructions Figure 4b one can visually inspect while still obtaining a good degree of compression. This model arguably typifies the domain most compression work is interested in, where most perceivable variations in the digit are retained in the compression. However, at these higher rates the failures of our current architectures to approach their theoretical performance becomes more apparent, as the corresponding ELBO of 128 nats is much higher than the 81 nats we obtain at low rates. This is also evident in the visual degradation in the generated samples.
+
+While it is popular to visualize both the reconstructions and generated samples from VAEs, we suggest researchers visually compare several sampled decodings using the same sample of the latent variable, whether it be from the encoder or the prior, as done here in Figure 4. By using a single sample of the latent variable, but decoding it multiple times, one can visually inspect what features of the input are captured in the observed value for the rate. This is particularly important to do when using powerful decoders, such as autoregressive models.
+
+# 5 DISCUSSION AND FURTHER WORK
+
+We have motivated the $\beta$ -VAE objective on information theoretic grounds, and demonstrated that comparing model architectures in terms of the rate-distortion plot offers a much better look at their performance and tradeoffs than simply comparing their marginal log likelihoods. Additionally, we have shown a simple way to fix models that ignore the latent space due to the use of a powerful decoder: simply reduce $\beta$ and retrain. This fix is much easier to implement than other solutions that have been proposed in the literature, and comes with a clear theoretical justification. We strongly encourage future work to report rate and distortion values independently, rather than just reporting the log likelihood. If future work proposes new architectural regularization techniques, we suggest the authors train their objective at various rate distortion tradeoffs to demonstrate and quantify the region of the RD plane where their method dominates.
+
+Through a large set of experiments we have demonstrated the performance at various rates and distortion tradeoffs for a set of representative architectures currently under study, confirming the power of autoregressive decoders, especially at low rates. We have also shown that current approaches seem to have a hard time achieving high rates at low distortion. This suggests a set of experiments with a simple encoder / decoder pair but a powerful autoregressive marginal posterior approximation, which should in principle be able to reach the autoencoding limit, with vanishing distortion and rates approaching the data entropy.
+
+Interpreting the $\beta$ -VAE objective as a constrained optimization problem also hints at the possibility of applying more powerful constrained optimization techniques, which we hope will be able to advance the state of the art in unsupervised representation learning.
+
+# REFERENCES
+
+A. Achille and S. Soatto. Information Dropout: Learning Optimal Representations Through Noisy Computation. In Information Control and Learning, September 2016. URL http://arxiv. org/abs/1611.01353.   
+A. Achille and S. Soatto. Emergence of Invariance and Disentangling in Deep Representations. Proceedings of the ICML Workshop on Principled Approaches to Deep Learning, 2017. URL https://arxiv.org/abs/1706.01350.   
+Felix Vsevolodovich Agakov. Variational Information Maximization in Stochastic Environments. PhD thesis, University of Edinburgh, 2006.   
+Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep Variational Information Bottleneck. In ICLR, 2017. URL http://arxiv.org/abs/1612.00410.   
+J. Balle, V. Laparra, and E. P. Simoncelli. End-to-end Optimized Image Compression. In ´ ICLR, 2017. URL http://arxiv.org/abs/1611.01704.   
+David Barber and Felix V. Agakov. Information maximization in noisy channels : A variational approach. In S. Thrun, L. K. Saul, and B. Scholkopf (eds.), ¨ Advances in Neural Information Processing Systems 16, pp. 201–208. MIT Press, 2003. URL http://papers.nips.cc/paper/ 2410-information-maximization-in-noisy-channels-a-variational-approach pdf.
+
+Samuel R Bowman, Luke Vilnis, Oriol Vinyals, Andrew M Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. CoNLL 2016, pp. 10, 2016. URL http://arxiv.org/abs/1511.06349.
+
+Yuri Burda, Roger Grosse, and Ruslan Salakhutdinov. Importance weighted autoencoders. In ICLR, 2015. URL http://arxiv.org/abs/1509.00519.
+
+X. Chen, D. P. Kingma, T. Salimans, Y. Duan, P. Dhariwal, J. Schulman, I. Sutskever, and P. Abbeel. Variational Lossy Autoencoder. In ICLR, 2017. URL https://arxiv.org/abs/1611. 02731.
+
+Thomas M Cover and Joy A Thomas. Elements of information theory. John Wiley & Sons, 2012.
+
+Jifeng Dai, Yang Lu, and Ying-Nian Wu. Generative modeling of convolutional neural networks. In ICLR, 2015. URL http://arxiv.org/abs/1412.6296.
+
+Yann N. Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 933–941, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr.press/v70/dauphin17a.html.
+
+Weihao Gao, Sreeram Kannan, Sewoong Oh, and Pramod Viswanath. Estimating mutual information for discrete-continuous mixtures. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 5988–5999. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 7180-estimating-mutual-information-for-discrete-continuous-mixtures. pdf.
+
+Mathieu Germain, Karol Gregor, Iain Murray, and Hugo Larochelle. Made: Masked autoencoder for distribution estimation. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 881–889, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings. mlr.press/v37/germain15.html.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2672–2680. Curran Associates, Inc., 2014. URL http://papers. nips.cc/paper/5423-generative-adversarial-nets.pdf.
+
+I. Higgins, L. Matthey, X. Glorot, A. Pal, B. Uria, C. Blundell, S. Mohamed, and A. Lerchner. Early Visual Concept Learning with Unsupervised Deep Learning. ArXiv e-prints, June 2016. URL https://arxiv.org/abs/1606.05579.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. $\beta$ -VAE: Learning Basic Visual Concepts with a Constrained Variational Framework. In ICLR, 2017. URL https://openreview.net/pdf? id=Sy2fzU9gl.
+
+Geoffrey E Hinton and Drew Van Camp. Keeping the neural networks simple by minimizing the description length of the weights. In Proceedings of the sixth annual conference on Computational learning theory, pp. 5–13. ACM, 1993.
+
+Z. Hu, Z. Yang, R. Salakhutdinov, and E. P. Xing. On Unifying Deep Generative Models. ArXiv e-prints, June 2017. URL https://arxiv.org/abs/1706.00550.
+
+Jonathan Huang, Vivek Rathod, Chen Sun, Menglong Zhu, Anoop Korattikara, Alireza Fathi, Ian Fischer, Zbigniew Wojna, Yang Song, Sergio Guadarrama, et al. Speed/accuracy trade-offs for modern convolutional object detectors. Conference on Computer Vision and Pattern Recognition, 2017.
+
+N. Johnston, D. Vincent, D. Minnen, M. Covell, S. Singh, T. Chinen, S. J. Hwang, J. Shor, and G. Toderici. Improved Lossy Image Compression with Priming and Spatially Adaptive Bit Rates for Recurrent Networks. ArXiv e-prints, March 2017. URL https://arxiv.org/abs/ 1703.10114.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. URL https://arxiv.org/abs/1412.6980.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. In ICLR, 2014. URL https://arxiv.org/abs/1312.6114.
+
+Diederik P Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improved variational inference with inverse autoregressive flow. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4743–4751. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6581-improved-variational-inference-with-inverse-autoregressive-flow. pdf.
+
+Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. ISSN 0036-8075. doi: 10.1126/science.aab3050. URL http://science.sciencemag.org/content/ 350/6266/1332.
+
+Hugo Larochelle and Iain Murray. The neural autoregressive distribution estimator. In Geoffrey Gordon, David Dunson, and Miroslav Dudk (eds.), Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, volume 15 of Proceedings of Machine Learning Research, pp. 29–37, Fort Lauderdale, FL, USA, 11–13 Apr 2011. PMLR. URL http://proceedings.mlr.press/v15/larochelle11a.html.
+
+Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, and Ian Goodfellow. Adversarial autoencoders. In ICLR, 2016. URL http://arxiv.org/abs/1511.05644.
+
+Aaron Van Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1747–1756, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http: //proceedings.mlr.press/v48/oord16.html.
+
+Liam Paninski. Estimation of entropy and mutual information. Neural Computation, 15(6):1191– 1253, 2003. doi: 10.1162/089976603321780272. URL https://doi.org/10.1162/ 089976603321780272.
+
+George Papamakarios, Iain Murray, and Theo Pavlakou. Masked autoregressive flow for density estimation. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 2335–2344. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6828-masked-autoregressive-flow-for-density-estimation.pdf.
+
+Yuchen Pu, Weiyao Wang, Ricardo Henao, Liqun Chen, Zhe Gan, Chunyuan Li, and Lawrence Carin. Adversarial symmetric variational autoencoder. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 4333– 4342. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 7020-adversarial-symmetric-variational-autoencoder.pdf.
+
+Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 1530–1538, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr.press/v37/rezende15. html.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Eric P. Xing and Tony Jebara (eds.), Proceedings of the 31st International Conference on Machine Learning, volume 32 of Proceedings of Machine Learning Research, pp. 1278–1286, Bejing, China, 22–24 Jun 2014. PMLR. URL http://proceedings.mlr.press/v32/rezende14.html.
+
+Oren Rippel and Lubomir Bourdev. Real-time adaptive image compression. In ICML, 2017. URL https://arxiv.org/abs/1705.05823.
+
+Tim Salimans, Andrej Karpathy, Xi Chen, and Diederik P Kingma. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. In ICLR, 2017. URL https://arxiv.org/abs/1701.05517.
+
+Ohad Shamir, Sivan Sabato, and Naftali Tishby. Learning and generalization with the information bottleneck. Theoretical Computer Science, 411(29):2696 – 2711, 2010. ISSN 0304-3975. doi: https://doi.org/10.1016/j.tcs.2010.04.006. URL http://www.sciencedirect.com/ science/article/pii/S030439751000201X. Algorithmic Learning Theory (ALT 2008).
+
+Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. CoRR, abs/1703.00810, 2017. URL http://arxiv.org/abs/1703.00810.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014. URL http://jmlr.org/papers/v15/ srivastava14a.html.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander Alemi. Inception-v4, inceptionresnet and the impact of residual connections on learning, 2017. URL https://www.aaai. org/ocs/index.php/AAAI/AAAI17/paper/view/14806.
+
+Casper Kaae Snderby, Tapani Raiko, Lars Maale, Sren Kaae Snderby, and Ole Winther. How to Train Deep Variational Autoencoders and Probabilistic Ladder Networks. 2016.
+
+Lucas Theis, Wenzhe Shi, Andrew Cunningham, and Ferenc Huszar. Lossy image compression with ´ compressive autoencoders. In ICLR, 2017. URL https://arxiv.org/abs/1703.00395.
+
+N. Tishby and N. Zaslavsky. Deep learning and the information bottleneck principle. In 2015 IEEE Information Theory Workshop (ITW), pp. 1–5, April 2015. doi: 10.1109/ITW.2015.7133169. URL https://arxiv.org/abs/1503.02406.
+
+N. Tishby, F.C. Pereira, and W. Biale. The information bottleneck method. In The 37th annual Allerton Conf. on Communication, Control, and Computing, pp. 368–377, 1999. URL https: //arxiv.org/abs/physics/0004057.
+
+J. M. Tomczak and M. Welling. VAE with a VampPrior. ArXiv e-prints, May 2017. URL https: //arxiv.org/abs/1705.07120.
+
+Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, koray kavukcuoglu, Oriol Vinyals, and Alex Graves. Conditional image generation with pixelcnn decoders. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4790–4798. Curran Associates, Inc., 2016. URL http://papers.nips.cc/ paper/6527-conditional-image-generation-with-pixelcnn-decoders. pdf.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 6000–6010. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf.
+
+Z. Wang, E. P. Simoncelli, and A. C. Bovik. Multiscale structural similarity for image quality assessment. In The Thrity-Seventh Asilomar Conference on Signals, Systems Computers, 2003, volume 2, pp. 1398–1402 Vol.2, Nov 2003. doi: 10.1109/ACSSC.2003.1292216.
+
+A. W. Yu, Q. Lin, R. Salakhutdinov, and J. Carbonell. Normalized Gradient with Adaptive Stepsize Method for Deep Neural Network Training. ArXiv e-prints, July 2017. URL https://arxiv. org/abs/1707.04822.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR, 2017. URL https://arxiv.org/ abs/1611.03530.
+
+# A RESULTS ON OMNIGLOT
+
+Figure 5 plots the RD curve for various models fit to the Omniglot dataset (Lake et al., 2015), in the same form as the MNIST results in Figure 3. Here we explored $\beta \mathbf { s }$ for the powerful decoder models ranging from 1.1 to 0.1, and $\beta \mathfrak { s }$ of 0.9, 1.0, and 1.1 for the weaker decoder models.
+
+![](images/b3735cfb2fe8bbe1656c2e19f674e526f38d99399653966c99b0c017d2b017da.jpg)  
+Figure 5: Results on Omniglot. Otherwise same description as Figure 3. (a) Rate-distortion curves. (b) The same data, but on the skew axes of $\mathrm { \therefore } \mathrm { B O } = R + D$ versus $R$ .
+
+On Omniglot, the powerful decoder models dominate over the weaker decoder models. The powerful decoder models with their autoregressive form most naturally sit at very low rates. We were able to obtain finite rates by means of KL annealing. Further experiments will help to fill in the details especially as we explore differing $\beta$ values for these architectures on the Omniglot dataset. Our best achieved ELBO was at 90.37 nats, set by the $  {  { \begin{array} { l } { {  { \begin{array} { l } { \end{array} } }  } }  } } + {  { \begin{array} { l } { { \begin{array} { l } { { \begin{array} { r l } } \end{array} } }  } } \end{array} } \end{array} \end{array}$ model with $\beta = 1 . 0$ and KL annealing. This model obtains $R = 0 . 7 7 , D = 8 9 . 6 0 , E L B O = 9 0 . 3 7$ and is nearly auto-decoding. We found 14 models with ELBOs below 91.2 nats ranging in rates from 0.0074 nats to 10.92 nats.
+
+Similar to Figure 4 in Figure 6 we show sample reconstruction and generated images from the same ”- $- + \mathbf { V } ^ { \dagger }$ model family trained with KL annealing but at various $\beta \mathbf { s }$ . Just like in the MNIST case, this demonstrates that we can smoothly interpolate between auto-decoding and auto-encoding behavior in a single model family, simply by adjusting the $\beta$ value.
+
+# B PROOFS
+
+# B.1 LOWER BOUND ON REPRESENTATIONAL MUTUAL INFORMATION
+
+Our lower bound is established by the fact that Kullback-Leibler (KL) divergences are positive semidefinite
+
+$$
+\mathrm { K L } [ q ( x | z ) | | p ( x | z ) ] = \int d x q ( x | z ) \log \frac { q ( x | z ) } { p ( x | z ) } \geq 0
+$$
+
+which implies for any distribution $p ( x | z )$ :
+
+$$
+\int d x q ( x | z ) \log q ( x | z ) \geq \int d x q ( x | z ) \log p ( x | z )
+$$
+
+![](images/7de9a2c9c65e4516f7122fd5cd5b81e83169557115d07f926c93b1a622257cf9.jpg)  
+(a) Omniglot Reconstructions: $z \sim e ( z | x ) , \hat { x } \sim d ( x | z )$ (b) Omniglot Generations: $z \sim m ( z ) , \hat { x } \sim d ( x | z )$   
+Figure 6: We can smoothly move between pure autodecoding and autoencoding behavior in a single model family by tuning $\beta$ . (a) Sampled reconstructions from the $\mathbf { - + v }$ model family trained at given $\beta$ values. Pairs of columns show a single reconstruction and the mean of 5 reconstructions. The first column shows the input samples. (b) Generated images from the same set of models. The pairs of columns are single samples and the mean of 5 samples. See text for discussion.
+
+$$
+\begin{array} { r l } & { \mathrm { L } _ { \mathrm { e r f } } = \mathrm { L } _ { \mathrm { e f f } } ( X ; Z ) = \displaystyle { \int } \int d x d z \ y _ { \mathrm { g } } ( z , z ) \log \frac { \rho _ { \mathrm { g } } ( z , z ) } { \rho ^ { \prime } ( x ) | \mathcal { D } _ { \mathrm { g } } ( z ) | \mathcal { D } _ { \mathrm { g } } ( z ) | } } \\ & { \quad = \displaystyle { \int } d x \rho _ { \mathrm { g } } ( z ) \int \ d x \nu _ { \mathrm { g } } ( z | z | ) \log \frac { \rho _ { \mathrm { g } } ( x | z | ) } { \rho ^ { \prime } ( x ) | \mathcal { D } _ { \mathrm { g } } ( z ) | } } \\ & { \quad = \displaystyle { \int } d x \rho _ { \mathrm { g } } ( z ) \left[ \int d x \nu _ { \mathrm { g } } ( z | z | ) \log r _ { \mathrm { g } } ( x | z | ) - \int d x \rho _ { \mathrm { g } } ( x | z | ) \log r ^ { \ast } ( x ) \right] } \\ & { \quad > \displaystyle { \int } d x \rho _ { \mathrm { g } } ( z ) \left[ \int d x \nu _ { \mathrm { g } } ( z | z | ) | \mathrm { g } _ { \mathrm { g } } ( x | z | ) - \int d x \rho _ { \mathrm { g } } ( x | z | ) | \mathrm { g } _ { \mathrm { g } } \rho ^ { \prime \prime } ( x ) \right] } \\ & { \quad = \displaystyle { \int } \int d x d z \nu _ { \mathrm { g } } ( x , z ) \log \frac { \rho _ { \mathrm { g } } ( z | x | ) } { \rho ^ { \prime } ( x ) | \mathcal { D } _ { \mathrm { g } } ( z ) | } } \\ & { \quad = \displaystyle { \int } d x \nu ^ { \ast } ( x ) \int d x \mathrm { e } ( z | \ s | ) \log r ^ { \ast } ( x ) } \\ & { \quad = \displaystyle { \int } \ d x \rho ^ { \ast } ( x | z | ) \log r ^ { \ast } ( x ) \ - \left( - \int d x p ^ { \ast } ( x ) \int d x \mathrm { e } ( z | s | ) \log b ( x | z | ) \right) } \\ & { \quad = \displaystyle { \int } \ d x \rho ^ { \ast } ( x | z | ) \log r ^ { \ast } ( x ) \ . } \end{array}
+$$
+
+# B.2 UPPER BOUND ON REPRESENTATIONAL MUTUAL INFORMATION
+
+The upper bound is established again by the positive semidefinite quality of KL divergence.
+
+$$
+\mathrm { K L } [ q ( z | x ) \mid \mid p ( z ) ] \ge 0 \implies \int d z q ( z | x ) \log q ( z | x ) \ge \int d z q ( z | x ) \log p ( z )
+$$
+
+$$
+\begin{array} { r l } {  { \| _ { \infty } - \| _ { \infty } ( X _ { + } ; \zeta ) - ( \int \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \mathrm { l e g } \frac { - \beta ( x , z ) } { \beta ^ { 2 } } \mathrm { l e g } ( x , z ) ) } } \\ & { = \int \displaystyle \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \frac { \beta ( z ) ( z ) } { \beta ^ { 2 } } } } \\ & { = \int \displaystyle \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \frac { \zeta ( z ) ( z ) ( z ) } { \beta ^ { 2 } } } - \int \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \beta ( z ) } \mathrm { l e g } _ { \beta ( z ) } } \\ & { = \int \displaystyle \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \alpha } \mathrm { e } ^ { \zeta \cdot \zeta } ( z ) - \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z ) \log _ { \beta ( z ) } \mathrm { l e g } _ { \beta ( z ) } } \\ & { \le \displaystyle \int \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \alpha } \mathrm { e } ^ { \zeta \cdot \zeta } ( z ) - \int \mathrm { d } z \mathrm { e } ^ { \zeta \cdot \zeta } ( z ) \log _ { \alpha } \mathrm { e } ^ { \zeta \cdot \zeta } ) } \\ & { = \int \displaystyle \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \frac { \zeta ( z ) ( z ) ( z ) } { \beta ^ { 2 } } } - \int \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \frac { \zeta ( z ) } { \beta ^ { 2 } } } } \\ & { - \displaystyle \int \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( z , z ) \log _ { \frac { \zeta ( z ) ( z ) ( z ) } { \beta ^ { 2 } } } } \\ & { = \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( x , z ) \log _ { \frac { \zeta ( z ) ( z ) } { \beta ^ { 2 } } } } \\ &  = \int \mathrm { d } x \mathrm { e } ^ { \zeta \cdot \zeta } ( x , z ) \log _  \frac { \zeta ( z ) ( z ) }  \ \end{array}
+$$
+
+B.3 OPTIMAL MARGINAL FOR FIXED ENCODER
+
+Here we establish that the optimal marginal approximation $p ( z )$ , is precisely the marginal distribution of the encoder.
+
+$$
+{ \cal R } \equiv \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \frac { e ( z | x ) } { m ( z ) }
+$$
+
+Consider the variational derivative of the rate with respect to the marginal approximation:
+
+$$
+m ( z )  m ( z ) + \delta m ( z ) \quad \int d z \delta m ( z ) = 0
+$$
+
+$$
+\begin{array} { l } { { \delta R = \displaystyle \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \frac { e ( z | x ) } { m ( z ) + \delta m ( z ) } - R } } \\ { { { } ~ = \displaystyle \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \left( 1 + \frac { \delta m ( z ) } { m ( z ) } \right) } } \\ { { { } ~ \sim \displaystyle \int d x p ^ { * } ( x ) \int d z e ( z | x ) \frac { \delta m ( z ) } { m ( z ) } } } \end{array}
+$$
+
+Where in the last line we have taken the first order variation, which must vanish if the total variation is to vanish. In particular, in order for this variation to vanish, since we are considering an arbitrary $\delta m ( z )$ , except for the fact that the integral of this variation must vanish, in order for the first order variation in the rate to vanish it must be true that for every value of $x , z$ we have that:
+
+$$
+m ( z ) \propto p ^ { * } ( x ) e ( z | x ) ,
+$$
+
+which when normalized gives:
+
+$$
+m ( z ) = \int d x p ^ { * } ( x ) e ( z | x ) ,
+$$
+
+or that the marginal approximation is the true encoder marginal.
+
+# B.4 OPTIMAL DECODER FOR FIXED ENCODER
+
+Next consider the variation in the distortion in terms of the decoding distribution with a fixed encoding distribution.
+
+$$
+d ( x | z )  d ( x | z ) + \delta d ( x | z ) \quad \int d x d ( x | z ) = 0
+$$
+
+$$
+\begin{array} { l } { { \displaystyle \delta D = - \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log ( d ( x | z ) + \delta d ( x | z ) ) - D } } \\ { { \displaystyle ~ = - \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \Big ( 1 + \frac { \delta d ( x | z ) } { d ( x | z ) } \Big ) } } \\ { { \displaystyle ~ \sim - \int d x p ^ { * } ( x ) \int d z e ( z | x ) \frac { \delta d ( x | z ) } { d ( x | z ) } } } \end{array}
+$$
+
+Similar to the section above, we took only the leading variation into account, which itself must vanish for the full variation to vanish. Since our variation in the decoder must integrate to 0, this term will vanish for every $x , z$ we have that:
+
+$$
+d ( x | z ) \propto p ^ { * } ( x ) e ( z | x ) ,
+$$
+
+when normalized this gives:
+
+$$
+d ( x | z ) = e ( z | x ) \frac { p ^ { * } ( x ) } { \int d x p ^ { * } ( x ) e ( z | x ) }
+$$
+
+which ensures that our decoding distribution is the correct posterior induced by our data and encoder.
+
+# B.5 LOWER BOUND ON GENERATIVE MUTUAL INFORMATION
+
+The lower bound is established as all other bounds have been established, with the positive semidefiniteness of $\mathrm { K L }$ divergences.
+
+$$
+\mathrm { K L } [ d ( z | x ) \mid \mid q ( z | x ) ] = \int d z d ( z | x ) \log \frac { d ( z | x ) } { q ( z | x ) } \geq 0
+$$
+
+which implies for any distribution $q ( z | x )$
+
+$$
+\int d z d ( z | x ) \log d ( z | x ) \geq \int d z d ( z | x ) \log q ( z | x )
+$$
+
+$$
+\begin{array} { r l } & { I _ { \mathrm { S t m } } = I _ { \mathrm { S t m } } ( X ; Z ) = \displaystyle \iint \displaystyle d x d z \ y _ { \mathrm { p o t } } ( x , z ) \log \frac { p _ { \mathrm { g o t } } ( x , z ) } { p _ { \mathrm { g o t } } ( x ) p _ { \mathrm { g r o t } } ( z ) } } \\ & { \quad = \displaystyle \iint d x p _ { \mathrm { g a t } } ( x ) \int d z p _ { \mathrm { g a t } } ( z | x ) \log \frac { p _ { \mathrm { g a t } } ( z | x ) } { m ( z ) } } \\ & { \quad = \displaystyle \int d x p _ { \mathrm { p a t } } ( x ) \left[ \int d z p _ { \mathrm { g a t } } ( z | x ) \log p _ { \mathrm { g r o t } } ( z | x ) - \int d z p _ { \mathrm { g a t } } ( z | x ) \log m ( z ) \right] } \\ & { \quad \ge \displaystyle \int d x p _ { \mathrm { g a t } } ( x ) \left[ \int d z p _ { \mathrm { g a t } } ( z | x ) \log e ( z | x ) - \int d z p _ { \mathrm { g a t } } ( z | x ) \log m ( z ) \right] } \\ & { \quad = \displaystyle \iint d x d z p _ { \mathrm { g a t } } ( x , z ) \log \frac { e ( z | x ) } { m ( z ) } } \\ & { \quad = \displaystyle \int d x d z p _ { \mathrm { f o t } } ( x , z ) \log \frac { e ( z | x ) } { m ( z ) } } \\ & { \quad = \displaystyle \int d x \left( z \right) \int d x d ( x | z ) \log \frac { e ( z | x ) } { m ( z ) } } \\ & { \quad = \displaystyle E } \end{array}
+$$
+
+B.6 UPPER BOUND ON GENERATIVE MUTUAL INFORMATION
+
+The upper bound is establish again by the positive semidefinite quality of KL divergence.
+
+$$
+\mathrm { K L } [ p ( x | z ) \mid \mid r ( x ) ] \ge 0 \implies \int d x p ( x | z ) \log p ( x | z ) \ge \int d x p ( x | z ) \log r ( x )
+$$
+
+$$
+\begin{array} { r l } & { I _ { \mathcal { G } ^ { \alpha } } = - f _ { \Phi ^ { \alpha } } ( X ; z ) = \displaystyle \int \int d x d z p _ { \Phi ^ { \alpha } } ( x , z ) \mathrm { l o g } \frac { \partial f _ { \Phi ^ { \alpha } } ( x , z ) } { \partial x _ { \Phi ^ { \alpha } } ( x , z ) m _ { \Phi ^ { \alpha } } ( x , z ) m _ { \Phi ^ { \alpha } } ( x , z ) } } \\ & { \quad = \displaystyle \int \int d x d z \mathrm { s p } _ { \Phi ^ { \alpha } ( z , z ) } \mathrm { l o g } \frac { \partial f _ { \Phi ^ { \alpha } } ( x , z ) } { \partial x _ { \Phi ^ { \alpha } } ( x , z ) } } \\ & { \quad - \displaystyle \int \int d x d z \mathrm { s p } _ { \alpha _ { \Phi ^ { \alpha } } ( z , z ) } \mathrm { l o g } \mathrm { l o g } \mathrm { l o g } ( z ) - \displaystyle \int \int d x d z \mathrm { s p } _ { \alpha _ { \Phi ^ { \alpha } } ( x , z ) } \mathrm { l o g } n _ { \Phi ^ { \alpha } } ( x , z ) } \\ & { \quad = \displaystyle \int \int d x d z p _ { \Phi ^ { \alpha } } ( x , z ) \mathrm { l o g } \mathrm { l o g } ( x , z ) - \displaystyle \int d x d z p _ { \Phi ^ { \alpha } } ( x ) \mathrm { l o g } y _ { \Phi ^ { \alpha } } ( x ) } \\ & { \quad \le \displaystyle \int \int d x d z p _ { \Phi ^ { \alpha } } ( z , z ) \mathrm { l o g } \mathrm { d } z ( z ) - \displaystyle \int d x d z p _ { \Phi ^ { \alpha } } ( x ) \mathrm { l o g } \mathrm { q } ( x ) } \\ & { \quad - \displaystyle \iint d x d z p _ { \Phi ^ { \alpha } } ( z , z ) \mathrm { l o g } \mathrm { d } z ( z ) - \displaystyle \int \int d x d z p _ { \Phi ^ { \alpha } } ( x , z ) \mathrm { l o g } ( z ) } \\ & { \quad = \displaystyle \int \int d x d z p _ { \Phi ^ { \alpha } } ( z , z ) \mathrm { l o g } \frac { d ( x , z ) } { \partial x _ { \Phi ^ { \alpha } } ( x , z ) } } \\ & { \quad = \displaystyle \int \int d x d z p _ { \Phi ^ { \alpha } } ( x , z ) \mathrm { l o g } \frac { d ( x , z ) } { \partial x _ { \Phi ^ { \alpha } } ( x , z ) } = \displaystyle \int \int d x d z p _ { \Phi ^ { \alpha } } ( x , z ) \mathrm { l o g } ( z ) } \\ &  \quad = \displaystyle \int d x d z p _ { \Phi ^ { \alpha } } ( x , z )  \end{array}
+$$
+
+# C GENERATIVE MUTUAL INFORMATION
+
+Given any four distributions: $p ^ { * } ( x )$ – a density over some data space $X$ , $e ( z | x ) - \mathbf { a }$ stochastic map from that data to a new representational space $Z$ , $d ( x | z )$ – a stochastic map in the reverse direction from $Z$ to $X$ , and $m ( z )$ – some density in the $Z$ space; we were able to find an inequality relating three functionals of these densities that must always hold. We found this inequality by deriving upper and lower bounds on the mutual information in the joint density defined by the natural representational path through the four distributions, $p _ { e } ( x , z ) \ = \ p ^ { * } ( x ) e ( z | x )$ . Doing so naturally made us consider the existence of two other distributions $d ( x | z )$ and $m ( z )$ . Let’s consider the mutual information along this new generative path.
+
+$$
+p _ { \mathrm { g e n } } ( x , z ) = m ( z ) d ( x | z )
+$$
+
+$$
+I _ { \mathrm { g e n } } ( X ; Z ) = \iint d x d z p _ { \mathrm { g e n } } ( x , z ) \log \frac { p _ { \mathrm { g e n } } ( x , z ) } { p _ { \mathrm { g e n } } ( x ) p _ { \mathrm { g e n } } ( z ) }
+$$
+
+Just as before we can easily establish both a variational lower and upper bound on this mutual information. For the lower bound (proved in Section B.5), we have:
+
+$$
+E \equiv \int d z p ( z ) \int d x p ( x | z ) \log \frac { q ( z | x ) } { p ( z ) } \leq { \cal I } _ { \mathrm { g e n } }
+$$
+
+Where we need to make a variational approximation to the decoder posterior, itself a distribution mapping $X$ to $Z$ . Since we already have such a distribution from our other considerations, we can certainly use the encoding distribution $q ( z | x )$ for this purpose, and since the bound holds for any choice it will hold with this choice. We will call this bound $E$ since it gives the distortion as measured through the encoder as it attempts to encode the generated samples back to their latent representation.
+
+We can also find a variational upper bound on the generative mutual information (proved in Section B.6):
+
+$$
+G \equiv \int d z m ( z ) \int d x d ( x | z ) \log \frac { d ( x | z ) } { q ( x ) } \geq I _ { \mathrm { g e n } }
+$$
+
+This time we need a variational approximation to the marginal density of our generative model, which we denote as $q ( x )$ . We call this bound $G$ for the rate in the generative model.
+
+Together these establish both lower and upper bounds on the generative mutual information:
+
+$$
+E \leq I _ { \mathrm { g e n } } \leq G .
+$$
+
+In our early experiments, it appears as though additionally constraining or targeting values for these generative mutual information bounds is important to ensure consistency in the underlying joint distributions. In particular, we notice a tendency of models trained with the $\beta$ -VAE objective to have loose bounds on the generative mutual information when $\beta$ varies away from 1.
+
+# C.1 REARRANGING THE REPRESENTATIONAL LOWER BOUND
+
+In light of the appearance of a new independent density estimate $q ( x )$ in deriving our variational upper bound on the mutual information in the generative model, let’s actually use that to rearrange our variational lower bound on the representational mutual information.
+
+$$
+\int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \frac { e ( z | x ) } { p ^ { * } ( x ) } = \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \frac { e ( z | x ) } { q ( x ) } - \int d x p ^ { * } ( x ) \log \frac { p ^ { * } ( x ) } { q ( x ) }
+$$
+
+Doing this, we can express our lower bound in terms of two reparameterization independent functionals:
+
+$$
+\begin{array} { l } { { U \equiv \displaystyle \int d x p ^ { * } ( x ) \int d z e ( z | x ) \log \frac { d ( x | z ) } { q ( x ) } } } \\ { { S \equiv \displaystyle \int d x p ^ { * } ( x ) \log \frac { p ^ { * } ( x ) } { q ( x ) } = - \int d x p ^ { * } ( x ) \log q ( x ) - H } } \end{array}
+$$
+
+This new reparameterization couples together the bounds we derived both the representational mutual information and the generative mutual information, using $q ( x )$ in both. The new function $S$ we’ve described is intractable on its own, but when split into the data entropy and a cross entropy term, suggests we set a target cross entropy on our own density estimate $q ( x )$ with respect to the empirical data distribution that might be finite in the case of finite data.
+
+Together we have an equivalent way to formulate our original bounds on the representaional mutual information
+
+$$
+U - S = H - D \leq I _ { \mathrm { r e p } } \leq R
+$$
+
+We believe this reparameterization offers and important and potential way to directly control for overfitting. In particular, given that we compute our objectives using a finite sample from the true data distribution, it will generically be true that $\mathrm { K L } [ \hat { p } ( x ) \bar { | | } p ^ { * } ( x ) ] \geq \bar { 0 }$ . In particular, the usual mode we operate in is one in which we only ever observe each example once in the training set, suggesting that in particular an estimate for this divergence would be:
+
+$$
+\operatorname { K L } [ { \hat { p } } ( x ) \mid \mid p ^ { * } ( x ) ] \sim H ( X ) - \log N .
+$$
+
+Early experiments suggest this offers a useful target for $S$ in the reparameterized objective that can prevent overfitting, at least in our toy problems.
+
+# D DETAILED RELATED WORK
+
+Here we expand on the brief related work in Section 3.
+
+# D.1 INFORMATION THEORY AND MACHINE LEARNING
+
+Much recent work has leveraged information theory to improve our understanding of machine learning in general, and unsupervised learning specifically. In Tishby & Zaslavsky (2015), the authors present theory for the success of supervised deep learning as approximately optimizing the information bottleneck objective, and also theoretically predict a supervised variant of the rate/distortion plane we describe here. Shwartz-Ziv & Tishby (2017) further proposes that training of deep learning models proceeds in two phases: error minimization followed by compression. They suggest that the compression phase diffuses the conditional entropy of the individual layers of the model, and when the model has converged, it lies near the information bottleneck optimal frontier on the proposed rate/distortion plane. In Higgins et al. (2016) the authors motivate the $\beta$ -VAE objective from a combined neuroscience and information theoretic perspective. The Higgins et al. (2017) propose that $\beta$ should be greater than 1 to properly learn disentangled representations in an unsupervised manner.
+
+Chen et al. (2017) described the issue of the too-powerful decoder when training standard VAEs, where $\beta = 1$ . They proposed a bits-back (Hinton & Van Camp, 1993) model to understand this phenomenon, as well as a noise-injection technique to combat it. Our approach removes the need for an additional noise source in the decoder, and concisely rephrases the problem as finding the optimal $\beta$ for the chosen model family, which can now be as powerful as we like, without risk of ignoring the latent space and collapsing to an autodecoding model.
+
+Bowman et al. (2016) suggested annealing the weight of the KL term of the ELBO $( \mathrm { K L } [ q ( \boldsymbol { z } | \boldsymbol { x } ) \mid | \boldsymbol { p } ( \boldsymbol { z } ) ] )$ from 0 to 1 to make it possible to train an RNN decoder without ignoring the latent space. Snderby et al. (2016) applies the same idea to ladder network decoders. We relate this idea of KL annealing to our optimal rate/distortion curve, and show empirically that KL annealing does not in general attain the performance possible when setting a fixed $\beta$ or a fixed target rate.
+
+In Achille & Soatto (2016), the authors proposed an information bottleneck approach to the activations of a network, termed Information Dropout, as a form of regularization that explains and generalizes Dropout (Srivastava et al., 2014). They suggest that, without such a form of regularization, standard SGD training only provides a sufficient statistic, but does not in general provide two other desiderata: minimality and invariance to nuisance factors. Both of these would be provided by a procedure that directly optimized the information bottleneck. They propose that simply injecting noise adaptively into the otherwise deterministic function computed by the deep network is sufficient to cause SGD to optimize toward disentangled and invariant representations. Achille & Soatto (2017) expands on this exploration of sufficiency, minimality, and invariance in deep networks. In particular they propose that architectural bottlenecks and depth both promote invariance directly, and they decompose the standard cross entropy loss used in supervised learning into four terms, including one which they name ‘overfitting’, and which, without other regularization, an optimization procedure can easily increase in order to reduce the total loss.
+
+Other recent work explores related theoretical frameworks for unsupervised learning, including Pu et al. (2017); Hu et al. (2017); Zhang et al. (2017).
+
+# D.2 MODEL FAMILIES FOR UNSUPERVISED LEARNING WITH NEURAL NETWORKS
+
+Burda et al. (2015) presented an importance-weighted variant of the VAE objective. By increasing the number of samples taken from the encoder during training, they are able to tighten the variational lower bound and improve the test log likelihood.
+
+Rezende & Mohamed (2015) proposed to use normalizing flows to approximate the true posterior during inference, in order to overcome the problem of the standard mean-field posterior approximation used in VAEs lacking sufficient representational power to model complex posterior distributions. Normalizing flow permits the use of a deep network to compute a differentiable function with a computable determinant of a random variable and have the resulting function be a valid normalized distribution. Kingma et al. (2016) expanded on this idea by introducing inverse autoregressive flow (IAF). IAF takes advantage of properties of current autoregressive models, including their expressive power and particulars of their Jacobians when inverted, and used them to learn expressive, parallelizeable normalizing flows that are efficient to compute when using high dimensional latent spaces for the posterior.
+
+Autoregressive models have also been applied successfully to the density estimation problem, as well as high quality sample generation. MADE (Germain et al., 2015) proposed directly masking the parameters of an autoencoder during generation such that a given unit makes its predictions based solely on the first $d$ activations of the layer below. This enforces that the autoencoder maintains the “autoregressive” property. In Oord et al. (2016), the authors presented a recurrent neural network that can autoregressively predict the pixels of an image, as well as provide tractable density estimation. This work was expanded to a convolutional model called PixelCNN (van den Oord et al., 2016), which enforced the autoregressive property by masking the convolutional filters. In Salimans et al. (2017), the authors further improved the performance with $\mathrm { P i x e l C N N + + }$ with a collection of architecture changes that allow for much faster training. Finally, Papamakarios et al. (2017) proposed another unification of normalizing flow models with autoregressive models for density estimation. The authors observe that the conditional ordering constraints required for valid autoregressive modeling enforces a choice which may be arbitrarily incorrect for any particular problem. In their proposal, Masked Autoregressive Flow (MAF), they explicitly model the random number generation process with stacked MADE layers. This particular choice means that MAF is fast at density estimation, whereas the nearly identical IAF architecture is fast at sampling.
+
+Tomczak & Welling (2017) proposed a novel method for learning the marginal posterior, $m ( z )$ (written $q ( z )$ in that work): learn $k$ pseudo-inputs that can be mixed to approximate any of the true samples $x \sim p ^ { * } ( x )$ .
+
+# E TOY MODEL DETAILS
+
+Data generation. The true data generating distribution is as follows. We first sample a latent binary variable, $z \sim \mathrm { B e r } ( 0 . 7 )$ , then sample a latent 1d continuous value from that variable, $h | z \sim$ $\mathcal { N } ( h | \mu _ { z } , \sigma _ { z } )$ , and finally we observe a discretized value, $\boldsymbol { x } = \mathrm { d i s c r e t i z e } ( \boldsymbol { h } ; \boldsymbol { B } )$ , where $\boldsymbol { B }$ is a set of 30 equally spaced bins. We set $\mu _ { z }$ and $\sigma _ { z }$ such that $R ^ { * } \equiv \mathrm { I } ( x ; z ) = 0 . 5$ nats, in the true generative process, representing the ideal rate target for a latent variable model.
+
+Model details. We choose to use a discrete latent representation with $K = 3 0$ values, with an encoder of the form $e ( z _ { i } | x _ { j } ) \propto - \exp [ ( w _ { i } ^ { e } x _ { j } - b _ { i } ^ { e } ) ^ { 2 } ]$ , where $z$ is the one-hot encoding of the latent categorical variable, and $x$ is the one-hot encoding of the observed categorical variable. Thus the encoder has $2 K = 6 0$ parameters. We use a decoder of the same form, but with different parameters: $d ( x _ { j } | z _ { i } ) \propto - \exp [ ( w _ { i } ^ { \dot { d } } x _ { j } - b _ { i } ^ { d } ) ^ { 2 } ]$ . Finally, we use a variational marginal, $m ( z _ { i } ) = \pi _ { i }$ . Given this, the true joint distribution has the form $p _ { e } ( x , z ) = p ^ { * } ( x ) e ( z | x )$ , with marginal $\begin{array} { r } { m ( z ) = \sum _ { x } p _ { e } ( x , z ) } \end{array}$ and conditional $p _ { e } ( x | z ) = p _ { e } ( x , z ) / p _ { e } ( z )$ .
+
+# F DETAILS FOR MNIST AND OMNIGLOT EXPERIMENTS
+
+We used the static binary MNIST dataset originally produced for (Larochelle & Murray, 2011)5, and the Omniglot dataset from Lake et al. (2015); Burda et al. (2015).
+
+As stated in the main text, for our experiments we considered twelve different model families corresponding to a simple and complex choice for the encoder and decoder and three different choices for the marginal.
+
+Unless otherwise specified, all layers used a linearly gated activation function activation function (Dauphin et al., 2017), $h ( x ) \stackrel { . } { = } ( W _ { 1 } x + b _ { 2 } ) \sigma ( W _ { 2 } \stackrel { . } { x } + b _ { 2 } )$ .
+
+# F.1 ENCODER ARCHITECTURES
+
+For the encoder, the simple encoder was a convolutional encoder outputting parameters to a diagonal Gaussian distribution. The inputs were first transformed to be between $^ { - 1 }$ and 1. The architecture contained 5 convolutional layers, summarized in the format Conv (depth, kernel size, stride, padding), followed by a linear layer to read out the mean and a linear layer with softplus nonlinearity to read out the variance of the diagonal Gaussiann distribution.
+
+• Input (28, 28, 1)   
+• Conv (32, 5, 1, same)   
+• Conv (32, 5, 2, same)   
+• Conv (64, 5, 1, same)   
+• Conv (64, 5, 2, same)   
+• Conv (256, 7, 1, valid)   
+• Gauss (Linear (64), Softplus (Linear (64)))
+
+For the more complicated encoder, the same 5 convolutional layer architecture was used, followed by 4 steps of mean-only Gaussian inverse autoregressive flow, with each step’s location parameters computed using a 3 layer MADE style masked network with 640 units in the hidden layers and ReLU activations.
+
+# F.2 DECODER ARCHITECTURES
+
+The simple decoder was a transposed convolutional network, with 6 layers of transposed convolution, denoted as Deconv (depth, kernel size, stride, padding) followed by a linear convolutional layer parameterizing an independent Bernoulli distribution over all of the pixels:
+
+• Input (1, 1, 64)   
+• Deconv (64, 7, 1, valid)   
+• Deconv (64, 5, 1, same)   
+• Deconv (64, 5, 2, same)   
+• Deconv (32, 5, 1, same)   
+• Deconv (32, 5, 2, same)   
+• Deconv (32, 4, 1, same)   
+• Bernoulli (Linear Conv (1, 5, 1, same))
+
+The complicated decoder was a slightly modified $\mathrm { P i x e l C N N + + }$ style network (Salimans et al., $2 0 1 7 ) ^ { 6 }$ . However in place of the original RELU activation functions we used linearly gated activation functions and used six blocks (with sizes $( 2 8 \times 2 8 ) - ( 1 4 \times 1 4 ) - ( 7 \times 7 ) - ( 7 \times 7 ) - ( 1 4 \times 1 4 )$ $- ( 2 8 \times 2 8 ) ,$ ) of two resnet layers in each block. All internal layers had a feature depth of 64. Shortcut connections were used throughout between matching sized featured maps. The 64-dimensional latent representation was sent through a dense lineary gated layer to produce a 784-dimensional representation that was reshaped to $( 2 8 \times 2 8 \times 1 )$ and concatenated with the target image to produce a $( 2 8 \times 2 8 \times 2 )$ dimensional input. The final output (of size $( 2 8 \times 2 8 \times 6 4 )$ ) was sent through a $( 1 \times 1 )$ convolution down to depth 1. These were interpreted as the logits for a Bernoulli distribution defined on each pixel.
+
+# F.3 MARGINAL ARCHITECTURES
+
+We used three different types of marginals. The simplest architecture (denoted (-)), was just a fixed isotropic gaussian distribution in 64 dimensions with means fixed at 0 and variance fixed at 1.
+
+The complicated marginal $( + )$ was created by transforming the isotropic Gaussian base distribution with 4 layers of mean-only Gaussian autoregressive flow, with each steps location parameters computed using a 3 layer MADE style masked network with 640 units in the hidden layers and relu activations. This network resembles the architecture used in Papamakarios et al. (2017).
+
+The last choice of marginal was based on VampPrior and denoted with (v), which uses a mixture of the encoder distributions computed on a set of pseudo-inputs to parameterize the prior (Tomczak & Welling, 2017). We add an additional learned set of weights on the mixture distributions that are constrained to sum to one using a softmax function: $\begin{array} { r } { m ( z ) = \sum _ { i = 1 } ^ { N } w _ { i } e ( z | \phi _ { i } ) } \end{array}$ where $N$ are the number of pseudo-inputs, are the weights, is the encoder, and $\phi$ are the pseudo-inputs that have the same dimensionality as the inputs.
+
+# F.4 OPTIMIZATION
+
+The models were all trained using the $\beta$ -VAE objective (Higgins et al., 2017) at various values of $\beta$ . No form of explicit regularization was used. The models were trained with Adam (Kingma & Ba, 2015) with normalized gradients (Yu et al., 2017) for 200 epochs to get good convergence on the training set, with a fixed learning rate of $3 \times 1 0 ^ { - 4 }$ for the first 100 epochs and a linearly decreasing learning rate towards 0 at the $2 0 0 \mathrm { { t h } }$ epoch.

parse/train/HkIQH7qel/HkIQH7qel.md

@@ -0,0 +1,249 @@
+# LEARNING RECURRENT SPAN REPRESENTATIONS FOR EXTRACTIVE QUESTION ANSWERING
+
+Kenton Lee∗   
+University of Washington   
+Seattle, WA   
+kentonl@cs.washington.edu   
+Tom Kwiatkowski Ankur Parikh Dipanjan Das   
+Google   
+New York, NY   
+{tomkwiat, aparikh, dipanjand}@google.com
+
+# ABSTRACT
+
+The reading comprehension task, that asks questions about a given evidence document, is a central problem in natural language understanding. Recent formulations of this task have typically focused on answer selection from a set of candidates pre-defined manually or through the use of an external NLP pipeline. However, Rajpurkar et al. (2016) recently released the SQUAD dataset in which the answers can be arbitrary strings from the supplied text. In this paper, we focus on this answer extraction task, presenting a novel model architecture that efficiently builds fixed length representations of all spans in the evidence document with a recurrent network. We show that scoring explicit span representations significantly improves performance over other approaches that factor the prediction into separate predictions about words or start and end markers. Our approach improves upon the best published results of Wang & Jiang (2016) by $5 \%$ and decreases the error of Rajpurkar et al.’s baseline by $\bar { > } 5 0 \%$ .
+
+# 1 INTRODUCTION
+
+A primary goal of natural language processing is to develop systems that can answer questions about the contents of documents. The reading comprehension task is of practical interest – we want computers to be able to read the world’s text and then answer our questions – and, since we believe it requires deep language understanding, it has also become a flagship task in NLP research.
+
+A number of reading comprehension datasets have been developed that focus on answer selection from a small set of alternatives defined by annotators (Richardson et al., 2013) or existing NLP pipelines that cannot be trained end-to-end (Hill et al., 2016; Hermann et al., 2015). Subsequently, the models proposed for this task have tended to make use of the limited set of candidates, basing their predictions on mention-level attention weights (Hermann et al., 2015), or centering classifiers (Chen et al., 2016), or network memories (Hill et al., 2016) on candidate locations.
+
+Recently, Rajpurkar et al. (2016) released the less restricted SQUAD dataset1 that does not place any constraints on the set of allowed answers, other than that they should be drawn from the evidence document. Rajpurkar et al. proposed a baseline system that chooses answers from the constituents identified by an existing syntactic parser. This allows them to prune the $O ( N ^ { 2 } )$ answer candidates in each document of length $N$ , but it also effectively renders $2 0 . 7 \%$ of all questions unanswerable.
+
+Subsequent work by Wang & Jiang (2016) significantly improve upon this baseline by using an endto-end neural network architecture to identify answer spans by labeling either individual words, or the start and end of the answer span. Both of these methods do not make independence assumptions about substructures, but they are susceptible to search errors due to greedy training and decoding.
+
+In contrast, here we argue that it is beneficial to simplify the decoding procedure by enumerating all possible answer spans. By explicitly representing each answer span, our model can be globally normalized during training and decoded exactly during evaluation. A naive approach to building the $O ( N ^ { 2 } )$ spans of up to length $N$ would require a network that is cubic in size with respect to the passage length, and such a network would be untrainable. To overcome this, we present a novel neural architecture called RASOR that builds fixed-length span representations, reusing recurrent computations for shared substructures. We demonstrate that directly classifying each of the competing spans, and training with global normalization over all possible spans, leads to a significant increase in performance. In our experiments, we show an increase in performance over Wang & Jiang (2016) of $5 \%$ in terms of exact match to a reference answer, and $3 . 6 \%$ in terms of predicted answer F1 with respect to the reference. On both of these metrics, we close the gap between Rajpurkar et al.’s baseline and the human-performance upper-bound by $> 5 0 \%$ .
+
+# 2 EXTRACTIVE QUESTION ANSWERING
+
+# 2.1 TASK DEFINITION
+
+Extractive question answering systems take as input a question $\mathbf { q } = \{ q _ { 0 } , \dots , q _ { n } \}$ and a passage of text $\mathbf { p } = \{ p _ { 0 } , \dots , p _ { m } \}$ from which they predict a single answer span $\mathbf { a } = \langle a _ { s t a r t } , a _ { e n d } \rangle$ , represented as a pair of indices into p. Machine learned extractive question answering systems, such as the one presented here, learn a predictor function $f ( \mathbf { q } , \mathbf { p } )  \mathbf { a }$ from a training dataset of $\langle \mathbf { q } , \mathbf { p } , \mathbf { a } \rangle$ triples.
+
+# 2.2 RELATED WORK
+
+For the SQUAD dataset, the original paper from Rajpurkar et al. (2016) implemented a linear model with sparse features based on $n$ -grams and part-of-speech tags present in the question and the candidate answer. Other than lexical features, they also used syntactic information in the form of dependency paths to extract more general features. They set a strong baseline for following work and also presented an in depth analysis, showing that lexical and syntactic features contribute most strongly to their model’s performance. Subsequent work by Wang & Jiang (2016) use an end-to-end neural network method that uses a Match-LSTM to model the question and the passage, and uses pointer networks (Vinyals et al., 2015) to extract the answer span from the passage. This model resorts to greedy decoding and falls short in terms of performance compared to our model (see Section 5 for more detail). While we only compare to published baselines, there are other unpublished competitive systems on the SQUAD leaderboard, as listed in footnote 5.
+
+A task that is closely related to extractive question answering is the Cloze task (Taylor, 1953), in which the goal is to predict a concealed span from a declarative sentence given a passage of supporting text. Recently, Hermann et al. (2015) presented a Cloze dataset in which the task is to predict the correct entity in an incomplete sentence given an abstractive summary of a news article. Hermann et al. also present various neural architectures to solve the problem. Although this dataset is large and varied in domain, recent analysis by Chen et al. (2016) shows that simple models can achieve close to the human upper bound. As noted by the authors of the SQUAD paper, the annotated answers in the SQUAD dataset are often spans that include non-entities and can be longer phrases, unlike the Cloze datasets, thus making the task more challenging.
+
+Another, more traditional line of work has focused on extractive question answering on sentences, where the task is to extract a sentence from a document, given a question. Relevant datasets include datasets from the annual TREC evaluations (Voorhees & Tice, 2000) and WikiQA (Yang et al., 2015), where the latter dataset specifically focused on Wikipedia passages. There has been a line of interesting recent publications using neural architectures, focused on this variety of extractive question answering (Tymoshenko et al., 2016; Wang et al., 2016, inter alia). These methods model the question and a candidate answer sentence, but do not focus on possible candidate answer spans that may contain the answer to the given question. In this work, we focus on the more challenging problem of extracting the precise answer span.
+
+# 3 MODEL
+
+We propose a model architecture called RASOR2 illustrated in Figure 1, that explicitly computes embedding representations for candidate answer spans. In most structured prediction problems (e.g. sequence labeling or parsing), the number of possible output structures is exponential in the input length, and computing representations for every candidate is prohibitively expensive. However, we exploit the simplicity of our task, where we can trivially and tractably enumerate all candidates. This facilitates an expressive model that computes joint representations of every answer span, that can be globally normalized during learning.
+
+In order to compute these span representations, we must aggregate information from the passage and the question for every answer candidate. For the example in Figure 1, RASOR computes an embedding for the candidate answer spans: fixed to, fixed to the, to the, etc. A naive approach for these aggregations would require a network that is cubic in size with respect to the passage length. Instead, our model reduces this to a quadratic size by reusing recurrent computations for shared substructures (i.e. common passage words) from different spans.
+
+Since the choice of answer span depends on the original question, we must incorporate this information into the computation of the span representation. We model this by augmenting the passage word embeddings with additional embedding representations of the question.
+
+In this section, we motivate and describe the architecture for RASOR in a top-down manner.
+
+# 3.1 SCORING ANSWER SPANS
+
+The goal of our extractive question answering system is to predict the single best answer span among all candidates from the passage $\mathbf { p }$ , denoted as $\mathbf { A } ( \mathbf { p } )$ . Therefore, we define a probability distribution over all possible answer spans given the question $\mathbf { q }$ and passage $\mathbf { p }$ , and the predictor function finds the answer span with the maximum likelihood:
+
+$$
+f ( \mathbf { q } , \mathbf { p } ) : = \underset { \mathbf { a } \in \mathbf { A } ( \mathbf { p } ) } { \operatorname { a r g m a x } } P ( \mathbf { a } \mid \mathbf { q } , \mathbf { p } )
+$$
+
+One might be tempted to introduce independence assumptions that would enable cheaper decoding. For example, this distribution can be modeled as (1) a product of conditionally independent distributions (binary) for every word or (2) a product of conditionally independent distributions (over words) for the start and end indices of the answer span. However, we show in Section 5.2 that such independence assumptions hurt the accuracy of the model, and instead we only assume a fixed-length representation $h _ { \mathbf { a } }$ of each candidate span that is scored and normalized with a softmax layer (Span score and Softmax in Figure 1):
+
+$$
+{ \begin{array} { r } { s _ { \mathbf { a } } = w _ { a } \cdot { \mathrm { F F N N } } ( h _ { \mathbf { a } } ) \qquad { \mathrm { ~ } } \mathbf { a } \in \mathbf { A } ( \mathbf { p } ) } \\ { P ( \mathbf { a } \mid \mathbf { q } , \mathbf { p } ) = { \frac { \exp \left( s _ { \mathbf { a } } \right) } { \sum _ { \mathbf { a ^ { \prime } } \in \mathbf { A } ( \mathbf { p } ) } \exp \left( s _ { \mathbf { a ^ { \prime } } } \right) } } \qquad \mathbf { a } \in \mathbf { A } ( \mathbf { p } ) } \end{array} }
+$$
+
+where $\mathrm { F F N N } ( \cdot )$ denotes a fully connected feed-forward neural network that provides a non-linear mapping of its input embedding, and $w _ { a }$ denotes a learned vector for scoring the last layer of the feed-forward neural network.
+
+# 3.2 RASOR: RECURRENT SPAN REPRESENTATION
+
+The previously defined probability distribution depends on the answer span representations, $h _ { \mathbf { a } }$ . When computing $h _ { \mathbf { a } }$ , we assume access to representations of individual passage words that have been augmented with a representation of the question. We denote these question-focused passage word embeddings as $\{ p _ { 1 } ^ { * } , \ldots , p _ { m } ^ { * } \}$ and describe their creation in Section 3.3. In order to reuse computation for shared substructures, we use a bidirectional LSTM (Hochreiter & Schmidhuber, 1997) to encode the left and right context of every $p _ { i } ^ { * }$ (Passage-level BiLSTM in Figure 1). This allows us to simply concatenate the bidirectional LSTM (BiLSTM) outputs at the endpoints of a span to jointly encode its inside and outside information (Span embedding in Figure 1):
+
+$$
+\begin{array} { r l } { { \{ p _ { 1 } ^ { * { \prime } } , \ldots , p _ { m } ^ { * { \prime } } \} } = \mathrm { { B I L S T M } } ( \{ p _ { 1 } ^ { * } , \ldots , p _ { m } ^ { * } \} ) } \\ { { h _ { \mathbf { a } } } = [ p _ { a _ { s t a r t } } ^ { * { \prime } } , p _ { a _ { e n d } } ^ { * { \prime } } ] ~ } & { { } \qquad \langle a _ { s t a r t } , a _ { e n d } \rangle \in \mathbf { A } ( \mathbf { p } ) } \end{array}
+$$
+
+where BILSTM $( \cdot )$ denotes a BiLSTM over its input embedding sequence and $p _ { i } ^ { * \prime }$ is the concatenation of forward and backward outputs at time-step $i$ . While the visualization in Figure 1 shows a single layer BiLSTM for simplicity, we use a multi-layer BiLSTM in our experiments. The concatenated output of each layer is used as input for the subsequent layer, allowing the upper layers to depend on the entire passage.
+
+# 3.3 QUESTION-FOCUSED PASSAGE WORD EMBEDDING
+
+Computing the question-focused passage word embeddings $\{ p _ { 1 } ^ { * } , \ldots , p _ { m } ^ { * } \}$ requires integrating question information into the passage. The architecture for this integration is flexible and likely depends on the nature of the dataset. For the SQUAD dataset, we find that both passage-aligned and passageindependent question representations are effective at incorporating this contextual information, and experiments will show that their benefits are complementary. To incorporate these question representations, we simply concatenate them with the passage word embeddings (Question-focused passage word embedding in Figure 1).
+
+We use fixed pretrained embeddings to represent question and passage words. Therefore, in the following discussion, notation for the words are interchangeable with their embedding representations.
+
+Question-independent passage word embedding The first component simply looks up the pretrained word embedding for the passage word, $p _ { i }$ .
+
+Passage-aligned question representation In this dataset, the question-passage pairs often contain large lexical overlap or similarity near the correct answer span. To encourage the model to exploit these similarities, we include a fixed-length representation of the question based on soft alignments with the passage word. The alignments are computed via neural attention (Bahdanau et al., 2014), and we use the variant proposed by Parikh et al. (2016), where attention scores are dot products between non-linear mappings of word embeddings.
+
+$$
+{ \begin{array} { r l r l } & { s _ { i j } = { \mathrm { F F N N } } ( p _ { i } ) \cdot { \mathrm { F F N N } } ( q _ { j } ) } & & { 1 \leq j \leq n } \\ & { a _ { i j } = { \frac { \exp \left( s _ { i j } \right) } { \displaystyle \sum _ { k = 1 } ^ { n } \exp \left( s _ { i k } \right) } } } & & { 1 \leq j \leq n } \\ & { q _ { i } ^ { a l i g n } = { \displaystyle \sum _ { j = 1 } ^ { n } a _ { i j } q _ { j } } } & & { } \end{array} }
+$$
+
+Passage-independent question representation We also include a representation of the question that does not depend on the passage and is shared for all passage words.
+
+Similar to the previous question representation, an attention score is computed via a dot-product, except the question word is compared to a universal learned embedding rather any particular passage word. Additionally, we incorporate contextual information with a BiLSTM before aggregating the outputs using this attention mechanism.
+
+The goal is to generate a coarse-grained summary of the question that depends on word order. Formally, the passage-independent question representation $q ^ { i \bar { n } d e p }$ is computed as follows:
+
+$$
+\begin{array} { c } { { \{ q _ { 1 } ^ { \prime } , \dots , q _ { n } ^ { \prime } \} = { \bf B I L S T M ( q ) } } } \\ { { \displaystyle s _ { j } = w _ { q } \cdot \mathrm { F F N N } ( q _ { j } ^ { \prime } ) } } \\ { { \displaystyle a _ { j } = \frac { \exp ( s _ { j } ) } { \sum _ { k = 1 } ^ { n } \exp ( s _ { k } ) } } } \\ { { \displaystyle q ^ { i n d e p } = \sum _ { j = 1 } ^ { n } a _ { j } q _ { j } ^ { \prime } } } \end{array}
+$$
+
+$$
+1 \leq j \leq n
+$$
+
+where $w _ { q }$ denotes a learned vector for scoring the last layer of the feed-forward neural network.
+
+This representation is a bidirectional generalization of the question representation recently proposed by Li et al. (2016) for a different question-answering task.
+
+Given the above three components, the complete question-focused passage word embedding for is their concatenation: $p _ { i } ^ { * } = [ p _ { i } , q _ { i } ^ { a l i g n } , q ^ { i n d e p } ]$ . $p _ { i }$
+
+# 3.4 LEARNING
+
+Given the above model specification, learning is straightforward. We simply maximize the loglikelihood of the correct answer candidates and backpropagate the errors end-to-end.
+
+![](images/8752e965adc93838cf65228158732801c7ede27e922f8b2cf3250e0840585f5c.jpg)  
+Figure 1: A visualization of RASOR, where the question is “What are the stators attached to?” and the passage is “. . . fixed to the turbine . . . ”. The model constructs question-focused passage word embeddings by concatenating (1) the original passage word embedding, (2) a passage-aligned representation of the question, and (3) a passage-independent representation of the question shared across all passage words. We use a BiLSTM over these concatenated embeddings to efficiently recover embedding representations of all possible spans, which are then scored by the final layer of the model.
+
+# 4 EXPERIMENTAL SETUP
+
+We represent each of the words in the question and document using 300 dimensional GloVe embeddings trained on a corpus of $8 4 0 \mathrm { b n }$ words (Pennington et al., 2014). These embeddings cover $2 0 0 \mathrm { k }$ words and all out of vocabulary (OOV) words are projected onto one of $1 \mathrm { m }$ randomly initialized 300d embeddings. We couple the input and forget gates in our LSTMs, as described in Greff et al. (2016), and we use a single dropout mask to apply dropout across all LSTM time-steps as proposed by Gal & Ghahramani (2016). Hidden layers in the feed-forward neural networks use rectified linear units (Nair & Hinton, 2010). Answer candidates are limited to spans with at most 30 words.
+
+To choose the final model configuration, we ran grid searches over: the dimensionality of the LSTM hidden states (25, 50, 100, 200); the number of stacked LSTM layers $( 1 , 2 , 3 )$ ; the width (50, 100, 150, 200) and depth $( 1 , 2 )$ of the feed-forward neural networks; the dropout rate $( 0 , 0 . 1 , \mathrm { { 0 . 2 } ) }$ ; and the decay multiplier $( 0 . 9 , 0 . 9 5 , 1 . 0 )$ with which we multiply the learning rate every 10k steps. The best model uses a single 150d hidden layer in all feed-forward neural networks; 50d LSTM states; two-layer BiLSTMs for the span encoder and the passage-independent question representation; dropout of 0.1 throughout; and a learning rate decay of $5 \%$ every $1 0 \mathrm { k }$ steps.
+
+All models are implemented using TensorFlow3 and trained on the SQUAD training set using the ADAM (Kingma & Ba, 2015) optimizer with a mini-batch size of 4 and trained using 10 asynchronous training threads on a single machine.
+
+# 5 RESULTS
+
+We train on the 80k (question, passage, answer span) triples in the SQUAD training set and report results on the 10k examples in the SQUAD development set. Due to copyright restrictions, we are currently not able to upload our models to Codalab4, which is required to run on the blind SQUAD test set, but we are working with Rajpurkar et al. to remedy this, and this paper will be updated with test numbers as soon as possible.
+
+All results are calculated using the official SQUAD evaluation script, which reports exact answer match and F1 overlap of the unigrams between the predicted answer and the closest labeled answer from the 3 reference answers given in the SQUAD development set.
+
+# 5.1 COMPARISONS TO OTHER WORK
+
+Our model with recurrent span representations (RASOR) is compared to all previously published systems 5. Rajpurkar et al. (2016) published a logistic regression baseline as well as human performance on the SQUAD task. The logistic regression baseline uses the output of an existing syntactic parser both as a constraint on the set of allowed answer spans, and as a method of creating sparse features for an answer-centric scoring model. Despite not having access to any external representation of linguistic structure, RASOR achieves an error reduction of more than $5 \dot { 0 } \%$ over this baseline, both in terms of exact match and F1, relative to the human performance upper bound.
+
+<table><tr><td></td><td colspan="2">Dev</td><td colspan="2">Test</td></tr><tr><td>System</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>Logistic regression baseline</td><td>39.8</td><td>51.0</td><td>40.4</td><td>51.0</td></tr><tr><td>Match-LSTM (Sequence)</td><td>54.5</td><td>67.7</td><td>54.8</td><td>68.0</td></tr><tr><td>Match-LSTM (Boundary)</td><td>60.5</td><td>70.7</td><td>59.4</td><td>70.0</td></tr><tr><td>RASOR</td><td>66.4</td><td>74.9</td><td>1</td><td>1</td></tr><tr><td>RASoR (Ensemble)</td><td>68.2</td><td>76.7</td><td>一</td><td>一</td></tr><tr><td>Human</td><td>81.4</td><td>91.0</td><td>82.3</td><td>91.2</td></tr></table>
+
+Table 1: Exact match (EM) and span F1 on SQUAD. We are currently unable to evaluate on the blind SQUAD test set due to copyright restrictions. We confirm that we did not overfit the development set via 5-fold cross validation of the hyper-parameters, resulting in $6 6 . 0 \pm 1 . 0$ exact match and $7 4 . 5 \pm \bar { 0 } . 9 \ : \mathrm { F 1 }$ .
+
+More closely related to RASOR is the boundary model with Match-LSTMs and Pointer Networks by Wang & Jiang (2016). Their model similarly uses recurrent networks to learn embeddings of each passage word in the context of the question, and it can also capture interactions between endpoints, since the end index probability distribution is conditioned on the start index. However, both training and evaluation are greedy, making their system susceptible to search errors when decoding. In contrast, RASOR can efficiently and explicitly model the quadratic number of possible answers, which leads to a $1 4 \%$ error reduction over the best performing Match-LSTM model.
+
+We also ensemble RASOR with a baseline model described in Section 5.2 that independently predicts endpoints rather than spans (Endpoints prediction in Table 2b). By simply computing the product of the output probabilities, this ensemble further increases performance to $6 8 . 2 \%$ exact-match. We examine the causes of this improvement in Section 6.
+
+Since we do not have access to the test set, we also present 5-fold cross validation experiments to demonstrate that our dev-set results are not an outcome of overfitting through hyper-parameter selection. In this 5-fold setting, we create 5 pseudo dev/test splits from the SQUAD development set.6 We choose hyper-parameters on the basis of the pseudo dev set, and report performance on the disjoint pseudo test set. Each of the pseudo dev sets led us to choose the same optimal model hyper-parameters from a grid of 59 settings, as well as very similar training stopping points. We compute the mean and standard deviation of both evaluation metrics for these optimal models on the pseudo test set, resulting in a $6 6 . 0 \pm 1 . 0$ exact match and $7 4 . 5 \pm 0 . 9 \operatorname { F } 1$ . These results show that our hyper-parameter selection procedure is not overfitting on the 10k SQUAD development set, and we subsequently expect that our model’s performance will translate to the SQUAD test set.
+
+# 5.2 MODEL VARIATIONS
+
+We investigate two main questions in the following ablations and comparisons. (1) How important are the two methods of representing the question described in Section 3.3? (2) What is the impact of learning a loss function that accurately reflects the span prediction task?
+
+Question representations Table 2a shows the performance of RASOR when either of the two question representations described in Section 3.3 is removed. The passage-aligned question representation is crucial, since lexically similar regions of the passage provide strong signal for relevant answer spans. If the question is only integrated through the inclusion of a passage-independent representation, performance drops drastically. The passage-independent question representation over the BiLSTM is less important, but it still accounts for over $3 \%$ exact match and F1. The input of both of these components is analyzed qualitatively in Section 6.
+
+Table 2: Results for variations of the model architecture presented in Section 3.   
+
+<table><tr><td>Question representation</td><td>EM</td><td>F1</td></tr><tr><td>Only passage-independent</td><td>48.7</td><td>56.6</td></tr><tr><td>Only passage-aligned</td><td>63.1</td><td>71.3</td></tr><tr><td>RASOR</td><td>66.4</td><td>74.9</td></tr></table>
+
+(a) Ablation of question representations.
+
+<table><tr><td>Learning objective</td><td>EM</td><td>F1</td></tr><tr><td>Membership prediction</td><td>57.9</td><td>69.7</td></tr><tr><td>BIO sequence prediction</td><td>63.9</td><td>73.0</td></tr><tr><td>Endpoints prediction</td><td>65.3</td><td>75.1</td></tr><tr><td>Span prediction w/log loss</td><td>65.2</td><td>73.6</td></tr></table>
+
+(b) Comparisons for different learning objectives given the same passage-level BiLSTM.
+
+Learning objectives Given a fixed architecture that is capable of encoding the input questionpassage pairs, there are many ways of setting up a learning objective to encourage the model to predict the correct span. In Table 2b, we provide comparisons of some alternatives (learned end-toend) given only the passage-level BiLSTM from RASOR. In order to provide clean comparisons, we restrict the alternatives to objectives that are trained and evaluated with exact decoding.
+
+The simplest alternative is to consider this task as binary classification for every word (Membership prediction in Table 2b). In this baseline, we optimize the logistic loss for binary labels indicating whether passage words belong to the correct answer span. At prediction time, a valid span can be recovered in linear time by finding the maximum contiguous sum of scores.
+
+Li et al. (2016) proposed a sequence-labeling scheme that is similar to the above baseline (BIO sequence prediction in Table 2b). We follow their proposed model and learn a conditional random field (CRF) layer after the passage-level BiLSTM to model transitions between the different labels. At prediction time, a valid span can be recovered in linear time using Viterbi decoding, with hard transition constraints to enforce a single contiguous output.
+
+We also consider a model that independently predicts the two endpoints of the answer span (Endpoints prediction in Table 2b). This model uses the softmax loss over passage words during learning. When decoding, we only need to enforce the constraint that the start index is no greater than the end index. Without the interactions between the endpoints, this can be computed in linear time. Note that this model has the same expressivity as RASOR if the span-level FFNN were removed.
+
+Lastly, we compare with a model using the same architecture as RASOR but is trained with a binary logistic loss rather than a softmax loss over spans (Span prediction w/ logistic loss in Table 2b).
+
+The trend in Table 2b shows that the model is better at leveraging the supervision as the learning objective more accurately reflects the fundamental task at hand: determining the best answer span.
+
+First, we observe general improvements when using labels that closely align with the task. For example, the labels for membership prediction simply happens to provide single contiguous spans in the supervision. The model must consider far more possible answers than it needs to (the power set of all words). The same problem holds for BIO sequence prediction– the model must do additional work to learn the semantics of the BIO tags. On the other hand, in RASOR, the semantics of an answer span is naturally encoded by the set of labels.
+
+Second, we observe the importance of allowing interactions between the endpoints using the spanlevel FFNN. RASOR outperforms the endpoint prediction model by 1.1 in exact match, The interaction between endpoints enables RASOR to enforce consistency across its two substructures. While this does not provide improvements for predicting the correct region of the answer (captured by the F1 metric, which drops by 0.2), it is more likely to predict a clean answer span that matches human judgment exactly (captured by the exact-match metric).
+
+# 6 ANALYSIS
+
+Figure 2 shows how the performances of RASOR and the endpoint predictor introduced in Section 5.2 degrade as the lengths of their predictions increase. The endpoint predictor underpredicts single word answer spans, while overpredicting answer spans with more than 8 words.
+
+![](images/5cc9e80ec83256790dc1bed04fd2c739275e558fb9115223174bd51060be15e5.jpg)  
+Figure 2: F1 and Exact Match accuracy of RASOR and the endpoint predictor over different predictions lengths, along with the distribution of both models’ prediction lengths and the gold answer lengths.
+
+Since the endpoints predictor does not explicitly model the interaction between the start and end of any given answer span, it is susceptible to choosing the span start and end points from separate answer candidates. For example, consider the following endpoints prediction that is most different in length from a correct span classification. Here, the span classifier correctly answers the question ‘Where did the Meuse flow before the flood?’ with ‘North Sea’ but the endpoints prediction is:
+
+‘south of today’s line Merwede-Oude Maas to the North Sea and formed an archipelago-like estuary with Waal and Lek. This system of numerous bays, estuary-like extended rivers, many islands and constant changes of the coastline, is hard to imagine today. From 1421 to 1904, the Meuse and Waal merged further upstream at Gorinchem to form Merwede. For flood protection reasons, the Meuse was separated from the Waal through a lock and diverted into a new outlet called ”Bergse Maas”, then Amer and then flows into the former bay Hollands Diep
+
+In this prediction, we can see that both the start ‘south of . . . ’ and the end ‘. . . Hollands Diep’ have a reasonable answer type. However, the endpoints predictor has failed to model the fact that they cannot resonably be part of the same answer, a common error case. The endpoints predictor predicts 514 answers with $> 2 5$ more words than the gold answer, but the span classifier never does this.
+
+![](images/28e6143ad8d835803865ce062c2a28bee3a4b09ba64682d7797a3baa60c2423b.jpg)  
+Figure 3: Attention masks from RASOR. Top predictions are ‘Egyptians’, ‘Egyptians against the British’, and ‘British’ in the first example and ‘unjust laws’, ‘what they deem to be unjust laws’, and ‘laws’ in the second.
+
+Table 3: Example questions and their most attended words in the passage-independent question representation (Equation 11). These examples have the greatest attention (normalized by the question length) in the development set. The attention mechanism typically seeks words in the question that indicate the answer type.   
+
+<table><tr><td rowspan=1 colspan=1>Most attended</td><td rowspan=1 colspan=1>Question</td></tr><tr><td rowspan=1 colspan=1>conditions</td><td rowspan=1 colspan=1>In Gebhard v Consiglio..Milano,the requirements to be registered in Milan beforebeing able to practice law would be allowed under what conditions?</td></tr><tr><td rowspan=1 colspan=1>Were</td><td rowspan=1 colspan=1>Were the restored tapes able to have color added to them to enhance the picture ordid they remain black and white?</td></tr><tr><td rowspan=1 colspan=1>Did</td><td rowspan=1 colspan=1>Did the European Court of Justice rule the defendant in the case of Commission v.Edith Cresson broke any laws?</td></tr><tr><td rowspan=1 colspan=1>whom</td><td rowspan=1 colspan=1>The church holds that they are equally bound to respect the sacredness of the lifeand well-being of whom?</td></tr><tr><td rowspan=1 colspan=1>Whose</td><td rowspan=1 colspan=1>Whose thesis states that the solution to a problem is solvable with reasonable re-sources assuming it allows for a polynomial time algorithm ?</td></tr><tr><td rowspan=1 colspan=1>language</td><td rowspan=1 colspan=1>What language did the Court of Justice accept to be required to teach in a Dublincollege in Groner v Minister for Education?</td></tr><tr><td rowspan=1 colspan=1>term</td><td rowspan=1 colspan=1>Income not from the creation of wealth but by grabbing a larger share of it is knowto economists by what term?</td></tr></table>
+
+Figure 3 shows attention masks for both of RASOR’s question representations. The passageindependent question representation pays most attention to the words that could attach to the answer in the passage (‘brought’, ‘against’) or describe the answer category (‘people’). Meanwhile, the passage-aligned question representation pays attention to similar words. The top predictions for both examples are all valid syntactic constituents, and they all have the correct semantic category. However, RASOR assigns almost as much probability mass to it’s incorrect third prediction ‘British’ as it does to the top scoring correct prediction ‘Egyptian’. This showcases a common failure case for RASOR, where it can find an answer of the correct type close to a phrase that overlaps with the question – but it cannot accurately represent the semantic dependency on that phrase.
+
+A significant architectural difference from other neural models for the SQUAD dataset, such as Wang & Jiang (2016), is the use of the question-independent passage representation (Equation 12). Table 3 shows examples in the development set where the model paid the most attention to a single word in the question. The attention mechanism tends to seek words in the question that indicate the answer type, e.g. ‘language’ from the question: ‘What language did the Court of Justic accept ...’ This pattern provides insight for the necessity of using both question representations, since the answer type information is orthogonal to passage alignment information.
+
+# 7 CONCLUSION
+
+We have shown a novel approach for perform extractive question answering on the SQUAD dataset by explicitly representing and scoring answer span candidates. The core of our model relies on a recurrent network that enables shared computation for the shared substructure across span candidates. We explore different methods of encoding the passage and question, showing the benefits of including both passage-independent and passage-aligned question representations. While we show that this encoding method is beneficial for the task, this is orthogonal to the core contribution of efficiently computing span representation. In future work, we plan to explore alternate architectures that provide input to the recurrent span representations.
+
+# REFERENCES
+
+Dzmitry Bahdanau, KyungHyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Danqi Chen, Jason Bolton, and Christopher D. Manning. A thorough examination of the cnn/daily mail reading comprehension task. In Proceedings of ACL, 2016.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. Proceedings of NIPS, 2016.
+
+Klaus Greff, Rupesh Kumar Srivastava, Jan Koutn´ık, Bas R. Steunebrink, and Jurgen Schmidhuber. ¨ LSTM: A search space odyssey. IEEE Transactions on Neural Networks and Learning Systems, PP:1–11, 2016.
+
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Proceedings of NIPS, 2015.
+
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. In Proceedings of ICLR, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-term Memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. Proceedings of ICLR, 2015.
+
+Peng Li, Wei Li, Zhengyan He, Xuguang Wang, Ying Cao, Jie Zhou, and Wei Xu. Dataset and neural recurrent sequence labeling model for open-domain factoid question answering. CoRR, abs/1607.06275, 2016.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of ICML, 2010.
+
+Ankur P Parikh, Oscar Tackstr ¨ om, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention ¨ model for natural language inference. In Proceedings of EMNLP, 2016.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In Proceedings of EMNLP, 2014.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. SQuAD: 100, $0 0 0 +$ questions for machine comprehension of text. In Proceedings of EMNLP, 2016.
+
+Matthew Richardson, Christopher JC Burges, and Erin Renshaw. Mctest: A challenge dataset for the open-domain machine comprehension of text. In Proceedings of EMNLP, 2013.
+
+Wilson Taylor. Cloze procedure: A new tool for measuring readability. Journalism Quarterly, 30: 415–433, 1953.
+
+Kateryna Tymoshenko, Daniele Bonadiman, and Alessandro Moschitti. Convolutional neural networks vs. convolution kernels: Feature engineering for answer sentence reranking. In Proceedings of NAACL, 2016.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Proceedings of NIPS, 2015.
+
+Ellen M. Voorhees and Dawn M. Tice. Building a question answering test collection. In Proceedings of SIGIR, 2000.
+
+Bingning Wang, Kang Liu, and Jun Zhao. Inner attention based recurrent neural networks for answer selection. In Proceedings of ACL, 2016.
+
+Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. arXiv preprint arXiv:1608.07905, 2016.
+
+Yi Yang, Wen-tau Yih, and Christopher Meek. Wikiqa: A challenge dataset for open-domain question answering. In Proceedings of EMNLP, 2015.

parse/train/HkIQH7qel/HkIQH7qel_content_list.json

@@ -0,0 +1,1318 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING RECURRENT SPAN REPRESENTATIONS FOR EXTRACTIVE QUESTION ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kenton Lee∗   \nUniversity of Washington   \nSeattle, WA   \nkentonl@cs.washington.edu   \nTom Kwiatkowski Ankur Parikh Dipanjan Das   \nGoogle   \nNew York, NY   \n{tomkwiat, aparikh, dipanjand}@google.com ",
+        "bbox": [
+            184,
+            174,
+            429,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            449,
+            172,
+            848,
+            231
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            266,
+            544,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The reading comprehension task, that asks questions about a given evidence document, is a central problem in natural language understanding. Recent formulations of this task have typically focused on answer selection from a set of candidates pre-defined manually or through the use of an external NLP pipeline. However, Rajpurkar et al. (2016) recently released the SQUAD dataset in which the answers can be arbitrary strings from the supplied text. In this paper, we focus on this answer extraction task, presenting a novel model architecture that efficiently builds fixed length representations of all spans in the evidence document with a recurrent network. We show that scoring explicit span representations significantly improves performance over other approaches that factor the prediction into separate predictions about words or start and end markers. Our approach improves upon the best published results of Wang & Jiang (2016) by $5 \\%$ and decreases the error of Rajpurkar et al.’s baseline by $\\bar { > } 5 0 \\%$ . ",
+        "bbox": [
+            233,
+            297,
+            764,
+            478
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            334,
+            521
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A primary goal of natural language processing is to develop systems that can answer questions about the contents of documents. The reading comprehension task is of practical interest – we want computers to be able to read the world’s text and then answer our questions – and, since we believe it requires deep language understanding, it has also become a flagship task in NLP research. ",
+        "bbox": [
+            176,
+            537,
+            823,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A number of reading comprehension datasets have been developed that focus on answer selection from a small set of alternatives defined by annotators (Richardson et al., 2013) or existing NLP pipelines that cannot be trained end-to-end (Hill et al., 2016; Hermann et al., 2015). Subsequently, the models proposed for this task have tended to make use of the limited set of candidates, basing their predictions on mention-level attention weights (Hermann et al., 2015), or centering classifiers (Chen et al., 2016), or network memories (Hill et al., 2016) on candidate locations. ",
+        "bbox": [
+            174,
+            601,
+            823,
+            684
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Rajpurkar et al. (2016) released the less restricted SQUAD dataset1 that does not place any constraints on the set of allowed answers, other than that they should be drawn from the evidence document. Rajpurkar et al. proposed a baseline system that chooses answers from the constituents identified by an existing syntactic parser. This allows them to prune the $O ( N ^ { 2 } )$ answer candidates in each document of length $N$ , but it also effectively renders $2 0 . 7 \\%$ of all questions unanswerable. ",
+        "bbox": [
+            174,
+            690,
+            823,
+            761
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Subsequent work by Wang & Jiang (2016) significantly improve upon this baseline by using an endto-end neural network architecture to identify answer spans by labeling either individual words, or the start and end of the answer span. Both of these methods do not make independence assumptions about substructures, but they are susceptible to search errors due to greedy training and decoding. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast, here we argue that it is beneficial to simplify the decoding procedure by enumerating all possible answer spans. By explicitly representing each answer span, our model can be globally normalized during training and decoded exactly during evaluation. A naive approach to building the $O ( N ^ { 2 } )$ spans of up to length $N$ would require a network that is cubic in size with respect to the passage length, and such a network would be untrainable. To overcome this, we present a novel neural architecture called RASOR that builds fixed-length span representations, reusing recurrent computations for shared substructures. We demonstrate that directly classifying each of the competing spans, and training with global normalization over all possible spans, leads to a significant increase in performance. In our experiments, we show an increase in performance over Wang & Jiang (2016) of $5 \\%$ in terms of exact match to a reference answer, and $3 . 6 \\%$ in terms of predicted answer F1 with respect to the reference. On both of these metrics, we close the gap between Rajpurkar et al.’s baseline and the human-performance upper-bound by $> 5 0 \\%$ . ",
+        "bbox": [
+            176,
+            830,
+            823,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 EXTRACTIVE QUESTION ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            519,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 TASK DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            265,
+            341,
+            280
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Extractive question answering systems take as input a question $\\mathbf { q } = \\{ q _ { 0 } , \\dots , q _ { n } \\}$ and a passage of text $\\mathbf { p } = \\{ p _ { 0 } , \\dots , p _ { m } \\}$ from which they predict a single answer span $\\mathbf { a } = \\langle a _ { s t a r t } , a _ { e n d } \\rangle$ , represented as a pair of indices into p. Machine learned extractive question answering systems, such as the one presented here, learn a predictor function $f ( \\mathbf { q } , \\mathbf { p } )  \\mathbf { a }$ from a training dataset of $\\langle \\mathbf { q } , \\mathbf { p } , \\mathbf { a } \\rangle$ triples. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            330,
+            378
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the SQUAD dataset, the original paper from Rajpurkar et al. (2016) implemented a linear model with sparse features based on $n$ -grams and part-of-speech tags present in the question and the candidate answer. Other than lexical features, they also used syntactic information in the form of dependency paths to extract more general features. They set a strong baseline for following work and also presented an in depth analysis, showing that lexical and syntactic features contribute most strongly to their model’s performance. Subsequent work by Wang & Jiang (2016) use an end-to-end neural network method that uses a Match-LSTM to model the question and the passage, and uses pointer networks (Vinyals et al., 2015) to extract the answer span from the passage. This model resorts to greedy decoding and falls short in terms of performance compared to our model (see Section 5 for more detail). While we only compare to published baselines, there are other unpublished competitive systems on the SQUAD leaderboard, as listed in footnote 5. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A task that is closely related to extractive question answering is the Cloze task (Taylor, 1953), in which the goal is to predict a concealed span from a declarative sentence given a passage of supporting text. Recently, Hermann et al. (2015) presented a Cloze dataset in which the task is to predict the correct entity in an incomplete sentence given an abstractive summary of a news article. Hermann et al. also present various neural architectures to solve the problem. Although this dataset is large and varied in domain, recent analysis by Chen et al. (2016) shows that simple models can achieve close to the human upper bound. As noted by the authors of the SQUAD paper, the annotated answers in the SQUAD dataset are often spans that include non-entities and can be longer phrases, unlike the Cloze datasets, thus making the task more challenging. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            675
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another, more traditional line of work has focused on extractive question answering on sentences, where the task is to extract a sentence from a document, given a question. Relevant datasets include datasets from the annual TREC evaluations (Voorhees & Tice, 2000) and WikiQA (Yang et al., 2015), where the latter dataset specifically focused on Wikipedia passages. There has been a line of interesting recent publications using neural architectures, focused on this variety of extractive question answering (Tymoshenko et al., 2016; Wang et al., 2016, inter alia). These methods model the question and a candidate answer sentence, but do not focus on possible candidate answer spans that may contain the answer to the given question. In this work, we focus on the more challenging problem of extracting the precise answer span. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            808
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            267,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a model architecture called RASOR2 illustrated in Figure 1, that explicitly computes embedding representations for candidate answer spans. In most structured prediction problems (e.g. sequence labeling or parsing), the number of possible output structures is exponential in the input length, and computing representations for every candidate is prohibitively expensive. However, we exploit the simplicity of our task, where we can trivially and tractably enumerate all candidates. This facilitates an expressive model that computes joint representations of every answer span, that can be globally normalized during learning. ",
+        "bbox": [
+            176,
+            858,
+            823,
+            901
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to compute these span representations, we must aggregate information from the passage and the question for every answer candidate. For the example in Figure 1, RASOR computes an embedding for the candidate answer spans: fixed to, fixed to the, to the, etc. A naive approach for these aggregations would require a network that is cubic in size with respect to the passage length. Instead, our model reduces this to a quadratic size by reusing recurrent computations for shared substructures (i.e. common passage words) from different spans. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since the choice of answer span depends on the original question, we must incorporate this information into the computation of the span representation. We model this by augmenting the passage word embeddings with additional embedding representations of the question. ",
+        "bbox": [
+            176,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we motivate and describe the architecture for RASOR in a top-down manner. ",
+        "bbox": [
+            171,
+            306,
+            774,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 SCORING ANSWER SPANS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            395,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal of our extractive question answering system is to predict the single best answer span among all candidates from the passage $\\mathbf { p }$ , denoted as $\\mathbf { A } ( \\mathbf { p } )$ . Therefore, we define a probability distribution over all possible answer spans given the question $\\mathbf { q }$ and passage $\\mathbf { p }$ , and the predictor function finds the answer span with the maximum likelihood: ",
+        "bbox": [
+            174,
+            363,
+            825,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30292a69ad32b1a085e574334af346db0dc669b9bec2a2895a3c0451339ad87b.jpg",
+        "text": "$$\nf ( \\mathbf { q } , \\mathbf { p } ) : = \\underset { \\mathbf { a } \\in \\mathbf { A } ( \\mathbf { p } ) } { \\operatorname { a r g m a x } } P ( \\mathbf { a } \\mid \\mathbf { q } , \\mathbf { p } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            421,
+            606,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One might be tempted to introduce independence assumptions that would enable cheaper decoding. For example, this distribution can be modeled as (1) a product of conditionally independent distributions (binary) for every word or (2) a product of conditionally independent distributions (over words) for the start and end indices of the answer span. However, we show in Section 5.2 that such independence assumptions hurt the accuracy of the model, and instead we only assume a fixed-length representation $h _ { \\mathbf { a } }$ of each candidate span that is scored and normalized with a softmax layer (Span score and Softmax in Figure 1): ",
+        "bbox": [
+            173,
+            452,
+            825,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/573807e0cc393a2c5b1ce9cb141c382ee366848764ca5ac42a10ce087ba5b0b2.jpg",
+        "text": "$$\n{ \\begin{array} { r } { s _ { \\mathbf { a } } = w _ { a } \\cdot { \\mathrm { F F N N } } ( h _ { \\mathbf { a } } ) \\qquad { \\mathrm { ~ } } \\mathbf { a } \\in \\mathbf { A } ( \\mathbf { p } ) } \\\\ { P ( \\mathbf { a } \\mid \\mathbf { q } , \\mathbf { p } ) = { \\frac { \\exp \\left( s _ { \\mathbf { a } } \\right) } { \\sum _ { \\mathbf { a ^ { \\prime } } \\in \\mathbf { A } ( \\mathbf { p } ) } \\exp \\left( s _ { \\mathbf { a ^ { \\prime } } } \\right) } } \\qquad \\mathbf { a } \\in \\mathbf { A } ( \\mathbf { p } ) } \\end{array} }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            550,
+            710,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { F F N N } ( \\cdot )$ denotes a fully connected feed-forward neural network that provides a non-linear mapping of its input embedding, and $w _ { a }$ denotes a learned vector for scoring the last layer of the feed-forward neural network. ",
+        "bbox": [
+            174,
+            612,
+            823,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 RASOR: RECURRENT SPAN REPRESENTATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            670,
+            534,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The previously defined probability distribution depends on the answer span representations, $h _ { \\mathbf { a } }$ . When computing $h _ { \\mathbf { a } }$ , we assume access to representations of individual passage words that have been augmented with a representation of the question. We denote these question-focused passage word embeddings as $\\{ p _ { 1 } ^ { * } , \\ldots , p _ { m } ^ { * } \\}$ and describe their creation in Section 3.3. In order to reuse computation for shared substructures, we use a bidirectional LSTM (Hochreiter & Schmidhuber, 1997) to encode the left and right context of every $p _ { i } ^ { * }$ (Passage-level BiLSTM in Figure 1). This allows us to simply concatenate the bidirectional LSTM (BiLSTM) outputs at the endpoints of a span to jointly encode its inside and outside information (Span embedding in Figure 1): ",
+        "bbox": [
+            173,
+            695,
+            825,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95a9f46147d030053659ef8d81c74a0cfaa4da9144f3d3fcf00cc8e83005d904.jpg",
+        "text": "$$\n\\begin{array} { r l } { { \\{ p _ { 1 } ^ { * { \\prime } } , \\ldots , p _ { m } ^ { * { \\prime } } \\} } = \\mathrm { { B I L S T M } } ( \\{ p _ { 1 } ^ { * } , \\ldots , p _ { m } ^ { * } \\} ) } \\\\ { { h _ { \\mathbf { a } } } = [ p _ { a _ { s t a r t } } ^ { * { \\prime } } , p _ { a _ { e n d } } ^ { * { \\prime } } ] ~ } & { { } \\qquad \\langle a _ { s t a r t } , a _ { e n d } \\rangle \\in \\mathbf { A } ( \\mathbf { p } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            809,
+            748,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where BILSTM $( \\cdot )$ denotes a BiLSTM over its input embedding sequence and $p _ { i } ^ { * \\prime }$ is the concatenation of forward and backward outputs at time-step $i$ . While the visualization in Figure 1 shows a single layer BiLSTM for simplicity, we use a multi-layer BiLSTM in our experiments. The concatenated output of each layer is used as input for the subsequent layer, allowing the upper layers to depend on the entire passage. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 QUESTION-FOCUSED PASSAGE WORD EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            570,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Computing the question-focused passage word embeddings $\\{ p _ { 1 } ^ { * } , \\ldots , p _ { m } ^ { * } \\}$ requires integrating question information into the passage. The architecture for this integration is flexible and likely depends on the nature of the dataset. For the SQUAD dataset, we find that both passage-aligned and passageindependent question representations are effective at incorporating this contextual information, and experiments will show that their benefits are complementary. To incorporate these question representations, we simply concatenate them with the passage word embeddings (Question-focused passage word embedding in Figure 1). ",
+        "bbox": [
+            173,
+            128,
+            825,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use fixed pretrained embeddings to represent question and passage words. Therefore, in the following discussion, notation for the words are interchangeable with their embedding representations. ",
+        "bbox": [
+            176,
+            234,
+            823,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Question-independent passage word embedding The first component simply looks up the pretrained word embedding for the passage word, $p _ { i }$ . ",
+        "bbox": [
+            173,
+            276,
+            820,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Passage-aligned question representation In this dataset, the question-passage pairs often contain large lexical overlap or similarity near the correct answer span. To encourage the model to exploit these similarities, we include a fixed-length representation of the question based on soft alignments with the passage word. The alignments are computed via neural attention (Bahdanau et al., 2014), and we use the variant proposed by Parikh et al. (2016), where attention scores are dot products between non-linear mappings of word embeddings. ",
+        "bbox": [
+            173,
+            320,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d82cccec6fdb85f367acbf93563b9fc0f071e698e58cdfc757325105fcf8b1c.jpg",
+        "text": "$$\n{ \\begin{array} { r l r l } & { s _ { i j } = { \\mathrm { F F N N } } ( p _ { i } ) \\cdot { \\mathrm { F F N N } } ( q _ { j } ) } & & { 1 \\leq j \\leq n } \\\\ & { a _ { i j } = { \\frac { \\exp \\left( s _ { i j } \\right) } { \\displaystyle \\sum _ { k = 1 } ^ { n } \\exp \\left( s _ { i k } \\right) } } } & & { 1 \\leq j \\leq n } \\\\ & { q _ { i } ^ { a l i g n } = { \\displaystyle \\sum _ { j = 1 } ^ { n } a _ { i j } q _ { j } } } & & { } \\end{array} }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            406,
+            699,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Passage-independent question representation We also include a representation of the question that does not depend on the passage and is shared for all passage words. ",
+        "bbox": [
+            171,
+            515,
+            823,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to the previous question representation, an attention score is computed via a dot-product, except the question word is compared to a universal learned embedding rather any particular passage word. Additionally, we incorporate contextual information with a BiLSTM before aggregating the outputs using this attention mechanism. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The goal is to generate a coarse-grained summary of the question that depends on word order. Formally, the passage-independent question representation $q ^ { i \\bar { n } d e p }$ is computed as follows: ",
+        "bbox": [
+            173,
+            613,
+            821,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a61aae3c216cc65e4bcb85b13d2af6e45709181da6447b6c5103cb9849be50d.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\{ q _ { 1 } ^ { \\prime } , \\dots , q _ { n } ^ { \\prime } \\} = { \\bf B I L S T M ( q ) } } } \\\\ { { \\displaystyle s _ { j } = w _ { q } \\cdot \\mathrm { F F N N } ( q _ { j } ^ { \\prime } ) } } \\\\ { { \\displaystyle a _ { j } = \\frac { \\exp ( s _ { j } ) } { \\sum _ { k = 1 } ^ { n } \\exp ( s _ { k } ) } } } \\\\ { { \\displaystyle q ^ { i n d e p } = \\sum _ { j = 1 } ^ { n } a _ { j } q _ { j } ^ { \\prime } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            643,
+            508,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f31acf49c7b00ef3b236e9279a463c07de49056799d79ae1c0fd6547228109b.jpg",
+        "text": "$$\n1 \\leq j \\leq n\n$$",
+        "text_format": "latex",
+        "bbox": [
+            627,
+            666,
+            700,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { q }$ denotes a learned vector for scoring the last layer of the feed-forward neural network. ",
+        "bbox": [
+            173,
+            765,
+            799,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This representation is a bidirectional generalization of the question representation recently proposed by Li et al. (2016) for a different question-answering task. ",
+        "bbox": [
+            173,
+            786,
+            820,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the above three components, the complete question-focused passage word embedding for is their concatenation: $p _ { i } ^ { * } = [ p _ { i } , q _ { i } ^ { a l i g n } , q ^ { i n d e p } ]$ . $p _ { i }$ ",
+        "bbox": [
+            173,
+            821,
+            823,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            290,
+            883
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the above model specification, learning is straightforward. We simply maximize the loglikelihood of the correct answer candidates and backpropagate the errors end-to-end. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8752e965adc93838cf65228158732801c7ede27e922f8b2cf3250e0840585f5c.jpg",
+        "image_caption": [
+            "Figure 1: A visualization of RASOR, where the question is “What are the stators attached to?” and the passage is “. . . fixed to the turbine . . . ”. The model constructs question-focused passage word embeddings by concatenating (1) the original passage word embedding, (2) a passage-aligned representation of the question, and (3) a passage-independent representation of the question shared across all passage words. We use a BiLSTM over these concatenated embeddings to efficiently recover embedding representations of all possible spans, which are then scored by the final layer of the model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            99,
+            795,
+            489
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            398,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We represent each of the words in the question and document using 300 dimensional GloVe embeddings trained on a corpus of $8 4 0 \\mathrm { b n }$ words (Pennington et al., 2014). These embeddings cover $2 0 0 \\mathrm { k }$ words and all out of vocabulary (OOV) words are projected onto one of $1 \\mathrm { m }$ randomly initialized 300d embeddings. We couple the input and forget gates in our LSTMs, as described in Greff et al. (2016), and we use a single dropout mask to apply dropout across all LSTM time-steps as proposed by Gal & Ghahramani (2016). Hidden layers in the feed-forward neural networks use rectified linear units (Nair & Hinton, 2010). Answer candidates are limited to spans with at most 30 words. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            744
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To choose the final model configuration, we ran grid searches over: the dimensionality of the LSTM hidden states (25, 50, 100, 200); the number of stacked LSTM layers $( 1 , 2 , 3 )$ ; the width (50, 100, 150, 200) and depth $( 1 , 2 )$ of the feed-forward neural networks; the dropout rate $( 0 , 0 . 1 , \\mathrm { { 0 . 2 } ) }$ ; and the decay multiplier $( 0 . 9 , 0 . 9 5 , 1 . 0 )$ with which we multiply the learning rate every 10k steps. The best model uses a single 150d hidden layer in all feed-forward neural networks; 50d LSTM states; two-layer BiLSTMs for the span encoder and the passage-independent question representation; dropout of 0.1 throughout; and a learning rate decay of $5 \\%$ every $1 0 \\mathrm { k }$ steps. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All models are implemented using TensorFlow3 and trained on the SQUAD training set using the ADAM (Kingma & Ba, 2015) optimizer with a mini-batch size of 4 and trained using 10 asynchronous training threads on a single machine. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            898
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            281,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train on the 80k (question, passage, answer span) triples in the SQUAD training set and report results on the 10k examples in the SQUAD development set. Due to copyright restrictions, we are currently not able to upload our models to Codalab4, which is required to run on the blind SQUAD test set, but we are working with Rajpurkar et al. to remedy this, and this paper will be updated with test numbers as soon as possible. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All results are calculated using the official SQUAD evaluation script, which reports exact answer match and F1 overlap of the unigrams between the predicted answer and the closest labeled answer from the 3 reference answers given in the SQUAD development set. ",
+        "bbox": [
+            176,
+            210,
+            825,
+            252
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 COMPARISONS TO OTHER WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            270,
+            437,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our model with recurrent span representations (RASOR) is compared to all previously published systems 5. Rajpurkar et al. (2016) published a logistic regression baseline as well as human performance on the SQUAD task. The logistic regression baseline uses the output of an existing syntactic parser both as a constraint on the set of allowed answer spans, and as a method of creating sparse features for an answer-centric scoring model. Despite not having access to any external representation of linguistic structure, RASOR achieves an error reduction of more than $5 \\dot { 0 } \\%$ over this baseline, both in terms of exact match and F1, relative to the human performance upper bound. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/bfab282a26a6881ec5f6aa8a2c9dbb95aca79a280a9186e6e8661b573eb0834d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Dev</td><td colspan=\"2\">Test</td></tr><tr><td>System</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>Logistic regression baseline</td><td>39.8</td><td>51.0</td><td>40.4</td><td>51.0</td></tr><tr><td>Match-LSTM (Sequence)</td><td>54.5</td><td>67.7</td><td>54.8</td><td>68.0</td></tr><tr><td>Match-LSTM (Boundary)</td><td>60.5</td><td>70.7</td><td>59.4</td><td>70.0</td></tr><tr><td>RASOR</td><td>66.4</td><td>74.9</td><td>1</td><td>1</td></tr><tr><td>RASoR (Ensemble)</td><td>68.2</td><td>76.7</td><td>一</td><td>一</td></tr><tr><td>Human</td><td>81.4</td><td>91.0</td><td>82.3</td><td>91.2</td></tr></table>",
+        "bbox": [
+            303,
+            405,
+            694,
+            532
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Exact match (EM) and span F1 on SQUAD. We are currently unable to evaluate on the blind SQUAD test set due to copyright restrictions. We confirm that we did not overfit the development set via 5-fold cross validation of the hyper-parameters, resulting in $6 6 . 0 \\pm 1 . 0$ exact match and $7 4 . 5 \\pm \\bar { 0 } . 9 \\ : \\mathrm { F 1 }$ . ",
+        "bbox": [
+            174,
+            547,
+            823,
+            587
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "More closely related to RASOR is the boundary model with Match-LSTMs and Pointer Networks by Wang & Jiang (2016). Their model similarly uses recurrent networks to learn embeddings of each passage word in the context of the question, and it can also capture interactions between endpoints, since the end index probability distribution is conditioned on the start index. However, both training and evaluation are greedy, making their system susceptible to search errors when decoding. In contrast, RASOR can efficiently and explicitly model the quadratic number of possible answers, which leads to a $1 4 \\%$ error reduction over the best performing Match-LSTM model. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also ensemble RASOR with a baseline model described in Section 5.2 that independently predicts endpoints rather than spans (Endpoints prediction in Table 2b). By simply computing the product of the output probabilities, this ensemble further increases performance to $6 8 . 2 \\%$ exact-match. We examine the causes of this improvement in Section 6. ",
+        "bbox": [
+            176,
+            714,
+            823,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since we do not have access to the test set, we also present 5-fold cross validation experiments to demonstrate that our dev-set results are not an outcome of overfitting through hyper-parameter selection. In this 5-fold setting, we create 5 pseudo dev/test splits from the SQUAD development set.6 We choose hyper-parameters on the basis of the pseudo dev set, and report performance on the disjoint pseudo test set. Each of the pseudo dev sets led us to choose the same optimal model hyper-parameters from a grid of 59 settings, as well as very similar training stopping points. We compute the mean and standard deviation of both evaluation metrics for these optimal models on the pseudo test set, resulting in a $6 6 . 0 \\pm 1 . 0$ exact match and $7 4 . 5 \\pm 0 . 9 \\operatorname { F } 1$ . These results show that our hyper-parameter selection procedure is not overfitting on the 10k SQUAD development set, and we subsequently expect that our model’s performance will translate to the SQUAD test set. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 MODEL VARIATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            190,
+            357,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We investigate two main questions in the following ablations and comparisons. (1) How important are the two methods of representing the question described in Section 3.3? (2) What is the impact of learning a loss function that accurately reflects the span prediction task? ",
+        "bbox": [
+            176,
+            215,
+            823,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Question representations Table 2a shows the performance of RASOR when either of the two question representations described in Section 3.3 is removed. The passage-aligned question representation is crucial, since lexically similar regions of the passage provide strong signal for relevant answer spans. If the question is only integrated through the inclusion of a passage-independent representation, performance drops drastically. The passage-independent question representation over the BiLSTM is less important, but it still accounts for over $3 \\%$ exact match and F1. The input of both of these components is analyzed qualitatively in Section 6. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/90c0677c09c6ac532de1fc90969050593ec802e4cf5c7aca141fc074b49877f1.jpg",
+        "table_caption": [
+            "Table 2: Results for variations of the model architecture presented in Section 3. "
+        ],
+        "table_footnote": [
+            "(a) Ablation of question representations. "
+        ],
+        "table_body": "<table><tr><td>Question representation</td><td>EM</td><td>F1</td></tr><tr><td>Only passage-independent</td><td>48.7</td><td>56.6</td></tr><tr><td>Only passage-aligned</td><td>63.1</td><td>71.3</td></tr><tr><td>RASOR</td><td>66.4</td><td>74.9</td></tr></table>",
+        "bbox": [
+            187,
+            401,
+            480,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8918f92c83cb8f424774de6c898bbdb89ec9bafb33f32cf385e13d83d9c76093.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Comparisons for different learning objectives given the same passage-level BiLSTM. "
+        ],
+        "table_body": "<table><tr><td>Learning objective</td><td>EM</td><td>F1</td></tr><tr><td>Membership prediction</td><td>57.9</td><td>69.7</td></tr><tr><td>BIO sequence prediction</td><td>63.9</td><td>73.0</td></tr><tr><td>Endpoints prediction</td><td>65.3</td><td>75.1</td></tr><tr><td>Span prediction w/log loss</td><td>65.2</td><td>73.6</td></tr></table>",
+        "bbox": [
+            509,
+            396,
+            810,
+            476
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Learning objectives Given a fixed architecture that is capable of encoding the input questionpassage pairs, there are many ways of setting up a learning objective to encourage the model to predict the correct span. In Table 2b, we provide comparisons of some alternatives (learned end-toend) given only the passage-level BiLSTM from RASOR. In order to provide clean comparisons, we restrict the alternatives to objectives that are trained and evaluated with exact decoding. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            636
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The simplest alternative is to consider this task as binary classification for every word (Membership prediction in Table 2b). In this baseline, we optimize the logistic loss for binary labels indicating whether passage words belong to the correct answer span. At prediction time, a valid span can be recovered in linear time by finding the maximum contiguous sum of scores. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            700
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Li et al. (2016) proposed a sequence-labeling scheme that is similar to the above baseline (BIO sequence prediction in Table 2b). We follow their proposed model and learn a conditional random field (CRF) layer after the passage-level BiLSTM to model transitions between the different labels. At prediction time, a valid span can be recovered in linear time using Viterbi decoding, with hard transition constraints to enforce a single contiguous output. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also consider a model that independently predicts the two endpoints of the answer span (Endpoints prediction in Table 2b). This model uses the softmax loss over passage words during learning. When decoding, we only need to enforce the constraint that the start index is no greater than the end index. Without the interactions between the endpoints, this can be computed in linear time. Note that this model has the same expressivity as RASOR if the span-level FFNN were removed. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we compare with a model using the same architecture as RASOR but is trained with a binary logistic loss rather than a softmax loss over spans (Span prediction w/ logistic loss in Table 2b). ",
+        "bbox": [
+            176,
+            859,
+            820,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The trend in Table 2b shows that the model is better at leveraging the supervision as the learning objective more accurately reflects the fundamental task at hand: determining the best answer span. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we observe general improvements when using labels that closely align with the task. For example, the labels for membership prediction simply happens to provide single contiguous spans in the supervision. The model must consider far more possible answers than it needs to (the power set of all words). The same problem holds for BIO sequence prediction– the model must do additional work to learn the semantics of the BIO tags. On the other hand, in RASOR, the semantics of an answer span is naturally encoded by the set of labels. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Second, we observe the importance of allowing interactions between the endpoints using the spanlevel FFNN. RASOR outperforms the endpoint prediction model by 1.1 in exact match, The interaction between endpoints enables RASOR to enforce consistency across its two substructures. While this does not provide improvements for predicting the correct region of the answer (captured by the F1 metric, which drops by 0.2), it is more likely to predict a clean answer span that matches human judgment exactly (captured by the exact-match metric). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            300,
+            290,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows how the performances of RASOR and the endpoint predictor introduced in Section 5.2 degrade as the lengths of their predictions increase. The endpoint predictor underpredicts single word answer spans, while overpredicting answer spans with more than 8 words. ",
+        "bbox": [
+            174,
+            332,
+            823,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5cc9e80ec83256790dc1bed04fd2c739275e558fb9115223174bd51060be15e5.jpg",
+        "image_caption": [
+            "Figure 2: F1 and Exact Match accuracy of RASOR and the endpoint predictor over different predictions lengths, along with the distribution of both models’ prediction lengths and the gold answer lengths. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            390,
+            759,
+            619
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since the endpoints predictor does not explicitly model the interaction between the start and end of any given answer span, it is susceptible to choosing the span start and end points from separate answer candidates. For example, consider the following endpoints prediction that is most different in length from a correct span classification. Here, the span classifier correctly answers the question ‘Where did the Meuse flow before the flood?’ with ‘North Sea’ but the endpoints prediction is: ",
+        "bbox": [
+            176,
+            683,
+            823,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "‘south of today’s line Merwede-Oude Maas to the North Sea and formed an archipelago-like estuary with Waal and Lek. This system of numerous bays, estuary-like extended rivers, many islands and constant changes of the coastline, is hard to imagine today. From 1421 to 1904, the Meuse and Waal merged further upstream at Gorinchem to form Merwede. For flood protection reasons, the Meuse was separated from the Waal through a lock and diverted into a new outlet called ”Bergse Maas”, then Amer and then flows into the former bay Hollands Diep ",
+        "bbox": [
+            232,
+            766,
+            766,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this prediction, we can see that both the start ‘south of . . . ’ and the end ‘. . . Hollands Diep’ have a reasonable answer type. However, the endpoints predictor has failed to model the fact that they cannot resonably be part of the same answer, a common error case. The endpoints predictor predicts 514 answers with $> 2 5$ more words than the gold answer, but the span classifier never does this. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/28e6143ad8d835803865ce062c2a28bee3a4b09ba64682d7797a3baa60c2423b.jpg",
+        "image_caption": [
+            "Figure 3: Attention masks from RASOR. Top predictions are ‘Egyptians’, ‘Egyptians against the British’, and ‘British’ in the first example and ‘unjust laws’, ‘what they deem to be unjust laws’, and ‘laws’ in the second. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            103,
+            756,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0776965ff6b7fd2e47f9255ab4f5e029b7cd9169b8fe371123606926baa5db64.jpg",
+        "table_caption": [
+            "Table 3: Example questions and their most attended words in the passage-independent question representation (Equation 11). These examples have the greatest attention (normalized by the question length) in the development set. The attention mechanism typically seeks words in the question that indicate the answer type. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Most attended</td><td rowspan=1 colspan=1>Question</td></tr><tr><td rowspan=1 colspan=1>conditions</td><td rowspan=1 colspan=1>In Gebhard v Consiglio..Milano,the requirements to be registered in Milan beforebeing able to practice law would be allowed under what conditions?</td></tr><tr><td rowspan=1 colspan=1>Were</td><td rowspan=1 colspan=1>Were the restored tapes able to have color added to them to enhance the picture ordid they remain black and white?</td></tr><tr><td rowspan=1 colspan=1>Did</td><td rowspan=1 colspan=1>Did the European Court of Justice rule the defendant in the case of Commission v.Edith Cresson broke any laws?</td></tr><tr><td rowspan=1 colspan=1>whom</td><td rowspan=1 colspan=1>The church holds that they are equally bound to respect the sacredness of the lifeand well-being of whom?</td></tr><tr><td rowspan=1 colspan=1>Whose</td><td rowspan=1 colspan=1>Whose thesis states that the solution to a problem is solvable with reasonable re-sources assuming it allows for a polynomial time algorithm ?</td></tr><tr><td rowspan=1 colspan=1>language</td><td rowspan=1 colspan=1>What language did the Court of Justice accept to be required to teach in a Dublincollege in Groner v Minister for Education?</td></tr><tr><td rowspan=1 colspan=1>term</td><td rowspan=1 colspan=1>Income not from the creation of wealth but by grabbing a larger share of it is knowto economists by what term?</td></tr></table>",
+        "bbox": [
+            184,
+            414,
+            810,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows attention masks for both of RASOR’s question representations. The passageindependent question representation pays most attention to the words that could attach to the answer in the passage (‘brought’, ‘against’) or describe the answer category (‘people’). Meanwhile, the passage-aligned question representation pays attention to similar words. The top predictions for both examples are all valid syntactic constituents, and they all have the correct semantic category. However, RASOR assigns almost as much probability mass to it’s incorrect third prediction ‘British’ as it does to the top scoring correct prediction ‘Egyptian’. This showcases a common failure case for RASOR, where it can find an answer of the correct type close to a phrase that overlaps with the question – but it cannot accurately represent the semantic dependency on that phrase. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A significant architectural difference from other neural models for the SQUAD dataset, such as Wang & Jiang (2016), is the use of the question-independent passage representation (Equation 12). Table 3 shows examples in the development set where the model paid the most attention to a single word in the question. The attention mechanism tends to seek words in the question that indicate the answer type, e.g. ‘language’ from the question: ‘What language did the Court of Justic accept ...’ This pattern provides insight for the necessity of using both question representations, since the answer type information is orthogonal to passage alignment information. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have shown a novel approach for perform extractive question answering on the SQUAD dataset by explicitly representing and scoring answer span candidates. The core of our model relies on a recurrent network that enables shared computation for the shared substructure across span candidates. We explore different methods of encoding the passage and question, showing the benefits of including both passage-independent and passage-aligned question representations. While we show that this encoding method is beneficial for the task, this is orthogonal to the core contribution of efficiently computing span representation. In future work, we plan to explore alternate architectures that provide input to the recurrent span representations. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            244
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            285,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, KyungHyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            174,
+            287,
+            821,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danqi Chen, Jason Bolton, and Christopher D. Manning. A thorough examination of the cnn/daily mail reading comprehension task. In Proceedings of ACL, 2016. ",
+        "bbox": [
+            174,
+            324,
+            820,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. Proceedings of NIPS, 2016. ",
+        "bbox": [
+            174,
+            361,
+            821,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Klaus Greff, Rupesh Kumar Srivastava, Jan Koutn´ık, Bas R. Steunebrink, and Jurgen Schmidhuber. ¨ LSTM: A search space odyssey. IEEE Transactions on Neural Networks and Learning Systems, PP:1–11, 2016. ",
+        "bbox": [
+            176,
+            397,
+            823,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Proceedings of NIPS, 2015. ",
+        "bbox": [
+            173,
+            448,
+            823,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. In Proceedings of ICLR, 2016. ",
+        "bbox": [
+            171,
+            500,
+            823,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long Short-term Memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. Proceedings of ICLR, 2015. ",
+        "bbox": [
+            174,
+            573,
+            823,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peng Li, Wei Li, Zhengyan He, Xuguang Wang, Ying Cao, Jie Zhou, and Wei Xu. Dataset and neural recurrent sequence labeling model for open-domain factoid question answering. CoRR, abs/1607.06275, 2016. ",
+        "bbox": [
+            171,
+            609,
+            825,
+            652
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of ICML, 2010. ",
+        "bbox": [
+            173,
+            660,
+            823,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ankur P Parikh, Oscar Tackstr ¨ om, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention ¨ model for natural language inference. In Proceedings of EMNLP, 2016. ",
+        "bbox": [
+            173,
+            696,
+            823,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In Proceedings of EMNLP, 2014. ",
+        "bbox": [
+            174,
+            733,
+            823,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. SQuAD: 100, $0 0 0 +$ questions for machine comprehension of text. In Proceedings of EMNLP, 2016. ",
+        "bbox": [
+            173,
+            771,
+            823,
+            800
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Richardson, Christopher JC Burges, and Erin Renshaw. Mctest: A challenge dataset for the open-domain machine comprehension of text. In Proceedings of EMNLP, 2013. ",
+        "bbox": [
+            173,
+            808,
+            821,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wilson Taylor. Cloze procedure: A new tool for measuring readability. Journalism Quarterly, 30: 415–433, 1953. ",
+        "bbox": [
+            174,
+            844,
+            821,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kateryna Tymoshenko, Daniele Bonadiman, and Alessandro Moschitti. Convolutional neural networks vs. convolution kernels: Feature engineering for answer sentence reranking. In Proceedings of NAACL, 2016. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Proceedings of NIPS, 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ellen M. Voorhees and Dawn M. Tice. Building a question answering test collection. In Proceedings of SIGIR, 2000. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bingning Wang, Kang Liu, and Jun Zhao. Inner attention based recurrent neural networks for answer selection. In Proceedings of ACL, 2016. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. arXiv preprint arXiv:1608.07905, 2016. ",
+        "bbox": [
+            171,
+            215,
+            821,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Yang, Wen-tau Yih, and Christopher Meek. Wikiqa: A challenge dataset for open-domain question answering. In Proceedings of EMNLP, 2015. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 10
+    }
+]

parse/train/HkxAS6VFDB/HkxAS6VFDB.md

@@ -0,0 +1,343 @@
+# PRUNE OR QUANTIZE? STRATEGY FOR PARETOOPTIMALLY LOW-COST AND ACCURATE CNN
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Pruning and quantization are typical approaches to reduce the computational cost of convolutional neural network (CNN) inference. Although the idea of combining both approaches seems natural, it is surprisingly difficult to determine the effects of the combination without measuring performance on the specific hardware that the user will use. This is because the benefits of pruning and quantization strongly depend on the hardware architecture where the model is executed. For example, a CPU-like architecture with no parallelization may fully exploit the reduction of computations by unstructured pruning to improve speed, but a GPUlike massive parallel architecture would not. Further, there have been emerging proposals of novel hardware architectures, such as those supporting variable bitprecision quantization. From an engineering viewpoint, optimization for each hardware architecture is useful and important in practice, but this is in essence a brute-force approach. Therefore, in this paper, we first propose a hardwareagnostic metric for measuring computational costs. Using the proposed metric, we demonstrate that Pareto-optimal performance, where the best accuracy is obtained at a given computational cost, is achieved when a slim model with fewer parameters is moderately quantized rather than a fat model with a huge number of parameters is quantized to extremely low bit precision, such as binary or ternary. Furthermore, we empirically find a possible quantitative relation between the proposed metric and the signal-to-noise ratio during stochastic gradient descent (SGD) training, by which information obtained during SGD training provides an optimal policy for quantization and pruning. We show the Pareto frontier is improved by $4 \times$ in a post-training quantization scenario based on these findings. These findings not only improve the Pareto frontier for accuracy versus computational cost, but also provide new insights into deep neural networks.
+
+# 1 INTRODUCTION
+
+Reducing execution cost of deep learning inference is one of the most active research topics for applying superhuman recognition in embedded IoT devices and robots. A typical approach for employing memory- and computation-efficient components is separable convolution, which is a combination of depth-wise and point-wise convolutions (Iandola et al., 2016; Zoph et al., 2018; Zhang et al., 2018; Howard et al., 2017), structured/unstructured pruning of connections and activations, and quantizing activation, weight, and their vectors (Stock et al., 2019; Jegou et al., 2011; Gong et al., 2014). Among these, separable convolution and structured pruning are similar, in that separable convolution can be viewed as convolutions pruned in a handcrafted manner. From a pruning viewpoint, since the separable convolution structure results from applying aggressive pruning to normal convolution, the result is drastic reductions in memory and computational cost at the expense of greatly decreased accuracy (Stock et al., 2019). On the other hand, structured pruning and quantization are seemingly orthogonal approaches that can be naturally combined (Tung & Mori, 2018; Han et al., 2016). However, their interactions are still not well-studied. For instance, the use of a single-bit representation is being actively explored as an extreme quantization. Since a nonnegligible accuracy drop is inevitable in extreme quantization, some papers have proposed increasing the number of channels to compensate for the lack of expressivity (Lin et al., 2017). In other words, a quantization approach can further reduce the number of bits by compromising the increase in number of channels, or the increase in number of computations. This indicates that, conversely, reducing channels by pruning may limit capability for quantization. This discussion raises a controversial question: which is better, a fat model with smaller bit width or a slim model with larger bit width? Answering this question requires a metric that fairly measures the effects of both pruning and quantization. One such metric in the literature is the inference speed when the model is executed on specific hardware. This metric is useful or even ideal when the target hardware is known in advance but strongly depends on features of the hardware architecture. Yang et al. (2018) searched for an optimal architecture using inference time as the optimization objective and found different optimal architectures depending on the target device. For example, if the hardware cannot handle extremely low bit-widths (1 or 2 bits), instead treating them as 8-bit integers with upper bits filled with zeros, we cannot exploit the reduction of bit width to improve inference speed. From a theoretical viewpoint, figuring out the extent to which we can reduce the computational complexity of deep neural networks is another important open question.
+
+The discussion so far urges us to develop a hardware-agnostic and theoretically reasonable metric for measuring computational costs of neural network architectures. In this paper, we propose the Frobenius norm of the effective value of weight parameters as one such metric. This metric is proportional to the total energy when the model is executed on ideal hardware, where energy consumption for a single multiply-accumulate (MAC) computation is proportional to the squared effective amplitude of the individual weight parameter used for the MAC computation. The basic idea of the metric is analogous to a highly efficient class-B amplifier circuit whose energy consumption is determined by the instant signal amplitude (Sechi, 1976). This metric successfully reflects the effects of both quantization and structured/unstructured pruning in accordance with intuition.
+
+Using the proposed metric, we empirically find that a slimmer model can achieve a far better Pareto frontier in a lower computational cost region than can a fatter model after quantization, while a fat model is advantageous for achieving higher accuracy in a larger computational cost region. Finally, we perform experiments under a post-training quantization scenario (Banner et al., 2018) on ImageNet dataset (Deng et al., 2009) to verify the validity of our claim, namely that prune-then-quantize is superior to quantize-only or prune-only for achieving a better Pareto frontier.
+
+Further, since this metric is relevant to the signal-to-noise ratio $( S / N )$ , it is measurable during SGD training, in which the absolute value of weights and the random walk of weight parameters correspond to signal and noise, respectively. We observe that the dependencies of the metric on validation accuracy seem to be correlated between those during training and those applying quantization after training. From this observation, we point out some possibilities for which we could expect robustness of a model for quantization from information obtained during training, we could determine an optimal policy for quantization of that model, and we could develop a novel optimization or regularization scheme.
+
+The main contributions of this paper are as follows:
+
+• We define a hardware-agnostic metric for measuring the computational cost of pruned and quantized models. We empirically find that models with fewer parameters achieve far better accuracy in a low computational cost region after quantization.   
+• We show a potential quantitative relation between quantization noise and perturbation of weight parameters during SGD training.
+
+And as implications, we hope to exploit our findings for
+
+• thorough comparison of various neural network architectures using the proposed hardwareagnostic metric,   
+• development of a method for extracting a quantization policy from information obtained during SGD training, and   
+• development of a training algorithm or regularization scheme for producing robust models based on the relation between quantization noise and perturbation of weight parameters during SGD training.
+
+![](images/45c4995af673290a29b96eb483a2dcadbe7d8ee1fa059b636974fe0dbcd95f81.jpg)  
+Figure 1: Left/Center: Computational cost strongly depends on the hardware architecture on which the model is executed. Right: Proposed computational cost for analysis or theoretical research, assuming an ideal hardware architecture.
+
+# 2 EFFECTIVE SIGNAL NORM
+
+We seek a metric that properly reflects the effects of both quantization and pruning. Conventionally, quantization effectiveness is evaluated according to the number of bits required to achieve a given accuracy, or the accuracy achieved by using certain bit numbers for specific network architectures (Stock et al., 2019). We cannot use this to compare efficiencies between different architecture models (e.g., MobileNet versus ResNet-18). The number of MAC computations or parameters can be used to compare different architectures, but the number of MAC computations does not consider quantization and the number of parameters is not directly related to inference time.
+
+Recently, the use of actual or estimated inference speeds as a metric for comparing network architectures has been proposed (Yang et al., 2018; Wang et al., 2019a; Cai et al., 2019). This metric is very useful when the target hardware is known in advance, and ideal for those who wish to use the model that performs best on that hardware. However, this metric is strongly hardware dependent. Indeed, Yang et al. (2018); Wang et al. (2019a); Cai et al. (2019) found that optimal architectures for different types of target hardware are totally different. Considering interest in, for example, the simplest realizable deep neural network model while achieving a required accuracy, there is a need for a hardware-agnostic metric.
+
+The metric for model evaluation should correlate with energy consumed when the model is executed on ideal hardware. We assume that energy consumption by ideal hardware monotonically decreases when the bit width is reduced by quantization and when the number of nonzeros in weight parameters is reduced by pruning. For example, hardware with an 8-bit integer MAC array cannot be further accelerated even if the bit width is reduced from 8 to 1 or 2 bits. Thus, the energy consumption measured using such hardware does not satisfy the aforementioned requirement and cannot be our metric. Hardware like a CPU, which processes each computation in serial, can naturally exploit the structured or unstructured sparsity of weight parameters by skipping computations with zeroed weights. However, because it is difficult to parallelize computations while maintaining such a strategy, it is generally difficult to benefit from sparsity in GPU-like hardware employing massively parallel MAC units. Hardware dedicated to sparse convolution (Lu et al., 2019) tends to show better performance only when sparsity is sufficiently high, due to relatively large overheads for encoding and decoding sparse weight parameters in a special format.
+
+Therefore, the benefit of sparsity from pruning and low bit width from quantization largely depends on the hardware architecture, so long as we consider only existing hardware. Because we require a hardware-agnostic metric, we assume ideal hardware in which energy consumption is linearly proportional to the number of nonzero weight parameters and monotonically depends on the bit width of weight parameters, as shown in Figure 1, setting aside the feasibility of such ideal hardware.
+
+# 2.1 DEFINITION OF EFFECTIVE SIGNAL NORM
+
+We define a metric called the effective signal norm (ESN) as
+
+$$
+\mathrm { E S N } = \sum _ { l } | | c ^ { l } f ( \mathbf { W } _ { \mathrm { i n t } } ^ { l } ) | | _ { F } ^ { 2 } ,
+$$
+
+with $\mathbf { \boldsymbol { \mathsf { W } } } _ { \mathrm { i n t } } ^ { l } = \lfloor \mathbf { \boldsymbol { \mathsf { W } } } ^ { l } / \varDelta ^ { l } \rfloor + 0 . 5$ , where $\boldsymbol { \mathsf { W } } ^ { l }$ is the weight tensor and $\varDelta ^ { l }$ is the quantization step size of the th layer; and $\bar { c } ^ { l }$ is a coefficient depending on the layer, in that if $c ^ { l } = 1$ , ESN is related to the number of parameters (cf. memory footprint), and if $c ^ { l }$ is the number of computations per parameter at the lth layer, ESN is related to the number of computations (cf. FLOP). ${ \bar { f } } ( \cdot )$ is an element-wise function that determines how the metric responds to the value of each weight parameter. We propose two functions for $f ( \cdot )$ . The first is $f ( \bar { \mathbf { W } _ { \mathrm { i n t } } ^ { l } } ) = \mathbf { W } _ { \mathrm { i n t } } ^ { l }$ , based on the assumption that energy consumption increases with the square of the value for each weight parameter or for each computation. When $c ^ { l } = 1$ , the definition is
+
+$$
+\mathrm { E S N } _ { a } = \sum _ { l } | | \mathbf { W } _ { \mathrm { i n t } } ^ { l } | | _ { F } ^ { 2 } .
+$$
+
+This assumption is reasonable when we employ an analog (or in-memory) MAC computation engine (Shafiee et al., 2016; Miyashita et al., 2017), because energy consumption is proportional to the square of the signal amplitude when the signal represents an analog quantity such as voltage or current. Assuming ideal hardware, we adopt a definition where energy consumption varies according to the instant amplitude (cf. class-B amplifier), which is more energy efficient than the case where energy consumption is constant and the value is determined by the maximal amplitude (cf. class-A amplifier) (Sechi, 1976).
+
+The second proposed function is $f ( \mathbf { W } _ { \mathrm { i n t } } ^ { l } ) = \lceil \log _ { 2 } ( \mathrm { a b s } ( \mathbf { W } _ { \mathrm { i n t } } ^ { l } ) ) + 1 \rceil$ , where $\log _ { 2 } \left( \cdot \right)$ and $\mathrm { a b s } \left( { \cdot } \right)$ are functions applied to each element of a tensor argument. This is based on the assumption that energy consumption increases with the binary logarithm of the value for each weight parameter. When $c ^ { l } = 1$ , the definition is
+
+$$
+\mathrm { E S N } _ { d } = \sum _ { l } \vert \vert \lceil \log _ { 2 } ( \mathrm { a b s } ( \boldsymbol { \mathsf { W } } _ { \mathrm { i n t } } ^ { l } ) ) + 1 \rceil \vert \vert _ { F } ^ { 2 } .
+$$
+
+In a digital circuit, a number is represented as a binary digit (bits), so the energy consumption for moving or processing signals is roughly proportional to the number of bits, which is the binary logarithm of the value. It is therefore reasonable to use Equation (3) for a digital circuit.
+
+# 2.2 RELATION BETWEEN ESN AND S/N
+
+The effective signal norm defined in Equation (2) is related to the signal-to-noise ratio $( S / N )$ when quantization noise is dominant and noise is approximated by a uniform distribution (Gray & Neuhoff, 1998).
+
+$$
+\mathrm { E S N } _ { a } = \sum _ { l } \left( \frac { | | \mathbf { W } ^ { l } | | _ { F } ^ { 2 } } { | | \mathbf { W } ^ { l } - \varDelta \cdot \mathbf { W } _ { \mathrm { i n t } } ^ { l } | | _ { F } ^ { 2 } } \cdot \frac { | | \mathbf { W } ^ { l } | | _ { 0 } } { 1 2 } \right) = \sum _ { l } \left( S / N _ { l } \cdot \frac { | | \mathbf { W } ^ { l } | | _ { 0 } } { 1 2 } \right) ,
+$$
+
+where $l$ is the layer index, $S / N _ { l }$ is the signal-to-quantization-noise ratio of the lth layer as defined by ||Wl||2FWl ∆ Wl 2 , and ||Wl||0 is the number of nonzero elements in the tensor Wl. Appendix E presents the derivation of Equation (4). This equation allows us to calculate $\mathrm { E S N } _ { a }$ , so long as $S / N$ is defined.
+
+# 2.3 $\mathrm { E S N } _ { a }$ DURING TRAINING
+
+For example, we can define $S / N$ by regarding perturbation of weight parameters during training as noise. Formally, we define the signal and noise at the $j$ th epoch as
+
+$$
+S _ { j } = \sum _ { l } \sum _ { i } | | \mathbf { W } _ { j , i } ^ { l } | | _ { F } ^ { 2 } , ~ N _ { j } = \sum _ { l } \sum _ { i } | | \mathbf { W } _ { j , i } ^ { l } - \mathbf { W } _ { \mathrm { i n i t } _ { j } } ^ { l } | | _ { F } ^ { 2 } ,
+$$
+
+where $\boldsymbol { \mathsf { W } } _ { j , i } ^ { l }$ is the weight parameters in the lth layer at the $i$ th iteration in the $j$ th epoch, and $\mathbf { \Delta } \mathbf { W } _ { \mathrm { i n i t } _ { j } } ^ { l }$ is a snapshot of the weight at the beginning of the $j$ th epoch. Then, $N _ { j }$ is the effective value of random walk noise for weight parameters in one epoch.
+
+![](images/235193dd0b15100d4b1b0a0a69dff68a6329561fa43a202e658f39c6adba7cf5.jpg)  
+Figure 2: Training curves of $\mathrm { E S N } _ { a }$ (left) and validation accuracy (right) on CIFAR-10. In the right graph, moving average curve between 3-epochs is overlapped on each plot.
+
+![](images/b7e6cb451b3162ad4574bca3208d8c0846905e2a94fdda0c255fe1d5704883d1.jpg)  
+Figure 3: Relation between validation accuracy and $\mathrm { E S N } _ { a }$ during training and after quantization. $\mathrm { E S N } _ { a }$ of the former is computed using Equation (5), and that of the latter is computed using Equation (2)
+
+The left figure in Figure 2 shows the $\mathrm { E S N } _ { a }$ curve during training, which is calculated by Equation (4), and $S / N$ as defined by Equation (5). In this experiment, we use ResNet-20 (He et al., 2016) on CIFAR-10 dataset (Krizhevsky, 2009). We use SGD with momentum 0.9, and we set the mini-batch size to 100 and the initial learning rate to 0.1, which is shifted by $1 / 1 0$ at epochs 80 and 120. We vary the weight decay factor from $\overline { { 5 } } \times 1 0 ^ { - 4 }$ to $2 \times 1 0 ^ { - 3 }$ , indicated by different colors in Figure 2.
+
+Interestingly, the $\mathrm { E S N } _ { a }$ curves look very similar to the validation accuracy curves shown in the right figure in Figure 2. Both $\mathrm { E S N } _ { a }$ and validation accuracy steeply increase at the point where the learning rate is decreased by $1 / 1 0$ , because decreasing the learning rate reduces perturbation (or random walk) of weight values during one epoch, increasing $S / N$ . We can also see that as the weight decay factor increases, $\mathrm { E S N } _ { a }$ tends to decrease. This is also reasonable, because weight decay decreases $| | \pmb { \mathsf { W } } | | _ { F } ^ { 2 }$ or the signal level, reducing $S / N$ . More interestingly, even this trivial tendency appears correlated with validation accuracy; for example, after a steep rise at epoch 80, both $\mathrm { E S N } _ { a } ^ { * }$ and validation accuracy gradually decrease, converging to stable values after overshooting. There is a similar relation between the amount of overshoot and weight decay factor, namely, we observed a larger overshoot with a smaller weight decay factor. These findings might be useful for developing a novel optimization algorithm, but we leave this for future work.
+
+The blue plots in Figure 3 show $\mathrm { E S N } _ { a }$ versus validation accuracy. In this experiment, we use VGG7 (Simonyan & Zisserman, 2014) and ResNet-20 on CIFAR-10, and DenseNet-BC with $l =$ 100, $k = 1 2$ (Huang et al., 2017) on CIFAR-100. We employ SGD with momentum 0.9 and set the initial learning rate to 0.1, followed by cosine annealing without restart (Ilya Loshchilov, 2017). The mini-batch size and weight decay factor are respectively set to 125 and $5 \times 1 0 ^ { - 4 }$ .
+
+The red curve shows the $\mathrm { E S N } _ { a }$ versus validation accuracy curve when applying quantization to weight parameters trained by the training process where the blue plots are obtained. As the figure shows, the red and blue curves seem to be correlated. This suggests that the model acquires robustness to quantization by having experienced similar perturbations due to a random walk during the training process. If so, the $\mathrm { E S N } _ { a }$ versus validation accuracy curve during training is available as a loose boundary on accuracy degradation due to decrease of $\mathrm { E S N } _ { a }$ by quantization. We discuss this hypothesis in Section 2.7 again.
+
+![](images/65c78a5c209e01a0c9dea837a7e5dc5c3c216284aac3dbcc3761065155f616c6.jpg)  
+Figure 4: Accuracy versus $\mathrm { E S N } _ { a }$ (left) and $\mathrm { E S N } _ { d }$ (right) for various network depths and widths.
+
+# 2.4 ESN VERSUS ACCURACY FOR VARIOUS MODEL SIZES
+
+With our metric defined, we next attempt to investigate which is better, a model that is slim (with the number of weight parameters and computations reduced by pruning) and mildly quantized (e.g., with 4–5 bits), or a model that is fat (with a large number of weight parameters and computations) and radically quantized (e.g., with 1–2 bits). We evaluate six network architectures with different depths and widths: ResNet-8, 14, 20 and VGG7 with different channel widths $( 1 \times , 0 . 5 \times , 0 . 2 5 \times )$ on CIFAR-10 dataset. In this experiment, we employ networks with originally small number of parameters as slim models instead of pruning fat models. The network architecture of ResNet is based on the original one without bottleneck architecture (He et al., 2016). The detailed network architecture of VGG7 is shown in Appendix F.
+
+Figure 4 shows validation accuracy versus $\mathrm { E S N } _ { a }$ and $\mathrm { E S N } _ { d }$ . Here, we consider differences in $\mathrm { E S N } _ { a }$ and $\mathrm { E S N } _ { d }$ . For simplicity, we assume that all weight parameters have the same value $v > 1$ , and that the number of weight parameters is $N$ . The definitions of $\mathrm { E S N } _ { a }$ and $\mathrm { E S N } _ { d }$ are expressed as follows,
+
+$$
+\mathrm { E S N } _ { a } = v ^ { 2 } \times N , \mathrm { E S N } _ { d } = \left\lceil \log _ { 2 } v + 1 \right\rceil \times N .
+$$
+
+Therefore, when we compare $\mathrm { E S N } _ { a }$ and $\mathrm { E S N } _ { d }$ , both are linearly proportional to the number of weight parameters, whereas values of weight parameters affect the metric at squared and logarithmic scales, respectively. This means that $\mathrm { E S N } _ { a }$ is more strongly dependent on the size of the values than on the number of weight parameters, and the opposite is true for $\mathrm { E S N } _ { d }$ . In other words, $\mathrm { E S N } _ { d }$ is more sensitive to pruning than to quantization, and $\mathrm { E S N } _ { a }$ is more sensitive to quantization than to pruning. Figure 4 clearly shows these tendencies. We can see that even when using the $\mathrm { E S N } _ { a }$ metric, which is advantageous for quantization, the slimmer model shows better validation accuracy in lower ESN regions. These experiments indicate that in lower ESN regions, or with lower energy consumption by ideal hardware, especially when employing digital computing, it is an advisable strategy to prune the model to the limit where the desired accuracy is achieved, and then to apply quantization to obtain the highest possible accuracy. In contrast, it is a bad strategy to apply quantization to a fat model, even if it shows much better accuracy than the pruned slim model before quantization. Consequently, to the question posed at the beginning of this subsection—whether a slim and mildly quantized model or a fat and radically quantized model is better—the answer is the former one, which may in a sense raise a question on trends in quantization research. Note that the above discussion also indicates that the importance of quantization will be relatively increased if analog computing become practical in the future.
+
+# 2.5 TRAINING UNDER LOW-ESN CONDITIONS
+
+We next observe how the weight parameters evolve in the training process. Figure 5 shows from left to right the loss, $\mathrm { E S N } _ { a }$ , and number of pruned filters (output channels). In this experiment, we train ResNet-20 on CIFAR-10 dataset with initial weight parameters of a trained model. We employ SGD with momentum 0.9, weight decay factor $5 \times 1 \bar { 0 } ^ { - 4 }$ , and mini-batch size 200, updating for 20 epochs. The learning rate (LR) is constant, with a value varied from 0.32 to 1.81 for each training. Note that we do not intentionally prune filters in this experiment; rather, filter pruning spontaneously occurs along with sequential updates of weight parameters by SGD. The center graph shows that as the learning rate increases, $\mathrm { E S N } _ { a }$ decreases due to the larger noise. The number of pruned filters after epoch 20 is larger with the larger learning rate, which corresponds to smaller $\mathrm { E S N } _ { a }$ . In the training process, rather than continuing to increase at a constant rate throughout the training process, the number of pruned filters steeply increases within a few epochs and then is maintained without noticeable change.
+
+![](images/65b7e15a1281061dd878ec2ce254f2bac5a00b56db35de70a4d382971aa01894.jpg)  
+Figure 5: Training curves for loss, $\mathrm { E S N } _ { a }$ , and number of pruned filters under different learning rate (LR) conditions. $\mathrm { E S N } _ { a }$ is calculated by Equations (4) and (5).
+
+![](images/c89a06ca0d298bf226b318acfebdde96ddcace59998d6234d38565dda598198c.jpg)  
+Figure 6: Accuracy versus $\mathrm { E S N } _ { a / d }$ (left/center) and histogram of the maximal bit width for each filter (right) in the pruning only, quantization only, and prune-then-quantize mixed cases.
+
+This indicates that under a small $\mathrm { E S N } _ { a }$ condition controlled by the learning rate, the optimizer finds a solution for reducing the number of parameters by pruning filters and prioritizing increases in amplitude of the remaining parameters, rather than letting all parameters survive with small amplitude.
+
+# 2.6 PRUNE then QUANTIZE
+
+In the previous two subsections, we empirically showed that achieving optimal accuracy in a low ESN region requires preparation of a slim model before applying quantization. A slim model can be generated by pruning a fat model or by designing a slim architecture. Based on the lottery ticket hypothesis (Frankle & Carbin, 2019), where a fat or overparameterized network can have higher potential for finding better optimal parameters by SGD training, we adopt the former method, namely, pruning weight parameters from a pretrained fat model. We apply ADMM regularization for structured pruning (Wang et al., 2019b), since this achieves state-of-the-art performance.
+
+In this experiment, we evaluate ResNet-20 on CIFAR-10 dataset. We update pretrained weight parameters through the SGD algorithm with alternating direction method of multipliers (ADMM) regularization (Wang et al., 2019b) for a few additional epochs. We then fine-tune the resulting pruned model over 160 epochs. In this fine tuning, we employ SGD with momentum 0.9 and set the mini-batch size to 100 and the initial learning rate to 0.1, followed by cosine annealing without restart. The weight decay factor is set to $5 \times 1 0 ^ { - 4 }$ . Since the weight parameters are not yet quantized in this phase, we update all parameters, except that we set weights for the filters (output channels) and channels (input channels) pruned in the previous phase to zero. Finally, we apply quantization.
+
+As Figure 6 shows, the Pareto frontier significantly improves by applying prune-then-quantize (red), as compared to applying extreme quantization (green). The right graph in Figure 6 shows a histogram of the maximal bit width under each filter (output channel) of the three models indicated by the broken line in the center graph $\mathrm { ( E S N _ { } = 3 9 M ( b i t s ) ) }$ . Since the pretrained model has 800 filters before pruning and quantization, summations of frequencies for each color are 800. In the pruning only (blue) case, the weight parameters in 555 filters, the largest number among the three methods, are pruned (represented as 0 bits). Most of remaining filters are 8 bits. In the quantization only (green) case, the number of pruned filters is a low 77, while the bit width of most remaining filters is 1 bit. In the proposed prune-then-quantize mixed (red) case, the number of pruned filters is 288 and the bit widths of most remaining filters are 3 or 4 bits, so the remaining filters are mildly quantized. As this case shows, while the $\mathrm { E S N } _ { d }$ values are similar, the validation accuracies differ depending on the number and bit width of the weight parameters. The prune-then-quantize mixed method properly produces a pruned and mildly quantized model, which achieves far better validation accuracy, especially in the low ESN region, as compared to the model produced by extremely quantizing a fat model without pruning.
+
+![](images/b8ddd3ff9df3e6ec00d462f05fa87053b7fdaf62fb93f886c6b0fb58b7c2a373.jpg)  
+Figure 7: Relation between random walk during SGD and quantization noise. Loss often steeply decreases when LR is shifted by (e.g., $1 / 1 0 \AA$ ). In this situation, loss before shifting LR is possibly governed by random walk noise due to the large LR, as shown in the left figure. When we quantize weight parameters of the trained model, however, the loss or accuracy should be determined by noise induced by quantization, as shown in the right figure. If we can assume that the loss landscapes of the two cases should not diverge too much, the loss (or accuracy) after quantization is possibly predicted by the dependency of loss (or accuracy) on $\mathrm { E S N } _ { a }$ during training.
+
+# 2.7 $\mathrm { E S N } _ { a }$ FOR QUANTIZATION
+
+As Section 2.3 showed, there is a possible quantitative relation between $\mathrm { E S N } _ { a }$ during model training and $\mathrm { E S N } _ { a }$ of the pruned and quantized version of that model after training. This finding inspires us to exploit $\mathrm { E S N } _ { a }$ information obtained during training to determine the quantization policy, for example, how many bits to allocate for each layer. Figure 7 shows the intuition behind this idea, namely straightforward use of the $\mathrm { E S N } _ { a }$ values for each layer at a certain epoch during training as targets for quantization. Appendix B describes a preliminary experiment for verifying this idea.
+
+# 3 EXPERIMENT ON IMAGENET
+
+To verify the validity of our claims, we performed experiments under a post-training quantization scenario (Banner et al., 2018) on ImageNet dataset (Deng et al., 2009). Post-training quantization assumes a use-case scenario where a user (e.g., at an edge side) quantizes a given pretrained CNN model with a limited number of unlabeled training samples for obtaining a lightweight model suited to a particular situation. As concluded in Section 2.4, in a low ESN region or with low energy consumption, we can achieve higher accuracy by quantizing a slim model than by quantizing a fat model, even if the latter is more accurate. To provide optimal accuracy in a low computationalcost region, we apply the proposed prune-then-quantize method to the post-training quantization scenario.
+
+Figure 8 shows the result of applying our method to ResNet-18 and ResNet-50 on ImageNet dataset. We used pretrained models12 as basic models with $1 \times$ channel width, and prune the models to various channel widths $0 . 2 5 \times$ , $0 . 5 \times$ , and $0 . 7 5 \times \mathrm { _ { \it { \cdot } } }$ ). In this experiment, we determine which filters (output channels) to prune based on the signal norm of weights calculated by Equation (5). We prune filters in order from the smallest signal norm, and tune each model for the pruned structure through the SGD algorithm over 4 epochs. The mini-batch size is set to 64, and the learning rate is initialized to 0.1 and divided by 10 at epochs 2 and 3. We then quantize each model. For quantization, we only fine-tune statistic parameters in BatchNorm layers (called running_mean and running_var in pytorch (Paszke et al., 2017)) with no labeled data (Sasaki et al., 2019), which is the same condition as conventional work (Banner et al., 2018).
+
+![](images/805ac050388734c55a9e403a956c51041e64cb91ba7ed78d2f987bb8a59cdc5c.jpg)  
+Figure 8: (Left/center) top-1 accuracy on ImageNet versus $\mathrm { E S N } _ { a / d }$ and (right) estimated $\mathrm { E S N } _ { d } ^ { \prime }$ , applying the prune-then-quantize method to (upper) ResNet-18 and (lower) ResNet-50.
+
+In addition to evaluations by $\mathrm { E S N } _ { a }$ and $\mathrm { E S N } _ { d }$ , to compare our method with the conventional work, we estimate its computational cost using Equation (1) with $c ^ { l }$ and $f ( \cdot )$ properly defined, as
+
+$$
+\mathrm { E S N } _ { d } ^ { \prime } = \sum _ { l } \sum _ { m } \mathrm { M A C } _ { l , m } \times \lceil \log _ { 2 } ( \operatorname* { m a x } ( \mathrm { a b s } ( \mathbf { W } _ { \mathrm { i n t } } ^ { l , m } ) ) ) + 1 \rceil ,
+$$
+
+where applyi $\mathrm { M A C } _ { l , m }$ he number of computation per filter and function, we restrict the number of bits to $\pmb { \mathsf { W } } _ { \mathrm { i n t } } ^ { l , m }$ is the me in e $m$ th filter of h filter. $\pmb { \mathsf { W } } _ { \mathrm { i n t } } ^ { l }$ . By $\operatorname* { m a x } ( { \mathord { \cdot } } )$
+
+We apply this metric3 to a recently proposed efficient MAC array architecture capable of handling variable bit precision (Maki et al., 2018).
+
+As Figure 8 shows, significantly using slim models after pruning some filters improves the Pareto frontier as compared to Banner et al. (2018). For example, in ResNet-18, $5 7 \ \%$ top-1 accuracy is achieved at $2 \times$ lower computational cost, and in ResNet-50, $6 3 \ \%$ top-1 accuracy is at $4 \times$ lower computational cost. These results suggest that we should adopt a slim model to achieve best accuracy in low computational cost regions, instead of quantizing weight parameters to an extremely low bit precision.
+
+# 4 CONCLUSION
+
+We proposed a hardware-agnostic metric called the effective signal norm (ESN) to measure computational costs. Using this metric, we demonstrated that a slim model with fewer weight parameters achieves better Pareto frontier performance in low computational cost regions than does an extremely quantized fat model. We also showed a possible quantitative relation between weight perturbation during SGD training and quantization noise or robustness against quantization.
+
+By defining this metric, on the hardware architecture side we can aim at realizing hardware whose energy consumption is proportional to the metric. On the algorithmic side, we can reduce the metric. We therefore expect consensus-sharing regarding the metric for computational cost to accelerate research progress for both algorithms and hardware architectures.
+
+# 5 RELATED WORKS
+
+Quantization Courbariaux & Bengio (2016); Rastegari et al. (2016); Zhu et al. (2017) quantize weight parameters and activations as 1 or 2. Since such extreme quantization deteriorates accuracy to a nonnegligible extent, quantization methods with, for example, 4–8 bits are also actively explored (Banner et al., 2018; Lin et al., 2017) to avoid the accuracy drop. Miyashita et al. (2016) attempts to quantize weight parameters and activations in a logarithmic domain, aiming not only at reducing information loss but also replacing multiplication with bit-shift to simplify computation. To reduce the average bit width as much as possible while maintaining accuracy, and to exploit it to accelerate inference speed, Maki et al. (2018) proposes variable bit-width quantization co-optimized with hardware architecture. Although nonuniform quantization (Tung & Mori, 2018; Han et al., 2016) and vector or product quantization (Gong et al., 2014; Jegou et al., 2011; Stock et al., 2019) are also actively studied, these approaches are effective for reducing the memory footprint but not for directly reducing computational costs. Use cases include quantization-aware training (Courbariaux & Bengio, 2016; Rastegari et al., 2016; Zhu et al., 2017; Lin et al., 2017; Zhang et al., 2018) and post-training quantization (Banner et al., 2018). Quantization-aware training achieves better accuracy with lower bit widths, and is almost inevitable for those with extreme quantization. However, it tends to incur higher training costs in most cases. The post-training quantization scenario, which is executable with less computational resources and a smaller training dataset, has potentially more applications, so we also target this scenario.
+
+Pruning Pruning methods include structured pruning, which prunes whole layers, filters, or channels to maintain a regular structure so that computations are easily parallelized, and unstructured pruning, which randomly prunes individual weight parameters. Since it is difficult to benefit from unstructured pruning unless sparsity is sufficiently large, due to its incompatibility with parallelization (Lu et al., 2019), we target structured pruning. Many pruning methods have also been proposed, such as criteria-based approaches (LeCun et al., 1990), regularization-based approaches (Han et al., 2015; Wang et al., 2019b), and methods employing reinforcement learning (Zhong et al., 2018). In this paper, we argue that a pruned slim model performs better after quantization in lower computational cost regions. Any pruning method can be applied to produce a pruned slim model.
+
+Metric for measuring cost In most quantization papers, the standard metric is accuracy achieved under a certain bit width. For pruning, the standard metric is the number of parameters or the number of computations (FLOP). Some papers use inference time when the model runs on specific hardware (Cai et al., 2019; Yang et al., 2018), but this metric is strongly hardware-dependent. In this paper, we propose a hardware-agnostic metric.
+
+Noise during training Relations between learning rate, batch size, and noise during training are widely discussed (Keskar et al., 2017; Xing et al., 2018). To make the model more robust to quantization, some papers propose intentional addition of noise to gradient or weight parameters (Spallanzani et al., 2019; Baskin et al., 2018a;b).
+
+# REFERENCES
+
+Ron Banner, Yury Nahshan, Elad Hoffer, and Daniel Soudry. ACIQ: analytical clipping for integer quantization of neural networks. CoRR, abs/1810.05723, 2018. URL http://arxiv.org/ abs/1810.05723.
+
+Chaim Baskin, Natan Liss, Yoav Chai, Evgenii Zheltonozhskii, Eli Schwartz, Raja Giryes, Avi Mendelson, and Alexander M. Bronstein. NICE: noise injection and clamping estimation for neural network quantization. CoRR, abs/1810.00162, 2018a. URL http://arxiv.org/ abs/1810.00162.
+
+Chaim Baskin, Eli Schwartz, Evgenii Zheltonozhskii, Natan Liss, Raja Giryes, Alexander M. Bronstein, and Avi Mendelson. UNIQ: uniform noise injection for the quantization of neural networks. CoRR, abs/1804.10969, 2018b. URL http://arxiv.org/abs/1804.10969.
+
+Han Cai, Chuang Gan, and Song Han. Once for all: Train one network and specialize it for efficient deployment. CoRR, abs/1908.09791, 2019. URL http://arxiv.org/abs/1908.09791.
+
+Matthieu Courbariaux and Yoshua Bengio. Binarynet: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. CoRR, abs/1602.02830, 2016. URL http://arxiv. org/abs/1602.02830.
+
+J. Deng, W. Dong, R. Socher, L. 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, June 2009. doi: 10.1109/CVPR.2009.5206848.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rJl-b3RcF7.
+
+A. Gersho. Quantization. IEEE Communications Society Magazine, 15(5):16–16, Sep. 1977. doi: 10.1109/MCOM.1977.1089500.
+
+Yunchao Gong, Liu Liu, Ming Yang, and Lubomir D. Bourdev. Compressing deep convolutional networks using vector quantization. CoRR, abs/1412.6115, 2014. URL http://arxiv.org/ abs/1412.6115.
+
+R. M. Gray and D. L. Neuhoff. Quantization. IEEE Transactions on Information Theory, 44(6): 2325–2383, Oct 1998. doi: 10.1109/18.720541.
+
+Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural network. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1135–1143. Curran Associates, Inc., 2015.
+
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. International Conference on Learning Representations (ICLR), 2016.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, June 2016. doi: 10.1109/CVPR.2016.90.
+
+Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017. URL http://arxiv.org/abs/ 1704.04861.
+
+G. Huang, Z. Liu, L. v. d. Maaten, and K. Q. Weinberger. Densely connected convolutional networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2261–2269, July 2017. doi: 10.1109/CVPR.2017.243.
+
+Forrest N. Iandola, Matthew W. Moskewicz, Khalid Ashraf, Song Han, William J. Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with $5 0 \mathrm { x }$ fewer parameters and ${ < } 1 \mathrm { m b }$ model size. CoRR, abs/1602.07360, 2016. URL http://arxiv.org/abs/1602.07360.
+
+Frank Hutter Ilya Loshchilov. SGDR: stochastic gradient descent with warm restarts. International Conference on Learning Representations (ICLR), 2017.
+
+H. Jegou, M. Douze, and C. Schmid. Product quantization for nearest neighbor search. IEEE Transactions on Pattern Analysis and Machine Intelligence, 33(1):117–128, Jan 2011. ISSN 0162-8828. doi: 10.1109/TPAMI.2010.57.
+
+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. International Conference on Learning Representations (ICLR), 2017.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 2, pp. 598–605. Morgan-Kaufmann, 1990. URL http://papers.nips.cc/paper/250-optimal-brain-damage.pdf.
+
+Xiaofan Lin, Cong Zhao, and Wei Pan. Towards accurate binary convolutional neural network. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 345–353. Curran Associates, Inc., 2017.
+
+L. Lu, J. Xie, R. Huang, J. Zhang, W. Lin, and Y. Liang. An efficient hardware accelerator for sparse convolutional neural networks on fpgas. In 2019 IEEE 27th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM), pp. 17–25, April 2019. doi: 10.1109/FCCM.2019.00013.
+
+A. Maki, D. Miyashita, K. Nakata, F. Tachibana, T. Suzuki, and J. Deguchi. Fpga-based cnn processor with filter-wise-optimized bit precision. In 2018 IEEE Asian Solid-State Circuits Conference (A-SSCC), pp. 47–50, Nov 2018. doi: 10.1109/ASSCC.2018.8579342.
+
+D. Miyashita, S. Kousai, T. Suzuki, and J. Deguchi. A neuromorphic chip optimized for deep learning and cmos technology with time-domain analog and digital mixed-signal processing. IEEE Journal of Solid-State Circuits, 52(10):2679–2689, Oct 2017. ISSN 0018-9200. doi: 10.1109/JSSC.2017.2712626.
+
+Daisuke Miyashita, Edward H. Lee, and Boris Murmann. Convolutional neural networks using logarithmic data representation. CoRR, abs/1603.01025, 2016. URL http://arxiv.org/ abs/1603.01025.
+
+Travis Oliphant. NumPy: A guide to NumPy. USA: Trelgol Publishing, 2006. URL http: //www.numpy.org/.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in PyTorch. In NIPS Autodiff Workshop, 2017.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016.
+
+S. Sasaki, A. Maki, D. Miyashita, and J. Deguchi. Post training weight compression with distribution-based filter-wise quantization step. In 2019 IEEE Symposium in Low-Power and High-Speed Chips (COOL CHIPS), pp. 1–3, April 2019. doi: 10.1109/CoolChips.2019.8721356.
+
+F. N. Sechi. Linearised class-b transistor amplifiers. IEEE Journal of Solid-State Circuits, 11(2): 264–270, April 1976. ISSN 0018-9200. doi: 10.1109/JSSC.1976.1050713.
+
+A. Shafiee, A. Nag, N. Muralimanohar, R. Balasubramonian, J. P. Strachan, M. Hu, R. S. Williams, and V. Srikumar. Isaac: A convolutional neural network accelerator with in-situ analog arithmetic in crossbars. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pp. 14–26, June 2016. doi: 10.1109/ISCA.2016.12.
+
+K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014.
+
+Matteo Spallanzani, Lukas Cavigelli, Gian Paolo Leonardi, Marko Bertogna, and Luca Benini. Additive noise annealing and approximation properties of quantized neural networks. CoRR, abs/1905.10452, 2019. URL http://arxiv.org/abs/1905.10452.
+
+Pierre Stock, Armand Joulin, Remi Gribonval, Benjamin Graham, and Herv ´ e J ´ egou. And the bit ´ goes down: Revisiting the quantization of neural networks. CoRR, abs/1907.05686, 2019. URL http://arxiv.org/abs/1907.05686.
+
+F. Tung and G. Mori. Clip-q: Deep network compression learning by in-parallel pruningquantization. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7873–7882, June 2018. doi: 10.1109/CVPR.2018.00821.
+
+Kuan Wang, Zhijian Liu, Yujun Lin, Ji Lin, and Song Han. Haq: Hardware-aware automated quantization with mixed precision. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019a.
+
+Yanzhi Wang, Shaokai Ye, Zhezhi He, Xiaolong Ma, Linfeng Zhang, Sheng Lin, Geng Yuan, Sia Huat Tan, Zhengang Li, Deliang Fan, Xuehai Qian, Xue Lin, and Kaisheng Ma. Nonstructured DNN weight pruning considered harmful. CoRR, abs/1907.02124, 2019b. URL http://arxiv.org/abs/1907.02124.
+
+Chen Xing, Devansh Arpit, Christos Tsirigotis, and Yoshua Bengio. A walk with sgd. CoRR, abs/1802.08770, 2018. URL http://arxiv.org/abs/1802.08770.
+
+Tien-Ju Yang, Andrew Howard, Bo Chen, Xiao Zhang, Alec Go, Mark Sandler, Vivienne Sze, and Hartwig Adam. Netadapt: Platform-aware neural network adaptation for mobile applications. In Vittorio Ferrari, Martial Hebert, Cristian Sminchisescu, and Yair Weiss (eds.), Computer Vision – ECCV 2018, pp. 289–304, Cham, 2018. Springer International Publishing. ISBN 978-3-030- 01249-6.
+
+Dongqing Zhang, Jiaolong Yang, Dongqiangzi Ye, and Gang Hua. Lq-nets: Learned quantization for highly accurate and compact deep neural networks. In European Conference on Computer Vision (ECCV), 2018.
+
+X. Zhang, X. Zhou, M. Lin, and J. Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6848–6856, June 2018. doi: 10.1109/CVPR.2018.00716.
+
+Jing Zhong, Guiguang Ding, Yuchen Guo, Jungong Han, and Bin Wang. Where to prune: Using lstm to guide end-to-end pruning. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI-18, pp. 3205–3211. International Joint Conferences on Artificial Intelligence Organization, 7 2018. doi: 10.24963/ijcai.2018/445. URL https://doi.org/ 10.24963/ijcai.2018/445.
+
+Chenzhuo Zhu, Song Han, Huizi Mao, and William J. Dally. Trained ternary quantization. International Conference on Learning Representations (ICLR), 2017.
+
+B. Zoph, V. Vasudevan, J. Shlens, and Q. V. Le. Learning transferable architectures for scalable image recognition. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8697–8710, June 2018. doi: 10.1109/CVPR.2018.00907.
+
+# A DETAILS OF THE QUANTIZATION PROCESS
+
+We basically apply a midrise-type quantization (Gersho, 1977), but modify it as follows. In the quantization phase, we prune filters in which all weight parameters are within $\pm \varDelta / 2$ , as described in the following pseudocode with Numpy (Oliphant, 2006) notation.
+
+# Quantize   
+# W: (filter(out_ch), channel(in_ch), ky, kx)   
+pruned $=$ numpy.all(abs(W) $<$ delta/2, axi $s = ( 1 , 2 , 3 )$ )   
+W_int $=$ numpy.floor(W/delta) $+ ~ 0 . 5$   
+W_int[pruned, :, :, : $\jmath \ = \ 0$
+
+# B $\mathrm { E S N } _ { a }$ FOR OPTIMAL QUANTIZATION POLICY
+
+We attempt to exploit the $\mathrm { E S N } _ { a }$ obtained during training to determine a quantization policy using VGG7 where numbers of filters in all convolutional layers are reduced to $0 . 2 5 \times$ on CIFAR-10. The left figure in Figure 9 show the validation accuracy versus $\mathrm { E S N } _ { a }$ during training and after quantization. As an initial policy, we apply the same bit width for all layers. The results shown in gray do not fit the blue plot during training, possibly indicating the policy is suboptimal. We next investigate the $\mathrm { E S N } _ { a }$ of each layer and find that the misfit is caused by the sixth layer, as shown in the right figure. When we consider validation accuracy versus the sixth-layer $\mathrm { E S N } _ { a }$ , shown in green symbols, validation accuracy after quantization deteriorates at a much higher $\mathrm { E S N } _ { a }$ than during training. An interpretation is that since this deterioration is caused by other layers (e.g., the first) rather than the sixth layer, weight parameters in the sixth layer should be more aggressively quantized. Based on this observation, we modify the quantization policy such that the bit width of the sixth layer become smaller than that in other layers, thereby improving performance as shown by the red plot in the left figure. This preliminary experimental result suggests we can use $\mathrm { E S N } _ { a }$ information during training to find an optimal quantization policy.
+
+# C RESNET-18 VERSUS RESNET-50
+
+The proposed metric allows us to compare different network architectures. In Figure 10, we compare the Pareto frontier of validation accuracy versus $\mathrm { E S N } _ { a / d }$ curves for ResNet-18 and ResNet-50. The plots in Figure 10 are extracted from Figure 8. This result shows that ResNet-50 has a better Pareto frontier than does ResNet-18. One convincing reason is that ResNet-50 employs a parameterefficient bottleneck structure, whereas ResNet-18 does not. In contrast, ResNet-18 shows better performance for $\mathrm { E S N } _ { d } < \mathrm { 2 G }$ , partly due to the higher sensitivity of $\mathrm { E S N } _ { d }$ to the number of parameters. This suggests use of ResNet-18 when employing digital computing in this $\mathrm { E S N } _ { d }$ region. Such comparisons enabled by the proposed metric are useful when searching for or developing efficient structures.
+
+![](images/d5aa136d8e61549ec8fd083414983846373dedea1a67e78d1c0cea7a30e1a771.jpg)  
+Figure 9: Relation between validation accuracy versus $\mathrm { E S N } _ { a }$ during training and after quantization.
+
+![](images/2a59b5a8878a8ea8f3d6ad840988ab26269ea2f2967344df1fa765e89eb20929.jpg)  
+Figure 10: Comparison of ResNet-18 and ResNet-50 with respect to top-1 accuracy on ImageNet versus $\mathrm { E S N } _ { a / d }$ (left/right).
+
+![](images/a0dce85d6c8c6554c8eb8f943057b2890541a50f8af1f3edac05daeaceff805c.jpg)  
+Figure 11: Comparison of other methods with respect to top-1 accuracy on ImageNet versus estimated $\mathrm { E S N } _ { d } ^ { \prime }$ .
+
+# D COMPARISON WITH OTHER METHODS
+
+In Figure 11, we superimpose results from other works on Figure 8. Lin et al. (2017) and Zhang et al. (2018) show better accuracy in smaller $\mathrm { E S N } _ { d } ^ { \prime }$ regions than ours, but these apply quantization-aware training, whereas our result is obtained by post-training quantization. Although we expect that the findings presented in this paper will also improve performance of quantization-aware training, we leave an explicit demonstration of this to future works.
+
+# E DERIVATION OF EQUATION (4)
+
+The mean squared noise energy $N$ due to quantization over the all elements in a tensor $\boldsymbol { \mathsf { W } }$ is computed as
+
+$$
+\begin{array} { r } { N = | | \mathbf { W } - \varDelta \cdot \mathbf { W } _ { \mathrm { i n t } } | | _ { F } ^ { 2 } / | | \mathbf { W } | | _ { 0 } , } \end{array}
+$$
+
+where $\pmb { \mathsf { W } } _ { \mathrm { i n t } } = \pmb { \mathsf { W } } / \Delta \rfloor + 0 . 5$ , $\varDelta$ is the quantization step size and $| | \pmb { \mathsf { W } } | | _ { 0 }$ is the number of nonzero elements in $\pmb { \mathsf { W } }$ . When quantization noise is approximated by a uniform distribution, the mean squared noise energy is (Gray & Neuhoff, 1998)
+
+$$
+N = \int _ { - \Delta / 2 } ^ { \Delta / 2 } \frac { 1 } { \varDelta } n ^ { 2 } d n = \frac { { \varDelta } ^ { 2 } } { 1 2 } .
+$$
+
+From Equations (8) and (9),
+
+$$
+\varDelta ^ { 2 } = | | \boldsymbol { \mathsf { W } } - \varDelta \cdot \boldsymbol { \mathsf { W } } _ { \mathrm { i n t } } | | _ { F } ^ { 2 } \times \frac { 1 2 } { | | \boldsymbol { \mathsf { W } } | | _ { 0 } } .
+$$
+
+Then,
+
+$$
+| | \mathbf { W } _ { \mathrm { i n t } } | | _ { F } ^ { 2 } \sim | | \mathbf { W } / \varDelta | | _ { F } ^ { 2 } = \frac { | | \mathbf { W } | | _ { F } ^ { 2 } } { \varDelta ^ { 2 } } = \frac { | | \mathbf { W } | | _ { F } ^ { 2 } } { | | \mathbf { W } - \varDelta \cdot \mathbf { W } _ { \mathrm { i n t } } | | _ { F } ^ { 2 } } \cdot \frac { | | \mathbf { W } | | _ { 0 } } { 1 2 } .
+$$
+
+Here we again assume that quantization noise is uniformly distributed. In this equation, since $| | \pmb { \mathsf { W } } | |$ and $| | \boldsymbol { \mathsf { W } } - \varDelta \cdot \boldsymbol { \mathsf { W } } | | _ { F } ^ { 2 }$ are respectively the signal and noise norm, the term $\frac { | | \mathbf { W } | | _ { F } ^ { 2 } } { | | \mathbf { W } - \varDelta \cdot \mathbf { W _ { \mathrm { i n t } } } | | _ { F } ^ { 2 } }$ is considered to be $S / N$ , and thus,
+
+$$
+| | \mathbf { W _ { \mathrm { i n t } } } | | _ { F } ^ { 2 } = \frac { | | \mathbf { W } | | _ { F } ^ { 2 } } { | | \mathbf { W } - \varDelta \cdot \mathbf { W _ { \mathrm { i n t } } } | | _ { F } ^ { 2 } } \cdot \frac { | | \mathbf { W } | | _ { 0 } } { 1 2 } = S / N \cdot \frac { | | \mathbf { W } | | _ { 0 } } { 1 2 } .
+$$
+
+We obtain Equation (4) by summing this value over all layers.
+
+# F DETAILS OF NETWORK ARCHITECTURES
+
+The network architecures of VGG7 ( $1 \times , 0 . 5 \times , 0 . 2 5 \times )$ which we use in section 2.4 are shown in table 1. These architectures are based on the original model of VGG (Simonyan & Zisserman, 2014).
+
+Table 1: Detailed network architecture of VGG7 for CIFAR-10. $C _ { I }$ and $C _ { O }$ represent the number of input and output channels, respectively in conv-layer. In fc-layer, they represent the number of input and output neurons   
+
+<table><tr><td rowspan=2 colspan=1>Layer name</td><td rowspan=1 colspan=2>VGG(1x)</td><td rowspan=1 colspan=2>VGG (0.5x)</td><td rowspan=1 colspan=2>VGG (0.25×)</td><td rowspan=2 colspan=1>kernel size</td><td rowspan=2 colspan=1> padding</td><td rowspan=2 colspan=1>stride</td></tr><tr><td rowspan=1 colspan=1>C1</td><td rowspan=1 colspan=1>Co</td><td rowspan=1 colspan=1>C1</td><td rowspan=1 colspan=1>Co</td><td rowspan=1 colspan=1>C1</td><td rowspan=1 colspan=1>Co</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>maxpool</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>conv4</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>maxpool</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>conv5</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>conv6</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>maxpool</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>fc</td><td rowspan=1 colspan=1>8192</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>4096</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr></table>

parse/train/HkxAS6VFDB/HkxAS6VFDB_content_list.json

@@ -0,0 +1,1801 @@
+[
+    {
+        "type": "text",
+        "text": "PRUNE OR QUANTIZE? STRATEGY FOR PARETOOPTIMALLY LOW-COST AND ACCURATE CNN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pruning and quantization are typical approaches to reduce the computational cost of convolutional neural network (CNN) inference. Although the idea of combining both approaches seems natural, it is surprisingly difficult to determine the effects of the combination without measuring performance on the specific hardware that the user will use. This is because the benefits of pruning and quantization strongly depend on the hardware architecture where the model is executed. For example, a CPU-like architecture with no parallelization may fully exploit the reduction of computations by unstructured pruning to improve speed, but a GPUlike massive parallel architecture would not. Further, there have been emerging proposals of novel hardware architectures, such as those supporting variable bitprecision quantization. From an engineering viewpoint, optimization for each hardware architecture is useful and important in practice, but this is in essence a brute-force approach. Therefore, in this paper, we first propose a hardwareagnostic metric for measuring computational costs. Using the proposed metric, we demonstrate that Pareto-optimal performance, where the best accuracy is obtained at a given computational cost, is achieved when a slim model with fewer parameters is moderately quantized rather than a fat model with a huge number of parameters is quantized to extremely low bit precision, such as binary or ternary. Furthermore, we empirically find a possible quantitative relation between the proposed metric and the signal-to-noise ratio during stochastic gradient descent (SGD) training, by which information obtained during SGD training provides an optimal policy for quantization and pruning. We show the Pareto frontier is improved by $4 \\times$ in a post-training quantization scenario based on these findings. These findings not only improve the Pareto frontier for accuracy versus computational cost, but also provide new insights into deep neural networks. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            613
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            642,
+            336,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reducing execution cost of deep learning inference is one of the most active research topics for applying superhuman recognition in embedded IoT devices and robots. A typical approach for employing memory- and computation-efficient components is separable convolution, which is a combination of depth-wise and point-wise convolutions (Iandola et al., 2016; Zoph et al., 2018; Zhang et al., 2018; Howard et al., 2017), structured/unstructured pruning of connections and activations, and quantizing activation, weight, and their vectors (Stock et al., 2019; Jegou et al., 2011; Gong et al., 2014). Among these, separable convolution and structured pruning are similar, in that separable convolution can be viewed as convolutions pruned in a handcrafted manner. From a pruning viewpoint, since the separable convolution structure results from applying aggressive pruning to normal convolution, the result is drastic reductions in memory and computational cost at the expense of greatly decreased accuracy (Stock et al., 2019). On the other hand, structured pruning and quantization are seemingly orthogonal approaches that can be naturally combined (Tung & Mori, 2018; Han et al., 2016). However, their interactions are still not well-studied. For instance, the use of a single-bit representation is being actively explored as an extreme quantization. Since a nonnegligible accuracy drop is inevitable in extreme quantization, some papers have proposed increasing the number of channels to compensate for the lack of expressivity (Lin et al., 2017). In other words, a quantization approach can further reduce the number of bits by compromising the increase in number of channels, or the increase in number of computations. This indicates that, conversely, reducing channels by pruning may limit capability for quantization. This discussion raises a controversial question: which is better, a fat model with smaller bit width or a slim model with larger bit width? Answering this question requires a metric that fairly measures the effects of both pruning and quantization. One such metric in the literature is the inference speed when the model is executed on specific hardware. This metric is useful or even ideal when the target hardware is known in advance but strongly depends on features of the hardware architecture. Yang et al. (2018) searched for an optimal architecture using inference time as the optimization objective and found different optimal architectures depending on the target device. For example, if the hardware cannot handle extremely low bit-widths (1 or 2 bits), instead treating them as 8-bit integers with upper bits filled with zeros, we cannot exploit the reduction of bit width to improve inference speed. From a theoretical viewpoint, figuring out the extent to which we can reduce the computational complexity of deep neural networks is another important open question. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The discussion so far urges us to develop a hardware-agnostic and theoretically reasonable metric for measuring computational costs of neural network architectures. In this paper, we propose the Frobenius norm of the effective value of weight parameters as one such metric. This metric is proportional to the total energy when the model is executed on ideal hardware, where energy consumption for a single multiply-accumulate (MAC) computation is proportional to the squared effective amplitude of the individual weight parameter used for the MAC computation. The basic idea of the metric is analogous to a highly efficient class-B amplifier circuit whose energy consumption is determined by the instant signal amplitude (Sechi, 1976). This metric successfully reflects the effects of both quantization and structured/unstructured pruning in accordance with intuition. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            402
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using the proposed metric, we empirically find that a slimmer model can achieve a far better Pareto frontier in a lower computational cost region than can a fatter model after quantization, while a fat model is advantageous for achieving higher accuracy in a larger computational cost region. Finally, we perform experiments under a post-training quantization scenario (Banner et al., 2018) on ImageNet dataset (Deng et al., 2009) to verify the validity of our claim, namely that prune-then-quantize is superior to quantize-only or prune-only for achieving a better Pareto frontier. ",
+        "bbox": [
+            174,
+            410,
+            823,
+            493
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Further, since this metric is relevant to the signal-to-noise ratio $( S / N )$ , it is measurable during SGD training, in which the absolute value of weights and the random walk of weight parameters correspond to signal and noise, respectively. We observe that the dependencies of the metric on validation accuracy seem to be correlated between those during training and those applying quantization after training. From this observation, we point out some possibilities for which we could expect robustness of a model for quantization from information obtained during training, we could determine an optimal policy for quantization of that model, and we could develop a novel optimization or regularization scheme. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of this paper are as follows: ",
+        "bbox": [
+            174,
+            618,
+            511,
+            632
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We define a hardware-agnostic metric for measuring the computational cost of pruned and quantized models. We empirically find that models with fewer parameters achieve far better accuracy in a low computational cost region after quantization.   \n• We show a potential quantitative relation between quantization noise and perturbation of weight parameters during SGD training. ",
+        "bbox": [
+            215,
+            650,
+            825,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "And as implications, we hope to exploit our findings for ",
+        "bbox": [
+            174,
+            775,
+            540,
+            789
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• thorough comparison of various neural network architectures using the proposed hardwareagnostic metric,   \n• development of a method for extracting a quantization policy from information obtained during SGD training, and   \n• development of a training algorithm or regularization scheme for producing robust models based on the relation between quantization noise and perturbation of weight parameters during SGD training. ",
+        "bbox": [
+            215,
+            804,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/45c4995af673290a29b96eb483a2dcadbe7d8ee1fa059b636974fe0dbcd95f81.jpg",
+        "image_caption": [
+            "Figure 1: Left/Center: Computational cost strongly depends on the hardware architecture on which the model is executed. Right: Proposed computational cost for analysis or theoretical research, assuming an ideal hardware architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            102,
+            756,
+            198
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 EFFECTIVE SIGNAL NORM ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            291,
+            426,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We seek a metric that properly reflects the effects of both quantization and pruning. Conventionally, quantization effectiveness is evaluated according to the number of bits required to achieve a given accuracy, or the accuracy achieved by using certain bit numbers for specific network architectures (Stock et al., 2019). We cannot use this to compare efficiencies between different architecture models (e.g., MobileNet versus ResNet-18). The number of MAC computations or parameters can be used to compare different architectures, but the number of MAC computations does not consider quantization and the number of parameters is not directly related to inference time. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, the use of actual or estimated inference speeds as a metric for comparing network architectures has been proposed (Yang et al., 2018; Wang et al., 2019a; Cai et al., 2019). This metric is very useful when the target hardware is known in advance, and ideal for those who wish to use the model that performs best on that hardware. However, this metric is strongly hardware dependent. Indeed, Yang et al. (2018); Wang et al. (2019a); Cai et al. (2019) found that optimal architectures for different types of target hardware are totally different. Considering interest in, for example, the simplest realizable deep neural network model while achieving a required accuracy, there is a need for a hardware-agnostic metric. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The metric for model evaluation should correlate with energy consumed when the model is executed on ideal hardware. We assume that energy consumption by ideal hardware monotonically decreases when the bit width is reduced by quantization and when the number of nonzeros in weight parameters is reduced by pruning. For example, hardware with an 8-bit integer MAC array cannot be further accelerated even if the bit width is reduced from 8 to 1 or 2 bits. Thus, the energy consumption measured using such hardware does not satisfy the aforementioned requirement and cannot be our metric. Hardware like a CPU, which processes each computation in serial, can naturally exploit the structured or unstructured sparsity of weight parameters by skipping computations with zeroed weights. However, because it is difficult to parallelize computations while maintaining such a strategy, it is generally difficult to benefit from sparsity in GPU-like hardware employing massively parallel MAC units. Hardware dedicated to sparse convolution (Lu et al., 2019) tends to show better performance only when sparsity is sufficiently high, due to relatively large overheads for encoding and decoding sparse weight parameters in a special format. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the benefit of sparsity from pruning and low bit width from quantization largely depends on the hardware architecture, so long as we consider only existing hardware. Because we require a hardware-agnostic metric, we assume ideal hardware in which energy consumption is linearly proportional to the number of nonzero weight parameters and monotonically depends on the bit width of weight parameters, as shown in Figure 1, setting aside the feasibility of such ideal hardware. ",
+        "bbox": [
+            174,
+            737,
+            823,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 DEFINITION OF EFFECTIVE SIGNAL NORM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            501,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define a metric called the effective signal norm (ESN) as ",
+        "bbox": [
+            174,
+            857,
+            571,
+            872
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36a3afc0bd7c3150cc7f7d5558ac5e9d318e164a042173754f562d46a905a2ae.jpg",
+        "text": "$$\n\\mathrm { E S N } = \\sum _ { l } | | c ^ { l } f ( \\mathbf { W } _ { \\mathrm { i n t } } ^ { l } ) | | _ { F } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            893,
+            589,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with $\\mathbf { \\boldsymbol { \\mathsf { W } } } _ { \\mathrm { i n t } } ^ { l } = \\lfloor \\mathbf { \\boldsymbol { \\mathsf { W } } } ^ { l } / \\varDelta ^ { l } \\rfloor + 0 . 5$ , where $\\boldsymbol { \\mathsf { W } } ^ { l }$ is the weight tensor and $\\varDelta ^ { l }$ is the quantization step size of the th layer; and $\\bar { c } ^ { l }$ is a coefficient depending on the layer, in that if $c ^ { l } = 1$ , ESN is related to the number of parameters (cf. memory footprint), and if $c ^ { l }$ is the number of computations per parameter at the lth layer, ESN is related to the number of computations (cf. FLOP). ${ \\bar { f } } ( \\cdot )$ is an element-wise function that determines how the metric responds to the value of each weight parameter. We propose two functions for $f ( \\cdot )$ . The first is $f ( \\bar { \\mathbf { W } _ { \\mathrm { i n t } } ^ { l } } ) = \\mathbf { W } _ { \\mathrm { i n t } } ^ { l }$ , based on the assumption that energy consumption increases with the square of the value for each weight parameter or for each computation. When $c ^ { l } = 1$ , the definition is ",
+        "bbox": [
+            173,
+            101,
+            825,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/946495dc28d92062ab1d83fea9d660a648e658416554b4213b0866bf5144c74e.jpg",
+        "text": "$$\n\\mathrm { E S N } _ { a } = \\sum _ { l } | | \\mathbf { W } _ { \\mathrm { i n t } } ^ { l } | | _ { F } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            233,
+            578,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This assumption is reasonable when we employ an analog (or in-memory) MAC computation engine (Shafiee et al., 2016; Miyashita et al., 2017), because energy consumption is proportional to the square of the signal amplitude when the signal represents an analog quantity such as voltage or current. Assuming ideal hardware, we adopt a definition where energy consumption varies according to the instant amplitude (cf. class-B amplifier), which is more energy efficient than the case where energy consumption is constant and the value is determined by the maximal amplitude (cf. class-A amplifier) (Sechi, 1976). ",
+        "bbox": [
+            173,
+            272,
+            825,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The second proposed function is $f ( \\mathbf { W } _ { \\mathrm { i n t } } ^ { l } ) = \\lceil \\log _ { 2 } ( \\mathrm { a b s } ( \\mathbf { W } _ { \\mathrm { i n t } } ^ { l } ) ) + 1 \\rceil$ , where $\\log _ { 2 } \\left( \\cdot \\right)$ and $\\mathrm { a b s } \\left( { \\cdot } \\right)$ are functions applied to each element of a tensor argument. This is based on the assumption that energy consumption increases with the binary logarithm of the value for each weight parameter. When $c ^ { l } = 1$ , the definition is ",
+        "bbox": [
+            173,
+            377,
+            825,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/068bde2045368092a861b516f98ae5b17fe5935983c31815af7fe7595a981a78.jpg",
+        "text": "$$\n\\mathrm { E S N } _ { d } = \\sum _ { l } \\vert \\vert \\lceil \\log _ { 2 } ( \\mathrm { a b s } ( \\boldsymbol { \\mathsf { W } } _ { \\mathrm { i n t } } ^ { l } ) ) + 1 \\rceil \\vert \\vert _ { F } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            452,
+            637,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In a digital circuit, a number is represented as a binary digit (bits), so the energy consumption for moving or processing signals is roughly proportional to the number of bits, which is the binary logarithm of the value. It is therefore reasonable to use Equation (3) for a digital circuit. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 RELATION BETWEEN ESN AND S/N ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            462,
+            564
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The effective signal norm defined in Equation (2) is related to the signal-to-noise ratio $( S / N )$ when quantization noise is dominant and noise is approximated by a uniform distribution (Gray & Neuhoff, 1998). ",
+        "bbox": [
+            174,
+            575,
+            826,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee161bb5b891cfb029f5e7936a055380c0f57a81cce1b305c14caec47f2eb301.jpg",
+        "text": "$$\n\\mathrm { E S N } _ { a } = \\sum _ { l } \\left( \\frac { | | \\mathbf { W } ^ { l } | | _ { F } ^ { 2 } } { | | \\mathbf { W } ^ { l } - \\varDelta \\cdot \\mathbf { W } _ { \\mathrm { i n t } } ^ { l } | | _ { F } ^ { 2 } } \\cdot \\frac { | | \\mathbf { W } ^ { l } | | _ { 0 } } { 1 2 } \\right) = \\sum _ { l } \\left( S / N _ { l } \\cdot \\frac { | | \\mathbf { W } ^ { l } | | _ { 0 } } { 1 2 } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            633,
+            740,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $l$ is the layer index, $S / N _ { l }$ is the signal-to-quantization-noise ratio of the lth layer as defined by ||Wl||2FWl ∆ Wl 2 , and ||Wl||0 is the number of nonzero elements in the tensor Wl. Appendix E presents the derivation of Equation (4). This equation allows us to calculate $\\mathrm { E S N } _ { a }$ , so long as $S / N$ is defined. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 $\\mathrm { E S N } _ { a }$ DURING TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            766,
+            390,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For example, we can define $S / N$ by regarding perturbation of weight parameters during training as noise. Formally, we define the signal and noise at the $j$ th epoch as ",
+        "bbox": [
+            171,
+            791,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c56985fea52cd6c59d0125021d677f1c2636c6570e552f9a00f6dbca02e859f3.jpg",
+        "text": "$$\nS _ { j } = \\sum _ { l } \\sum _ { i } | | \\mathbf { W } _ { j , i } ^ { l } | | _ { F } ^ { 2 } , ~ N _ { j } = \\sum _ { l } \\sum _ { i } | | \\mathbf { W } _ { j , i } ^ { l } - \\mathbf { W } _ { \\mathrm { i n i t } _ { j } } ^ { l } | | _ { F } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            835,
+            696,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\boldsymbol { \\mathsf { W } } _ { j , i } ^ { l }$ is the weight parameters in the lth layer at the $i$ th iteration in the $j$ th epoch, and $\\mathbf { \\Delta } \\mathbf { W } _ { \\mathrm { i n i t } _ { j } } ^ { l }$ is a snapshot of the weight at the beginning of the $j$ th epoch. Then, $N _ { j }$ is the effective value of random walk noise for weight parameters in one epoch. ",
+        "bbox": [
+            174,
+            878,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/235193dd0b15100d4b1b0a0a69dff68a6329561fa43a202e658f39c6adba7cf5.jpg",
+        "image_caption": [
+            "Figure 2: Training curves of $\\mathrm { E S N } _ { a }$ (left) and validation accuracy (right) on CIFAR-10. In the right graph, moving average curve between 3-epochs is overlapped on each plot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            101,
+            754,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7e6cb451b3162ad4574bca3208d8c0846905e2a94fdda0c255fe1d5704883d1.jpg",
+        "image_caption": [
+            "Figure 3: Relation between validation accuracy and $\\mathrm { E S N } _ { a }$ during training and after quantization. $\\mathrm { E S N } _ { a }$ of the former is computed using Equation (5), and that of the latter is computed using Equation (2) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            316,
+            813,
+            444
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The left figure in Figure 2 shows the $\\mathrm { E S N } _ { a }$ curve during training, which is calculated by Equation (4), and $S / N$ as defined by Equation (5). In this experiment, we use ResNet-20 (He et al., 2016) on CIFAR-10 dataset (Krizhevsky, 2009). We use SGD with momentum 0.9, and we set the mini-batch size to 100 and the initial learning rate to 0.1, which is shifted by $1 / 1 0$ at epochs 80 and 120. We vary the weight decay factor from $\\overline { { 5 } } \\times 1 0 ^ { - 4 }$ to $2 \\times 1 0 ^ { - 3 }$ , indicated by different colors in Figure 2. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, the $\\mathrm { E S N } _ { a }$ curves look very similar to the validation accuracy curves shown in the right figure in Figure 2. Both $\\mathrm { E S N } _ { a }$ and validation accuracy steeply increase at the point where the learning rate is decreased by $1 / 1 0$ , because decreasing the learning rate reduces perturbation (or random walk) of weight values during one epoch, increasing $S / N$ . We can also see that as the weight decay factor increases, $\\mathrm { E S N } _ { a }$ tends to decrease. This is also reasonable, because weight decay decreases $| | \\pmb { \\mathsf { W } } | | _ { F } ^ { 2 }$ or the signal level, reducing $S / N$ . More interestingly, even this trivial tendency appears correlated with validation accuracy; for example, after a steep rise at epoch 80, both $\\mathrm { E S N } _ { a } ^ { * }$ and validation accuracy gradually decrease, converging to stable values after overshooting. There is a similar relation between the amount of overshoot and weight decay factor, namely, we observed a larger overshoot with a smaller weight decay factor. These findings might be useful for developing a novel optimization algorithm, but we leave this for future work. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The blue plots in Figure 3 show $\\mathrm { E S N } _ { a }$ versus validation accuracy. In this experiment, we use VGG7 (Simonyan & Zisserman, 2014) and ResNet-20 on CIFAR-10, and DenseNet-BC with $l =$ 100, $k = 1 2$ (Huang et al., 2017) on CIFAR-100. We employ SGD with momentum 0.9 and set the initial learning rate to 0.1, followed by cosine annealing without restart (Ilya Loshchilov, 2017). The mini-batch size and weight decay factor are respectively set to 125 and $5 \\times 1 0 ^ { - 4 }$ . ",
+        "bbox": [
+            174,
+            791,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The red curve shows the $\\mathrm { E S N } _ { a }$ versus validation accuracy curve when applying quantization to weight parameters trained by the training process where the blue plots are obtained. As the figure shows, the red and blue curves seem to be correlated. This suggests that the model acquires robustness to quantization by having experienced similar perturbations due to a random walk during the training process. If so, the $\\mathrm { E S N } _ { a }$ versus validation accuracy curve during training is available as a loose boundary on accuracy degradation due to decrease of $\\mathrm { E S N } _ { a }$ by quantization. We discuss this hypothesis in Section 2.7 again. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/65c78a5c209e01a0c9dea837a7e5dc5c3c216284aac3dbcc3761065155f616c6.jpg",
+        "image_caption": [
+            "Figure 4: Accuracy versus $\\mathrm { E S N } _ { a }$ (left) and $\\mathrm { E S N } _ { d }$ (right) for various network depths and widths. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            820,
+            193
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            255,
+            825,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.4 ESN VERSUS ACCURACY FOR VARIOUS MODEL SIZES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            315,
+            583,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With our metric defined, we next attempt to investigate which is better, a model that is slim (with the number of weight parameters and computations reduced by pruning) and mildly quantized (e.g., with 4–5 bits), or a model that is fat (with a large number of weight parameters and computations) and radically quantized (e.g., with 1–2 bits). We evaluate six network architectures with different depths and widths: ResNet-8, 14, 20 and VGG7 with different channel widths $( 1 \\times , 0 . 5 \\times , 0 . 2 5 \\times )$ on CIFAR-10 dataset. In this experiment, we employ networks with originally small number of parameters as slim models instead of pruning fat models. The network architecture of ResNet is based on the original one without bottleneck architecture (He et al., 2016). The detailed network architecture of VGG7 is shown in Appendix F. ",
+        "bbox": [
+            173,
+            340,
+            825,
+            465
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows validation accuracy versus $\\mathrm { E S N } _ { a }$ and $\\mathrm { E S N } _ { d }$ . Here, we consider differences in $\\mathrm { E S N } _ { a }$ and $\\mathrm { E S N } _ { d }$ . For simplicity, we assume that all weight parameters have the same value $v > 1$ , and that the number of weight parameters is $N$ . The definitions of $\\mathrm { E S N } _ { a }$ and $\\mathrm { E S N } _ { d }$ are expressed as follows, ",
+        "bbox": [
+            173,
+            472,
+            825,
+            527
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e44e2fb3299aa4e2ad0c630e7352dc2c665c9bb9739a591a98bd679946bfe3fb.jpg",
+        "text": "$$\n\\mathrm { E S N } _ { a } = v ^ { 2 } \\times N , \\mathrm { E S N } _ { d } = \\left\\lceil \\log _ { 2 } v + 1 \\right\\rceil \\times N .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            526,
+            655,
+            544
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Therefore, when we compare $\\mathrm { E S N } _ { a }$ and $\\mathrm { E S N } _ { d }$ , both are linearly proportional to the number of weight parameters, whereas values of weight parameters affect the metric at squared and logarithmic scales, respectively. This means that $\\mathrm { E S N } _ { a }$ is more strongly dependent on the size of the values than on the number of weight parameters, and the opposite is true for $\\mathrm { E S N } _ { d }$ . In other words, $\\mathrm { E S N } _ { d }$ is more sensitive to pruning than to quantization, and $\\mathrm { E S N } _ { a }$ is more sensitive to quantization than to pruning. Figure 4 clearly shows these tendencies. We can see that even when using the $\\mathrm { E S N } _ { a }$ metric, which is advantageous for quantization, the slimmer model shows better validation accuracy in lower ESN regions. These experiments indicate that in lower ESN regions, or with lower energy consumption by ideal hardware, especially when employing digital computing, it is an advisable strategy to prune the model to the limit where the desired accuracy is achieved, and then to apply quantization to obtain the highest possible accuracy. In contrast, it is a bad strategy to apply quantization to a fat model, even if it shows much better accuracy than the pruned slim model before quantization. Consequently, to the question posed at the beginning of this subsection—whether a slim and mildly quantized model or a fat and radically quantized model is better—the answer is the former one, which may in a sense raise a question on trends in quantization research. Note that the above discussion also indicates that the importance of quantization will be relatively increased if analog computing become practical in the future. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            782
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.5 TRAINING UNDER LOW-ESN CONDITIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            800,
+            504,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We next observe how the weight parameters evolve in the training process. Figure 5 shows from left to right the loss, $\\mathrm { E S N } _ { a }$ , and number of pruned filters (output channels). In this experiment, we train ResNet-20 on CIFAR-10 dataset with initial weight parameters of a trained model. We employ SGD with momentum 0.9, weight decay factor $5 \\times 1 \\bar { 0 } ^ { - 4 }$ , and mini-batch size 200, updating for 20 epochs. The learning rate (LR) is constant, with a value varied from 0.32 to 1.81 for each training. Note that we do not intentionally prune filters in this experiment; rather, filter pruning spontaneously occurs along with sequential updates of weight parameters by SGD. The center graph shows that as the learning rate increases, $\\mathrm { E S N } _ { a }$ decreases due to the larger noise. The number of pruned filters after epoch 20 is larger with the larger learning rate, which corresponds to smaller $\\mathrm { E S N } _ { a }$ . In the training process, rather than continuing to increase at a constant rate throughout the training process, the number of pruned filters steeply increases within a few epochs and then is maintained without noticeable change. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/65b7e15a1281061dd878ec2ce254f2bac5a00b56db35de70a4d382971aa01894.jpg",
+        "image_caption": [
+            "Figure 5: Training curves for loss, $\\mathrm { E S N } _ { a }$ , and number of pruned filters under different learning rate (LR) conditions. $\\mathrm { E S N } _ { a }$ is calculated by Equations (4) and (5). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            101,
+            758,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c89a06ca0d298bf226b318acfebdde96ddcace59998d6234d38565dda598198c.jpg",
+        "image_caption": [
+            "Figure 6: Accuracy versus $\\mathrm { E S N } _ { a / d }$ (left/center) and histogram of the maximal bit width for each filter (right) in the pruning only, quantization only, and prune-then-quantize mixed cases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            279,
+            756,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            452,
+            825,
+            522
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This indicates that under a small $\\mathrm { E S N } _ { a }$ condition controlled by the learning rate, the optimizer finds a solution for reducing the number of parameters by pruning filters and prioritizing increases in amplitude of the remaining parameters, rather than letting all parameters survive with small amplitude. ",
+        "bbox": [
+            176,
+            529,
+            823,
+            571
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2.6 PRUNE then QUANTIZE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            590,
+            370,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the previous two subsections, we empirically showed that achieving optimal accuracy in a low ESN region requires preparation of a slim model before applying quantization. A slim model can be generated by pruning a fat model or by designing a slim architecture. Based on the lottery ticket hypothesis (Frankle & Carbin, 2019), where a fat or overparameterized network can have higher potential for finding better optimal parameters by SGD training, we adopt the former method, namely, pruning weight parameters from a pretrained fat model. We apply ADMM regularization for structured pruning (Wang et al., 2019b), since this achieves state-of-the-art performance. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we evaluate ResNet-20 on CIFAR-10 dataset. We update pretrained weight parameters through the SGD algorithm with alternating direction method of multipliers (ADMM) regularization (Wang et al., 2019b) for a few additional epochs. We then fine-tune the resulting pruned model over 160 epochs. In this fine tuning, we employ SGD with momentum 0.9 and set the mini-batch size to 100 and the initial learning rate to 0.1, followed by cosine annealing without restart. The weight decay factor is set to $5 \\times 1 0 ^ { - 4 }$ . Since the weight parameters are not yet quantized in this phase, we update all parameters, except that we set weights for the filters (output channels) and channels (input channels) pruned in the previous phase to zero. Finally, we apply quantization. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As Figure 6 shows, the Pareto frontier significantly improves by applying prune-then-quantize (red), as compared to applying extreme quantization (green). The right graph in Figure 6 shows a histogram of the maximal bit width under each filter (output channel) of the three models indicated by the broken line in the center graph $\\mathrm { ( E S N _ { } = 3 9 M ( b i t s ) ) }$ . Since the pretrained model has 800 filters before pruning and quantization, summations of frequencies for each color are 800. In the pruning only (blue) case, the weight parameters in 555 filters, the largest number among the three methods, are pruned (represented as 0 bits). Most of remaining filters are 8 bits. In the quantization only (green) case, the number of pruned filters is a low 77, while the bit width of most remaining filters is 1 bit. In the proposed prune-then-quantize mixed (red) case, the number of pruned filters is 288 and the bit widths of most remaining filters are 3 or 4 bits, so the remaining filters are mildly quantized. As this case shows, while the $\\mathrm { E S N } _ { d }$ values are similar, the validation accuracies differ depending on the number and bit width of the weight parameters. The prune-then-quantize mixed method properly produces a pruned and mildly quantized model, which achieves far better validation accuracy, especially in the low ESN region, as compared to the model produced by extremely quantizing a fat model without pruning. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8ddd3ff9df3e6ec00d462f05fa87053b7fdaf62fb93f886c6b0fb58b7c2a373.jpg",
+        "image_caption": [
+            "Figure 7: Relation between random walk during SGD and quantization noise. Loss often steeply decreases when LR is shifted by (e.g., $1 / 1 0 \\AA$ ). In this situation, loss before shifting LR is possibly governed by random walk noise due to the large LR, as shown in the left figure. When we quantize weight parameters of the trained model, however, the loss or accuracy should be determined by noise induced by quantization, as shown in the right figure. If we can assume that the loss landscapes of the two cases should not diverge too much, the loss (or accuracy) after quantization is possibly predicted by the dependency of loss (or accuracy) on $\\mathrm { E S N } _ { a }$ during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            104,
+            754,
+            218
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            367,
+            825,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "2.7 $\\mathrm { E S N } _ { a }$ FOR QUANTIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            397,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As Section 2.3 showed, there is a possible quantitative relation between $\\mathrm { E S N } _ { a }$ during model training and $\\mathrm { E S N } _ { a }$ of the pruned and quantized version of that model after training. This finding inspires us to exploit $\\mathrm { E S N } _ { a }$ information obtained during training to determine the quantization policy, for example, how many bits to allocate for each layer. Figure 7 shows the intuition behind this idea, namely straightforward use of the $\\mathrm { E S N } _ { a }$ values for each layer at a certain epoch during training as targets for quantization. Appendix B describes a preliminary experiment for verifying this idea. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            619
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENT ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            638,
+            442,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To verify the validity of our claims, we performed experiments under a post-training quantization scenario (Banner et al., 2018) on ImageNet dataset (Deng et al., 2009). Post-training quantization assumes a use-case scenario where a user (e.g., at an edge side) quantizes a given pretrained CNN model with a limited number of unlabeled training samples for obtaining a lightweight model suited to a particular situation. As concluded in Section 2.4, in a low ESN region or with low energy consumption, we can achieve higher accuracy by quantizing a slim model than by quantizing a fat model, even if the latter is more accurate. To provide optimal accuracy in a low computationalcost region, we apply the proposed prune-then-quantize method to the post-training quantization scenario. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 8 shows the result of applying our method to ResNet-18 and ResNet-50 on ImageNet dataset. We used pretrained models12 as basic models with $1 \\times$ channel width, and prune the models to various channel widths $0 . 2 5 \\times$ , $0 . 5 \\times$ , and $0 . 7 5 \\times \\mathrm { _ { \\it { \\cdot } } }$ ). In this experiment, we determine which filters (output channels) to prune based on the signal norm of weights calculated by Equation (5). We prune filters in order from the smallest signal norm, and tune each model for the pruned structure through the SGD algorithm over 4 epochs. The mini-batch size is set to 64, and the learning rate is initialized to 0.1 and divided by 10 at epochs 2 and 3. We then quantize each model. For quantization, we only fine-tune statistic parameters in BatchNorm layers (called running_mean and running_var in pytorch (Paszke et al., 2017)) with no labeled data (Sasaki et al., 2019), which is the same condition as conventional work (Banner et al., 2018). ",
+        "bbox": [
+            174,
+            803,
+            825,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/805ac050388734c55a9e403a956c51041e64cb91ba7ed78d2f987bb8a59cdc5c.jpg",
+        "image_caption": [
+            "Figure 8: (Left/center) top-1 accuracy on ImageNet versus $\\mathrm { E S N } _ { a / d }$ and (right) estimated $\\mathrm { E S N } _ { d } ^ { \\prime }$ , applying the prune-then-quantize method to (upper) ResNet-18 and (lower) ResNet-50. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            108,
+            741,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            391,
+            825,
+            448
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In addition to evaluations by $\\mathrm { E S N } _ { a }$ and $\\mathrm { E S N } _ { d }$ , to compare our method with the conventional work, we estimate its computational cost using Equation (1) with $c ^ { l }$ and $f ( \\cdot )$ properly defined, as ",
+        "bbox": [
+            169,
+            454,
+            823,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0fcda5635dd8eb1a8bbc7395d47924ec3f296eac53b5de4e909b90839255e03.jpg",
+        "text": "$$\n\\mathrm { E S N } _ { d } ^ { \\prime } = \\sum _ { l } \\sum _ { m } \\mathrm { M A C } _ { l , m } \\times \\lceil \\log _ { 2 } ( \\operatorname* { m a x } ( \\mathrm { a b s } ( \\mathbf { W } _ { \\mathrm { i n t } } ^ { l , m } ) ) ) + 1 \\rceil ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            501,
+            697,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where applyi $\\mathrm { M A C } _ { l , m }$ he number of computation per filter and function, we restrict the number of bits to $\\pmb { \\mathsf { W } } _ { \\mathrm { i n t } } ^ { l , m }$ is the me in e $m$ th filter of h filter. $\\pmb { \\mathsf { W } } _ { \\mathrm { i n t } } ^ { l }$ . By $\\operatorname* { m a x } ( { \\mathord { \\cdot } } )$ ",
+        "bbox": [
+            173,
+            551,
+            825,
+            580
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We apply this metric3 to a recently proposed efficient MAC array architecture capable of handling variable bit precision (Maki et al., 2018). ",
+        "bbox": [
+            173,
+            587,
+            823,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As Figure 8 shows, significantly using slim models after pruning some filters improves the Pareto frontier as compared to Banner et al. (2018). For example, in ResNet-18, $5 7 \\ \\%$ top-1 accuracy is achieved at $2 \\times$ lower computational cost, and in ResNet-50, $6 3 \\ \\%$ top-1 accuracy is at $4 \\times$ lower computational cost. These results suggest that we should adopt a slim model to achieve best accuracy in low computational cost regions, instead of quantizing weight parameters to an extremely low bit precision. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            318,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed a hardware-agnostic metric called the effective signal norm (ESN) to measure computational costs. Using this metric, we demonstrated that a slim model with fewer weight parameters achieves better Pareto frontier performance in low computational cost regions than does an extremely quantized fat model. We also showed a possible quantitative relation between weight perturbation during SGD training and quantization noise or robustness against quantization. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "By defining this metric, on the hardware architecture side we can aim at realizing hardware whose energy consumption is proportional to the metric. On the algorithmic side, we can reduce the metric. We therefore expect consensus-sharing regarding the metric for computational cost to accelerate research progress for both algorithms and hardware architectures. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            895
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            354,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Quantization Courbariaux & Bengio (2016); Rastegari et al. (2016); Zhu et al. (2017) quantize weight parameters and activations as 1 or 2. Since such extreme quantization deteriorates accuracy to a nonnegligible extent, quantization methods with, for example, 4–8 bits are also actively explored (Banner et al., 2018; Lin et al., 2017) to avoid the accuracy drop. Miyashita et al. (2016) attempts to quantize weight parameters and activations in a logarithmic domain, aiming not only at reducing information loss but also replacing multiplication with bit-shift to simplify computation. To reduce the average bit width as much as possible while maintaining accuracy, and to exploit it to accelerate inference speed, Maki et al. (2018) proposes variable bit-width quantization co-optimized with hardware architecture. Although nonuniform quantization (Tung & Mori, 2018; Han et al., 2016) and vector or product quantization (Gong et al., 2014; Jegou et al., 2011; Stock et al., 2019) are also actively studied, these approaches are effective for reducing the memory footprint but not for directly reducing computational costs. Use cases include quantization-aware training (Courbariaux & Bengio, 2016; Rastegari et al., 2016; Zhu et al., 2017; Lin et al., 2017; Zhang et al., 2018) and post-training quantization (Banner et al., 2018). Quantization-aware training achieves better accuracy with lower bit widths, and is almost inevitable for those with extreme quantization. However, it tends to incur higher training costs in most cases. The post-training quantization scenario, which is executable with less computational resources and a smaller training dataset, has potentially more applications, so we also target this scenario. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            385
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pruning Pruning methods include structured pruning, which prunes whole layers, filters, or channels to maintain a regular structure so that computations are easily parallelized, and unstructured pruning, which randomly prunes individual weight parameters. Since it is difficult to benefit from unstructured pruning unless sparsity is sufficiently large, due to its incompatibility with parallelization (Lu et al., 2019), we target structured pruning. Many pruning methods have also been proposed, such as criteria-based approaches (LeCun et al., 1990), regularization-based approaches (Han et al., 2015; Wang et al., 2019b), and methods employing reinforcement learning (Zhong et al., 2018). In this paper, we argue that a pruned slim model performs better after quantization in lower computational cost regions. Any pruning method can be applied to produce a pruned slim model. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            518
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Metric for measuring cost In most quantization papers, the standard metric is accuracy achieved under a certain bit width. For pruning, the standard metric is the number of parameters or the number of computations (FLOP). Some papers use inference time when the model runs on specific hardware (Cai et al., 2019; Yang et al., 2018), but this metric is strongly hardware-dependent. In this paper, we propose a hardware-agnostic metric. ",
+        "bbox": [
+            174,
+            525,
+            823,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Noise during training Relations between learning rate, batch size, and noise during training are widely discussed (Keskar et al., 2017; Xing et al., 2018). To make the model more robust to quantization, some papers propose intentional addition of noise to gradient or weight parameters (Spallanzani et al., 2019; Baskin et al., 2018a;b). ",
+        "bbox": [
+            174,
+            602,
+            823,
+            657
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            681,
+            285,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ron Banner, Yury Nahshan, Elad Hoffer, and Daniel Soudry. ACIQ: analytical clipping for integer quantization of neural networks. CoRR, abs/1810.05723, 2018. URL http://arxiv.org/ abs/1810.05723. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chaim Baskin, Natan Liss, Yoav Chai, Evgenii Zheltonozhskii, Eli Schwartz, Raja Giryes, Avi Mendelson, and Alexander M. Bronstein. NICE: noise injection and clamping estimation for neural network quantization. CoRR, abs/1810.00162, 2018a. URL http://arxiv.org/ abs/1810.00162. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chaim Baskin, Eli Schwartz, Evgenii Zheltonozhskii, Natan Liss, Raja Giryes, Alexander M. Bronstein, and Avi Mendelson. UNIQ: uniform noise injection for the quantization of neural networks. CoRR, abs/1804.10969, 2018b. URL http://arxiv.org/abs/1804.10969. ",
+        "bbox": [
+            174,
+            837,
+            823,
+            880
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Chuang Gan, and Song Han. Once for all: Train one network and specialize it for efficient deployment. CoRR, abs/1908.09791, 2019. URL http://arxiv.org/abs/1908.09791. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux and Yoshua Bengio. Binarynet: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. CoRR, abs/1602.02830, 2016. URL http://arxiv. org/abs/1602.02830. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L. 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, June 2009. doi: 10.1109/CVPR.2009.5206848. ",
+        "bbox": [
+            176,
+            154,
+            820,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ rJl-b3RcF7. ",
+        "bbox": [
+            174,
+            205,
+            821,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A. Gersho. Quantization. IEEE Communications Society Magazine, 15(5):16–16, Sep. 1977. doi: 10.1109/MCOM.1977.1089500. ",
+        "bbox": [
+            173,
+            256,
+            823,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunchao Gong, Liu Liu, Ming Yang, and Lubomir D. Bourdev. Compressing deep convolutional networks using vector quantization. CoRR, abs/1412.6115, 2014. URL http://arxiv.org/ abs/1412.6115. ",
+        "bbox": [
+            173,
+            294,
+            825,
+            337
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "R. M. Gray and D. L. Neuhoff. Quantization. IEEE Transactions on Information Theory, 44(6): 2325–2383, Oct 1998. doi: 10.1109/18.720541. ",
+        "bbox": [
+            173,
+            344,
+            820,
+            375
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural network. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1135–1143. Curran Associates, Inc., 2015. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            439
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            491
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, June 2016. doi: 10.1109/CVPR.2016.90. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017. URL http://arxiv.org/abs/ 1704.04861. ",
+        "bbox": [
+            173,
+            550,
+            825,
+            607
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "G. Huang, Z. Liu, L. v. d. Maaten, and K. Q. Weinberger. Densely connected convolutional networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2261–2269, July 2017. doi: 10.1109/CVPR.2017.243. ",
+        "bbox": [
+            176,
+            614,
+            823,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Forrest N. Iandola, Matthew W. Moskewicz, Khalid Ashraf, Song Han, William J. Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with $5 0 \\mathrm { x }$ fewer parameters and ${ < } 1 \\mathrm { m b }$ model size. CoRR, abs/1602.07360, 2016. URL http://arxiv.org/abs/1602.07360. ",
+        "bbox": [
+            176,
+            666,
+            823,
+            710
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Frank Hutter Ilya Loshchilov. SGDR: stochastic gradient descent with warm restarts. International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            169,
+            718,
+            825,
+            747
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H. Jegou, M. Douze, and C. Schmid. Product quantization for nearest neighbor search. IEEE Transactions on Pattern Analysis and Machine Intelligence, 33(1):117–128, Jan 2011. ISSN 0162-8828. doi: 10.1109/TPAMI.2010.57. ",
+        "bbox": [
+            176,
+            755,
+            823,
+            797
+        ],
+        "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. International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            806,
+            821,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            171,
+            858,
+            803,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 2, pp. 598–605. Morgan-Kaufmann, 1990. URL http://papers.nips.cc/paper/250-optimal-brain-damage.pdf. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaofan Lin, Cong Zhao, and Wei Pan. Towards accurate binary convolutional neural network. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 345–353. Curran Associates, Inc., 2017. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "L. Lu, J. Xie, R. Huang, J. Zhang, W. Lin, and Y. Liang. An efficient hardware accelerator for sparse convolutional neural networks on fpgas. In 2019 IEEE 27th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM), pp. 17–25, April 2019. doi: 10.1109/FCCM.2019.00013. ",
+        "bbox": [
+            173,
+            169,
+            825,
+            226
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A. Maki, D. Miyashita, K. Nakata, F. Tachibana, T. Suzuki, and J. Deguchi. Fpga-based cnn processor with filter-wise-optimized bit precision. In 2018 IEEE Asian Solid-State Circuits Conference (A-SSCC), pp. 47–50, Nov 2018. doi: 10.1109/ASSCC.2018.8579342. ",
+        "bbox": [
+            174,
+            234,
+            825,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D. Miyashita, S. Kousai, T. Suzuki, and J. Deguchi. A neuromorphic chip optimized for deep learning and cmos technology with time-domain analog and digital mixed-signal processing. IEEE Journal of Solid-State Circuits, 52(10):2679–2689, Oct 2017. ISSN 0018-9200. doi: 10.1109/JSSC.2017.2712626. ",
+        "bbox": [
+            174,
+            286,
+            825,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daisuke Miyashita, Edward H. Lee, and Boris Murmann. Convolutional neural networks using logarithmic data representation. CoRR, abs/1603.01025, 2016. URL http://arxiv.org/ abs/1603.01025. ",
+        "bbox": [
+            173,
+            352,
+            821,
+            395
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Travis Oliphant. NumPy: A guide to NumPy. USA: Trelgol Publishing, 2006. URL http: //www.numpy.org/. ",
+        "bbox": [
+            169,
+            404,
+            821,
+            434
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in PyTorch. In NIPS Autodiff Workshop, 2017. ",
+        "bbox": [
+            176,
+            441,
+            823,
+            484
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016. ",
+        "bbox": [
+            171,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "S. Sasaki, A. Maki, D. Miyashita, and J. Deguchi. Post training weight compression with distribution-based filter-wise quantization step. In 2019 IEEE Symposium in Low-Power and High-Speed Chips (COOL CHIPS), pp. 1–3, April 2019. doi: 10.1109/CoolChips.2019.8721356. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            575
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "F. N. Sechi. Linearised class-b transistor amplifiers. IEEE Journal of Solid-State Circuits, 11(2): 264–270, April 1976. ISSN 0018-9200. doi: 10.1109/JSSC.1976.1050713. ",
+        "bbox": [
+            174,
+            583,
+            823,
+            613
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A. Shafiee, A. Nag, N. Muralimanohar, R. Balasubramonian, J. P. Strachan, M. Hu, R. S. Williams, and V. Srikumar. Isaac: A convolutional neural network accelerator with in-situ analog arithmetic in crossbars. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pp. 14–26, June 2016. doi: 10.1109/ISCA.2016.12. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            679
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. ",
+        "bbox": [
+            173,
+            688,
+            823,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matteo Spallanzani, Lukas Cavigelli, Gian Paolo Leonardi, Marko Bertogna, and Luca Benini. Additive noise annealing and approximation properties of quantized neural networks. CoRR, abs/1905.10452, 2019. URL http://arxiv.org/abs/1905.10452. ",
+        "bbox": [
+            173,
+            726,
+            823,
+            768
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pierre Stock, Armand Joulin, Remi Gribonval, Benjamin Graham, and Herv ´ e J ´ egou. And the bit ´ goes down: Revisiting the quantization of neural networks. CoRR, abs/1907.05686, 2019. URL http://arxiv.org/abs/1907.05686. ",
+        "bbox": [
+            176,
+            777,
+            823,
+            820
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "F. Tung and G. Mori. Clip-q: Deep network compression learning by in-parallel pruningquantization. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7873–7882, June 2018. doi: 10.1109/CVPR.2018.00821. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kuan Wang, Zhijian Liu, Yujun Lin, Ji Lin, and Song Han. Haq: Hardware-aware automated quantization with mixed precision. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019a. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yanzhi Wang, Shaokai Ye, Zhezhi He, Xiaolong Ma, Linfeng Zhang, Sheng Lin, Geng Yuan, Sia Huat Tan, Zhengang Li, Deliang Fan, Xuehai Qian, Xue Lin, and Kaisheng Ma. Nonstructured DNN weight pruning considered harmful. CoRR, abs/1907.02124, 2019b. URL http://arxiv.org/abs/1907.02124. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chen Xing, Devansh Arpit, Christos Tsirigotis, and Yoshua Bengio. A walk with sgd. CoRR, abs/1802.08770, 2018. URL http://arxiv.org/abs/1802.08770. ",
+        "bbox": [
+            171,
+            169,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tien-Ju Yang, Andrew Howard, Bo Chen, Xiao Zhang, Alec Go, Mark Sandler, Vivienne Sze, and Hartwig Adam. Netadapt: Platform-aware neural network adaptation for mobile applications. In Vittorio Ferrari, Martial Hebert, Cristian Sminchisescu, and Yair Weiss (eds.), Computer Vision – ECCV 2018, pp. 289–304, Cham, 2018. Springer International Publishing. ISBN 978-3-030- 01249-6. ",
+        "bbox": [
+            174,
+            207,
+            826,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dongqing Zhang, Jiaolong Yang, Dongqiangzi Ye, and Gang Hua. Lq-nets: Learned quantization for highly accurate and compact deep neural networks. In European Conference on Computer Vision (ECCV), 2018. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            328
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "X. Zhang, X. Zhou, M. Lin, and J. Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6848–6856, June 2018. doi: 10.1109/CVPR.2018.00716. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            380
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jing Zhong, Guiguang Ding, Yuchen Guo, Jungong Han, and Bin Wang. Where to prune: Using lstm to guide end-to-end pruning. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI-18, pp. 3205–3211. International Joint Conferences on Artificial Intelligence Organization, 7 2018. doi: 10.24963/ijcai.2018/445. URL https://doi.org/ 10.24963/ijcai.2018/445. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            459
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chenzhuo Zhu, Song Han, Huizi Mao, and William J. Dally. Trained ternary quantization. International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            171,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B. Zoph, V. Vasudevan, J. Shlens, and Q. V. Le. Learning transferable architectures for scalable image recognition. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8697–8710, June 2018. doi: 10.1109/CVPR.2018.00907. ",
+        "bbox": [
+            176,
+            506,
+            821,
+            549
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A DETAILS OF THE QUANTIZATION PROCESS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            565,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We basically apply a midrise-type quantization (Gersho, 1977), but modify it as follows. In the quantization phase, we prune filters in which all weight parameters are within $\\pm \\varDelta / 2$ , as described in the following pseudocode with Numpy (Oliphant, 2006) notation. ",
+        "bbox": [
+            173,
+            137,
+            823,
+            180
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "# Quantize   \n# W: (filter(out_ch), channel(in_ch), ky, kx)   \npruned $=$ numpy.all(abs(W) $<$ delta/2, axi $s = ( 1 , 2 , 3 )$ )   \nW_int $=$ numpy.floor(W/delta) $+ ~ 0 . 5$   \nW_int[pruned, :, :, : $\\jmath \\ = \\ 0$ ",
+        "bbox": [
+            174,
+            200,
+            661,
+            268
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B $\\mathrm { E S N } _ { a }$ FOR OPTIMAL QUANTIZATION POLICY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            296,
+            580,
+            313
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We attempt to exploit the $\\mathrm { E S N } _ { a }$ obtained during training to determine a quantization policy using VGG7 where numbers of filters in all convolutional layers are reduced to $0 . 2 5 \\times$ on CIFAR-10. The left figure in Figure 9 show the validation accuracy versus $\\mathrm { E S N } _ { a }$ during training and after quantization. As an initial policy, we apply the same bit width for all layers. The results shown in gray do not fit the blue plot during training, possibly indicating the policy is suboptimal. We next investigate the $\\mathrm { E S N } _ { a }$ of each layer and find that the misfit is caused by the sixth layer, as shown in the right figure. When we consider validation accuracy versus the sixth-layer $\\mathrm { E S N } _ { a }$ , shown in green symbols, validation accuracy after quantization deteriorates at a much higher $\\mathrm { E S N } _ { a }$ than during training. An interpretation is that since this deterioration is caused by other layers (e.g., the first) rather than the sixth layer, weight parameters in the sixth layer should be more aggressively quantized. Based on this observation, we modify the quantization policy such that the bit width of the sixth layer become smaller than that in other layers, thereby improving performance as shown by the red plot in the left figure. This preliminary experimental result suggests we can use $\\mathrm { E S N } _ { a }$ information during training to find an optimal quantization policy. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            527
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C RESNET-18 VERSUS RESNET-50 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            555,
+            480,
+            571
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The proposed metric allows us to compare different network architectures. In Figure 10, we compare the Pareto frontier of validation accuracy versus $\\mathrm { E S N } _ { a / d }$ curves for ResNet-18 and ResNet-50. The plots in Figure 10 are extracted from Figure 8. This result shows that ResNet-50 has a better Pareto frontier than does ResNet-18. One convincing reason is that ResNet-50 employs a parameterefficient bottleneck structure, whereas ResNet-18 does not. In contrast, ResNet-18 shows better performance for $\\mathrm { E S N } _ { d } < \\mathrm { 2 G }$ , partly due to the higher sensitivity of $\\mathrm { E S N } _ { d }$ to the number of parameters. This suggests use of ResNet-18 when employing digital computing in this $\\mathrm { E S N } _ { d }$ region. Such comparisons enabled by the proposed metric are useful when searching for or developing efficient structures. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            717
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d5aa136d8e61549ec8fd083414983846373dedea1a67e78d1c0cea7a30e1a771.jpg",
+        "image_caption": [
+            "Figure 9: Relation between validation accuracy versus $\\mathrm { E S N } _ { a }$ during training and after quantization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            748,
+            736,
+            885
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a59b5a8878a8ea8f3d6ad840988ab26269ea2f2967344df1fa765e89eb20929.jpg",
+        "image_caption": [
+            "Figure 10: Comparison of ResNet-18 and ResNet-50 with respect to top-1 accuracy on ImageNet versus $\\mathrm { E S N } _ { a / d }$ (left/right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            103,
+            746,
+            262
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/a0dce85d6c8c6554c8eb8f943057b2890541a50f8af1f3edac05daeaceff805c.jpg",
+        "image_caption": [
+            "Figure 11: Comparison of other methods with respect to top-1 accuracy on ImageNet versus estimated $\\mathrm { E S N } _ { d } ^ { \\prime }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            343,
+            745,
+            525
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D COMPARISON WITH OTHER METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            529,
+            621
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figure 11, we superimpose results from other works on Figure 8. Lin et al. (2017) and Zhang et al. (2018) show better accuracy in smaller $\\mathrm { E S N } _ { d } ^ { \\prime }$ regions than ours, but these apply quantization-aware training, whereas our result is obtained by post-training quantization. Although we expect that the findings presented in this paper will also improve performance of quantization-aware training, we leave an explicit demonstration of this to future works. ",
+        "bbox": [
+            173,
+            635,
+            825,
+            705
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E DERIVATION OF EQUATION (4) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            724,
+            464,
+            741
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The mean squared noise energy $N$ due to quantization over the all elements in a tensor $\\boldsymbol { \\mathsf { W } }$ is computed as ",
+        "bbox": [
+            173,
+            756,
+            821,
+            785
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6fa8b5270850c0f46483806f4d821a18739ac6e43d2cab9458180832dd1f70a.jpg",
+        "text": "$$\n\\begin{array} { r } { N = | | \\mathbf { W } - \\varDelta \\cdot \\mathbf { W } _ { \\mathrm { i n t } } | | _ { F } ^ { 2 } / | | \\mathbf { W } | | _ { 0 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            803,
+            606,
+            821
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\mathsf { W } } _ { \\mathrm { i n t } } = \\pmb { \\mathsf { W } } / \\Delta \\rfloor + 0 . 5$ , $\\varDelta$ is the quantization step size and $| | \\pmb { \\mathsf { W } } | | _ { 0 }$ is the number of nonzero elements in $\\pmb { \\mathsf { W } }$ . When quantization noise is approximated by a uniform distribution, the mean squared noise energy is (Gray & Neuhoff, 1998) ",
+        "bbox": [
+            174,
+            830,
+            825,
+            873
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcd6d0f87a7f402a7814b41c76d7a3c08d417d04e08a162375bfe74553452b3c.jpg",
+        "text": "$$\nN = \\int _ { - \\Delta / 2 } ^ { \\Delta / 2 } \\frac { 1 } { \\varDelta } n ^ { 2 } d n = \\frac { { \\varDelta } ^ { 2 } } { 1 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            888,
+            594,
+            928
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "From Equations (8) and (9), ",
+        "bbox": [
+            173,
+            103,
+            359,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8454b2d15ed6f91bd9b59c01956ac5200ef7ed1ff1f3a582e9895d18685b0058.jpg",
+        "text": "$$\n\\varDelta ^ { 2 } = | | \\boldsymbol { \\mathsf { W } } - \\varDelta \\cdot \\boldsymbol { \\mathsf { W } } _ { \\mathrm { i n t } } | | _ { F } ^ { 2 } \\times \\frac { 1 2 } { | | \\boldsymbol { \\mathsf { W } } | | _ { 0 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            135,
+            617,
+            167
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Then, ",
+        "bbox": [
+            173,
+            178,
+            215,
+            191
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3157b6e9a39830ca995aa770798eefb7287bf4b8f0ccc1389893f7e801ce8c55.jpg",
+        "text": "$$\n| | \\mathbf { W } _ { \\mathrm { i n t } } | | _ { F } ^ { 2 } \\sim | | \\mathbf { W } / \\varDelta | | _ { F } ^ { 2 } = \\frac { | | \\mathbf { W } | | _ { F } ^ { 2 } } { \\varDelta ^ { 2 } } = \\frac { | | \\mathbf { W } | | _ { F } ^ { 2 } } { | | \\mathbf { W } - \\varDelta \\cdot \\mathbf { W } _ { \\mathrm { i n t } } | | _ { F } ^ { 2 } } \\cdot \\frac { | | \\mathbf { W } | | _ { 0 } } { 1 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            208,
+            715,
+            243
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Here we again assume that quantization noise is uniformly distributed. In this equation, since $| | \\pmb { \\mathsf { W } } | |$ and $| | \\boldsymbol { \\mathsf { W } } - \\varDelta \\cdot \\boldsymbol { \\mathsf { W } } | | _ { F } ^ { 2 }$ are respectively the signal and noise norm, the term $\\frac { | | \\mathbf { W } | | _ { F } ^ { 2 } } { | | \\mathbf { W } - \\varDelta \\cdot \\mathbf { W _ { \\mathrm { i n t } } } | | _ { F } ^ { 2 } }$ is considered to be $S / N$ , and thus, ",
+        "bbox": [
+            173,
+            253,
+            825,
+            306
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96cb7237ac4599d852497cbd8b506550c63e8c8ef7fff637ad9d5e9d4ef285ff.jpg",
+        "text": "$$\n| | \\mathbf { W _ { \\mathrm { i n t } } } | | _ { F } ^ { 2 } = \\frac { | | \\mathbf { W } | | _ { F } ^ { 2 } } { | | \\mathbf { W } - \\varDelta \\cdot \\mathbf { W _ { \\mathrm { i n t } } } | | _ { F } ^ { 2 } } \\cdot \\frac { | | \\mathbf { W } | | _ { 0 } } { 1 2 } = S / N \\cdot \\frac { | | \\mathbf { W } | | _ { 0 } } { 1 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            321,
+            691,
+            358
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We obtain Equation (4) by summing this value over all layers. ",
+        "bbox": [
+            173,
+            367,
+            581,
+            383
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F DETAILS OF NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            401,
+            544,
+            419
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The network architecures of VGG7 ( $1 \\times , 0 . 5 \\times , 0 . 2 5 \\times )$ which we use in section 2.4 are shown in table 1. These architectures are based on the original model of VGG (Simonyan & Zisserman, 2014). ",
+        "bbox": [
+            174,
+            433,
+            823,
+            463
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/23a37116bfc282e598df13941a03ec5bc882e3e3630a38691cf499f03ae12323.jpg",
+        "table_caption": [
+            "Table 1: Detailed network architecture of VGG7 for CIFAR-10. $C _ { I }$ and $C _ { O }$ represent the number of input and output channels, respectively in conv-layer. In fc-layer, they represent the number of input and output neurons "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Layer name</td><td rowspan=1 colspan=2>VGG(1x)</td><td rowspan=1 colspan=2>VGG (0.5x)</td><td rowspan=1 colspan=2>VGG (0.25×)</td><td rowspan=2 colspan=1>kernel size</td><td rowspan=2 colspan=1> padding</td><td rowspan=2 colspan=1>stride</td></tr><tr><td rowspan=1 colspan=1>C1</td><td rowspan=1 colspan=1>Co</td><td rowspan=1 colspan=1>C1</td><td rowspan=1 colspan=1>Co</td><td rowspan=1 colspan=1>C1</td><td rowspan=1 colspan=1>Co</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>maxpool</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>conv4</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>maxpool</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>conv5</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>conv6</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>3×3</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>maxpool</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2×2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>fc</td><td rowspan=1 colspan=1>8192</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>4096</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr></table>",
+        "bbox": [
+            184,
+            534,
+            812,
+            712
+        ],
+        "page_idx": 15
+    }
+]

parse/train/HyfHgI6aW/HyfHgI6aW.md

@@ -0,0 +1,319 @@
+# MEMORY AUGMENTED CONTROL NETWORKS
+
+Arbaaz Khan, Clark Zhang, Nikolay Atanasov, Konstantinos Karydis, Vijay Kumar, Daniel D. Lee
+
+GRASP Laboratory, University of Pennsylvania
+
+# ABSTRACT
+
+Planning problems in partially observable environments cannot be solved directly with convolutional networks and require some form of memory. But, even memory networks with sophisticated addressing schemes are unable to learn intelligent reasoning satisfactorily due to the complexity of simultaneously learning to access memory and plan. To mitigate these challenges we propose the Memory Augmented Control Network (MACN). The network splits planning into a hierarchical process. At a lower level, it learns to plan in a locally observed space. At a higher level, it uses a collection of policies computed on locally observed spaces to learn an optimal plan in the global environment it is operating in. The performance of the network is evaluated on path planning tasks in environments in the presence of simple and complex obstacles and in addition, is tested for its ability to generalize to new environments not seen in the training set.
+
+# 1 INTRODUCTION
+
+A planning task in a partially observable environment involves two steps: inferring the environment structure from local observation and acting based on the current environment estimate. In the past, such perception-action loops have been learned using supervised learning with deep networks as well as deep reinforcement learning (Daftry et al., 2016), (Chebotar et al., 2016), (Lee et al., 2017). Popular approaches in this spirit are often end-to-end (i.e. mapping sensor readings directly to motion commands) and manage to solve problems in which the underlying dynamics of the environment or the agent are too complex to model. Approaches to learn end-to-end perception-action loops have been extended to complex reinforcement learning tasks such as learning how to play Atari games (Mnih et al., 2013a), as well as to imitation learning tasks like controlling a robot arm (Levine et al., 2015).
+
+Purely convolutional architectures (CNNs) perform poorly when applied to planning problems due to the reactive nature of the policies learned by them (Zhang et al., 2016b), (Giusti et al., 2016). The complexity of this problem is compounded when the environment is only partially observable as is the case with most real world tasks. In planning problems, when using a function approximator such as a convolutional neural network, the optimal actions are dependent on an internal state. If one wishes to use a state-less network (such as a CNN) to obtain the optimal action, the input for the network should be the whole history of observations and actions. Since this does not scale well, we need a network that has an internal state such as a recurrent neural network or a memory network. (Zhang et al., 2016a) showed that when learning how to plan in partially observable environments, it becomes necessary to use memory to retain information about states visited in the past. Using recurrent networks to store past information and learn optimal control has been explored before in (Levine, 2013). While (Siegelmann & Sontag, 1995) have shown that recurrent networks are Turing complete and are hence capable of generating any arbitrary sequence in theory, this does not always translate into practice. Recent advances in memory augmented networks have shown that it is beneficial to use external memory with read and write operators that can be learned by a neural network over recurrent neural networks (Graves et al., 2014), (Graves et al., 2016). Specifically, we are interested in the Differentiable Neural Computer (DNC) (Graves et al., 2016) which uses an external memory and a network controller to learn how to read, write and access locations in the external memory. The DNC is structured such that computation and memory operations are separated from each other. Such a memory network can in principle be plugged into the convolutional architectures described above, and be trained end to end since the read and write operations are differentiable. However, as we show in our work, directly using such a memory scheme with CNNs performs poorly for partially observable planning problems and also does not generalize well to new environments.
+
+To address the aforementioned challenges we propose the Memory Augmented Control Network (MACN), a novel architecture specifically designed to learn how to plan in partially observable environments under sparse rewards.1 Environments with sparse rewards are harder to navigate since there is no immediate feedback. The intuition behind this architecture is that planning problem can be split into two levels of hierarchy. At a lower level, a planning module computes optimal policies using a feature rich representation of the locally observed environment. This local policy along with a sparse feature representation of the partially observed environment is part of the optimal solution in the global environment. Thus, the key to our approach is using a planning module to output a local policy which is used to augment the neural memory to produce an optimal policy for the global environment. Our work builds on the idea of introducing options for planning and knowledge representation while learning control policies in MDPs (Sutton et al., 1999). The ability of the proposed model is evaluated by its ability to learn policies (continuous and discrete) when trained in environments with the presence of simple and complex obstacles. Further, the model is evaluated on its ability to generalize to environments and situations not seen in the training set.
+
+The key contributions of this paper are:
+
+1. A new network architecture that uses a differentiable memory scheme to maintain an estimate of the environment geometry and a hierarchical planning scheme to learn how to plan paths to the goal.   
+2. Experimentation to analyze the ability of the architecture to learn how to plan and generalize in environments with high dimensional state and action spaces.
+
+# 2 METHODOLOGY
+
+Section 2.1 outlines notation and formally states the problem considered in this paper. Section 2.2 and 2.3 briefly cover the theory behind value iteration networks and memory augmented networks. Finally, in section 2.4 the intuition and the computation graph is explained for the practical implementation of the model.
+
+# 2.1 PRELIMINARIES
+
+Consider an agent with state $s _ { t } \in S$ at discrete time $t$ . Let the states $s$ be a discrete set $\left[ s _ { 1 } , s _ { 2 } , \ldots , s _ { n } \right]$ For a given action $a _ { t } \in { \mathcal { A } }$ , the agent evolves according to known deterministic dynamics: $s _ { t + 1 } =$ $f ( s _ { t } , \bar { a } _ { t } )$ . The agent operates in an unknown environment and must remain safe by avoiding collisions. Let $m \in \{ - 1 , 0 \} ^ { n }$ be a hidden labeling of the states into free (0) and occupied $( - 1 )$ . The agent has access to a sensor that reveals the labeling of nearby states through an observations $z _ { t } = H ( s _ { t } ) m \in$ $\{ - 1 , 0 \} ^ { n }$ , where $H ( s ) \in \mathbb { R } ^ { n \times n }$ captures the local field of view of the agent at state $s$ . The local observation consists of ones for observable states and zeros for unobservable states. The observation $z _ { t }$ contains zeros for unobservable states. Note that $m$ and $z _ { t }$ are $n \times 1$ vectors and can be indexed by the state $s _ { t }$ . The agent’s task is to reach a goal region ${ \mathcal { S } } ^ { \mathrm { g o a l } } \subset { \mathcal { S } }$ , which is assumed obstacle-free, i.e., $m [ s ] = 0$ for all $\bar { s } \in S ^ { \mathrm { g o a l } }$ . The information available to the agent at time $t$ to compute its action $a _ { t }$ is $h _ { t } : = \left( s _ { 0 : t } , z _ { 0 : t } , a _ { 0 : t - 1 } , S ^ { \mathrm { g o a l } } \right) \in \mathcal { H }$ , where $\mathcal { H }$ is the set of possible sequences of observations, states, and actions. Our problem can then be stated as follows :
+
+Problem 1. Given an initial state $s _ { 0 } \in S$ with $m [ s _ { 0 } ] = 0$ (obstacle-free) and a goal region $S ^ { g o a l }$ find a function $\mu : { \mathcal { S } }  A$ such that applying the actions $a _ { t } : = \mu ( s _ { t } )$ results in a sequence of states $s _ { 0 } , s _ { 1 } , \ldots , s _ { T }$ satisfying $s _ { T } \in S ^ { g o a l }$ and $m [ s _ { t } ] = 0$ for all $t = 0 , \ldots , T$ .
+
+Instead of trying to estimate the hidden labeling $m$ using a mapping approach, our goal is to learn a policy $\mu$ that maps the sequence of sensor observations $z _ { 0 } , z _ { 1 } , \dots z _ { T }$ directly to actions for the agent. The partial observability requires an explicit consideration of memory in order to learn $\mu$ successfully. A partially observable problem can be represented via a Markov Decision Process (MDP) over the history space $\mathcal { H }$ . More precisely, we consider a finite-horizon discounted MDP defined by $\mathcal { M } ( \mathcal { H } , \mathcal { A } , \mathcal { T } , r , \gamma )$ , where $\gamma \in ( 0 , 1 ]$ is a discount factor, $\mathcal { T } : \mathcal { H } \times \mathcal { A }  \mathcal { H }$ is a deterministic transition function, and $r : \mathcal { H } \to \mathbb { R }$ is the reward function, defined as follows:
+
+$$
+\begin{array} { r l } & { \mathcal { T } ( h _ { t } , a _ { t } ) = ( h _ { t } , s _ { t + 1 } = f ( s _ { t } , a _ { t } ) , z _ { t + 1 } = H ( s _ { t + 1 } ) m , a _ { t } ) } \\ & { ~ r ( h _ { t } , a _ { t } ) = z _ { t } [ s _ { t } ] } \end{array}
+$$
+
+The reward function definition stipulates that the reward of a state $s$ can be measured only after its occupancy state has been observed.
+
+Given observations $z _ { 0 : t }$ , we can obtain an estimate $\begin{array} { r } { \hat { m } = \operatorname* { m a x } \{ \sum _ { \tau } z _ { \tau } , - 1 \} } \end{array}$ of the map of the environment and use it to formulate a locally valid, fully-observable problem as the MDP $\mathcal { M } _ { t } ( S , \mathcal { A } , f , r , \gamma )$ with transition function given by the agent dynamics $f$ and reward $r ( s _ { t } ) : = \hat { m } [ s _ { t } ]$ given by the map estimate $\hat { m }$ .
+
+# 2.2 VALUE ITERATION NETWORKS
+
+The typical algorithm to solve an MDP is Value Iteration (VI) (Sutton $\&$ Barto, 1998). The value of a state (i.e. the expected reward over the time horizon if an optimal policy is followed) is computed iteratively by calculating an action value function $Q ( s , a )$ for each state. The value for state $s$ can then be calculated by $\bar { V } ( s ) : = \operatorname* { m a x } _ { a } Q ( s , a )$ . By iterating multiple times over all states and all actions possible in each state, we can get a policy $\pi = \arg \operatorname* { m a x } _ { a } Q ( s , a )$ . Given a transition function $\bar { \mathcal { T } _ { r } } ( s ^ { \prime } | s , \bar { a } )$ , the update rule for value iteration is given by (1)
+
+$$
+V _ { k + 1 } ( s ) = \operatorname* { m a x } _ { a } [ r ( s , a ) + \gamma \sum _ { s ^ { \prime } } \mathcal { T } _ { r } ( s ^ { \prime } | s , a ) V _ { k } ( s ) ] \enspace .
+$$
+
+A key aspect of our network is the inclusion of this network component that can approximate this Value Iteration algorithm. To this end we use the VI module in Value Iteration Networks (VIN) (Tamar et al., 2016). Their insight is that value iteration can be approximated by a convolutional network with max pooling. The standard form for windowed convolution is
+
+$$
+V ( x ) = \sum _ { k = x - w } ^ { x + w } V ( k ) u ( k ) .
+$$
+
+(Tamar et al., 2016) show that the summation in (2) is analogous to $\begin{array} { r } { \sum _ { s ^ { \prime } } \mathcal { T } ( s ^ { \prime } | s , a ) V _ { k } ( s ) } \end{array}$ in (1). When (2) is stacked with reward, max pooled and repeated $\mathbf { K }$ times, the convolutional architecture can be used to represent an approximation of the value iteration algorithm over $\mathrm { K }$ iterations.
+
+# 2.3 EXTERNAL MEMORY NETWORKS
+
+Recent works on deep learning employ neural networks with external memory (Graves et al., 2014), (Graves et al., 2016), (Kurach et al., 2015), (Parisotto & Salakhutdinov, 2017). Contrary to earlier works that explored the idea of the network learning how to read and access externally fixed memories, these recent works focus on learning to read and write to external memories, and thus forgo the task of designing what to store in the external memory. We are specifically interested in the DNC (Graves et al., 2016) architecture. This is similar to the work introduced by (Oh et al., 2016) and (Chen et al., 2017). The external memory uses differentiable attention mechanisms to determine the degree to which each location in the external memory $M$ is involved in a read or write operation. The DNC makes use of a controller (a recurrent neural network such as LSTM) to learn to read and write to the memory matrix. A brief overview of the read and write operations follows.2
+
+# 2.3.1 READ AND WRITE OPERATION
+
+The read operation is defined as a weighted average over the contents of the locations in the memory. This produces a set of vectors defined as the read vectors. $R$ read weightings $\{ w _ { t } ^ { r e a d , 1 } , \ldots , w _ { t } ^  r e a d , \bar { R _ { \} } } \}$ are used to compute weighted averages of the contents of the locations in the memory. At time $t$ the read vectors $\{ r \dot { e } _ { t } ^ { 1 } , \ldots , r \check { e } _ { t } ^ { R } \}$ are defined as :
+
+$$
+r e _ { t } ^ { i } = M _ { t } ^ { \top } w _ { t } ^ { r e a d , i }
+$$
+
+where $w _ { t } ^ { r e a d , i }$ are the read weightings, $r e _ { t }$ is the read vector, and $M _ { t }$ is the state of the memory at time $t$ . These read vectors are appended to the controller input at the next time step which provides it access to the memory. The write operation consists of a write weight $w _ { t } ^ { W }$ , an erase vector $e _ { t }$ and a write vector $v _ { t }$ . The write vector and the erase vector are emitted by the controller. These three components modify the memory at time $t$ as :
+
+$$
+M _ { t } = M _ { t - 1 } ( 1 - w _ { t } ^ { W } e _ { t } ^ { \top } ) + w _ { t } ^ { W } v _ { t } ^ { \top } .
+$$
+
+Memory addressing is defined separately for writing and reading. A combination of content-based addressing and dynamic memory allocation determines memory write locations, while a combination of content-based addressing and temporal memory linkage is used to determine read locations.
+
+# 2.4 MEMORY AUGMENTED CONTROL MODEL
+
+![](images/807a18b731de9006de4670460028b904a32ce1d310cfd68d534829208fc8e3b1.jpg)  
+Figure 1: 2D Environment a) Let the agent (blue square) operate in a 2D environment. The goal region is represented by the red square and the orange square represents the agents observation b) Agents observation. The gray area is not observable. c) It is possible to plan on this locally observed space since it is a MDP.
+
+Consider the 2D grid world in Fig 1a. The agent is spawned randomly in this world and is represented by the blue square. The goal of the agent is to learn how to navigate to the red goal region. Let this environment in Fig 1a be represented by a MDP $\mathcal { M }$ . The key intuition behind designing this architecture is that planning in $\mathcal { M }$ can be decomposed into two levels. At a lower level, planning is done in a local space within the boundaries of our locally observed environment space. Let this locally observed space be $z ^ { \prime }$ . Fig 1b represents this locally observed space. As stated before in Section 2.1, this observation can be formulated as a fully observable problem $\mathcal { M } _ { t } ( S , \mathcal { A } , f , r , \gamma )$ . It is possible to plan in $\mathcal { M } _ { t }$ and calculate the optimal policy for this local space, $\pi _ { l } ^ { * }$ independent of previous observations (Fig 1c). It is then possible to use any planning algorithm to calculate the optimal value function $V _ { l } ^ { * }$ from the optimal policy $\pi _ { l } ^ { * }$ in $z ^ { \prime }$ . Let $\mathrm { \dot { I } } = [ \pi _ { l } ^ { \mathrm { \scriptsize { 1 } } } , \pi _ { l } ^ { \mathrm { \scriptsize { 2 } } } , \pi _ { l } ^ { 3 } , \pi _ { l } ^ { 4 } , \dots , \pi _ { l } ^ { n } ]$ be the list of optimal policies calculated from such consecutive observation spaces $[ z _ { 0 } , z _ { 1 } , \dots z _ { T } ]$ . Given these two lists, it is possible to train a convolutional neural network with supervised learning.The network could then be used to compute a policy $\pi _ { l } ^ { n e w }$ when a new observation $z ^ { n e w }$ is recorded.
+
+This policy learned by the convolutional network is purely reactive as it is computed for the $z ^ { n e w }$ observation independent of the previous observations. Such an approach fails when there are local minima in the environment. In a 2D/3D world, these local minima could be long narrow tunnels culminating in dead ends (see Fig 2). In the scenario where the environment is populated with tunnels, (Fig 2) the environment is only partially observable and the agent has no prior knowledge about the structure of this tunnel forcing it to explore the tunnel all the way to the end. Further, when entering and exiting such a structure, the agent’s observations are the same, i.e $z _ { 1 } = z _ { 2 }$ , but the optimal actions under the policies $\pi _ { l } ^ { 1 }$ and $\pi _ { l } ^ { 2 }$ (computed by the convolutional network) at these time steps are not the same, i.e $a _ { \pi ^ { 1 } } \neq a _ { \pi ^ { 2 } }$ . To backtrack successfully from these tunnels/nodes, information about previously visited states is required, necessitating memory.
+
+To solve this problem, we propose using a differentiable memory to estimate the map of the environment $\hat { m }$ . The controller in the memory network learns to selectively read and write information to the memory bank. When such a differentiable memory scheme is trained it is seen that it keeps track of important events/landmarks (in the case of tunnel, this is the observation that the dead end has been reached) in its memory state and discards redundant information. In theory one can use a CNN to extract features from the observation $z ^ { \prime }$ and pass these features to the differentiable memory. Instead, we propose the use of a VI module (Tamar et al., 2016) that approximates the value iteration algorithm within the framework of a neural network to learn value maps from the local information. We hypothesize that using these value maps in the differential memory scheme provides us with better planning as compared to when only using features extracted from a CNN. This architecture is shown in Figure 3.
+
+![](images/a0c63b60f38470c2b081aa2fa37fcc9a2efa52f7afee027307c51db2d47e5c67.jpg)  
+Figure 2: Environment with local minima. The agents observation when entering the tunnel to explore it and when backtracking after seeing the dead end are the same. Using a reactive policy for such environments leads to the agent getting stuck near the dead end .
+
+The VI module is setup to learn how to plan on the local observations $z$ . The local value maps (which can be used to calculate local policies) are concatenated with a low level feature representation of the environment and sent to a controller network. The controller network interfaces with the memory through an access module (another network layer) and emits read heads, write heads and access heads. In addition, the controller network also performs its own computation for planning. The output from the controller network and the access module are concatenated and sent through a linear layer to produce an action. This entire architecture is then trained end to end. Thus, to summarize, the planning problem is solved by decomposing it into a two level problem. At a lower level a feature rich representation of the environment (obtained from the current observation) is used to generate local policies. At the next level, a representation of the histories that is learned and stored in the memory, and a sparse feature representation of the currently observed environment is used to generate a policy optimal in the global environment.
+
+Computation Graph: To explain the computation graph, consider the case of a 2D grid world with randomly placed obstacles, a start region and a goal region as shown in Fig 1a. The actions for this grid world are considered to be discrete. The 2D grid world is presented in the form of an image $I$ of size $m \times n$ to the network. Let the goal region be $[ m _ { g o a l } , n _ { g o a l } ]$ and the start position be $[ m _ { s t a r t } , n _ { s t a r t } ]$ . At any given instant, only a small part of $I$ is observed by the network and the rest of the image $I$ is blacked out. This corresponds to the agent only observing what is visible within the range of its sensor. In addition to this the image is stacked with a reward map $R _ { m }$ as explained in (Tamar et al., 2016). The reward map consists of an array of size $m \times n$ where all elements of the array except the one corresponding to index $[ m _ { g o a l } , n _ { g o a l } ]$ are zero. Array element corresponding to $[ m _ { g o a l } , n _ { g o a l } ]$ is set to a high value(in our experiments it is set to 1) denoting reward. The input image of dimension $[ m \times n \times 2 ]$ is first convolved with a kernel of size $\left( 3 \times 3 \right)$ , 150 channels and stride of 1 everywhere. This is then convolved again with a kernel of size (1,1), 4 channels and stride of 1. Let this be the reward layer $R$ . $R$ is convolved with another filter of size (3,3) with 4 channels. This is the initial estimate of the action value function or $Q ( s , a )$ . The initial value of the state $V ( s )$ is also calculated by taking max over $Q ( s , a )$ . The operations up to this point are summarized by the "Conv" block in Figure 3. Once these initial values have been computed, the model executes a for loop k times (the value of $\mathbf { k }$ ranges based on the task). Inside the for loop at every iteration, the R and $\mathrm { v }$ are first concatenated. This is then convolved with another filter of size (3,3) and 4 channels to get the updated action value of the state, $Q ( s , a )$ . We find the value of the state $\mathrm { V } ( { \mathrm { s } } )$ by taking the max of the action value function. The values of the kernel sizes are constant across all three experiments. The updated value maps are then fed into a DNC controller. The DNC controller is a LSTM (hidden units vary according to task) that has access to an external memory. The external memory has 32 slots with word size 8 and we use 4 read heads and 1 write head. This varies from task to task since some of the more complex environments need more memory. The output from the DNC controller and the memory is concatenated through a linear layer to get prediction for the action that the agent should execute. The optimizer used is the RMSProp and we use a learning rate of 0.0001 for our experiments.
+
+![](images/99d427c3ce99c73186eca0c7305f1d3337fd410b47391b7965662fee348c77cd.jpg)  
+Figure 3: MACN Architecture. The architecture proposed uses convolutional layers to extract features from the environment. The value maps are generated with these features. The controller network uses the value maps and low level features to emit read and write heads in addition to doing its own planning computation.
+
+This formulation is easy enough to be extended to environments where the state space is larger than two dimensions and the action space is larger. We demonstrate this in our experiments.
+
+# 3 EXPERIMENTS
+
+To investigate the performance of MACN, we design our experiments to answer three key questions:
+
+• Can it learn how to plan in partially observable environments with sparse rewards?   
+• How well does it generalize to new unknown environments?   
+• Can it be extended to other domains?
+
+We first demonstrate that MACN can learn how to plan in a 2D grid world environment. Without loss of generality, we set the probability of all actions equal. The action space is discrete, $\mathcal { A } : =$ $\{ d o w n , \bar { r } i g h t , u \bar { p } , l e f t \}$ . This can be easily extended to continuous domains since our networks output is a probability over actions. We show this in experiment 3.4. We then demonstrate that our network can learn how to plan even when the states are not constrained to a two dimensional space and the action space is larger than four actions.
+
+# 3.1 NAVIGATION IN PRESENCE OF SIMPLE OBSTACLES
+
+We first evaluate the ability of our network to successfully navigate a 2D grid world populated with obstacles at random positions. We make the task harder by having random start and goal positions. The full map shown in Fig. 4 is the top down view of the entire environment. The input to the network is the sensor map, where the area that lies outside the agents sensing abilities is grayed out as explained before. VIN: With just the VI module and no memory in place, we test the performance of the value iteration network on this 2D partially observable environment. $\mathbf { C N N + }$ Memory: We setup a CNN architecture where the sensor image with the reward map is forward propagated through four convolutional layers to extract features. We test if these features alone are enough for the memory to navigate the 2D grid world. A natural question to ask at this point is can we achieve planning in partially observable environments with just a planning module and a simple recurrent neural network such as a LSTM. To answer this we also test MACN with a LSTM in place of the memory scheme. We present our results in Table 1. These results are obtained from testing on a held out test-set consisting of maps with random start, goal and obstacle positions.
+
+![](images/87b22140e9954f7e0c84f4d540a7cb6f697a40bff09609a7ba26fa644a1ca407.jpg)  
+Figure 4: Performance on grid world environment . In the map the blue square represents the start position while the red square represents the goal. The red dotted line is the ground truth and the blue dash line represents the agents path. The maps shown here are from the test set and have not been seen before by the agent during training.   
+Table 1: Performance on 2D grid world with simple obstacles: All models are tested on maps generated via the same random process, and were not present in the training set. Episodes over 40 (for a $1 6 \times 1 6$ wide map), 60 (for $3 2 \times 3 2$ ) and 80 (for $6 4 \times 6 4$ ) time steps were terminated and counted as a failure. Episodes where the agent collided with an obstacle were also counted as failures.
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Performance</td><td rowspan=1 colspan=1>16 × 16</td><td rowspan=1 colspan=1>32 × 32</td><td rowspan=1 colspan=1>64 × 64</td></tr><tr><td rowspan=2 colspan=1>VIN</td><td rowspan=1 colspan=1>Success(%)</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>Test Error</td><td rowspan=1 colspan=1>0.63</td><td rowspan=1 colspan=1>0.78</td><td rowspan=1 colspan=1>0.81</td></tr><tr><td rowspan=2 colspan=1>CNN + Memory</td><td rowspan=1 colspan=1>Success(%)</td><td rowspan=1 colspan=1>0.12</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>TestError</td><td rowspan=1 colspan=1>0.43</td><td rowspan=1 colspan=1>0.618</td><td rowspan=1 colspan=1>0.73</td></tr><tr><td rowspan=2 colspan=1>MACN (LSTM)</td><td rowspan=1 colspan=1>Success (%)</td><td rowspan=1 colspan=1>88.12</td><td rowspan=1 colspan=1>73.4</td><td rowspan=1 colspan=1>64</td></tr><tr><td rowspan=1 colspan=1>Test Error</td><td rowspan=1 colspan=1>0.077</td><td rowspan=1 colspan=1>0.12</td><td rowspan=1 colspan=1>0.21</td></tr><tr><td rowspan=2 colspan=1>MACN</td><td rowspan=1 colspan=1>Success(%)</td><td rowspan=1 colspan=1>96.3</td><td rowspan=1 colspan=1>85.91</td><td rowspan=1 colspan=1>78.44</td></tr><tr><td rowspan=1 colspan=1>TestError</td><td rowspan=1 colspan=1>0.02</td><td rowspan=1 colspan=1>0.08</td><td rowspan=1 colspan=1>0.13</td></tr></table>
+
+Our results show that MACN can learn how to navigate partially observable 2D unknown environments. Note that the VIN does not work by itself since it has no memory to help it remember past actions. We would also like to point out that while the $\mathrm { C N N + I }$ Memory architecture is similar to (Oh et al., 2016), its performance in our experiments is very poor due to the sparse rewards structure. MACN significantly outperforms all other architectures. Furthermore, MACN’s drop in testing accuracy as the grid world scales up is not as large compared to the other architectures. While these results seem promising, in the next section we extend the experiment to determine whether MACN actually learns how to plan or it is overfitting.
+
+# 3.2 NAVIGATION IN PRESENCE OF LOCAL MINIMA
+
+The previous experiment shows that MACN can learn to plan in 2D partially observable environments. While the claim that the network can plan on environments it has not seen before stands, this is weak evidence in support of the generalizability of the network. In our previous experiment the test environments have the same dimensions as in the training set, the number of combinations of random obstacles especially in the smaller environments is not very high and during testing some of the wrong actions can still carry the agent to the goal. Thus, our network could be overfitting and may not generalize to new environments. In the following experiment we test our proposed network’s capacity to generalize.
+
+![](images/bff5f799acad0b662efd955487804006695439a733cc16fa1881bfd614b1bd5c.jpg)  
+Figure 5: Grid world environment with local minima. Left: In the full map the blue square represents the current position while the red square represents the goal. Center-left: The partial map represents a stitched together version of all states explored by the agent. Since the agent does not know if the tunnel culminates in a dead end, it must explore it all the way to the end. Center-right: The sensor input is the information available to the agent. Right: The full map that we test our agent on after being trained on smaller maps. The dimensions of the map as well as the tunnel are larger.   
+Table 2: Performance on grid world with local minima: All models are trained on tunnels of length 20 units. The success percentages represent the number of times the robot reaches the goal position in the test set after exploring the tunnel all the way to the end. Maximum generalization length is the length of the longest tunnel that the robot is able to successfully navigate after being trained on tunnels of length 20 units.
+
+The environment is setup with tunnels. The agent starts off at random positions inside the tunnel. While the orientation of the tunnel is fixed, its position is not. To comment on the the ability of our network to generalize to new environments with the same task, we look to answer the following question: When trained to reach the goal on tunnels of a fixed length, can the network generalize to longer tunnels in bigger maps not seen in the training set?
+
+The network is set up the same way as before. The task here highlights the significance of using memory in a planning network. The agent’s observations when exploring the tunnel and exiting the tunnel are the same but the actions mapped to these observations are different. The memory in our network remembers past information and previously executed policies in those states, to output the right action. We report our results in Table 2. To show that traditional deep reinforcement learning performs poorly on this task, we implement the DQN architecture as introduced in (Mnih et al., 2013b). We observe that even after one million iterations, the DQN does not converge to the optimal policy on the training set. This can be attributed to the sparse reward structure of the environment. We report similar findings when tested with A3C as introduced in (Mnih et al., 2016). We also observe that the $\mathrm { C N N + }$ memory scheme learns to turn around at a fixed length and does not explore the longer tunnels in the test set all the way to the end.
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Success (%)</td><td rowspan=1 colspan=1>Maximum generalization length</td></tr><tr><td rowspan=1 colspan=1>DQN</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>A3C</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>CNN + Memory</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>VIN</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>MACN</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>330</td></tr></table>
+
+These results offer insight into the ability of MACN to generalize to new environments. Our network is found capable of planning in environments it has not seen in the training set at all. On visualizing the memory (see supplemental material), we observe that there is a big shift in the memory states only when the agent sees the end of the wall and when the agent exits the tunnel. A t-sne (Maaten & Hinton, 2008) visualization over the action spaces (see Fig. 6) clearly shows that the output of our network is separable. We can conclude from this that the network has learned the spatial structure of the tunnel, and it is now able to generalize to tunnels of longer length in larger maps.
+
+Thus, we can claim that our proposed model is generalizable to new environments that are structurally similar to the environments seen in the training set but have not been trained on. In addition to this in all our experiments are state and action spaces have been constrained to a small number of dimensions. In our next experiment we show that MACN can learn how to plan even when the state space and action space are scaled up.
+
+![](images/ee5fb9944af9662ead41ef6d73dd1663dcfb760c3b3ecdfc1b3c8261b8cb1d63.jpg)  
+Figure 6: T-sne visualization on 2D grid worlds with tunnels. a) T-sne visualization of the raw images fed into the network. Most of the input images for going into the tunnel and exiting the tunnel are the same but have different action labels. b) T-sne visualization from the outputs of the pre planning module. While it has done some separation, it is still not completely separable. c) Final output from the MACN. The actions are now clearly separable.
+
+# 3.3 GENERAL GRAPH SEARCH
+
+In our earlier experiments, the state space was constrained in two dimensions, and only four actions were available. It is nearly impossible to constrain every real world task to a two dimensional space with only four actions. However, it is easier to formulate a lot of partially observable planning problems as a graph.We define our environment as an undirected graph $G = ( V , E )$ where the connections between the nodes are generated randomly (see Fig. 7). In Fig 7 the blue node is the start state and the red node is the goal state. Each node represents a possible state the agent could be in. The agent can only observe all edges connected to the node it currently is in thus making it partially observable. The action space for this state is then any of the possible nodes that the agent can visit next. As before, the agent only gets a reward when it reaches the goal. We also add in random start and goal positions. In addition, we add a transition probability of 0.8. (For training details and generation of graph see Appendix.) We present our results in Table 3. On graphs with small number of nodes, the reinforcement learning with DQN and A3C sometimes converge to the optimal goal due to the small state size and random actions leading to the goal node in some of the cases. However, as before the MACN outperforms all other models. On map sizes larger than 36 nodes, performance of our network starts to degrade. Further, we observe that even though the agent outputs a wrong action at some times, it still manages to get to the goal in a reasonably small number of attempts. From these results, we can conclude that MACN can learn to plan in more general problems where the state space is not limited to two dimensions and the action space is not limited to four actions.
+
+![](images/1ea8afe17d0beebb2e804bd2078be3c08060e936a6c29f3087867893a2186dc2.jpg)  
+Figure 7: 9 Node Graph Search. Blue is start and Red is goal.
+
+# 3.4 CONTINUOUS CONTROL DOMAIN
+
+Learning how to navigate in unknown environments, where only some part of the environment is observable is a problem highly relevant in robotics. Traditional robotics solve this problem by creating and storing a representation of the entire environment. However, this can quickly get memory intensive. In this experiment we extend MACN to a SE2 robot. The SE2 notation implies that the robot is capable of translating in the x-y plane and has orientation. The robot has a differential drive controller that outputs continuous control values. The robot is spawned in the environment shown in Fig (8a). As before, the robot only sees a small part of the environment at any given time. In this case the robot has a laser scanner that is used to perceive the environment.
+
+Table 3: Performance on General Graph Search. Test error is not applicable for the reinforcement learning models A3C and DQN   
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=1 colspan=4>Test Error, Success(%)</td></tr><tr><td rowspan=1 colspan=1>9 Nodes</td><td rowspan=1 colspan=1>16 Nodes</td><td rowspan=1 colspan=1>25 Nodes</td><td rowspan=1 colspan=1>36 Nodes</td></tr><tr><td rowspan=1 colspan=1>VIN</td><td rowspan=1 colspan=1>0.57,23.39</td><td rowspan=1 colspan=1>0.61,14</td><td rowspan=1 colspan=1>0.68,0</td><td rowspan=1 colspan=1>0.71,0</td></tr><tr><td rowspan=1 colspan=1>A3C</td><td rowspan=1 colspan=1>NA,10</td><td rowspan=1 colspan=1>NA,7</td><td rowspan=1 colspan=1>NA,0</td><td rowspan=1 colspan=1>NA,0</td></tr><tr><td rowspan=1 colspan=1>DQN</td><td rowspan=1 colspan=1>NA,12</td><td rowspan=1 colspan=1>NA, 5.2</td><td rowspan=1 colspan=1>NA,0</td><td rowspan=1 colspan=1>NA,0</td></tr><tr><td rowspan=1 colspan=1>CNN + Memory</td><td rowspan=1 colspan=1>0.25, 81.5</td><td rowspan=1 colspan=1>0.32,63</td><td rowspan=1 colspan=1>0.56,19</td><td rowspan=1 colspan=1>0.68,9.7</td></tr><tr><td rowspan=1 colspan=1>MACN (LSTM)</td><td rowspan=1 colspan=1>0.14,98</td><td rowspan=1 colspan=1>0.19, 96.27</td><td rowspan=1 colspan=1>0.26, 84.33</td><td rowspan=1 colspan=1>0.29,78</td></tr><tr><td rowspan=1 colspan=1>MACN</td><td rowspan=1 colspan=1>0.1,100</td><td rowspan=1 colspan=1>0.18,100</td><td rowspan=1 colspan=1>0.22, 95.5</td><td rowspan=1 colspan=1>0.28, 89.4</td></tr></table>
+
+![](images/4ad0fe162f199d01c8c57ca698bdca67156078f239cd1a9496f6575f2e6a0103.jpg)  
+Figure 8: Navigation in a 3D environment on a continuous control robot. a) The robot is spawned in a 3d simulated environment. b) Only a small portion of the entire map is visible at any given point to the robot c) The green line denotes ground truth and red line indicates the output of MACN.
+
+It is easy to convert this environment to a 2D framework that the MACN needs. We fix the size of the environment to a $m \times n$ grid. This translates to a $m \times n$ matrix that is fed into the MACN. The parts of the map that lie within the range of the laser scanner are converted to obstacle free and obstacle occupied regions and added to the matrix. Lastly, an additional reward map denoting a high value for the goal location and zero elsewhere as explained before is appended to the matrix and fed into the MACN. The network output is used to generate way points that are sent to the underlying controller. The training set is generated by randomizing the spawn and goal locations and using a suitable heuristic. The performance is tested on a held out test set of start and goal locations. More experimental details are outlined in the appendix.
+
+Table 4: Performance on robot world   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Success (%)</td></tr><tr><td rowspan=1 colspan=1>DQN,A3C</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>VIN</td><td rowspan=1 colspan=1>57.60</td></tr><tr><td rowspan=1 colspan=1>CNN +Memory</td><td rowspan=1 colspan=1>59.74</td></tr><tr><td rowspan=1 colspan=1>MACN</td><td rowspan=1 colspan=1>71.3</td></tr></table>
+
+We observe in Table 4 that the proposed architecture is able to find its way to the goal a large number of times and its trajectory is close to the ground truth. This task is more complex than the grid world navigation due to the addition of orientation. The lack of explicit planning in the $\mathrm { C N N + 1 }$ Memory architecture hampers its ability to get to the goal in this task. In addition to this, as observed before deep reinforcement learning is unable to converge to the goal. We also report some additional results in Fig 9. In Fig 9a we show that MACN converges faster to the goal than other baselines.
+
+In addition to rate of convergence, one of the biggest advantages of MACN over other architectures, for a fixed memory size is its ability to scale up when the size of the environment increases. We show that MACN is able to beat other baselines when scaling up the environment. In this scenario, scaling up refers to placing the goal further away from the start position. While the success percentage gradually drops to a low value, it is observed that when the memory is increased accordingly, the success percentage increases again. Lastly, in Fig 10 we observe that in the robot world, the performance of MACN scales up to goal positions further away by adjusting the size of the external memory in the differentiable block accordingly.
+
+![](images/6bc2678923dc2e2dcb2688ff3f00c4b5d6b7152b8384204d77d458165f2d1c6d.jpg)  
+Figure 9: Performance on simulated environment. a) We report a plot of the number of steps left to the goal as the agent executes the learned policy in the environment (Lower is better). In this plot, the agent always starts at a position 40 steps away from the goal. b) The biggest advantage of MACN over other architectures is its ability to scale. We observe that as the distance to the goal increases, MACN still beats other baselines at computing a trajectory to the goal.(Higher success $\%$ is better)
+
+![](images/11ca49f3462a87d6fbce6fdd641e5efdd9ddc143c28071b47d81d42d72555a47.jpg)  
+Figure 10: Effect of Memory in Robot World MACN scales well to larger environments in the robot world when memory is increased suitably.
+
+In this section, we analyze the performance of the proposed network against traditional motion planning baselines. As stated before, for the grid world environments and the tunnel task, we obtain expert trajectories by running $A ^ { * }$ on the environment. In the case of the continuous control domain, we use the the Human Friendly Navigation (HFN) paradigm Guzzi et al. (2013) which uses a variant of $A ^ { * }$ along with a constraint for safe distances from obstacles to plan paths from start location to goal location. For the grid worlds (both with simple obstacles and local minima), we compute the ratio of path length predicted by network architecture to the path length computed by $A ^ { * }$ . Our results are presented in Table 5.
+
+The VIN alone is unable to reach the goal in a fixed number of steps. This behavior is consistent across all grid worlds. In the case of the tunnels, the VIN gets stuck inside the local minima and is unable to navigate to the goal. Thus, the ratio of path length produced by VIN to the path length produced by $A ^ { * }$ is infinite. In the case of the CNN+Memory, the network is able to navigate to the goal only when the grid world is small enough. In the case of the tunnels, the CNN+Memory learns to turn around at a fixed distance instead of exploring the tunnel all the way to the end. For example, when trained on tunnels of length 20 units and tested on tunnels of length 32 and 64 units, the CNN+Memory turns around after it has traversed 20 units in the tunnel. For this task, to demonstrate the ineffectiveness of the $\mathrm { C N N + N }$ Memory model, we placed the goal just inside the tunnel at the dead end. Thus, the ratio of path length produced by CNN+Memory to $A ^ { * }$ is $\infty$ since the agent never explored the tunnel all the way to the end. For the case of the MACN, we observe performance close to $A ^ { * }$ for the small worlds. The performance gets worse when the size of the grid world is increased. However, the dropoff for MACN with the DNC is lesser than that of the MACN with LSTM. For the tunnel world environment, both network architectures are successfully able to emulate the performance of $A ^ { * }$ and explore the tunnel all the way to the end.
+
+It is important to note here that $A ^ { * }$ is a model based approach and requires complete knowledge of the cost and other parameters such as the dynamics of the agent (transition probabilities). In addition, planners like $A ^ { * }$ require the user to explicitly construct a map as input, while MACN learns to construct a map to plan on which leads to more compact representations that only includes vital parts of the map (like the end of the tunnel in the grid world case). Our proposed method is a model free approach that learns
+
+1. A dynamics model of the agent,   
+2. A compact map representation,   
+3. How to plan on the learned model and map.
+
+This model free paradigm also allows us to move to different environments with a previously trained policy and be able to perform well by fine-tuning it to learn new features.
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=1 colspan=5>A* Ratio</td></tr><tr><td rowspan=1 colspan=1>G(16 ×16)</td><td rowspan=1 colspan=1>G(32 × 32)</td><td rowspan=1 colspan=1>G(64 × 64)</td><td rowspan=1 colspan=1>T(L =32)</td><td rowspan=1 colspan=1>T(L = 64)</td></tr><tr><td rowspan=1 colspan=1>VIN</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>8</td></tr><tr><td rowspan=1 colspan=1>CNN +Memory</td><td rowspan=1 colspan=1>1.43</td><td rowspan=1 colspan=1>2.86</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>8</td></tr><tr><td rowspan=1 colspan=1>MACN (LSTM)</td><td rowspan=1 colspan=1>1.2</td><td rowspan=1 colspan=1>1.4</td><td rowspan=1 colspan=1>1.62</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td></tr><tr><td rowspan=1 colspan=1>MACN</td><td rowspan=1 colspan=1>1.07</td><td rowspan=1 colspan=1>1.11</td><td rowspan=1 colspan=1>1.47</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td></tr></table>
+
+Table 5: Comparison to $A ^ { * }$ . G corresponds to grid world with simple obstacles with the size of the world specified inside the parenthesis. L corresponds to grid worlds with local minima/tunnels with the length of the tunnel specified inside the parenthesis. All ratios are computed during testing. For the worlds with tunnels, the network is trained on tunnels of length 20 units.
+
+# 4 RELATED WORK
+
+Using value iteration networks augmented with memory has been explored before in (Gupta et al., 2017). In their work a planning module together with a map representation of a robot’s free space is used for navigation in a partially observable environment using image scans. The image scans are projected into a 2D grid world by approximating all possible robot poses. This projection is also learned by the model. This is in contrast to our work here in which we design a general memory based network that can be used for any partially observed planning problem. An additional difference between our work and that of (Gupta et al., 2017) is that we do not attempt to build a 2D map of the environment as this hampers the ability of the network to be applied to environments that cannot be projected into such a 2D environment. We instead focusing on learning a belief over the environment and storing this belief in the differentiable memory. Another similar work is that of (Oh et al., 2016) where a network is designed to play Minecraft. The game environment is projected into a 2D grid world and the agent is trained by RL to navigate to the goal. That network architecture uses a CNN to extract high level features followed by a differentiable memory scheme. This is in contrast to our paper where we approach this planning by splitting the problem into local and global planning. Using differential network schemes with CNNs for feature extraction has also been explored in (Chen et al., 2017). Lastly, a recently released paper Neural SLAM (Zhang et al., 2017) uses the soft attention based addressing in DNC to mimic subroutines of simultaneous localization and mapping. This approach helps in exploring the environment robustly when compared to other traditional methods. A possible extension of our work presented here, is to use this modified memory scheme with the differentiable planner to learn optimal paths in addition to efficient exploration. We leave this for future work.
+
+# 5 CONCLUSION
+
+Planning in environments that are partially observable and have sparse rewards with deep learning has not received a lot of attention. Also, the ability of policies learned with deep RL to generalize to new environments is often not investigated. In this work we take a step toward designing architectures that compute optimal policies even when the rewards are sparse, and thoroughly investigate the generalization power of the learned policy. In addition we show our network is able to scale well to large dimensional spaces.
+
+The grid world experiments offer conclusive evidence about the ability of our network to learn how to plan in such environments. We address the concern of oversimplifying our environment to a 2D grid world by experimenting with planning in a graph with no constraint on the state space or the action space. We also show our model is capable of learning how to plan under continuous control. In the future, we intend to extend our policies trained in simulation to a real world platform such as a robot learning to plan in partially observable environments. Additionally, in our work we use simple perfect sensors and do not take into account sensor effects such as occlusion, noise which could aversely affect performance of the agent. This need for perfect labeling is currently a limitation of our work and as such cannot be applied directly to a scenario where a sensor cannot provide direct information about nearby states such as a RGB camera. We intend to explore this problem space in the future, where one might have to learn sensor models in addition to learning how to plan.
+
+# ACKNOWLEDGEMENT
+
+We gratefully acknowledge the support of ARL grants W911NF-08-2-0004 and W911NF-10-2-0016, ARO grant W911NF-13-1-0350, ONR grants N00014-07-1-0829, N00014-14-1-0510, DARPA grant HR001151626/HR0011516850 and DARPA HR0011-15-C-0100, USDA grant 2015-67021-23857 NSF grants IIS-1138847, IIS-1426840, CNS-1446592, CNS-1521617, and IIS-1328805. Clark Zhang is supported by the National Science Foundation Graduate Research Fellowship Program under Grant No. DGE-1321851. The authors would like to thank Anand Rajaraman, Steven Chen, Jnaneswar Das, Ekaterina Tolstoya and others at the GRASP lab for interesting discussions related to this paper.
+
+# REFERENCES
+
+Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th annual international conference on machine learning, pp. 41–48. ACM, 2009.
+
+Yevgen Chebotar, Karol Hausman, Zhe Su, Gaurav S Sukhatme, and Stefan Schaal. Self-supervised regrasping using spatio-temporal tactile features and reinforcement learning. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on, pp. 1960–1966. IEEE, 2016.
+
+Steven W Chen, Nikolay Atanasov, Arbaaz Khan, Konstantinos Karydis, Daniel D Lee, and Vijay Kumar. Neural network memory architectures for autonomous robot navigation. arXiv preprint arXiv:1705.08049, 2017.
+
+Shreyansh Daftry, J Andrew Bagnell, and Martial Hebert. Learning transferable policies for monocular reactive mav control. In International Symposium on Experimental Robotics, pp. 3–11. Springer, 2016.
+
+Alessandro Giusti, Jérôme Guzzi, Dan C Cire¸san, Fang-Lin He, Juan P Rodríguez, Flavio Fontana, Matthias Faessler, Christian Forster, Jürgen Schmidhuber, Gianni Di Caro, et al. A machine learning approach to visual perception of forest trails for mobile robots. IEEE Robotics and Automation Letters, 1(2):661–667, 2016.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, et al. ´ Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626): 471–476, 2016.
+
+Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. arXiv preprint arXiv:1702.03920, 2017.
+
+Jérôme Guzzi, Alessandro Giusti, Luca M Gambardella, Guy Theraulaz, and Gianni A Di Caro. Human-friendly robot navigation in dynamic environments. In Robotics and Automation (ICRA), 2013 IEEE International Conference on, pp. 423–430. IEEE, 2013.
+
+Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random-access machines. arXiv preprint arXiv:1511.06392, 2015.
+
+Alex X Lee, Sergey Levine, and Pieter Abbeel. Learning visual servoing with deep features and fitted q-iteration. arXiv preprint arXiv:1703.11000, 2017.
+
+Sergey Levine. Exploring deep and recurrent architectures for optimal control. arXiv preprint arXiv:1311.1761, 2013.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. arXiv preprint arXiv:1504.00702, 2015.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013a.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013b.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.
+
+Junhyuk Oh, Valliappa Chockalingam, Satinder Singh, and Honglak Lee. Control of memory, active perception, and action in minecraft. arXiv preprint arXiv:1605.09128, 2016.
+
+Emilio Parisotto and Ruslan Salakhutdinov. Neural map: Structured memory for deep reinforcement learning. arXiv preprint arXiv:1702.08360, 2017.
+
+Stuart J. Russell and Peter Norvig. Artificial Intelligence: A Modern Approach. Pearson Education, 2 edition, 2003. ISBN 0137903952.   
+Hava T Siegelmann and Eduardo D Sontag. On the computational power of neural nets. Journal of computer and system sciences, 50(1):132–150, 1995.   
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.   
+Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.   
+Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. In Advances in Neural Information Processing Systems, pp. 2154–2162, 2016.   
+Sebastian Thrun and John J Leonard. Simultaneous localization and mapping. In Springer handbook of robotics, pp. 871–889. Springer, 2008.   
+Jingwei Zhang, Lei Tai, Joschka Boedecker, Wolfram Burgard, and Ming Liu. Neural slam. arXiv preprint arXiv:1706.09520, 2017.   
+Marvin Zhang, Zoe McCarthy, Chelsea Finn, Sergey Levine, and Pieter Abbeel. Learning deep neural network policies with continuous memory states. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pp. 520–527. IEEE, 2016a.   
+Tianhao Zhang, Gregory Kahn, Sergey Levine, and Pieter Abbeel. Learning deep control policies for autonomous aerial vehicles with mpc-guided policy search. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pp. 528–535. IEEE, 2016b.
+
+# APPENDIX
+
+# A GRID WORLD EXPERIMENTS
+
+For the grid world we define our sensor to be a $7 \times 7$ patch with the agent at the center of this patch. Our input image $I$ to the VI module is $[ m \times n \times 2 ]$ image where $^ { m , n }$ are the height and width of the image. $I [ : , : , 0 ]$ is the sensor input. Since we set our rewards to be sparse, $I [ : , : , 1 ]$ is the reward map and is zero everywhere except at the goal position $( m _ { g o a l } , n _ { g o a l } )$ . $I$ is first convolved to obtain a reward image $R$ of dimension $[ n \times m \times u ]$ where $u$ is the number of hidden units (vary between 100-150). This reward image is sent to the VI module. The value maps from the VI module after K iterations are fed into the memory network controller. The output from the network controller (here a LSTM with 256 hidden units) and the access module is concatenated and sent through a linear layer followed by a soft max to get a probability distribution over $\mathcal { A }$ .
+
+During training and testing we roll out our sequence state by state based on the ground truth or the networks output respectively. Further, the set of transitions from start to goal to are considered to be an episode. During training at the end of each episode the internal state of the controller and the memory is cleared. The size of the external memory is $3 2 \times 8$ the grid world task. An additional hyperparameter is the number of read heads and write heads. This parameter controls the frequency of reads vs frequency of writes. For the the grid world task, we fix the number of read heads to 4 and the number of write heads to 1. For the grid world with simple obstacles, we observe that the MACN performs better when trained with curriculum (Bengio et al., 2009). This is expected since both the original VIN paper and the DNC paper show that better results are achieved when trained with curriculum. For establishing baselines, the VIN and the $\mathrm { C N N + I }$ Memory models are also trained with curriculum learning. In the grid world environment it is easy to define tasks that are harder than other tasks to aid with curriculum training. For a grid world with size $( m , n )$ we increase the difficulty of the task by increasing the number of obstacles and the maximum size of the obstacles. Thus, for a $3 2 \times 3 2$ grid, we start with a maximum of 2 obstacles and the maximum size being $2 \times 2$ Both parameters are then increased gradually. The optimal action in the grid world experiments is generated by A star (Russell & Norvig, 2003). We use the Manhattan distance between our current position and the goal as a heuristic. Our error curves on the test set for the MACN with the LSTM and the addressable memory scheme are shown in Figure 11.
+
+![](images/4472d4c40800bc1539cdbc988708bd0a24bbebf8b2d30640731ae2181ed01676.jpg)  
+Figure 11: Testing Error on grid world $( 3 2 \mathbf { x } 3 2 )$
+
+# B ENVIRONMENTS WITH TUNNELS
+
+We setup the network the same way as we did for the grid world experiments with blob shaped obstacles. Due to the relatively simple structure of the environment, we observe that we do not really need to train our networks with curriculum. Additionally, the read and write heads are both set to 1 for this experiment.
+
+# B.1 VI MODULE $^ +$ PARTIAL MAPS
+
+We observe that for the tunnel shaped obstacle when just the VI module is fed the partial map (stitched together version of states explored) as opposed to the sensor input, it performs extremely well and is able to generalize to new maps with longer tunnels without needing any memory. This is interesting because it proves our intuition about the planning task needing memory. Ideally we would like the network to learn this partial map on its own instead of providing it with a hand engineered version of it. The partial map represents an account of all states visited in the past. We argue that not all information from the past is necessary and the non redundant information that is required for planning in the global environment can be learned by the network. This can be seen in the memory ablation.
+
+# B.2 DQN
+
+As stated in the main paper, we observe that the DQN performs very poorly since the rewards are very sparse. The network is setup exactly as described in (Mnih et al., 2013a). We observe that even after 1 million iterations, the agent never reaches the goal and instead converges to a bad policy. This can be seen in Figure 12. It is clear that under the random initial policy the agent is unable to reach the goal and converged to a bad policy. Similar results are observed for A3C. Further, it is observed that even when the partial map instead of the sensor input is fed in to DQN, the agent does not converge.
+
+![](images/17585b51eac20c6796da9b58476bea037f3c707bcfb6e1863874c123fbaf2418.jpg)  
+Figure 12: Learning optimal policy with Deep Q networks. In this case the input to the DQN is the sensor input. State after 1 million iterations. The agent gets stuck along the wall (left wall between 40 and 50)
+
+# B.3 VISUALIZING THE MEMORY STATE
+
+For the tunnel task, we use an external memory with 32 rows $N = 3 2$ ) and a word size of 8 $( W = 8 )$ ). We observe that when testing the network, the memory registers a change in its states only when important events are observed. In Figure 11, the left hand image represents the activations from the memory when the agent is going into the tunnel. We observe that the activations from the memory remain constant until the agent observes the end of the tunnel. The memory states change when the agent observes the end of the tunnel, when it exits the tunnel and when it turns towards its goal (Figure 13). Another key observation for this task is that the MACN is prone to over fitting for this task. This is expected because ideally, only three states need to be stored in the memory; entered the tunnel, observe end of tunnel and exit tunnel. To avoid overfitting we add L2 regularization to our memory access weights.
+
+![](images/ce787799f0116462d8eec9c8007626739a51ed290ac608625b29ef8337ad9cd8.jpg)  
+Figure 13: Shift in memory states just before and after the end of the tunnel is observed. Once the agent has turned around, the memory state stays constant till it reaches the end of the tunnel.
+
+# C GRAPH EXPERIMENTS
+
+For the graph experiment, we generate a random connected undirected graph with $N$ nodes. We will call this graph $G = ( V , E )$ , with nodes $V = \{ V _ { 1 } , V _ { 2 } , \dots , V _ { N } \}$ and edges, $E$ . The agent, at any point in the simulation, is located at a specific node $V _ { i }$ and travels between nodes via the edges. The agent can take actions from a set $U = \{ u _ { 1 } , u _ { 2 } , \dots , u _ { N } \}$ where choosing action $u _ { i }$ will attempt to move to node $V _ { i }$ . We have transition probabilities
+
+$$
+p ( V _ { j } | V _ { i } , u _ { k } ) = { \left\{ \begin{array} { l l } { 0 , { \mathrm { i f ~ } } k \neq j { \mathrm { ~ o r ~ } } ( V _ { i } , V _ { j } ) \notin E } \\ { 1 , { \mathrm { i f ~ } } k = j { \mathrm { ~ a n d ~ } } ( V _ { i } , V _ { j } ) \in E } \end{array} \right. }
+$$
+
+At each node, the agent has access to the unique node number (all nodes are labeled with a unique ID), as well as the $( A ) _ { i }$ , the $i ^ { t h }$ row of the adjacency matrix $A$ . It also has access to the unique node number of the goal (but no additional information about the goal).
+
+![](images/4852689c17c701cc752a3ef96e0c9bcbf35bd339e488d01056872adbeb5f6544.jpg)  
+Figure 14: a) A random connected undirected graph with a the goal given by the star-shaped node, and the current state given by the blue node b) Shows the corresponding adjacency matrix where white indicates a connection and black indicates no connection. The goal is given by the row shaded in green, and the current state is given by the row shaded in blue.
+
+To train the network to navigate this graph, we used supervised training with an expert demonstrating an intended behavior (breadth first search). Training samples were generated by running breadth first search (and connecting nodes that are explored by traveling previously explored nodes of the graph). Thus, for each state of the node and goal, we obtain a desired action. To fit this into the framework of our network and 2D convolutions, we reshaped the row vector of the matrix into a matrix that could use the same convolution operation. The reward prior is also a row vector with a 1 at the index of the goal node and zero everywhere else. This row vector is reshaped and stacked with the observation. We train the graph by giving example paths between pairs of nodes. We then test on pairs of nodes not shown during training. The training network is setup as before in the grid world navigation task. Due to the increased action space and state space, this task is significantly more complex than the grid world navigation task. We train MACN and the baselines with curriculum training. In the graph task it is easy to define a measure of increasing complexity by changing the number of hops between the start state and the goal state. Additionally, for the graph task the number of read heads and write heads are set to 1 and 4 respectively.
+
+# D CONTINUOUS CONTROL
+
+Navigating an unknown environment is a highly relevant problem in robotics. The traditional methodology localizes the position of the robot in the unknown world and tries to estimate a map. This approach is called Simultaneous Localization and Mapping (SLAM) and has been explored in depth in robotics (Thrun & Leonard, 2008). For the continuous control experiment, we use a differential drive robot (Figure 15). The robot is equipped with a head mounted LIDAR and also has a ASUS Xtion Pro that can provide the depth as well as the image from the front facing camera. In this work, we only use the information from the LIDAR and leave the idea of using data from the camera for future work. The ground truth maps are generated by using
+
+![](images/d51604872fa573f316ed92fe67acdc770f43ebc00ae156998464931fed943a99.jpg)  
+Figure 15: Simulated ground robot
+
+Human Friendly Navigation (HFN) (Guzzi et al., 2013) which generates reactive collision avoidance paths to the goal. Given a start and goal position, the HFN algorithm generates way points that are sent to the controller. For our experiment, we generate a tuple of $( x , y , \theta )$ associated with every observation. To train the network, a $m \times n$ matrix (environment matrix) corresponding to the $m \times n$ environment is initialized. A corresponding reward array (reward matrix) also of size $m \times n$ with a 1 at the goal position and zero elsewhere is concatenated with the environment matrix. The observations corresponding to the laser scan are converted to a $j \times k$ matrix (observation matrix) where $j < m$ and $k < n$ . The values at the indices in the environment array corresponding to the local observation are updated with the values from the observation matrix. At every iteration, the environment matrix is reset to zero to ensure that the MACN only has access to the partially observable environment.
+
+For the continuous world we define our observation to be a $1 0 \times 1 0$ matrix with the agent at the bottom of this patch. We change our formulation in the previous cases where our agent was at the center since the LIDAR only has a 270 degree field of view and the environment behind the robot is not observed. Our input image $I$ to the VI module is $[ m \times n \times 2 ]$ image where $m = 2 0 0 , n = 2 0 0$ are the height and width of the environment. $I [ : , : , 0 ]$ is the sensor input. $I$ is first convolved to obtain a reward image $R$ of dimension $[ n \times m \times u ]$ where $u$ is the number of hidden units (200 in this case). The K (parameter corresponding to number of iterations of value iteration) here is 40. The network controller is a LSTM with 512 hidden units and the external memory has 1024 rows and a word size of 512. We use 16 write heads and 4 read heads in the access module. The output from the access module is concatenated with the output from the LSTM controller and sent through a linear layer followed by a soft max to get probability distributions for $( x , y , \theta )$ . We sample from these distributions to get the next waypoint. These way points are then sent to the controller. The waypoints are clipped to ensure that the robot takes incremental steps.
+
+For this task, we find that the performance increases when trained by curriculum training. MACN in addition to the baselines is first trained on maps where the goal is close and later trained on maps where the goal is further away. An additional point here, is that due to the complexity of the task, we train and test on the same map. Maps in the train set and test set differ by having random start and goal regions.

parse/train/KCd-3Pz8VjM/KCd-3Pz8VjM.md

@@ -0,0 +1,305 @@
+# Automatic Unsupervised Outlier Model Selection
+
+Yue Zhao Carnegie Mellon University zhaoy@cmu.edu
+
+Ryan A. Rossi Adobe Research ryrossi@adobe.com
+
+Leman Akoglu Carnegie Mellon University lakoglu@andrew.cmu.edu
+
+# Abstract
+
+Given an unsupervised outlier detection task on a new dataset, how can we automatically select a good outlier detection algorithm and its hyperparameter(s) (collectively called a model)? In this work, we tackle the unsupervised outlier model selection (UOMS) problem, and propose METAOD, a principled, data-driven approach to UOMS based on meta-learning. The UOMS problem is notoriously challenging, as compared to model selection for classification and clustering, since (i) model evaluation is infeasible due to the lack of hold-out data with labels, and $( i i )$ model comparison is infeasible due to the lack of a universal objective function. METAOD capitalizes on the performances of a large body of detection models on historical outlier detection benchmark datasets, and carries over this prior experience to automatically select an effective model to be employed on a new dataset without any labels, model evaluations or model comparisons. To capture task similarity within our meta-learning framework, we introduce specialized metafeatures that quantify outlying characteristics of a dataset. Extensive experiments show that selecting a model by METAOD significantly outperforms no model selection (e.g. always using the same popular model or the ensemble of many) as well as other meta-learning techniques that we tailored for UOMS. Moreover upon (meta-)training, METAOD is extremely efficient at test time; selecting from a large pool of $3 0 0 +$ models takes less than 1 second for a new task. We open-source1 METAOD and our meta-learning database for practical use and to foster further research on the UOMS problem.
+
+# 1 Introduction
+
+The lack of a universal learning model that performs well on all problem instances is well recognized [53]. Therefore, effort has been directed toward building a toolbox of various models and algorithms, which has given rise to the problem of algorithm selection and hyperparameter tuning (i.e., model selection). The same problem applies to outlier detection (OD); a long list of detectors has been developed in the last decades [2], with no universal “winners” [8].
+
+In supervised learning, model selection can be done via performance evaluation of each trained model on labeled hold-out data. In contrast, unsupervised OD does not have access to any labels, nor is there a universal objective function that could guide model selection (cf. clustering where a loss function enables model comparison). Unsupervised model selection for OD is challenging exactly because both model evaluation and comparison are not feasible—which renders any trial-and-error techniques like grid search or iterative strategies like Bayesian hyperparameter optimization [57] inapplicable. Consequently, there has been no principled work on unsupervised outlier model selection—rather, the choice of a model for a new task (or dataset) remains “a black art”. A typical approach is to use popular OD algorithms, like LOF [6] and iForest [31] (often with default hyperparameters) which are shown to be competitive on average on many benchmark datasets. However, as noted earlier, none of these methods can universally outperform others on all tasks [8]. We argue that model selection is exactly how one can “break the performance ceiling” for OD.
+
+In this work, we tackle the unsupervised outlier model selection (UOMS) problem systematically. To that end, we introduce (to the best of our knowledge) the first UOMS approach that selects an effective model to be employed on a new detection task without any model evaluation (using labels) or model comparison (via loss criteria). Our proposed method, called METAOD, is based on meta-learning, and stands on the prior performances of a large collection of existing detection models on an extensive corpora of historical outlier detection benchmark datasets. In a nutshell, the idea is to estimate a candidate model’s performance on the new task (with no labels) based on its prior performance on similar historical tasks. We remark that METAOD is strictly a model selection technique – that picks one model (a detector and its associated hyperparameter(s)) from a pool of (existing) candidate models – and not yet-another outlier detection algorithm itself.
+
+In leveraging meta-learning, we establish a connection between the UOMS problem and the cold-start problem in collaborative filtering (CF), where the new task in UOMS is akin to a new user in CF (with no available evaluations, hence cold-start) and the model space is analogous to the item-set. Differently, OD necessitates the identification of a single best model (i.e., top-1 rank), whereas CF typically operates in a top- $k$ setting. In CF, future recommendations can be improved based on user feedback which is not applicable to OD. Moreover, METAOD requires the effective learning of task similarities based on characteristic dataset features (namely, meta-features) that capture the outlying properties within a dataset, whereas user features (location, age, etc.) in CF may be readily available.
+
+In summary, the key contributions of this work include the following:
+
+• First Approach to Unsupervised Outlier Model Selection: We propose METAOD, (to our knowledge) the first effort on unsupervised model selection for OD tasks. Notably, given a new dataset (i.e., at test time), it does not rely on any ground-truth labels for model evaluation or any loss or heuristic criterion for model comparison. METAOD stands on meta-learning in principle, and historical collections of outlier models and benchmark datasets in practice.
+
+• Problem Formulation: We establish a correspondence between UOMS and CF under cold-start, where the new task “better likes” a model that performs better on similar historical tasks.
+
+• Specialized Meta-features: We design novel meta-features to capture the outlying characteristics in a dataset toward effectively quantifying task similarity specifically among OD tasks.
+
+• Effectiveness and Efficiency: Through extensive experiments on two benchmark testbeds that we have constructed, we show that selecting a model by METAOD for each given task significantly outperforms always using a popular model like iForest, as well as other possible meta-learning approaches that we tailored for UOMS. Moreover, METAOD incurs negligible run-time overhead ( $\cdot < 1$ second) at test time.
+
+• Open-source Platform: We open-source1 METAOD and our meta-learning database for the community to use it for UOMS in practice, and to extend it with new datasets and models. We expect the growth of the database would make meta-learning based approaches, like METAOD, more powerful and also help foster further research on this new direction to an important problem.
+
+# 2 Related Work
+
+# 2.1 Model Selection for Outlier Detection (OD)
+
+Most outlier mining work have focused on developing new, better methods for detection on different types of data [2]. In comparison, there are only a few work on the outlier model selection problem –which detector and hyperparameter(s) to use on a new task– all of which require some labeled data. Recent work include AutoOD [29] that focuses on automatic neural architecture search, however, it is limited to deep autoencoder based detection, and more importantly it relies on hold-out labeled data for evaluation. Similarly, PyODDS [30] and TODS [25] both require ground truth labels.
+
+To our knowledge, there is no existing work on the general unsupervised outlier model selection (UOMS) problem, which is considerably more challenging, as (1) model evaluation is infeasible due to the lack of any ground truth labels, and (2) model comparison of different heterogeneous detectors is infeasible due to the lack of a universal OD loss function.
+
+We note that some OD methods do have a loss function; e.g. auto-encoders [9, 63] aim to minimize reconstruction error for modeling the inliers, and one-class classification (OCSVM [38], SVDD [46], etc.) aims to maximize margin to the origin or minimize the radius of a data-enclosing hyperball. There is also work on model selection for one-class models [7, 54], however, those are limited to this specific family of methods and do not apply in the general case. Our proposed METAOD is not limited to one specific model family, but can select among any (heterogeneous) set of detectors.
+
+# 2.2 Model Selection in ML, AutoML, Meta-Learning
+
+Model selection refers to the process of algorithm selection and/or hyperparameter optimization (HO). With the advent of complex (e.g. deep) models, HO in high dimensions has become impractical to be human-powered [59]. As such, automating ML pipelines has seen a surge of attention [18]. Meta-learning has been a key contributor to the AutoML effort [41, 49, 58].
+
+Supervised Model Selection: Most existing work focus on the supervised setting, and use hold-out data with labels. Randomized [3], bandit-based [27], and Bayesian optimization (BO) techniques [40] are various state-of-the-art (SOTA) approaches to HO. Specifically sequential model-based BO [19, 22] evaluates hold-out performance at various initial hyperparameter configurations (HC), where a (smooth) surrogate function is fit to the resulting $\langle \mathrm { H C }$ , performancei pairs, which is then used to strategically query other HCs, e.g., via hyper-gradient based search [15]. Meta-learning has also been employed [13, 52], e.g., to find promising initialization for (i.e. warm-starting) BO [14, 51].
+
+Note that all of these approaches rely on multiple model evaluations (i.e., performance queries) for various HCs, and hence cannot be applied to the unsupervised outlier model selection problem.
+
+Unsupervised Model Selection: Unsupervised ML tasks (e.g., clustering) poses additional challenges for model selection [12, 47]. Nonetheless, those exhibit established objective criteria that enable model comparison, unlike OD. For example, BO methods still apply where the surrogate can be trained on hHC, objective valuei pairs, for which meta-learning can provide favorable priors.
+
+Task-independent meta-learning [1], that simply identifies the globally best model on historical tasks, applies to the unsupervised setting and hence OD. This can be refined by identifying the best model on not all, but similar tasks, where task similarity is measured in the meta-feature space via clustering [23] or nearest neighbors [33]. This type of similarity-based recommendations points to a connection between algorithm selection and collaborative filtering (CF), first recognized by Stern et al. [44]. The most related to UOMS is CF under cold start, where evaluations are not-available (in our case, infeasible) for a new user (in our case, task). There have been a number of work using meta-learning for the cold-start recommendation problem [4, 26, 50], and vice versa, using CF solutions for ML algorithm selection [32, 56]. We tailor these to UOMS and compare to METAOD in the experiments.
+
+# 3 Unsupervised Outlier Model Selection via Meta-learning
+
+# 3.1 Problem Statement
+
+We consider the model selection problem for unsupervised outlier detection, which we refer to as UOMS (unsupervised outlier model selection) hereafter. Given a new dataset, without any labels, the problem is to select both (i) a detector/algorithm and $( i i )$ its associated hyperparameter(s) (HP). The former is a discrete choice, given the finite set of existing detection algorithms. The latter is continuous, and hence induces infinitely many candidate models.
+
+Under certain assumptions, such as performance changing smoothly in the HP space, a HP configuration can be selected iteratively based on evaluations on several other carefully-chosen configurations. Importantly however, OD is not amenable for such iterative search over models—evaluations are not possible due to the lack of labels and absence of a universal objective criterion. The selection of a model, therefore, is to be done without building or evaluating any model on the new dataset. Given this constraint, we discretize the HP space for each candidate detector to make the search space tractable, which induces a finite pool of models denoted $\pmb { \mathcal { M } } = \{ M _ { 1 } , \dots , M _ { m } \}$ . Each model $M \in \mathcal { M }$ can be seen as a $\{$ {detector, configuration $\}$ pair, where the configuration depicts a specific set of values for the detector’s HP(s). (See Appendix A for details.) Then, the UOMS problem is stated as follows:
+
+Problem 1 (Unsupervised Outlier Model Selection (UOMS)) Given a new input dataset (i.e., detection task) $\mathbf { D } _ { t e s t } \bar { = } \left( \mathbf { X } _ { t e s t } \right)$ without any labels, Select a model $M \in \mathcal { M }$ to employ on $\mathbf { X } _ { t e s t }$ .
+
+# 3.2 Proposed METAOD
+
+In this work we consider the UOMS problem and propose a meta-learning based solution, leveraging past experience on historical detection tasks. As such, our METAOD relies on
+
+• a collection of historical outlier detection datasets $\mathbf { \mathcal { D } } _ { \mathrm { t r a i n } } = \{ \mathbf { D } _ { 1 } , \dots , \mathbf { D } _ { n } \}$ , namely, a meta-train   
+database with ground truth labels, i.e., $\{ \mathbf { D } _ { i } = ( \mathbf { X } _ { i } , \mathbf { y } _ { i } ) \} _ { i = 1 } ^ { n }$ , and   
+• the historical performances of the pool of candidate models, $\mathbf { \mathcal { M } }$ , on the meta-train datasets. We denote by $\mathbf { P } \in \mathbb { R } ^ { n \times m }$ the performance matrix, where $\mathbf { P } _ { i j }$ corresponds to the $j$ -th model $M _ { j }$ ’s performance2 on the $i$ -th meta-train dataset $\mathbf { D } _ { i }$ .
+
+Note that model performance can be evaluated on the historical meta-train datasets as they contain ground truth labels, which however is not the case for any newcoming task at test time.
+
+Our METAOD consists of two-phases: offline (meta-)training of the meta-learner on $\pmb { \mathcal { D } } _ { \mathrm { t r a i n } }$ , and online prediction that enables unsupervised model selection at test time for $\mathbf { D _ { \mathrm { t e s t } } }$ . Arguably, the running time of the offline phase is not critical. In contrast, model selection for a newcoming task should incur small run-time overhead, as it precedes the actual building of the selected OD model. Fig. 1 summarizes the process and the major components of METAOD, where we highlight the components transferred from offline (meta-learning) to online stage (model selection) in blue. We also provide the detailed steps of METAOD in pseudo-code, for both meta-training (offline) and model selection (online), in Appendix D Algo. 1.
+
+# 3.2.1 (Meta-)Training (Offline)
+
+In principle, meta-learning carries over prior experience on a set of historical tasks to “do better” on a new task. Such improvement can be unlocked only if the new task resembles and thus can build on at least some of the historical tasks (such as learning ice-skating given prior experience with roller-blading), rather than representing completely unrelated phenomena. This entails defining an effective way to capture task similarity between an input task and the historical tasks at hand.
+
+In machine learning, similarity between meta-train and test datasets are quantified through characteristic features of a dataset, also known as meta-features. Those typically capture statistical properties of the data distributions. (See survey [49] for various types of meta-features.)
+
+To capture prior experience, METAOD first constructs the performance matrix $\mathbf { P }$ by running/building and evaluating all the $m$ models in our defined model space $\mathbf { \mathcal { M } }$ on all the $n$ meta-train datasets $\mathcal { D } _ { \mathrm { t r a i n } }$ .3 To capture task similarity, it then extracts a set of $d$ meta-features from each meta-train dataset, denoted by $\mathbf { M } = \psi ( \{ \mathbf { X } _ { 1 } ^ { \cdot } , \dots , \mathbf { X } _ { n } \} ) \in \mathbb { R } ^ { n \times d }$ where $\psi ( \cdot )$ depicts the feature extraction module. We defer the details on the meta-feature specifics to $\ S 3 . 3$ .
+
+At this stage, it is easy to recognize the connection between the UOMS and the collaborative filtering (CF) under cold start problems. Simply put, meta-train datasets are akin to existing users in CF that have prior evaluations on a set of models that are akin to the item-set in CF. The test task is akin to a newcoming user with no prior evaluations (and in our case, no possible future evaluation either), which however exhibits some pre-defined features.
+
+Capitalizing on this connection, we take a matrix factorization based approach where $\mathbf { P }$ is approximated by the dot product of what-we-call dataset matrix $\mathbf { U } \in \mathbb { R } ^ { n \times k }$ and model matrix $\mathbf { V } \in \mathbf { \hat { \mathbb { R } } } ^ { m \times k }$ The intent is to capture the inherent dataset-to-model affinity via the dot product similarity in the $k$ -dimensional latent space, such that $\mathbf { P } _ { i j } \approx \mathbf { U } _ { i } \mathbf { V } _ { j } ^ { \ T }$ where matrix subscript denotes the row.
+
+What loss criterion is suitable for the factorization? In CF the typical goal is top- $k$ item recommendation. In METAOD, we aim to select the model with the best performance on a task which demands top-1 optimization. Therefore, we discard least squares and instead optimize the rank-based (row- or dataset-wise) discounted cumulative gain (DCG) [21],
+
+$$
+\operatorname* { m a x } _ { { \bf U } , { \bf V } } \ \sum _ { i = 1 } ^ { n } \mathrm { D C G } _ { i } ( { \bf P } _ { i } , { \bf U } _ { i } { \bf V } ^ { T } ) \ .
+$$
+
+The factorization is solved via alternating optimization, where initialization plays an important role for such non-convex problems. We find that initializing $\mathbf { U }$ , denoted $\mathbf { U } ^ { ( 0 ) }$ , based on meta-features facilitates stable training, potentially by hinting at inherent similarities among datasets as compared to random initialization. Specifically, an embedding function $\phi ( \cdot )$ is used to set $\mathbf { U } ^ { ( 0 ) } : = \phi ( \mathbf { M } )$ for $\phi : \mathbb { R } ^ { d } \mapsto \mathbb { R } ^ { k }$ , $k < d$ . Details on objective criteria and optimization are deferred to $\ S 3 . 4$ .
+
+By construction, matrix factorization is transductive. On the other hand, we would need $\mathbf { U } _ { \mathrm { t e s t } }$ to be able to estimate performances of the model set $\mathbf { \mathcal { M } }$ on a new dataset $\mathbf { X } _ { \mathrm { t e s t } }$ . To this end, one can learn an (inductive) multi-output regression model that maps the meta-features onto the latent features. We simplify by learning a regression function $f : \mathbb { R } ^ { \dot { k } } \mapsto \mathbb { R } ^ { k }$ that maps the (lower dimensional) embedding features $\phi ( \mathbf { M } )$ (which are also used to initialize U) onto the final optimized U. Note that this requires an inductive embedding function $\phi ( \cdot )$ to be applicable to newcoming datasets. In implementation, we use PCA for $\phi ( \cdot )$ and a random forest regressor for $f ( \cdot )$ although METAOD is flexible to accommodate any others provided they are inductive.
+
+Remark: METAOD improves over the existing methods that use CF in machine learning model selection (see $\ S 2 . 2 )$ in two aspects. First, METAOD builds specialized landmarker features tailored for capturing outlying characteristics of a dataset, while the existing ML model selection mainly uses generic statistical features (see $\ S 3 . 3 )$ . Second, METAOD uses a customized (backpropagatable/smooth) rank-based loss in CF for more effective top-1 optimization (see $\ S 3 . 4$ ), while existing approaches mainly leverage mean squared loss (MSE).
+
+# 3.2.2 Prediction for Unsupervised Model Selection (Online)
+
+Meta-training stage yields the estimated functions $\psi ( \cdot ) , \phi ( \cdot )$ , and $f ( \cdot )$ as well as the model matrix $\mathbf { V } \in \mathbb { R } ^ { m \times k }$ , which we save for test time (See Fig. 1). Given a new dataset $\mathbf { X } _ { \mathrm { t e s t } }$ for OD, METAOD first computes the corresponding meta-features as $\mathbf { \bar { M } } _ { \mathrm { t e s t } } : = \psi ( \mathbf { X } _ { \mathrm { t e s t } } ) \in \mathbb { R } ^ { d }$ . Those are then embedded via $\phi ( \mathbf { M } _ { \mathrm { t e s t } } ) \in \mathbb { R } ^ { k }$ , which are regressed to obtain the latent features, i.e., $\mathbf { U } _ { \mathrm { t e s t } } : = f ( \phi ( \mathbf { M } _ { \mathrm { t e s t } } ) ) \in \mathbb { R } ^ { k }$ Model set performances are predicted as $\mathbf { P } _ { \mathrm { t e s t } } : = \mathbf { U } _ { \mathrm { t e s t } } \mathbf { V } ^ { T } \in \mathbb { R } ^ { m }$ . Finally, the model with the largest predicted performance is outputted as the selected model, that is,
+
+$$
+\arg \operatorname* { m a x } _ { j } ~ \langle ~ f ( \phi ( \psi ( { \bf X } _ { \mathrm { t e s t } } ) ) ) , { \bf V } _ { j } ~ \rangle ~ .
+$$
+
+Remark: Notice that model selection by Eq. (2) for a newcoming dataset is solely based on its meta-features and other pre-trained components from meta-learning. It does not rely on ground-truth labels or any OD model evaluations, therefore, METAOD provides unsupervised outlier model selection. Further, it does not require choosing or tuning any values at test time, and hence is fully automatic. In terms of computation, test-time embedding by $\phi$ (PCA) and regression by $f$ (regression trees) take near-constant time given the small number of meta-features, embedding dimensions, and trees of fixed depth. Moreover, we use meta-features with computational complexity linear in the dataset size as we describe next.
+
+# 3.3 Meta-Features for Outlier Detection
+
+A key part of METAOD is the extraction of meta-features that capture the important characteristics of an arbitrary dataset. Existing outlier detection models have different methodological designs (e.g., density, distance, angle, etc. based) and different assumptions around the topology of outliers (e.g., global, local, clustered). As a result, we expect different models to perform differently depending on the input dataset and the nature of outliers it exhibits—hence no “winner”. In our meta-learning approach, the goal is to identify the datasets in the meta-train database that exhibit similar characteristics to a given test dataset, and focus on models that do well on those similar datasets. This is akin to recommending to a new user those items liked by similar users.
+
+To this end, we extract meta-features that can be organized into two categories: (1) statistical features, and (2) landmarker features. Broadly speaking, the former captures statistical properties of the underlying data distributions; e.g., min, max, variance, skewness, covariance, etc. of the features and feature combinations. (See Appendix B Table 3 for the complete list.) These kinds of meta-features have been commonly used in the AutoML literature [5].
+
+![](images/152c22b7a74d39034f73788d645e1522e6cccaac9328075bb76f524cbba57196.jpg)  
+Figure 1: METAOD overview; components that transfer from offline (meta-learning) to online (model selection) phase shown in blue; namely, meta-feature extractors $( \psi )$ , embedding model $( \phi )$ , regressor $f$ , dataset matrix $\mathbf { U }$ , and model matrix $\mathbf { V }$ . For the online phase, the input dataset $\mathbf { X } _ { \mathrm { t e s t } }$ and the predicted model performance $\mathbf { P _ { \mathrm { t e s t } } }$ are denoted in yellow.
+
+The optimal set of meta-features has been shown to be application-dependent [49]. Therefore, perhaps more important are the landmarker features, which are problem-specific, and aim to capture the outlying characteristics of a dataset. The idea is to apply a few of the fast, easy-to-construct OD models on a dataset and extract features from (i) the structure of the estimated OD model, and (ii) its output outlier scores. For the OD-specific landmarkers, we use four OD algorithms: iForest [31], HBOS [17], LODA [34], and PCA [20] (reconstruction error as outlier score). We choose the four OD algorithms due to their efficiency and diversity (as a group). First, they are all fast algorithms and able to handle large, high-dimensional datasets [2]. This makes the meta-feature generation efficient and practical in the real world. Second, these four OD algorithms as a group show decent diversity (i.e., internal detection mechanism) to capture rich outlying characteristics. Consider iForest as an example. It creates a set of what-is-called extremely randomized trees that define the model structure, from which we extract structural features such as average horizontal and vertical tree imbalance. As another example, LODA builds on random-projection histograms from which we extract features such as entropy. In addition, based on the list of outlier scores from these models, we compute features such as dispersion, max consecutive gap in the sorted order, etc. We elaborate on the details of the landmarker features in Appendix B.2.
+
+# 3.4 Meta-Learning Objective and Training
+
+# 3.4.1 Rank-based Criterion
+
+A typical loss criterion for matrix factorization is the mean squared error (MSE), a.k.a. the Frobenius norm of the error matrix $\mathbf { P } - \mathbf { U } \mathbf { V } ^ { T }$ . While having nice properties from an optimization perspective, MSE does not (at least directly) concern with the ranking quality. In contrast, our goal is to rank the models for each dataset row-wise, as model selection concerns with picking the best possible model to employ. Therefore, we use a rank-based criterion called DCG from the information retrieval literature [21]. For a given ranking, DCG is given as
+
+$$
+\mathrm { D C G } = \sum _ { r } { \frac { b ^ { r e l } - 1 } { \log _ { 2 } ( r + 1 ) } }
+$$
+
+where rel_ $\cdot ^ { r }$ depicts the true relevance of the item ranked at the $r$ -th position and $b$ is a scalar (typically set to 2). In our setting, we use the performance of a model to reflect its true relevance to a dataset. As such, DCG for dataset $i$ is re-written as
+
+$$
+\mathrm { D C G } _ { i } = \sum _ { j = 1 } ^ { m } { \frac { b ^ { \mathbf { P } _ { i j } } - 1 } { \log _ { 2 } ( 1 + \sum _ { k = 1 } ^ { m } \mathbb { 1 } [ { \widehat { \mathbf { P } } } _ { i j } \leq { \widehat { \mathbf { P } } } _ { i k } ] ) } }
+$$
+
+where $\widehat { \mathbf { P } } _ { i j } = \langle \mathbf { U } _ { i } , \mathbf { V } _ { j } \rangle$ is the predicted performance that dictates the ranking order. Intuitively, ranking high-performing models at the top leads to higher DCG, and a larger $b$ increases the emphasis on the quality of models at the higher rank positions.
+
+A challenge with DCG is that it is not differentiable, unlike MSE, as it involves ranking/sorting. Specifically, the sum term in the denominator of Eq. (4) uses the (nonsmooth) indicator function to obtain the position of model $j$ as ranked by the estimated performances. We circumvent this challenge by replacing the indicator function by the (smooth) sigmoid approximation [16] as follows.
+
+$$
+\mathrm { D C G } _ { i } \approx \mathrm { s D C G } _ { i } = \sum _ { j = 1 } ^ { m } \frac { b ^ { \mathbf { P } _ { i j } } - 1 } { \log _ { 2 } ( 1 + \sum _ { k = 1 } ^ { m } \sigma ( \widehat { \mathbf { P } } _ { i k } - \widehat { \mathbf { P } } _ { i j } ) ) }
+$$
+
+# 3.4.2 Initialization & Alternating Optimization
+
+Overall we optimize the smoothed criterion, sDCG, over all meta-train datasets $\mathbf { \mathcal { D } } _ { \operatorname { t r a i n } } = \{ \mathbf { D } _ { i } \} _ { i = 1 } ^ { n }$ as
+
+$$
+\operatorname* { m i n } _ { \mathbf { U } , \mathbf { V } } L = - \sum _ { i = 1 } ^ { n } \mathrm { s D C G } _ { i } ( \mathbf { P } _ { i } , \mathbf { U } _ { i } \mathbf { V } ^ { T } ) \ ,
+$$
+
+by alternatingly solving for $\mathbf { U }$ as we fix $\mathbf { V }$ (and vice versa) by gradient descent. We initialize $\mathbf { U }$ by leveraging the meta-features, which are embedded to a space with the same size as U. By capturing the latent similarities among the datasets, such an initialization not only accelerates convergence [62] but also facilitates convergence to a better local optimum. $\mathbf { V }$ is initialized from a unit Normal.
+
+As we aim to maximize the total dataset-wise DCG, we make a pass over meta-train datasets one by one at each epoch. For brevity, we give the gradients for $\mathbf { U } _ { i }$ and $\mathbf { V } _ { j }$ in Eq.s (7) and (8), respectively.
+
+$$
+{ \frac { \partial L } { \partial \mathbf { U } _ { i } } } = \ln { ( 2 ) } \sum _ { j = 1 } ^ { m } \left[ { \frac { b ^ { \mathbf { P } _ { i j } } - 1 } { \beta _ { j } ^ { i } \ln ^ { 2 } { ( \beta _ { j } ^ { i } ) } } } \sum _ { k \neq j } \sigma ( w _ { j k } ^ { i } ) { ( 1 - \sigma ( w _ { j k } ^ { i } ) ) } ( \mathbf { V } _ { k } - \mathbf { V } _ { j } ) \right]
+$$
+
+$$
+\frac { \partial L } { \partial \mathbf { V } _ { j } } = - \ln { ( 2 ) } \sum _ { j = 1 } ^ { m } \left[ \frac { b ^ { \mathbf { P } _ { i j } } - 1 } { \beta _ { j } ^ { i } \ln ^ { 2 } { ( \beta _ { j } ^ { i } ) } } { \sum _ { k \neq j } { \sigma } ( w _ { j k } ^ { i } ) } ( 1 - \sigma ( w _ { j k } ^ { i } ) ) \mathbf { U } _ { i } \right]
+$$
+
+where $w _ { j k } ^ { i } = \langle \mathbf { U } _ { i } , ( \mathbf { V } _ { k } - \mathbf { V } _ { j } ) \rangle$ and $\begin{array} { r } { \beta _ { j } ^ { i } = \frac { 3 } { 2 } + \sum _ { k \neq j } \sigma ( w _ { j k } ^ { i } ) } \end{array}$ ; see derivations in Appendix C.
+
+# 4 Experiments
+
+# 4.1 Experiment Setting
+
+Model Set and Evaluation. We pair 8 SOTA OD algorithms and their corresponding hyperparameters to compose a model set $\mathbf { \mathcal { M } }$ with 302 unique models. (See Appendix A Table 2 for the complete list.) We evaluate METAOD and the baselines on 2 testbeds introduced below, resp. with 100 and 62 datasets, via cross-validation where datasets are split into meta-train/test in each fold. For each testbed, we first generate the performance matrix $\mathbf { P }$ , by evaluating the models from $\mathbf { \mathcal { M } }$ against the benchmark datasets in the testbed. For randomized detectors (random-split trees/random projections/etc.), we run five independent trials and record the average performance. For consistency, all models are built using the PyOD library [61] on an Intel i7-9700 $@ 3 . 0 0$ GHz, 64GB RAM, 8-core workstation. We compare two methods statistically, using the pairwise Wilcoxon signed rank test on performances across datasets (significance level $p < 0 . 0 5$ ).
+
+Testbed Setup. Meta-learning works well if a new task can leverage prior knowledge; e.g., mastering motorcycle can benefit from bike riding experience. As such, METAOD relies on the assumption that a newcoming test dataset shares similarity with some meta-train datasets. We create two testbeds with different train/test dataset similarity, to systematically study the effect of task similarity.
+
+1. Proof-of-Concept (POC) testbed contains 100 datasets that form clusters of similar datasets, where 5 different detection tasks (“siblings”) are created from each one of 20 “mothersets”. 2. Stress Testing (ST) testbed consists of 62 independent datasets from 3 different public-domain OD dataset repositories , which exhibit relatively lower similarity to one another.
+
+We refer to Appendix E for the complete list of datasets and details on testbed generation. Fig. 2 illustrates the differences between POC and ST testbeds, where the meta-features of their constituting datasets are embedded to 2-D by t-SNE [48]. By construction, POC consists of clusters and hence exhibits higher task/dataset similarity as compared to ST.
+
+![](images/187806346b4a18b8a40e7703cb4981866a220c736e383e1d0c277715f175d301.jpg)  
+Figure 2: 2-D embedding of datasets in (left) POC and (right) ST. POC exhibits higher task similarity, wherein “siblings” (marked by same color) form clusters. ST contains independent datasets with no apparent clusters.
+
+Baselines. Being the first work for UOMS, METAOD does not have immediate competing baselines. Therefore we employ simple ideas and tailor some existing methods for comparison. We also create 2 variations of METAOD (marked with $\dagger .$ ) for ablation analysis.
+
+In Appendix F we give detailed descriptions of all 10 baselines. Briefly, they are organized as follows: (i) no model selection always employs the same popular model, namely (1) LOF [6] or (2) iForest [31], or the ensemble of all the models called (3) Mega Ensemble (ME); (ii) simple metalearners include (4) Global Best (GB) that selects the model with the largest avg. performance across meta-train datasets, (5) ISAC [23] and (6) ARGOSMART (AS) [33]; and (iii) optimization-based meta-learners include (7) Supervised Surrogates (SS) [55] and (8) ALORS [32].
+
+Variants of METAOD are (9) $\mathbf { \dagger M E T A O D \_ C }$ where performance and meta-feature matrices are concatenated as $\mathbf { C } = [ \mathbf { P } , \mathbf { M } ] \in \mathbb { R } ^ { n \times ( m + d ) }$ , before factorization, $\mathbf { C } \approx \mathbf { U } \mathbf { V } ^ { T }$ . Given a test dataset, zeroconcatenated meta-features are projected and reconstructed as $[ \widehat { \mathbf { P } } _ { \mathrm { t e s t } } ; \widehat { \mathbf { M } } _ { \mathrm { t e s t } } ] : = [ 0 \ldots 0 ; \mathbf { M } _ { \mathrm { n e w } } ] \mathbf { V } \mathbf { V } ^ { T }$ ; and (10) $\mathbf { \dagger M E T A O D \_ F }$ where $\mathbf { U }$ is fixed at $\phi ( \mathbf { M } )$ after the embedding step and only $\mathbf { V }$ is optimized.
+
+Additionally, we report Empirical Upper Bound (EUB) (only) for POC, as the performance of the best model on a dataset’s 4 “siblings”; this (valuable) information is not available in practice–hence “upper bound”. For ST with lower task similarity, we include Random Selection (RS) as baseline.
+
+# 4.2 POC Testbed Results
+
+Testbed Setting. POC testbed is built to simulate the scenario where there are similar meta-train tasks to a given test task. We use the benchmark datasets4 by Emmott et al. [11], who created “childsets” from 20 independent “mothersets” by sampling. Consequently, the childsets generated from the same motherset using the same generation properties (e.g., the frequency of anomalies) can be deemed as “siblings” with large similarity. We build the POC testbed by using 5 siblings from each motherset, resulting in 100 datasets. We split them into 5 folds for cross-validation, each test fold containing 20 independent childsets without siblings.
+
+![](images/8c692434cc48d91fe3db1887282b8347589eea80e647c27d770a69a1f7751713.jpg)  
+Figure 3: Comparison of avg. rank (lower is better) of methods w.r.t. performance across datasets in POC. Mean AP across datasets (higher is better) shown on lines. METAOD is the topperforming meta-learner, and comparable to EUB.
+
+Results. In Fig. 3, we observe that METAOD is superior to all baseline methods w.r.t. the average rank and mean average precision (MAP), and performs comparably to the Empirical Upper Bound (EUB). Table 1 (left) shows that METAOD is the only meta-learner that is not significantly different from both EUB $( \mathbf { M A P = } 0 . 2 0 5 1 )$ ) and the $_ { 4 - t h }$ best model (0.2185). Moreover, METAOD is significantly better than the baselines that do not employ any model selection (LOF (0.1282), iForest (0.1536), and ME (0.1382)), as well as all the other meta-learners including GB (0.1524), ISAC (0.1658) and ALORS (0.1728). For the full POC evaluation, see Appendix G.1.
+
+Averaging all models (ME) does not lead to good performance as one may expect. As shown in Fig. 3, ME is the worst baseline by average rank in the POC testbed. Using a single detector, e.g., iForest, is significantly better. This is mainly because some models perform poorly on any given dataset, and ensembling all the models indiscriminately draws overall performance down. Using selective ensembles [36] could be beneficial, however, ensembles of many models are expensive to build in practice. In contrast, METAOD is fast at test time and selects without building any models.
+
+<table><tr><td>Ours</td><td>Baseline</td><td>p-value</td><td>Ours</td><td>Baseline</td><td>p-value</td></tr><tr><td>MetaOD MetaOD</td><td>EUB 4-th Best</td><td>0.0522 0.0929</td><td>MetaOD MetaOD</td><td>58-th Best RS</td><td>0.0517 0.0001</td></tr><tr><td>MetaOD</td><td>LOF</td><td>0.0013</td><td>MetaOD</td><td>LOF</td><td>0.0001</td></tr><tr><td>MetaOD</td><td>iForest</td><td>0.0090</td><td>MetaOD</td><td>iForest</td><td>0.1129</td></tr><tr><td>MetaOD</td><td></td><td>0.0004</td><td>MetaOD</td><td></td><td>0.0001</td></tr><tr><td></td><td>ME</td><td></td><td></td><td>ME</td><td></td></tr><tr><td>MetaOD</td><td>GB</td><td>0.0051</td><td>MetaOD</td><td>GB</td><td>0.0030</td></tr><tr><td>MetaOD</td><td>ISAC</td><td>0.0019</td><td>MetaOD</td><td>ISAC</td><td>0.0006</td></tr><tr><td>MetaOD</td><td>AS</td><td>0.2959</td><td>MetaOD</td><td>AS</td><td>0.0009</td></tr><tr><td>MetaOD</td><td>SS</td><td>0.7938</td><td>MetaOD</td><td>SS</td><td>0.0190</td></tr><tr><td>MetaOD</td><td>ALORS</td><td>0.0025</td><td>MetaOD</td><td>ALORS</td><td>0.0001</td></tr><tr><td>MetaOD</td><td>MetaOD_C</td><td>0.6874</td><td>MetaOD</td><td>MetaOD_C</td><td>0.0001</td></tr><tr><td>MetaOD</td><td>MetaOD_F</td><td>0.1165</td><td>MetaOD</td><td>MetaOD_F</td><td>0.0001</td></tr></table>
+
+Meta-learners perform significantly better than methods without model selection. In particular, four meta-learners (METAOD, SS, METAOD_C, METAOD_F) significantly outperform single outlier detection methods (LOF and iForest) as well as the Mega Ensemble (ME) that averages all the models. METAOD respectively has $5 8 . 7 4 \%$ , $3 2 . 4 8 \%$ , and $4 7 . 2 5 \%$ higher MAP over LOF, iForest, and ME. These results signify the benefits of model selection.
+
+Optimization-based meta learners generally perform better than simple meta learners. Top-3 meta learners by average rank (METAOD, SS, and METAOD_C) are all optimization-based and significantly outperform simple meta-learners like ISAC as shown in Fig. 3. Simple meta-learners weigh meta-features equally for task similarity, whereas others learn which meta-features matter (e.g., regression on meta-features), leading to better results. We find that METAOD respectively achieves $3 3 . 5 3 \%$ , $2 2 . 7 4 \%$ , and $4 . 7 3 \%$ higher MAP than simple meta-learners including GB, ISAC, and AS.
+
+# 4.3 ST Testbed Results
+
+Testbed Setting. When meta-train datasets lack similarity to the test dataset, it is hard to capitalize on prior experience. In the extreme case, meta-learning may not perform better than no-model-selection baselines, e.g., a single detector. To investigate the impact of the train/test similarity on meta-learning performance, we build the ST testbed that consists of 62 public-domain datasets from 3 different repositories (See Appendix E Table 4) with relatively low similarity as shown in Fig. 2. For evaluation on ST, we use leave-one-out cross validation; each time using 61 datasets as meta-train.
+
+![](images/cea78d2a5ca86db9c2179a749d4c94eb12b3952736319ec3d367f8d281767d81.jpg)  
+Table 1: Pairwise statistical test results between METAOD and baselines by Wilcoxon signed rank test. Statistically better method shown in bold (both marked bold if no significance). In (left) POC, METAOD is the only meta-learner with no diff. from both EUB and the 4- th best model. In (right) ST, METAOD is the only meta-learner with no statistical diff. from the $5 8 – t h$ best model. It is statistically better than all except iForest.   
+Figure 4: Comparison of avg. rank (lower is better) of methods w.r.t. performance across datasets in ST. Mean AP (higher is better) shown on lines. METAOD outperforms all baselines.
+
+Results. For the ST testbed, METAOD still outperforms all baseline methods w.r.t. average rank and MAP as shown in Fig. 4. Table 1 (right) shows that METAOD (0.3382) could select, from a pool of 302, the model that is as good as the $5 8 – t h$ best model (top $20 \%$ ) per dataset (0.3513) in this challenging testbed. The comparable model changes from the $4 { - } t h$ best per dataset in POC to $5 8 – t h$ best in ST, which is expected due to the lower task similarity to leverage in ST. Notably, all other baselines are worse than the $8 0 { - } t h$ best model with statistical significance. Moreover, METAOD is significantly better than all baselines except iForest. Note that METAOD also significantly outperforms RS, showing that it is able to exploit the meta-train database despite limited task similarity and not simply resorting to random picking. These results suggest that METAOD is a good choice under various extent of similarity among train/test datasets. We refer to Appendix G.2 for detailed ST results on individual ST datasets.
+
+Training stability affects performance for optimization-based methods. Notably, several optimization-based meta-learners, such as ALORS and METAOD_C, do not perform well for ST. We find that the training process of matrix factorization is not stable when latent similarities are weak. In METAOD, we employ two strategies that help stabilize the training. First, we leverage meta-feature based (rather than random) initialization. Second, we use cyclical learning rates that help escape saddle points for better local optima [43]. Consequently, METAOD (0.3382) significantly outperforms ALORS (0.2981) and METAOD_C (0.1946) with $1 3 . 4 5 \%$ and $7 3 . 7 9 \%$ higher MAP.
+
+Global methods outperform local methods under limited task similarity. In ST, datasets are less similar and simple meta-learners that leverage task similarity locally often perform poorly. For example, AS selects the model based on the 1-NN, and is likely to fail if the most similar meta-train task is still quite dissimilar to the current task. Notably, the global meta-learner GB outperforms AS and ISAC. Note the opposite ordering among these methods in POC as shown in Fig. 3. In short, effectiveness of simple meta-learners tends to be sensitive to the train/test dataset similarity, which makes them hard to use in general. In contrast, METAOD performs well in both settings.
+
+# 4.4 Runtime Analysis
+
+Empowered by meta-training, METAOD (meta-feature generation and model selection) takes less than 1 second on most test datasets, as shown in Fig. 5, where it incurs negligible overhead relative to building/training the selected outlier model ${ \approx } 1 0 \%$ on avg.). Fig. 6 corroborates the statement by showing the comparison on the 10 largest datasets in POC.
+
+![](images/08e711edb6192c86913d387d4db9bc55fff133351b793d7d96be8cf9d2ae443d.jpg)  
+Figure 5: METAOD running time at test time in sec.s (left), and percentage of time relative to building the selected model (right). Notice that it is fast, and incurs negligible computational overhead.
+
+![](images/3977eaf46a3db5377566f002678a0687980b13583178d8bce5583d3ad9f4761a.jpg)  
+Figure 6: Time for METAOD vs. training of the selected model (on 10 largest datasets in POC). METAOD incurs only negligible overhead (diff. shown w/ black arrows).
+
+Notably, meta-feature extraction may be trivially parallelized whereas the model selection is even faster, e.g., using SUOD [60], effectively taking constant time (See $\ S 3 . 2 . 2 )$ .
+
+# 5 Conclusion
+
+We addressed the unsupervised outlier model selection (UOMS) problem without relying on any labels, model evaluations or comparisons for the first time. Our proposed METAOD is a meta-learner, and builds on an extensive pool of historical outlier detection datasets and models. Given a new task, it selects a model based on the past performances of models on similar historical tasks. To effectively capture task similarity, we designed novel problem-specific meta-features. Importantly, METAOD is $( i )$ fully automatic, requiring no supervision at test time, and $( i i )$ lightweight, incurring relatively small selection time overhead prior to outlier model building. Extensive experiments on two large testbeds showed that METAOD significantly improves detection performance over always using some of the most popular outlier models as well as several other meta-learners tailored for UOMS.
+
+We open-source1 METAOD and our meta-learning database for use in practice. We expect metalearning to become more powerful as the meta-train database grows. Therefore, we also share all our code and testbeds with the community to stimulate further advances in automating UOMS. Future work can address UOMS in the continuous hyperparameter space, leverage self-aware learning [28] and conformal prediction [39] to estimate the confidence in selection, and explore the potential bias and fairness issues in OD model selection [10, 42].
+
+References   
+[1] S. M. Abdulrahman, P. Brazdil, J. N. van Rijn, and J. Vanschoren. Speeding up algorithm selection using average ranking and active testing by introducing runtime. Mach. Learn., 107(1):79–108, 2018.   
+[2] C. C. Aggarwal. Outlier Analysis. Springer, 2013.   
+[3] J. Bergstra and Y. Bengio. Random search for hyper-parameter optimization. J. Mach. Learn. Res., 13:281–305, 2012.   
+[4] H. Bharadhwaj. Meta-learning for user cold-start recommendation. In IJCNN, pages 1–8. IEEE, 2019.   
+[5] B. Bilalli, A. Abelló Gamazo, and T. Aluja Banet. On the predictive power of meta-features in OpenML. International Journal of Applied Mathematics and Computer Science, 27(4):697–712, 2017.   
+[6] M. M. Breunig, H.-P. Kriegel, R. T. Ng, and J. Sander. LOF: Identifying density-based local outliers. In SIGMOD Conference, pages 93–104. ACM, 2000. SIGMOD Record 29(2), June 2000.   
+[7] E. Burnaev, P. Erofeev, and D. Smolyakov. Model selection for anomaly detection. In ICMV, volume 9875 of SPIE Proceedings, page 987525. SPIE, 2015.   
+[8] G. O. Campos, A. Zimek, J. Sander, R. J. G. B. Campello, B. Micenková, E. Schubert, I. Assent, and M. E. Houle. On the evaluation of unsupervised outlier detection: measures, datasets, and an empirical study. Data Min. Knowl. Discov., 30(4):891–927, 2016.   
+[9] J. Chen, S. Sathe, C. C. Aggarwal, and D. S. Turaga. Outlier detection with autoencoder ensembles. In SDM, pages 90–98. SIAM, 2017.   
+[10] I. Davidson and S. S. Ravi. A framework for determining the fairness of outlier detection. In G. D. Giacomo, A. Catalá, B. Dilkina, M. Milano, S. Barro, A. Bugarín, and J. Lang, editors, ECAI 2020 - 24th European Conference on Artificial Intelligence, 29 August-8 September 2020, Santiago de Compostela, Spain, August 29 - September 8, 2020 - Including 10th Conference on Prestigious Applications of Artificial Intelligence (PAIS 2020), volume 325 of Frontiers in Artificial Intelligence and Applications, pages 2465–2472. IOS Press, 2020.   
+[11] A. Emmott, S. Das, T. G. Dietterich, A. Fern, and W.-K. Wong. Anomaly detection meta-analysis benchmarks. 2016.   
+[12] X. Fan, Y. Yue, P. Sarkar, and Y. X. R. Wang. A unified framework for tuning hyperparameters in clustering problems. CoRR, abs/1910.08018, 2019.   
+[13] M. Feurer, B. Letham, and E. Bakshy. Scalable meta-learning for bayesian optimization. CoRR, abs/1802.02219, 2018.   
+[14] M. Feurer, J. T. Springenberg, and F. Hutter. Initializing bayesian hyperparameter optimization via meta-learning. In AAAI, pages 1128–1135. AAAI Press, 2015.   
+[15] L. Franceschi, M. Donini, P. Frasconi, and M. Pontil. Forward and reverse gradient-based hyperparameter optimization. In ICML, volume 70 of Proceedings of Machine Learning Research, pages 1165–1173. PMLR, 2017.   
+[16] J. Fréry, A. Habrard, M. Sebban, O. Caelen, and L. He-Guelton. Efficient top rank optimization with gradient boosting for supervised anomaly detection. In ECML/PKDD, volume 10534, pages 20–35, 2017.   
+[17] M. Goldstein and A. Dengel. Histogram-based outlier score (hbos): A fast unsupervised anomaly detection algorithm. KI-2012: Poster and Demo Track, pages 59–63, 2012.   
+[18] X. He, K. Zhao, and X. Chu. Automl: A survey of the state-of-the-art. Knowl. Based Syst., 212:106622, 2021.   
+[19] F. Hutter, H. H. Hoos, and K. Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In C. A. C. Coello, editor, LION, volume 6683 of Lecture Notes in Computer Science, pages 507–523. Springer, 2011.   
+[20] T. Idé and H. Kashima. Eigenspace-based anomaly detection in computer systems. In W. Kim, R. Kohavi, J. Gehrke, and W. DuMouchel, editors, KDD, pages 440–449. ACM, 2004.   
+[21] K. Järvelin and J. Kekäläinen. Cumulated gain-based evaluation of IR techniques. ACM Transactions on Information Systems (TOIS), 20(4):422–446, 2002.   
+[22] D. R. Jones, M. Schonlau, and W. J. Welch. Efficient global optimization of expensive black-box functions. J. Global Optimization, 13(4):455–492, 1998.   
+[23] S. Kadioglu, Y. Malitsky, M. Sellmann, and K. Tierney. Isac - instance-specific algorithm configuration. In ECAI, volume 215 of Frontiers in Artificial Intelligence and Applications, pages 751–756. IOS Press, 2010.   
+[24] H.-P. Kriegel, M. Schubert, and A. Zimek. Angle-based outlier detection in high-dimensional data. In Y. Li, B. Liu, and S. Sarawagi, editors, KDD, pages 444–452. ACM, 2008.   
+[25] K. Lai, D. Zha, G. Wang, J. Xu, Y. Zhao, D. Kumar, Y. Chen, P. Zumkhawaka, M. Wan, D. Martinez, and X. Hu. TODS: an automated time series outlier detection system. In Thirty-Fifth AAAI Conference on Artificial Intelligence, AAAI 2021, Thirty-Third Conference on Innovative Applications of Artificial Intelligence, IAAI 2021, The Eleventh Symposium on Educational Advances in Artificial Intelligence, EAAI 2021, Virtual Event, February 2-9, 2021, pages 16060–16062. AAAI Press, 2021.   
+[26] H. Lee, J. Im, S. Jang, H. Cho, and S. Chung. MeLU: Meta-learned user preference estimator for cold-start recommendation. In KDD, pages 1073–1082. ACM, 2019.   
+[27] L. Li, K. G. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. J. Mach. Learn. Res., 18:185:1–185:52, 2017.   
+[28] L. Li, M. L. Littman, T. J. Walsh, and A. L. Strehl. Knows what it knows: a framework for self-aware learning. Mach. Learn., 82(3):399–443, 2011.   
+[29] Y. Li, Z. Chen, D. Zha, K. Zhou, H. Jin, H. Chen, and X. Hu. Autood: Neural architecture search for outlier detection. In 37th IEEE International Conference on Data Engineering, ICDE 2021, Chania, Greece, April 19-22, 2021, pages 2117–2122. IEEE, 2021.   
+[30] Y. Li, D. Zha, P. K. Venugopal, N. Zou, and X. Hu. Pyodds: An end-to-end outlier detection system with automated machine learning. In A. E. F. Seghrouchni, G. Sukthankar, T. Liu, and M. van Steen, editors, Companion of The 2020 Web Conference 2020, Taipei, Taiwan, April 20-24, 2020, pages 153–157. ACM / IW3C2, 2020.   
+[31] F. T. Liu, K. M. Ting, and Z.-H. Zhou. Isolation forest. In ICDM, pages 413–422. IEEE Computer Society, 2008.   
+[32] M. Misir and M. Sebag. Alors: An algorithm recommender system. Artif. Intell., 244:291–314, 2017.   
+[33] M. Nikolic, F. Maric, and P. Janicic. Simple algorithm portfolio for sat. Artif. Intell. Rev., 40(4):457–465, 2013.   
+[34] T. Pevný. Loda: Lightweight on-line detector of anomalies. Mach. Learn., 102(2):275–304, 2016.   
+[35] S. Ramaswamy, R. Rastogi, and K. Shim. Efficient algorithms for mining outliers from large data sets. In W. Chen, J. F. Naughton, and P. A. Bernstein, editors, SIGMOD Conference, pages 427–438. ACM, 2000. SIGMOD Record 29(2), June 2000.   
+[36] S. Rayana and L. Akoglu. Less is more: Building selective anomaly ensembles. ACM Trans. Knowl. Discov. Data, 10(4):42:1–42:33, 2016.   
+[37] B. Schölkopf, J. C. Platt, J. Shawe-Taylor, A. J. Smola, and R. C. Williamson. Estimating the support of a high-dimensional distribution. Neural Computation, 13(7):1443–1471, July 2001.   
+[38] B. Schölkopf, R. C. Williamson, A. J. Smola, J. Shawe-Taylor, and J. C. Platt. Support vector method for novelty detection. In NIPS, pages 582–588. The MIT Press, 1999.   
+[39] G. Shafer and V. Vovk. A tutorial on conformal prediction. J. Mach. Learn. Res., 9:371–421, 2008.   
+[40] B. Shahriari, K. Swersky, Z. Wang, R. P. Adams, and N. de Freitas. Taking the human out of the loop: A review of bayesian optimization. Proc. IEEE, 104(1):148–175, 2016.   
+[41] R. E. Shawi, M. Maher, and S. Sakr. Automated machine learning: State-of-the-art and open challenges. CoRR, abs/1906.02287, 2019.   
+[42] S. Shekhar, N. Shah, and L. Akoglu. Fairod: Fairness-aware outlier detection. In M. Fourcade, B. Kuipers, S. Lazar, and D. K. Mulligan, editors, AIES ’21: AAAI/ACM Conference on AI, Ethics, and Society, Virtual Event, USA, May 19-21, 2021, pages 210–220. ACM, 2021.   
+[43] L. N. Smith. Cyclical learning rates for training neural networks. In WACV, pages 464–472. IEEE Computer Society, 2017.   
+[44] D. H. Stern, H. Samulowitz, R. Herbrich, T. Graepel, L. Pulina, and A. Tacchella. Collaborative expert portfolio management. In AAAI. AAAI Press, 2010.   
+[45] J. Tang, Z. Chen, A. W. Fu, and D. W. Cheung. Enhancing effectiveness of outlier detections for low density patterns. In PAKDD, volume 2336 of Lecture Notes in Computer Science, pages 535–548, 2002.   
+[46] D. M. J. Tax and R. P. W. Duin. Support vector data description. Mach. Learn., 54(1):45–66, 2004.   
+[47] S. Vaithyanathan and B. Dom. Generalized model selection for unsupervised learning in high dimensions. In NIPS, pages 970–976. The MIT Press, 1999.   
+[48] L. van der Maaten and G. Hinton. Visualizing high-dimensional data using t-sne. J. of Mach. Lear. Res., 9:2579–2605, 2008.   
+[49] J. Vanschoren. Meta-learning. In Automated Machine Learning, pages 35–61. Springer, 2019.   
+[50] M. Vartak, A. Thiagarajan, C. Miranda, J. Bratman, and H. Larochelle. A meta-learning perspective on cold-start recommendations for items. In NeurIPS, pages 6904–6914, 2017.   
+[51] M. Wistuba, N. Schilling, and L. Schmidt-Thieme. Learning hyperparameter optimization initializations. In DSAA, pages 1–10. IEEE, 2015.   
+[52] M. Wistuba, N. Schilling, and L. Schmidt-Thieme. Scalable gaussian process-based transfer surrogates for hyperparameter optimization. Mach. Learn., 107(1):43–78, 2018.   
+[53] D. H. Wolpert and W. G. Macready. No free lunch theorems for optimization. IEEE Trans. Evolutionary Computation, 1(1):67–82, 1997.   
+[54] Y. Xiao, H. Wang, L. Zhang, and W. Xu. Two methods of selecting gaussian kernel parameters for one-class SVM and their application to fault detection. Knowl. Based Syst., 59:75–84, 2014.   
+[55] L. Xu, F. Hutter, J. Shen, H. H. Hoos, and K. Leyton-Brown. Satzilla2012: Improved algorithm selection based on cost-sensitive classification models. Proceedings of SAT Challenge, pages 57–58, 2012.   
+[56] C. Yang, Y. Akimoto, D. W. Kim, and M. Udell. OBOE: collaborative filtering for AutoML model selection. In KDD, pages 1173–1183. ACM, 2019.   
+[57] L. Yang and A. Shami. On hyperparameter optimization of machine learning algorithms: Theory and practice. Neurocomputing, 415:295–316, 2020.   
+[58] Q. Yao, M. Wang, H. J. Escalante, I. Guyon, Y. Hu, Y. Li, W. Tu, Q. Yang, and Y. Yu. Taking human out of learning applications: A survey on automated machine learning. CoRR, abs/1810.13306, 2018.   
+[59] T. Yu and H. Zhu. Hyper-parameter optimization: A review of algorithms and applications. CoRR, abs/2003.05689, 2020.   
+[60] Y. Zhao, X. Hu, C. Cheng, C. Wang, C. Wan, W. Wang, J. Yang, H. Bai, Z. Li, C. Xiao, Y. Wang, Z. Qiao, J. Sun, and L. Akoglu. SUOD: Accelerating large-scale unsupervised heterogeneous outlier detection. Proceedings of Machine Learning and Systems, 2021.   
+[61] Y. Zhao, Z. Nasrullah, and Z. Li. PyOD: A python toolbox for scalable outlier detection. J. Mach. Learn. Res., 20:96:1–96:7, 2019.   
+[62] Z. Zheng, J. Yang, and Y. Zhu. Initialization enhancer for non-negative matrix factorization. Eng. Appl. Artif. Intell., 20(1):101–110, 2007.   
+[63] C. Zhou and R. C. Paffenroth. Anomaly detection with robust deep autoencoders. In KDD, pages 665–674. ACM, 2017.

parse/train/KCd-3Pz8VjM/KCd-3Pz8VjM_content_list.json

@@ -0,0 +1,1365 @@
+[
+    {
+        "type": "text",
+        "text": "Automatic Unsupervised Outlier Model Selection ",
+        "text_level": 1,
+        "bbox": [
+            200,
+            122,
+            795,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yue Zhao Carnegie Mellon University zhaoy@cmu.edu ",
+        "bbox": [
+            202,
+            200,
+            385,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ryan A. Rossi Adobe Research ryrossi@adobe.com ",
+        "bbox": [
+            421,
+            200,
+            570,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Leman Akoglu Carnegie Mellon University lakoglu@andrew.cmu.edu ",
+        "bbox": [
+            606,
+            202,
+            795,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Given an unsupervised outlier detection task on a new dataset, how can we automatically select a good outlier detection algorithm and its hyperparameter(s) (collectively called a model)? In this work, we tackle the unsupervised outlier model selection (UOMS) problem, and propose METAOD, a principled, data-driven approach to UOMS based on meta-learning. The UOMS problem is notoriously challenging, as compared to model selection for classification and clustering, since (i) model evaluation is infeasible due to the lack of hold-out data with labels, and $( i i )$ model comparison is infeasible due to the lack of a universal objective function. METAOD capitalizes on the performances of a large body of detection models on historical outlier detection benchmark datasets, and carries over this prior experience to automatically select an effective model to be employed on a new dataset without any labels, model evaluations or model comparisons. To capture task similarity within our meta-learning framework, we introduce specialized metafeatures that quantify outlying characteristics of a dataset. Extensive experiments show that selecting a model by METAOD significantly outperforms no model selection (e.g. always using the same popular model or the ensemble of many) as well as other meta-learning techniques that we tailored for UOMS. Moreover upon (meta-)training, METAOD is extremely efficient at test time; selecting from a large pool of $3 0 0 +$ models takes less than 1 second for a new task. We open-source1 METAOD and our meta-learning database for practical use and to foster further research on the UOMS problem. ",
+        "bbox": [
+            232,
+            310,
+            766,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            310,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The lack of a universal learning model that performs well on all problem instances is well recognized [53]. Therefore, effort has been directed toward building a toolbox of various models and algorithms, which has given rise to the problem of algorithm selection and hyperparameter tuning (i.e., model selection). The same problem applies to outlier detection (OD); a long list of detectors has been developed in the last decades [2], with no universal “winners” [8]. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In supervised learning, model selection can be done via performance evaluation of each trained model on labeled hold-out data. In contrast, unsupervised OD does not have access to any labels, nor is there a universal objective function that could guide model selection (cf. clustering where a loss function enables model comparison). Unsupervised model selection for OD is challenging exactly because both model evaluation and comparison are not feasible—which renders any trial-and-error techniques like grid search or iterative strategies like Bayesian hyperparameter optimization [57] inapplicable. Consequently, there has been no principled work on unsupervised outlier model selection—rather, the choice of a model for a new task (or dataset) remains “a black art”. A typical approach is to use popular OD algorithms, like LOF [6] and iForest [31] (often with default hyperparameters) which are shown to be competitive on average on many benchmark datasets. However, as noted earlier, none of these methods can universally outperform others on all tasks [8]. We argue that model selection is exactly how one can “break the performance ceiling” for OD. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we tackle the unsupervised outlier model selection (UOMS) problem systematically. To that end, we introduce (to the best of our knowledge) the first UOMS approach that selects an effective model to be employed on a new detection task without any model evaluation (using labels) or model comparison (via loss criteria). Our proposed method, called METAOD, is based on meta-learning, and stands on the prior performances of a large collection of existing detection models on an extensive corpora of historical outlier detection benchmark datasets. In a nutshell, the idea is to estimate a candidate model’s performance on the new task (with no labels) based on its prior performance on similar historical tasks. We remark that METAOD is strictly a model selection technique – that picks one model (a detector and its associated hyperparameter(s)) from a pool of (existing) candidate models – and not yet-another outlier detection algorithm itself. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In leveraging meta-learning, we establish a connection between the UOMS problem and the cold-start problem in collaborative filtering (CF), where the new task in UOMS is akin to a new user in CF (with no available evaluations, hence cold-start) and the model space is analogous to the item-set. Differently, OD necessitates the identification of a single best model (i.e., top-1 rank), whereas CF typically operates in a top- $k$ setting. In CF, future recommendations can be improved based on user feedback which is not applicable to OD. Moreover, METAOD requires the effective learning of task similarities based on characteristic dataset features (namely, meta-features) that capture the outlying properties within a dataset, whereas user features (location, age, etc.) in CF may be readily available. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, the key contributions of this work include the following: ",
+        "bbox": [
+            174,
+            387,
+            629,
+            401
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• First Approach to Unsupervised Outlier Model Selection: We propose METAOD, (to our knowledge) the first effort on unsupervised model selection for OD tasks. Notably, given a new dataset (i.e., at test time), it does not rely on any ground-truth labels for model evaluation or any loss or heuristic criterion for model comparison. METAOD stands on meta-learning in principle, and historical collections of outlier models and benchmark datasets in practice. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Problem Formulation: We establish a correspondence between UOMS and CF under cold-start, where the new task “better likes” a model that performs better on similar historical tasks. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Specialized Meta-features: We design novel meta-features to capture the outlying characteristics in a dataset toward effectively quantifying task similarity specifically among OD tasks. ",
+        "bbox": [
+            174,
+            510,
+            821,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Effectiveness and Efficiency: Through extensive experiments on two benchmark testbeds that we have constructed, we show that selecting a model by METAOD for each given task significantly outperforms always using a popular model like iForest, as well as other possible meta-learning approaches that we tailored for UOMS. Moreover, METAOD incurs negligible run-time overhead ( $\\cdot < 1$ second) at test time. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Open-source Platform: We open-source1 METAOD and our meta-learning database for the community to use it for UOMS in practice, and to extend it with new datasets and models. We expect the growth of the database would make meta-learning based approaches, like METAOD, more powerful and also help foster further research on this new direction to an important problem. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            321,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Model Selection for Outlier Detection (OD) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            736,
+            513,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most outlier mining work have focused on developing new, better methods for detection on different types of data [2]. In comparison, there are only a few work on the outlier model selection problem –which detector and hyperparameter(s) to use on a new task– all of which require some labeled data. Recent work include AutoOD [29] that focuses on automatic neural architecture search, however, it is limited to deep autoencoder based detection, and more importantly it relies on hold-out labeled data for evaluation. Similarly, PyODDS [30] and TODS [25] both require ground truth labels. ",
+        "bbox": [
+            173,
+            766,
+            825,
+            849
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To our knowledge, there is no existing work on the general unsupervised outlier model selection (UOMS) problem, which is considerably more challenging, as (1) model evaluation is infeasible due to the lack of any ground truth labels, and (2) model comparison of different heterogeneous detectors is infeasible due to the lack of a universal OD loss function. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We note that some OD methods do have a loss function; e.g. auto-encoders [9, 63] aim to minimize reconstruction error for modeling the inliers, and one-class classification (OCSVM [38], SVDD [46], etc.) aims to maximize margin to the origin or minimize the radius of a data-enclosing hyperball. There is also work on model selection for one-class models [7, 54], however, those are limited to this specific family of methods and do not apply in the general case. Our proposed METAOD is not limited to one specific model family, but can select among any (heterogeneous) set of detectors. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Model Selection in ML, AutoML, Meta-Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            195,
+            553,
+            210
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model selection refers to the process of algorithm selection and/or hyperparameter optimization (HO). With the advent of complex (e.g. deep) models, HO in high dimensions has become impractical to be human-powered [59]. As such, automating ML pipelines has seen a surge of attention [18]. Meta-learning has been a key contributor to the AutoML effort [41, 49, 58]. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Supervised Model Selection: Most existing work focus on the supervised setting, and use hold-out data with labels. Randomized [3], bandit-based [27], and Bayesian optimization (BO) techniques [40] are various state-of-the-art (SOTA) approaches to HO. Specifically sequential model-based BO [19, 22] evaluates hold-out performance at various initial hyperparameter configurations (HC), where a (smooth) surrogate function is fit to the resulting $\\langle \\mathrm { H C }$ , performancei pairs, which is then used to strategically query other HCs, e.g., via hyper-gradient based search [15]. Meta-learning has also been employed [13, 52], e.g., to find promising initialization for (i.e. warm-starting) BO [14, 51]. ",
+        "bbox": [
+            174,
+            286,
+            825,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that all of these approaches rely on multiple model evaluations (i.e., performance queries) for various HCs, and hence cannot be applied to the unsupervised outlier model selection problem. ",
+        "bbox": [
+            173,
+            388,
+            821,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised Model Selection: Unsupervised ML tasks (e.g., clustering) poses additional challenges for model selection [12, 47]. Nonetheless, those exhibit established objective criteria that enable model comparison, unlike OD. For example, BO methods still apply where the surrogate can be trained on hHC, objective valuei pairs, for which meta-learning can provide favorable priors. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Task-independent meta-learning [1], that simply identifies the globally best model on historical tasks, applies to the unsupervised setting and hence OD. This can be refined by identifying the best model on not all, but similar tasks, where task similarity is measured in the meta-feature space via clustering [23] or nearest neighbors [33]. This type of similarity-based recommendations points to a connection between algorithm selection and collaborative filtering (CF), first recognized by Stern et al. [44]. The most related to UOMS is CF under cold start, where evaluations are not-available (in our case, infeasible) for a new user (in our case, task). There have been a number of work using meta-learning for the cold-start recommendation problem [4, 26, 50], and vice versa, using CF solutions for ML algorithm selection [32, 56]. We tailor these to UOMS and compare to METAOD in the experiments. ",
+        "bbox": [
+            174,
+            484,
+            826,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Unsupervised Outlier Model Selection via Meta-learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            635,
+            676,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Problem Statement ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            346,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider the model selection problem for unsupervised outlier detection, which we refer to as UOMS (unsupervised outlier model selection) hereafter. Given a new dataset, without any labels, the problem is to select both (i) a detector/algorithm and $( i i )$ its associated hyperparameter(s) (HP). The former is a discrete choice, given the finite set of existing detection algorithms. The latter is continuous, and hence induces infinitely many candidate models. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            766
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Under certain assumptions, such as performance changing smoothly in the HP space, a HP configuration can be selected iteratively based on evaluations on several other carefully-chosen configurations. Importantly however, OD is not amenable for such iterative search over models—evaluations are not possible due to the lack of labels and absence of a universal objective criterion. The selection of a model, therefore, is to be done without building or evaluating any model on the new dataset. Given this constraint, we discretize the HP space for each candidate detector to make the search space tractable, which induces a finite pool of models denoted $\\pmb { \\mathcal { M } } = \\{ M _ { 1 } , \\dots , M _ { m } \\}$ . Each model $M \\in \\mathcal { M }$ can be seen as a $\\{$ {detector, configuration $\\}$ pair, where the configuration depicts a specific set of values for the detector’s HP(s). (See Appendix A for details.) Then, the UOMS problem is stated as follows: ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Problem 1 (Unsupervised Outlier Model Selection (UOMS)) Given a new input dataset (i.e., detection task) $\\mathbf { D } _ { t e s t } \\bar { = } \\left( \\mathbf { X } _ { t e s t } \\right)$ without any labels, Select a model $M \\in \\mathcal { M }$ to employ on $\\mathbf { X } _ { t e s t }$ . ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Proposed METAOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            140,
+            348,
+            155
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work we consider the UOMS problem and propose a meta-learning based solution, leveraging past experience on historical detection tasks. As such, our METAOD relies on ",
+        "bbox": [
+            171,
+            167,
+            825,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• a collection of historical outlier detection datasets $\\mathbf { \\mathcal { D } } _ { \\mathrm { t r a i n } } = \\{ \\mathbf { D } _ { 1 } , \\dots , \\mathbf { D } _ { n } \\}$ , namely, a meta-train   \ndatabase with ground truth labels, i.e., $\\{ \\mathbf { D } _ { i } = ( \\mathbf { X } _ { i } , \\mathbf { y } _ { i } ) \\} _ { i = 1 } ^ { n }$ , and   \n• the historical performances of the pool of candidate models, $\\mathbf { \\mathcal { M } }$ , on the meta-train datasets. We denote by $\\mathbf { P } \\in \\mathbb { R } ^ { n \\times m }$ the performance matrix, where $\\mathbf { P } _ { i j }$ corresponds to the $j$ -th model $M _ { j }$ ’s performance2 on the $i$ -th meta-train dataset $\\mathbf { D } _ { i }$ . ",
+        "bbox": [
+            173,
+            202,
+            826,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that model performance can be evaluated on the historical meta-train datasets as they contain ground truth labels, which however is not the case for any newcoming task at test time. ",
+        "bbox": [
+            173,
+            280,
+            823,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our METAOD consists of two-phases: offline (meta-)training of the meta-learner on $\\pmb { \\mathcal { D } } _ { \\mathrm { t r a i n } }$ , and online prediction that enables unsupervised model selection at test time for $\\mathbf { D _ { \\mathrm { t e s t } } }$ . Arguably, the running time of the offline phase is not critical. In contrast, model selection for a newcoming task should incur small run-time overhead, as it precedes the actual building of the selected OD model. Fig. 1 summarizes the process and the major components of METAOD, where we highlight the components transferred from offline (meta-learning) to online stage (model selection) in blue. We also provide the detailed steps of METAOD in pseudo-code, for both meta-training (offline) and model selection (online), in Appendix D Algo. 1. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 (Meta-)Training (Offline) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            400,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In principle, meta-learning carries over prior experience on a set of historical tasks to “do better” on a new task. Such improvement can be unlocked only if the new task resembles and thus can build on at least some of the historical tasks (such as learning ice-skating given prior experience with roller-blading), rather than representing completely unrelated phenomena. This entails defining an effective way to capture task similarity between an input task and the historical tasks at hand. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In machine learning, similarity between meta-train and test datasets are quantified through characteristic features of a dataset, also known as meta-features. Those typically capture statistical properties of the data distributions. (See survey [49] for various types of meta-features.) ",
+        "bbox": [
+            174,
+            546,
+            825,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To capture prior experience, METAOD first constructs the performance matrix $\\mathbf { P }$ by running/building and evaluating all the $m$ models in our defined model space $\\mathbf { \\mathcal { M } }$ on all the $n$ meta-train datasets $\\mathcal { D } _ { \\mathrm { t r a i n } }$ .3 To capture task similarity, it then extracts a set of $d$ meta-features from each meta-train dataset, denoted by $\\mathbf { M } = \\psi ( \\{ \\mathbf { X } _ { 1 } ^ { \\cdot } , \\dots , \\mathbf { X } _ { n } \\} ) \\in \\mathbb { R } ^ { n \\times d }$ where $\\psi ( \\cdot )$ depicts the feature extraction module. We defer the details on the meta-feature specifics to $\\ S 3 . 3$ . ",
+        "bbox": [
+            174,
+            594,
+            825,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At this stage, it is easy to recognize the connection between the UOMS and the collaborative filtering (CF) under cold start problems. Simply put, meta-train datasets are akin to existing users in CF that have prior evaluations on a set of models that are akin to the item-set in CF. The test task is akin to a newcoming user with no prior evaluations (and in our case, no possible future evaluation either), which however exhibits some pre-defined features. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Capitalizing on this connection, we take a matrix factorization based approach where $\\mathbf { P }$ is approximated by the dot product of what-we-call dataset matrix $\\mathbf { U } \\in \\mathbb { R } ^ { n \\times k }$ and model matrix $\\mathbf { V } \\in \\mathbf { \\hat { \\mathbb { R } } } ^ { m \\times k }$ The intent is to capture the inherent dataset-to-model affinity via the dot product similarity in the $k$ -dimensional latent space, such that $\\mathbf { P } _ { i j } \\approx \\mathbf { U } _ { i } \\mathbf { V } _ { j } ^ { \\ T }$ where matrix subscript denotes the row. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            805
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "What loss criterion is suitable for the factorization? In CF the typical goal is top- $k$ item recommendation. In METAOD, we aim to select the model with the best performance on a task which demands top-1 optimization. Therefore, we discard least squares and instead optimize the rank-based (row- or dataset-wise) discounted cumulative gain (DCG) [21], ",
+        "bbox": [
+            174,
+            809,
+            825,
+            852
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            90,
+            529,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/10116d30d96eb1ff36aa231668064a121b06b2b146aaf3a5c8be8d39ad034f6d.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { { \\bf U } , { \\bf V } } \\ \\sum _ { i = 1 } ^ { n } \\mathrm { D C G } _ { i } ( { \\bf P } _ { i } , { \\bf U } _ { i } { \\bf V } ^ { T } ) \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            111,
+            601,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The factorization is solved via alternating optimization, where initialization plays an important role for such non-convex problems. We find that initializing $\\mathbf { U }$ , denoted $\\mathbf { U } ^ { ( 0 ) }$ , based on meta-features facilitates stable training, potentially by hinting at inherent similarities among datasets as compared to random initialization. Specifically, an embedding function $\\phi ( \\cdot )$ is used to set $\\mathbf { U } ^ { ( 0 ) } : = \\phi ( \\mathbf { M } )$ for $\\phi : \\mathbb { R } ^ { d } \\mapsto \\mathbb { R } ^ { k }$ , $k < d$ . Details on objective criteria and optimization are deferred to $\\ S 3 . 4$ . ",
+        "bbox": [
+            173,
+            159,
+            825,
+            233
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By construction, matrix factorization is transductive. On the other hand, we would need $\\mathbf { U } _ { \\mathrm { t e s t } }$ to be able to estimate performances of the model set $\\mathbf { \\mathcal { M } }$ on a new dataset $\\mathbf { X } _ { \\mathrm { t e s t } }$ . To this end, one can learn an (inductive) multi-output regression model that maps the meta-features onto the latent features. We simplify by learning a regression function $f : \\mathbb { R } ^ { \\dot { k } } \\mapsto \\mathbb { R } ^ { k }$ that maps the (lower dimensional) embedding features $\\phi ( \\mathbf { M } )$ (which are also used to initialize U) onto the final optimized U. Note that this requires an inductive embedding function $\\phi ( \\cdot )$ to be applicable to newcoming datasets. In implementation, we use PCA for $\\phi ( \\cdot )$ and a random forest regressor for $f ( \\cdot )$ although METAOD is flexible to accommodate any others provided they are inductive. ",
+        "bbox": [
+            173,
+            237,
+            825,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark: METAOD improves over the existing methods that use CF in machine learning model selection (see $\\ S 2 . 2 )$ in two aspects. First, METAOD builds specialized landmarker features tailored for capturing outlying characteristics of a dataset, while the existing ML model selection mainly uses generic statistical features (see $\\ S 3 . 3 )$ . Second, METAOD uses a customized (backpropagatable/smooth) rank-based loss in CF for more effective top-1 optimization (see $\\ S 3 . 4$ ), while existing approaches mainly leverage mean squared loss (MSE). ",
+        "bbox": [
+            174,
+            354,
+            825,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 Prediction for Unsupervised Model Selection (Online) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            453,
+            598,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Meta-training stage yields the estimated functions $\\psi ( \\cdot ) , \\phi ( \\cdot )$ , and $f ( \\cdot )$ as well as the model matrix $\\mathbf { V } \\in \\mathbb { R } ^ { m \\times k }$ , which we save for test time (See Fig. 1). Given a new dataset $\\mathbf { X } _ { \\mathrm { t e s t } }$ for OD, METAOD first computes the corresponding meta-features as $\\mathbf { \\bar { M } } _ { \\mathrm { t e s t } } : = \\psi ( \\mathbf { X } _ { \\mathrm { t e s t } } ) \\in \\mathbb { R } ^ { d }$ . Those are then embedded via $\\phi ( \\mathbf { M } _ { \\mathrm { t e s t } } ) \\in \\mathbb { R } ^ { k }$ , which are regressed to obtain the latent features, i.e., $\\mathbf { U } _ { \\mathrm { t e s t } } : = f ( \\phi ( \\mathbf { M } _ { \\mathrm { t e s t } } ) ) \\in \\mathbb { R } ^ { k }$ Model set performances are predicted as $\\mathbf { P } _ { \\mathrm { t e s t } } : = \\mathbf { U } _ { \\mathrm { t e s t } } \\mathbf { V } ^ { T } \\in \\mathbb { R } ^ { m }$ . Finally, the model with the largest predicted performance is outputted as the selected model, that is, ",
+        "bbox": [
+            173,
+            476,
+            825,
+            564
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83c2c4a3ed830bcee36d746cbb8894f310009588a229b153d06c393ad2e09b2c.jpg",
+        "text": "$$\n\\arg \\operatorname* { m a x } _ { j } ~ \\langle ~ f ( \\phi ( \\psi ( { \\bf X } _ { \\mathrm { t e s t } } ) ) ) , { \\bf V } _ { j } ~ \\rangle ~ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            569,
+            612,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark: Notice that model selection by Eq. (2) for a newcoming dataset is solely based on its meta-features and other pre-trained components from meta-learning. It does not rely on ground-truth labels or any OD model evaluations, therefore, METAOD provides unsupervised outlier model selection. Further, it does not require choosing or tuning any values at test time, and hence is fully automatic. In terms of computation, test-time embedding by $\\phi$ (PCA) and regression by $f$ (regression trees) take near-constant time given the small number of meta-features, embedding dimensions, and trees of fixed depth. Moreover, we use meta-features with computational complexity linear in the dataset size as we describe next. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Meta-Features for Outlier Detection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            464,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A key part of METAOD is the extraction of meta-features that capture the important characteristics of an arbitrary dataset. Existing outlier detection models have different methodological designs (e.g., density, distance, angle, etc. based) and different assumptions around the topology of outliers (e.g., global, local, clustered). As a result, we expect different models to perform differently depending on the input dataset and the nature of outliers it exhibits—hence no “winner”. In our meta-learning approach, the goal is to identify the datasets in the meta-train database that exhibit similar characteristics to a given test dataset, and focus on models that do well on those similar datasets. This is akin to recommending to a new user those items liked by similar users. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To this end, we extract meta-features that can be organized into two categories: (1) statistical features, and (2) landmarker features. Broadly speaking, the former captures statistical properties of the underlying data distributions; e.g., min, max, variance, skewness, covariance, etc. of the features and feature combinations. (See Appendix B Table 3 for the complete list.) These kinds of meta-features have been commonly used in the AutoML literature [5]. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/152c22b7a74d39034f73788d645e1522e6cccaac9328075bb76f524cbba57196.jpg",
+        "image_caption": [
+            "Figure 1: METAOD overview; components that transfer from offline (meta-learning) to online (model selection) phase shown in blue; namely, meta-feature extractors $( \\psi )$ , embedding model $( \\phi )$ , regressor $f$ , dataset matrix $\\mathbf { U }$ , and model matrix $\\mathbf { V }$ . For the online phase, the input dataset $\\mathbf { X } _ { \\mathrm { t e s t } }$ and the predicted model performance $\\mathbf { P _ { \\mathrm { t e s t } } }$ are denoted in yellow. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            97,
+            640,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            328,
+            823,
+            357
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The optimal set of meta-features has been shown to be application-dependent [49]. Therefore, perhaps more important are the landmarker features, which are problem-specific, and aim to capture the outlying characteristics of a dataset. The idea is to apply a few of the fast, easy-to-construct OD models on a dataset and extract features from (i) the structure of the estimated OD model, and (ii) its output outlier scores. For the OD-specific landmarkers, we use four OD algorithms: iForest [31], HBOS [17], LODA [34], and PCA [20] (reconstruction error as outlier score). We choose the four OD algorithms due to their efficiency and diversity (as a group). First, they are all fast algorithms and able to handle large, high-dimensional datasets [2]. This makes the meta-feature generation efficient and practical in the real world. Second, these four OD algorithms as a group show decent diversity (i.e., internal detection mechanism) to capture rich outlying characteristics. Consider iForest as an example. It creates a set of what-is-called extremely randomized trees that define the model structure, from which we extract structural features such as average horizontal and vertical tree imbalance. As another example, LODA builds on random-projection histograms from which we extract features such as entropy. In addition, based on the list of outlier scores from these models, we compute features such as dispersion, max consecutive gap in the sorted order, etc. We elaborate on the details of the landmarker features in Appendix B.2. ",
+        "bbox": [
+            173,
+            363,
+            826,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Meta-Learning Objective and Training ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            483,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4.1 Rank-based Criterion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            379,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A typical loss criterion for matrix factorization is the mean squared error (MSE), a.k.a. the Frobenius norm of the error matrix $\\mathbf { P } - \\mathbf { U } \\mathbf { V } ^ { T }$ . While having nice properties from an optimization perspective, MSE does not (at least directly) concern with the ranking quality. In contrast, our goal is to rank the models for each dataset row-wise, as model selection concerns with picking the best possible model to employ. Therefore, we use a rank-based criterion called DCG from the information retrieval literature [21]. For a given ranking, DCG is given as ",
+        "bbox": [
+            173,
+            648,
+            825,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a445326ec0da36692c68f4b8c7ad7aebd4b7791fccddb8cd834b81cd30fca1c.jpg",
+        "text": "$$\n\\mathrm { D C G } = \\sum _ { r } { \\frac { b ^ { r e l } - 1 } { \\log _ { 2 } ( r + 1 ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            734,
+            583,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where rel_ $\\cdot ^ { r }$ depicts the true relevance of the item ranked at the $r$ -th position and $b$ is a scalar (typically set to 2). In our setting, we use the performance of a model to reflect its true relevance to a dataset. As such, DCG for dataset $i$ is re-written as ",
+        "bbox": [
+            174,
+            776,
+            826,
+            818
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f120662b3179486409dc2c82640362b5d6d22e108f50eaaa828f91593cd1d240.jpg",
+        "text": "$$\n\\mathrm { D C G } _ { i } = \\sum _ { j = 1 } ^ { m } { \\frac { b ^ { \\mathbf { P } _ { i j } } - 1 } { \\log _ { 2 } ( 1 + \\sum _ { k = 1 } ^ { m } \\mathbb { 1 } [ { \\widehat { \\mathbf { P } } } _ { i j } \\leq { \\widehat { \\mathbf { P } } } _ { i k } ] ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            820,
+            648,
+            863
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\widehat { \\mathbf { P } } _ { i j } = \\langle \\mathbf { U } _ { i } , \\mathbf { V } _ { j } \\rangle$ is the predicted performance that dictates the ranking order. Intuitively, ranking high-performing models at the top leads to higher DCG, and a larger $b$ increases the emphasis on the quality of models at the higher rank positions. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A challenge with DCG is that it is not differentiable, unlike MSE, as it involves ranking/sorting. Specifically, the sum term in the denominator of Eq. (4) uses the (nonsmooth) indicator function to obtain the position of model $j$ as ranked by the estimated performances. We circumvent this challenge by replacing the indicator function by the (smooth) sigmoid approximation [16] as follows. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d18038f6c773cb994ff53513f5c0b40dfb1b166263fd5f2af64ef7aada393987.jpg",
+        "text": "$$\n\\mathrm { D C G } _ { i } \\approx \\mathrm { s D C G } _ { i } = \\sum _ { j = 1 } ^ { m } \\frac { b ^ { \\mathbf { P } _ { i j } } - 1 } { \\log _ { 2 } ( 1 + \\sum _ { k = 1 } ^ { m } \\sigma ( \\widehat { \\mathbf { P } } _ { i k } - \\widehat { \\mathbf { P } } _ { i j } ) ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            154,
+            683,
+            196
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4.2 Initialization & Alternating Optimization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            222,
+            514,
+            238
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Overall we optimize the smoothed criterion, sDCG, over all meta-train datasets $\\mathbf { \\mathcal { D } } _ { \\operatorname { t r a i n } } = \\{ \\mathbf { D } _ { i } \\} _ { i = 1 } ^ { n }$ as ",
+        "bbox": [
+            176,
+            244,
+            820,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6447f320bcdde39e0729288d6851afa1eef05e8372624d8ed63af952ad211d38.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { U } , \\mathbf { V } } L = - \\sum _ { i = 1 } ^ { n } \\mathrm { s D C G } _ { i } ( \\mathbf { P } _ { i } , \\mathbf { U } _ { i } \\mathbf { V } ^ { T } ) \\ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            267,
+            625,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "by alternatingly solving for $\\mathbf { U }$ as we fix $\\mathbf { V }$ (and vice versa) by gradient descent. We initialize $\\mathbf { U }$ by leveraging the meta-features, which are embedded to a space with the same size as U. By capturing the latent similarities among the datasets, such an initialization not only accelerates convergence [62] but also facilitates convergence to a better local optimum. $\\mathbf { V }$ is initialized from a unit Normal. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As we aim to maximize the total dataset-wise DCG, we make a pass over meta-train datasets one by one at each epoch. For brevity, we give the gradients for $\\mathbf { U } _ { i }$ and $\\mathbf { V } _ { j }$ in Eq.s (7) and (8), respectively. ",
+        "bbox": [
+            169,
+            376,
+            823,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad8f469472050f81fc3c73b29757e208f063477138aaa5dde874905d6d7d6cd9.jpg",
+        "text": "$$\n{ \\frac { \\partial L } { \\partial \\mathbf { U } _ { i } } } = \\ln { ( 2 ) } \\sum _ { j = 1 } ^ { m } \\left[ { \\frac { b ^ { \\mathbf { P } _ { i j } } - 1 } { \\beta _ { j } ^ { i } \\ln ^ { 2 } { ( \\beta _ { j } ^ { i } ) } } } \\sum _ { k \\neq j } \\sigma ( w _ { j k } ^ { i } ) { ( 1 - \\sigma ( w _ { j k } ^ { i } ) ) } ( \\mathbf { V } _ { k } - \\mathbf { V } _ { j } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            411,
+            728,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f9cd13756fb894714d6cece14623419ae232aead59871a7a8756a7d4703db71.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial \\mathbf { V } _ { j } } = - \\ln { ( 2 ) } \\sum _ { j = 1 } ^ { m } \\left[ \\frac { b ^ { \\mathbf { P } _ { i j } } - 1 } { \\beta _ { j } ^ { i } \\ln ^ { 2 } { ( \\beta _ { j } ^ { i } ) } } { \\sum _ { k \\neq j } { \\sigma } ( w _ { j k } ^ { i } ) } ( 1 - \\sigma ( w _ { j k } ^ { i } ) ) \\mathbf { U } _ { i } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            468,
+            710,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { j k } ^ { i } = \\langle \\mathbf { U } _ { i } , ( \\mathbf { V } _ { k } - \\mathbf { V } _ { j } ) \\rangle$ and $\\begin{array} { r } { \\beta _ { j } ^ { i } = \\frac { 3 } { 2 } + \\sum _ { k \\neq j } \\sigma ( w _ { j k } ^ { i } ) } \\end{array}$ ; see derivations in Appendix C. ",
+        "bbox": [
+            173,
+            522,
+            784,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            558,
+            312,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experiment Setting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            588,
+            348,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Model Set and Evaluation. We pair 8 SOTA OD algorithms and their corresponding hyperparameters to compose a model set $\\mathbf { \\mathcal { M } }$ with 302 unique models. (See Appendix A Table 2 for the complete list.) We evaluate METAOD and the baselines on 2 testbeds introduced below, resp. with 100 and 62 datasets, via cross-validation where datasets are split into meta-train/test in each fold. For each testbed, we first generate the performance matrix $\\mathbf { P }$ , by evaluating the models from $\\mathbf { \\mathcal { M } }$ against the benchmark datasets in the testbed. For randomized detectors (random-split trees/random projections/etc.), we run five independent trials and record the average performance. For consistency, all models are built using the PyOD library [61] on an Intel i7-9700 $@ 3 . 0 0$ GHz, 64GB RAM, 8-core workstation. We compare two methods statistically, using the pairwise Wilcoxon signed rank test on performances across datasets (significance level $p < 0 . 0 5$ ). ",
+        "bbox": [
+            173,
+            613,
+            825,
+            753
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Testbed Setup. Meta-learning works well if a new task can leverage prior knowledge; e.g., mastering motorcycle can benefit from bike riding experience. As such, METAOD relies on the assumption that a newcoming test dataset shares similarity with some meta-train datasets. We create two testbeds with different train/test dataset similarity, to systematically study the effect of task similarity. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. Proof-of-Concept (POC) testbed contains 100 datasets that form clusters of similar datasets, where 5 different detection tasks (“siblings”) are created from each one of 20 “mothersets”. 2. Stress Testing (ST) testbed consists of 62 independent datasets from 3 different public-domain OD dataset repositories , which exhibit relatively lower similarity to one another. ",
+        "bbox": [
+            173,
+            820,
+            826,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We refer to Appendix E for the complete list of datasets and details on testbed generation. Fig. 2 illustrates the differences between POC and ST testbeds, where the meta-features of their constituting datasets are embedded to 2-D by t-SNE [48]. By construction, POC consists of clusters and hence exhibits higher task/dataset similarity as compared to ST. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/187806346b4a18b8a40e7703cb4981866a220c736e383e1d0c277715f175d301.jpg",
+        "image_caption": [
+            "Figure 2: 2-D embedding of datasets in (left) POC and (right) ST. POC exhibits higher task similarity, wherein “siblings” (marked by same color) form clusters. ST contains independent datasets with no apparent clusters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            92,
+            411,
+            176
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            204,
+            823,
+            233
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Baselines. Being the first work for UOMS, METAOD does not have immediate competing baselines. Therefore we employ simple ideas and tailor some existing methods for comparison. We also create 2 variations of METAOD (marked with $\\dagger .$ ) for ablation analysis. ",
+        "bbox": [
+            176,
+            239,
+            823,
+            281
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Appendix F we give detailed descriptions of all 10 baselines. Briefly, they are organized as follows: (i) no model selection always employs the same popular model, namely (1) LOF [6] or (2) iForest [31], or the ensemble of all the models called (3) Mega Ensemble (ME); (ii) simple metalearners include (4) Global Best (GB) that selects the model with the largest avg. performance across meta-train datasets, (5) ISAC [23] and (6) ARGOSMART (AS) [33]; and (iii) optimization-based meta-learners include (7) Supervised Surrogates (SS) [55] and (8) ALORS [32]. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            371
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Variants of METAOD are (9) $\\mathbf { \\dagger M E T A O D \\_ C }$ where performance and meta-feature matrices are concatenated as $\\mathbf { C } = [ \\mathbf { P } , \\mathbf { M } ] \\in \\mathbb { R } ^ { n \\times ( m + d ) }$ , before factorization, $\\mathbf { C } \\approx \\mathbf { U } \\mathbf { V } ^ { T }$ . Given a test dataset, zeroconcatenated meta-features are projected and reconstructed as $[ \\widehat { \\mathbf { P } } _ { \\mathrm { t e s t } } ; \\widehat { \\mathbf { M } } _ { \\mathrm { t e s t } } ] : = [ 0 \\ldots 0 ; \\mathbf { M } _ { \\mathrm { n e w } } ] \\mathbf { V } \\mathbf { V } ^ { T }$ ; and (10) $\\mathbf { \\dagger M E T A O D \\_ F }$ where $\\mathbf { U }$ is fixed at $\\phi ( \\mathbf { M } )$ after the embedding step and only $\\mathbf { V }$ is optimized. ",
+        "bbox": [
+            174,
+            377,
+            826,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we report Empirical Upper Bound (EUB) (only) for POC, as the performance of the best model on a dataset’s 4 “siblings”; this (valuable) information is not available in practice–hence “upper bound”. For ST with lower task similarity, we include Random Selection (RS) as baseline. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            486
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 POC Testbed Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            361,
+            516
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Testbed Setting. POC testbed is built to simulate the scenario where there are similar meta-train tasks to a given test task. We use the benchmark datasets4 by Emmott et al. [11], who created “childsets” from 20 independent “mothersets” by sampling. Consequently, the childsets generated from the same motherset using the same generation properties (e.g., the frequency of anomalies) can be deemed as “siblings” with large similarity. We build the POC testbed by using 5 siblings from each motherset, resulting in 100 datasets. We split them into 5 folds for cross-validation, each test fold containing 20 independent childsets without siblings. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            625
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c692434cc48d91fe3db1887282b8347589eea80e647c27d770a69a1f7751713.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of avg. rank (lower is better) of methods w.r.t. performance across datasets in POC. Mean AP across datasets (higher is better) shown on lines. METAOD is the topperforming meta-learner, and comparable to EUB. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            648,
+            545,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. In Fig. 3, we observe that METAOD is superior to all baseline methods w.r.t. the average rank and mean average precision (MAP), and performs comparably to the Empirical Upper Bound (EUB). Table 1 (left) shows that METAOD is the only meta-learner that is not significantly different from both EUB $( \\mathbf { M A P = } 0 . 2 0 5 1 )$ ) and the $_ { 4 - t h }$ best model (0.2185). Moreover, METAOD is significantly better than the baselines that do not employ any model selection (LOF (0.1282), iForest (0.1536), and ME (0.1382)), as well as all the other meta-learners including GB (0.1524), ISAC (0.1658) and ALORS (0.1728). For the full POC evaluation, see Appendix G.1. ",
+        "bbox": [
+            173,
+            756,
+            825,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Averaging all models (ME) does not lead to good performance as one may expect. As shown in Fig. 3, ME is the worst baseline by average rank in the POC testbed. Using a single detector, e.g., iForest, is significantly better. This is mainly because some models perform poorly on any given dataset, and ensembling all the models indiscriminately draws overall performance down. Using selective ensembles [36] could be beneficial, however, ensembles of many models are expensive to build in practice. In contrast, METAOD is fast at test time and selects without building any models. ",
+        "bbox": [
+            173,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3624836da7717a2e3f08013452f17b4ca3c11ce4c4124a8df034d06629bf1f9f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ours</td><td>Baseline</td><td>p-value</td><td>Ours</td><td>Baseline</td><td>p-value</td></tr><tr><td>MetaOD MetaOD</td><td>EUB 4-th Best</td><td>0.0522 0.0929</td><td>MetaOD MetaOD</td><td>58-th Best RS</td><td>0.0517 0.0001</td></tr><tr><td>MetaOD</td><td>LOF</td><td>0.0013</td><td>MetaOD</td><td>LOF</td><td>0.0001</td></tr><tr><td>MetaOD</td><td>iForest</td><td>0.0090</td><td>MetaOD</td><td>iForest</td><td>0.1129</td></tr><tr><td>MetaOD</td><td></td><td>0.0004</td><td>MetaOD</td><td></td><td>0.0001</td></tr><tr><td></td><td>ME</td><td></td><td></td><td>ME</td><td></td></tr><tr><td>MetaOD</td><td>GB</td><td>0.0051</td><td>MetaOD</td><td>GB</td><td>0.0030</td></tr><tr><td>MetaOD</td><td>ISAC</td><td>0.0019</td><td>MetaOD</td><td>ISAC</td><td>0.0006</td></tr><tr><td>MetaOD</td><td>AS</td><td>0.2959</td><td>MetaOD</td><td>AS</td><td>0.0009</td></tr><tr><td>MetaOD</td><td>SS</td><td>0.7938</td><td>MetaOD</td><td>SS</td><td>0.0190</td></tr><tr><td>MetaOD</td><td>ALORS</td><td>0.0025</td><td>MetaOD</td><td>ALORS</td><td>0.0001</td></tr><tr><td>MetaOD</td><td>MetaOD_C</td><td>0.6874</td><td>MetaOD</td><td>MetaOD_C</td><td>0.0001</td></tr><tr><td>MetaOD</td><td>MetaOD_F</td><td>0.1165</td><td>MetaOD</td><td>MetaOD_F</td><td>0.0001</td></tr></table>",
+        "bbox": [
+            156,
+            88,
+            537,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            255,
+            825,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Meta-learners perform significantly better than methods without model selection. In particular, four meta-learners (METAOD, SS, METAOD_C, METAOD_F) significantly outperform single outlier detection methods (LOF and iForest) as well as the Mega Ensemble (ME) that averages all the models. METAOD respectively has $5 8 . 7 4 \\%$ , $3 2 . 4 8 \\%$ , and $4 7 . 2 5 \\%$ higher MAP over LOF, iForest, and ME. These results signify the benefits of model selection. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Optimization-based meta learners generally perform better than simple meta learners. Top-3 meta learners by average rank (METAOD, SS, and METAOD_C) are all optimization-based and significantly outperform simple meta-learners like ISAC as shown in Fig. 3. Simple meta-learners weigh meta-features equally for task similarity, whereas others learn which meta-features matter (e.g., regression on meta-features), leading to better results. We find that METAOD respectively achieves $3 3 . 5 3 \\%$ , $2 2 . 7 4 \\%$ , and $4 . 7 3 \\%$ higher MAP than simple meta-learners including GB, ISAC, and AS. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 ST Testbed Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            493,
+            346,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Testbed Setting. When meta-train datasets lack similarity to the test dataset, it is hard to capitalize on prior experience. In the extreme case, meta-learning may not perform better than no-model-selection baselines, e.g., a single detector. To investigate the impact of the train/test similarity on meta-learning performance, we build the ST testbed that consists of 62 public-domain datasets from 3 different repositories (See Appendix E Table 4) with relatively low similarity as shown in Fig. 2. For evaluation on ST, we use leave-one-out cross validation; each time using 61 datasets as meta-train. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/cea78d2a5ca86db9c2179a749d4c94eb12b3952736319ec3d367f8d281767d81.jpg",
+        "image_caption": [
+            "Table 1: Pairwise statistical test results between METAOD and baselines by Wilcoxon signed rank test. Statistically better method shown in bold (both marked bold if no significance). In (left) POC, METAOD is the only meta-learner with no diff. from both EUB and the 4- th best model. In (right) ST, METAOD is the only meta-learner with no statistical diff. from the $5 8 – t h$ best model. It is statistically better than all except iForest. ",
+            "Figure 4: Comparison of avg. rank (lower is better) of methods w.r.t. performance across datasets in ST. Mean AP (higher is better) shown on lines. METAOD outperforms all baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            614,
+            547,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results. For the ST testbed, METAOD still outperforms all baseline methods w.r.t. average rank and MAP as shown in Fig. 4. Table 1 (right) shows that METAOD (0.3382) could select, from a pool of 302, the model that is as good as the $5 8 – t h$ best model (top $20 \\%$ ) per dataset (0.3513) in this challenging testbed. The comparable model changes from the $4 { - } t h$ best per dataset in POC to $5 8 – t h$ best in ST, which is expected due to the lower task similarity to leverage in ST. Notably, all other baselines are worse than the $8 0 { - } t h$ best model with statistical significance. Moreover, METAOD is significantly better than all baselines except iForest. Note that METAOD also significantly outperforms RS, showing that it is able to exploit the meta-train database despite limited task similarity and not simply resorting to random picking. These results suggest that METAOD is a good choice under various extent of similarity among train/test datasets. We refer to Appendix G.2 for detailed ST results on individual ST datasets. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Training stability affects performance for optimization-based methods. Notably, several optimization-based meta-learners, such as ALORS and METAOD_C, do not perform well for ST. We find that the training process of matrix factorization is not stable when latent similarities are weak. In METAOD, we employ two strategies that help stabilize the training. First, we leverage meta-feature based (rather than random) initialization. Second, we use cyclical learning rates that help escape saddle points for better local optima [43]. Consequently, METAOD (0.3382) significantly outperforms ALORS (0.2981) and METAOD_C (0.1946) with $1 3 . 4 5 \\%$ and $7 3 . 7 9 \\%$ higher MAP. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Global methods outperform local methods under limited task similarity. In ST, datasets are less similar and simple meta-learners that leverage task similarity locally often perform poorly. For example, AS selects the model based on the 1-NN, and is likely to fail if the most similar meta-train task is still quite dissimilar to the current task. Notably, the global meta-learner GB outperforms AS and ISAC. Note the opposite ordering among these methods in POC as shown in Fig. 3. In short, effectiveness of simple meta-learners tends to be sensitive to the train/test dataset similarity, which makes them hard to use in general. In contrast, METAOD performs well in both settings. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4 Runtime Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            273,
+            336,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Empowered by meta-training, METAOD (meta-feature generation and model selection) takes less than 1 second on most test datasets, as shown in Fig. 5, where it incurs negligible overhead relative to building/training the selected outlier model ${ \\approx } 1 0 \\%$ on avg.). Fig. 6 corroborates the statement by showing the comparison on the 10 largest datasets in POC. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            357
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/08e711edb6192c86913d387d4db9bc55fff133351b793d7d96be8cf9d2ae443d.jpg",
+        "image_caption": [
+            "Figure 5: METAOD running time at test time in sec.s (left), and percentage of time relative to building the selected model (right). Notice that it is fast, and incurs negligible computational overhead. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            375,
+            813,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/3977eaf46a3db5377566f002678a0687980b13583178d8bce5583d3ad9f4761a.jpg",
+        "image_caption": [
+            "Figure 6: Time for METAOD vs. training of the selected model (on 10 largest datasets in POC). METAOD incurs only negligible overhead (diff. shown w/ black arrows). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            486,
+            532,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Notably, meta-feature extraction may be trivially parallelized whereas the model selection is even faster, e.g., using SUOD [60], effectively taking constant time (See $\\ S 3 . 2 . 2 )$ . ",
+        "bbox": [
+            173,
+            607,
+            823,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            299,
+            678
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We addressed the unsupervised outlier model selection (UOMS) problem without relying on any labels, model evaluations or comparisons for the first time. Our proposed METAOD is a meta-learner, and builds on an extensive pool of historical outlier detection datasets and models. Given a new task, it selects a model based on the past performances of models on similar historical tasks. To effectively capture task similarity, we designed novel problem-specific meta-features. Importantly, METAOD is $( i )$ fully automatic, requiring no supervision at test time, and $( i i )$ lightweight, incurring relatively small selection time overhead prior to outlier model building. Extensive experiments on two large testbeds showed that METAOD significantly improves detection performance over always using some of the most popular outlier models as well as several other meta-learners tailored for UOMS. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We open-source1 METAOD and our meta-learning database for use in practice. We expect metalearning to become more powerful as the meta-train database grows. Therefore, we also share all our code and testbeds with the community to stimulate further advances in automating UOMS. Future work can address UOMS in the continuous hyperparameter space, leverage self-aware learning [28] and conformal prediction [39] to estimate the confidence in selection, and explore the potential bias and fairness issues in OD model selection [10, 42]. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] S. M. Abdulrahman, P. Brazdil, J. N. van Rijn, and J. Vanschoren. Speeding up algorithm selection using average ranking and active testing by introducing runtime. Mach. Learn., 107(1):79–108, 2018.   \n[2] C. C. Aggarwal. Outlier Analysis. Springer, 2013.   \n[3] J. Bergstra and Y. Bengio. Random search for hyper-parameter optimization. J. Mach. Learn. Res., 13:281–305, 2012.   \n[4] H. Bharadhwaj. Meta-learning for user cold-start recommendation. In IJCNN, pages 1–8. IEEE, 2019.   \n[5] B. Bilalli, A. Abelló Gamazo, and T. Aluja Banet. On the predictive power of meta-features in OpenML. International Journal of Applied Mathematics and Computer Science, 27(4):697–712, 2017.   \n[6] M. M. Breunig, H.-P. Kriegel, R. T. Ng, and J. Sander. LOF: Identifying density-based local outliers. In SIGMOD Conference, pages 93–104. ACM, 2000. SIGMOD Record 29(2), June 2000.   \n[7] E. Burnaev, P. Erofeev, and D. Smolyakov. Model selection for anomaly detection. In ICMV, volume 9875 of SPIE Proceedings, page 987525. SPIE, 2015.   \n[8] G. O. Campos, A. Zimek, J. Sander, R. J. G. B. Campello, B. Micenková, E. Schubert, I. Assent, and M. E. Houle. On the evaluation of unsupervised outlier detection: measures, datasets, and an empirical study. Data Min. Knowl. Discov., 30(4):891–927, 2016.   \n[9] J. Chen, S. Sathe, C. C. Aggarwal, and D. S. Turaga. Outlier detection with autoencoder ensembles. In SDM, pages 90–98. SIAM, 2017.   \n[10] I. Davidson and S. S. Ravi. A framework for determining the fairness of outlier detection. In G. D. Giacomo, A. Catalá, B. Dilkina, M. Milano, S. Barro, A. Bugarín, and J. Lang, editors, ECAI 2020 - 24th European Conference on Artificial Intelligence, 29 August-8 September 2020, Santiago de Compostela, Spain, August 29 - September 8, 2020 - Including 10th Conference on Prestigious Applications of Artificial Intelligence (PAIS 2020), volume 325 of Frontiers in Artificial Intelligence and Applications, pages 2465–2472. IOS Press, 2020.   \n[11] A. Emmott, S. Das, T. G. Dietterich, A. Fern, and W.-K. Wong. Anomaly detection meta-analysis benchmarks. 2016.   \n[12] X. Fan, Y. Yue, P. Sarkar, and Y. X. R. Wang. A unified framework for tuning hyperparameters in clustering problems. CoRR, abs/1910.08018, 2019.   \n[13] M. Feurer, B. Letham, and E. Bakshy. Scalable meta-learning for bayesian optimization. CoRR, abs/1802.02219, 2018.   \n[14] M. Feurer, J. T. Springenberg, and F. Hutter. Initializing bayesian hyperparameter optimization via meta-learning. In AAAI, pages 1128–1135. AAAI Press, 2015.   \n[15] L. Franceschi, M. Donini, P. Frasconi, and M. Pontil. Forward and reverse gradient-based hyperparameter optimization. In ICML, volume 70 of Proceedings of Machine Learning Research, pages 1165–1173. PMLR, 2017.   \n[16] J. Fréry, A. Habrard, M. Sebban, O. Caelen, and L. He-Guelton. Efficient top rank optimization with gradient boosting for supervised anomaly detection. In ECML/PKDD, volume 10534, pages 20–35, 2017.   \n[17] M. Goldstein and A. Dengel. Histogram-based outlier score (hbos): A fast unsupervised anomaly detection algorithm. KI-2012: Poster and Demo Track, pages 59–63, 2012.   \n[18] X. He, K. Zhao, and X. Chu. Automl: A survey of the state-of-the-art. Knowl. Based Syst., 212:106622, 2021.   \n[19] F. Hutter, H. H. Hoos, and K. Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In C. A. C. Coello, editor, LION, volume 6683 of Lecture Notes in Computer Science, pages 507–523. Springer, 2011.   \n[20] T. Idé and H. Kashima. Eigenspace-based anomaly detection in computer systems. In W. Kim, R. Kohavi, J. Gehrke, and W. DuMouchel, editors, KDD, pages 440–449. ACM, 2004.   \n[21] K. Järvelin and J. Kekäläinen. Cumulated gain-based evaluation of IR techniques. ACM Transactions on Information Systems (TOIS), 20(4):422–446, 2002.   \n[22] D. R. Jones, M. Schonlau, and W. J. Welch. Efficient global optimization of expensive black-box functions. J. Global Optimization, 13(4):455–492, 1998.   \n[23] S. Kadioglu, Y. Malitsky, M. Sellmann, and K. Tierney. Isac - instance-specific algorithm configuration. In ECAI, volume 215 of Frontiers in Artificial Intelligence and Applications, pages 751–756. IOS Press, 2010.   \n[24] H.-P. Kriegel, M. Schubert, and A. Zimek. Angle-based outlier detection in high-dimensional data. In Y. Li, B. Liu, and S. Sarawagi, editors, KDD, pages 444–452. ACM, 2008.   \n[25] K. Lai, D. Zha, G. Wang, J. Xu, Y. Zhao, D. Kumar, Y. Chen, P. Zumkhawaka, M. Wan, D. Martinez, and X. Hu. TODS: an automated time series outlier detection system. In Thirty-Fifth AAAI Conference on Artificial Intelligence, AAAI 2021, Thirty-Third Conference on Innovative Applications of Artificial Intelligence, IAAI 2021, The Eleventh Symposium on Educational Advances in Artificial Intelligence, EAAI 2021, Virtual Event, February 2-9, 2021, pages 16060–16062. AAAI Press, 2021.   \n[26] H. Lee, J. Im, S. Jang, H. Cho, and S. Chung. MeLU: Meta-learned user preference estimator for cold-start recommendation. In KDD, pages 1073–1082. ACM, 2019.   \n[27] L. Li, K. G. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. J. Mach. Learn. Res., 18:185:1–185:52, 2017.   \n[28] L. Li, M. L. Littman, T. J. Walsh, and A. L. Strehl. Knows what it knows: a framework for self-aware learning. Mach. Learn., 82(3):399–443, 2011.   \n[29] Y. Li, Z. Chen, D. Zha, K. Zhou, H. Jin, H. Chen, and X. Hu. Autood: Neural architecture search for outlier detection. In 37th IEEE International Conference on Data Engineering, ICDE 2021, Chania, Greece, April 19-22, 2021, pages 2117–2122. IEEE, 2021.   \n[30] Y. Li, D. Zha, P. K. Venugopal, N. Zou, and X. Hu. Pyodds: An end-to-end outlier detection system with automated machine learning. In A. E. F. Seghrouchni, G. Sukthankar, T. Liu, and M. van Steen, editors, Companion of The 2020 Web Conference 2020, Taipei, Taiwan, April 20-24, 2020, pages 153–157. ACM / IW3C2, 2020.   \n[31] F. T. Liu, K. M. Ting, and Z.-H. Zhou. Isolation forest. In ICDM, pages 413–422. IEEE Computer Society, 2008.   \n[32] M. Misir and M. Sebag. Alors: An algorithm recommender system. Artif. Intell., 244:291–314, 2017.   \n[33] M. Nikolic, F. Maric, and P. Janicic. Simple algorithm portfolio for sat. Artif. Intell. Rev., 40(4):457–465, 2013.   \n[34] T. Pevný. Loda: Lightweight on-line detector of anomalies. Mach. Learn., 102(2):275–304, 2016.   \n[35] S. Ramaswamy, R. Rastogi, and K. Shim. Efficient algorithms for mining outliers from large data sets. In W. Chen, J. F. Naughton, and P. A. Bernstein, editors, SIGMOD Conference, pages 427–438. ACM, 2000. SIGMOD Record 29(2), June 2000.   \n[36] S. Rayana and L. Akoglu. Less is more: Building selective anomaly ensembles. ACM Trans. Knowl. Discov. Data, 10(4):42:1–42:33, 2016.   \n[37] B. Schölkopf, J. C. Platt, J. Shawe-Taylor, A. J. Smola, and R. C. Williamson. Estimating the support of a high-dimensional distribution. Neural Computation, 13(7):1443–1471, July 2001.   \n[38] B. Schölkopf, R. C. Williamson, A. J. Smola, J. Shawe-Taylor, and J. C. Platt. Support vector method for novelty detection. In NIPS, pages 582–588. The MIT Press, 1999.   \n[39] G. Shafer and V. Vovk. A tutorial on conformal prediction. J. Mach. Learn. Res., 9:371–421, 2008.   \n[40] B. Shahriari, K. Swersky, Z. Wang, R. P. Adams, and N. de Freitas. Taking the human out of the loop: A review of bayesian optimization. Proc. IEEE, 104(1):148–175, 2016.   \n[41] R. E. Shawi, M. Maher, and S. Sakr. Automated machine learning: State-of-the-art and open challenges. CoRR, abs/1906.02287, 2019.   \n[42] S. Shekhar, N. Shah, and L. Akoglu. Fairod: Fairness-aware outlier detection. In M. Fourcade, B. Kuipers, S. Lazar, and D. K. Mulligan, editors, AIES ’21: AAAI/ACM Conference on AI, Ethics, and Society, Virtual Event, USA, May 19-21, 2021, pages 210–220. ACM, 2021.   \n[43] L. N. Smith. Cyclical learning rates for training neural networks. In WACV, pages 464–472. IEEE Computer Society, 2017.   \n[44] D. H. Stern, H. Samulowitz, R. Herbrich, T. Graepel, L. Pulina, and A. Tacchella. Collaborative expert portfolio management. In AAAI. AAAI Press, 2010.   \n[45] J. Tang, Z. Chen, A. W. Fu, and D. W. Cheung. Enhancing effectiveness of outlier detections for low density patterns. In PAKDD, volume 2336 of Lecture Notes in Computer Science, pages 535–548, 2002.   \n[46] D. M. J. Tax and R. P. W. Duin. Support vector data description. Mach. Learn., 54(1):45–66, 2004.   \n[47] S. Vaithyanathan and B. Dom. Generalized model selection for unsupervised learning in high dimensions. In NIPS, pages 970–976. The MIT Press, 1999.   \n[48] L. van der Maaten and G. Hinton. Visualizing high-dimensional data using t-sne. J. of Mach. Lear. Res., 9:2579–2605, 2008.   \n[49] J. Vanschoren. Meta-learning. In Automated Machine Learning, pages 35–61. Springer, 2019.   \n[50] M. Vartak, A. Thiagarajan, C. Miranda, J. Bratman, and H. Larochelle. A meta-learning perspective on cold-start recommendations for items. In NeurIPS, pages 6904–6914, 2017.   \n[51] M. Wistuba, N. Schilling, and L. Schmidt-Thieme. Learning hyperparameter optimization initializations. In DSAA, pages 1–10. IEEE, 2015.   \n[52] M. Wistuba, N. Schilling, and L. Schmidt-Thieme. Scalable gaussian process-based transfer surrogates for hyperparameter optimization. Mach. Learn., 107(1):43–78, 2018.   \n[53] D. H. Wolpert and W. G. Macready. No free lunch theorems for optimization. IEEE Trans. Evolutionary Computation, 1(1):67–82, 1997.   \n[54] Y. Xiao, H. Wang, L. Zhang, and W. Xu. Two methods of selecting gaussian kernel parameters for one-class SVM and their application to fault detection. Knowl. Based Syst., 59:75–84, 2014.   \n[55] L. Xu, F. Hutter, J. Shen, H. H. Hoos, and K. Leyton-Brown. Satzilla2012: Improved algorithm selection based on cost-sensitive classification models. Proceedings of SAT Challenge, pages 57–58, 2012.   \n[56] C. Yang, Y. Akimoto, D. W. Kim, and M. Udell. OBOE: collaborative filtering for AutoML model selection. In KDD, pages 1173–1183. ACM, 2019.   \n[57] L. Yang and A. Shami. On hyperparameter optimization of machine learning algorithms: Theory and practice. Neurocomputing, 415:295–316, 2020.   \n[58] Q. Yao, M. Wang, H. J. Escalante, I. Guyon, Y. Hu, Y. Li, W. Tu, Q. Yang, and Y. Yu. Taking human out of learning applications: A survey on automated machine learning. CoRR, abs/1810.13306, 2018.   \n[59] T. Yu and H. Zhu. Hyper-parameter optimization: A review of algorithms and applications. CoRR, abs/2003.05689, 2020.   \n[60] Y. Zhao, X. Hu, C. Cheng, C. Wang, C. Wan, W. Wang, J. Yang, H. Bai, Z. Li, C. Xiao, Y. Wang, Z. Qiao, J. Sun, and L. Akoglu. SUOD: Accelerating large-scale unsupervised heterogeneous outlier detection. Proceedings of Machine Learning and Systems, 2021.   \n[61] Y. Zhao, Z. Nasrullah, and Z. Li. PyOD: A python toolbox for scalable outlier detection. J. Mach. Learn. Res., 20:96:1–96:7, 2019.   \n[62] Z. Zheng, J. Yang, and Y. Zhu. Initialization enhancer for non-negative matrix factorization. Eng. Appl. Artif. Intell., 20(1):101–110, 2007.   \n[63] C. Zhou and R. C. Paffenroth. Anomaly detection with robust deep autoencoders. In KDD, pages 665–674. ACM, 2017. ",
+        "bbox": [
+            171,
+            79,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            75,
+            828,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            54,
+            828,
+            919
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            88,
+            828,
+            337
+        ],
+        "page_idx": 13
+    }
+]

parse/train/LXMSvPmsm0g/LXMSvPmsm0g.md

@@ -0,0 +1,407 @@
+# LONG LIVE THE LOTTERY: THE EXISTENCE OF WINNING TICKETS IN LIFELONG LEARNING
+
+Tianlong $\mathbf { C h e n ^ { 1 ^ { * } } }$ , Zhenyu Zhang2\*, Sijia $\mathbf { L i u } ^ { 3 , 4 }$ , Shiyu Chang4, Zhangyang Wang1 1University of Texas at Austin,2University of Science and Technology of China 3Michigan State University, 4MIT-IBM Watson AI Lab, IBM Research {tianlong.chen,atlaswang}@utexas.edu, zzy19969@mail.ustc.edu.cn liusiji5@msu.edu, shiyu.chang@ibm.com
+
+# ABSTRACT
+
+The lottery ticket hypothesis states that a highly sparsified sub-network can be trained in isolation, given the appropriate weight initialization. This paper extends that hypothesis from one-shot task learning, and demonstrates for the first time that such extremely compact and independently trainable sub-networks can be also identified in the lifelong learning scenario, which we call lifelong tickets. We show that the resulting lifelong ticket can further be leveraged to improve the performance of learning over continual tasks. However, it is highly non-trivial to conduct network pruning in the lifelong setting. Two critical roadblocks arise: i) As many tasks now arrive sequentially, finding tickets in a greedy weight pruning fashion will inevitably suffer from the intrinsic bias, that the earlier emerging tasks impact more; ii) As lifelong learning is consistently challenged by catastrophic forgetting, the compact network capacity of tickets might amplify the risk of forgetting. In view of those, we introduce two pruning options, e.g., top-down and bottom-up, for finding lifelong tickets. Compared to the top-down pruning that extends vanilla (iterative) pruning over sequential tasks, we show that the bottomup one, which can dynamically shrink and (re-)expand model capacity, effectively avoids the undesirable excessive pruning in the early stage. We additionally introduce lottery teaching that further overcomes forgetting via knowledge distillation aided by external unlabeled data. Unifying those ingredients, we demonstrate the existence of very competitive lifelong tickets, e.g., achieving $3 - 8 \%$ of the dense model size with even higher accuracy, compared to strong class-incremental learning baselines on CIFAR-10/CIFAR-100/Tiny-ImageNet datasets. Codes available at https://github.com/VITA-Group/Lifelong-Learning-LTH.
+
+# 1 INTRODUCTION
+
+The lottery ticket hypothesis (LTH) (Frankle & Carbin, 2019) suggests the existence of an extremely sparse sub-network, within an overparameterized dense neural network, that can reach similar performance as the dense network when trained in isolation with proper initialization. Such a subnetwork together with the used initialization is called a winning ticket (Frankle & Carbin, 2019). The original LTH studies the sparse pattern of neural networks with a single task (classification), leaving the question of generalization across multiple tasks open. Following that, a few works (Morcos et al., 2019; Mehta, 2019) have explored LTH in transfer learning. They study the transferability of a winning ticket found in a source task to another target task. This provides insights on one-shot transferability of LTH. In parallel, lifelong learning not only suffers from notorious catastrophic forgetting over sequentially arriving tasks but also often comes at the price of increasing model capacity. With those in mind, we ask a much more ambitious question:
+
+Does LTH hold in the setting of lifelong learning when different tasks arrive sequentially?
+
+Intuitively, a desirable “ticket” sub-network in lifelong learning (McCloskey & Cohen, 1989; Parisi et al., 2019) needs to be: 1) independently trainable, same as the original LTH; 2) trained to perform competitively to the dense lifelong model, including both maintaining the performance of previous tasks, and quickly achieving good generalization at newly added tasks; 3) found online, as the tasks sequentially arrive without any pre-assumed order. We define such a sub-network with its initialization as a lifelong lottery ticket.
+
+This paper seeks to locate the lifelong ticket in class-incremental learning (CIL) (Wang et al., 2017; Rosenfeld & Tsotsos, 2018; Kemker & Kanan, 2017; Li & Hoiem, 2017; Belouadah & Popescu, 2019; 2020), a popular, realistic and challenging setting of lifelong learning. A natural idea to extend the original LTH is to introduce sequential pruning: we continually prune the dense network until the desired sparsity level, as new tasks are incrementally added. However, we show that the direct application of the iterative magnitude pruning (IMP) used in LTH fails in the scenario of CIL since the pruning schedule becomes critical when tasks arrive sequentially. To circumvent this challenge, we generalize IMP to incorporate a curriculum pruning schedule. We term this technique top-down lifelong pruning. When the total number of tasks is pre-known and small, then with some “lottery” initialization (achieved by rewinding (Frankle et al., 2019) or similar), we find that the pruned sparse ticket can be re-trained to similar performance as the dense network. However, if the number of tasks keeps increasing, the above ticket will soon witness performance collapse as its limited capacity cannot afford the over-pruning.
+
+The limitation of top-down lifelong pruning reminds us of two unique dilemmas that might challenge the validity of lifelong tickets. i) Greedy weight pruning v.s. all tasks’ performance: While the sequential pruning has to be performed online, its greedy nature inevitably biases against later arriving tasks, as earlier tasks apparently will contribute to shaping the ticket more (and might even use up the sparsity budget). ii) Catastrophic forgetting v.s. small ticket size: To overcome the notorious catastrophic forgetting (McCloskey & Cohen, 1989; Tishby & Zaslavsky, 2015), many lifelong learning models have to frequently consolidate weights to carefully re-assign the model capacity (Zhang et al., 2020) or even grow model size as tasks come in (Wang et al., 2017). Those seem to contradict our goal of pruning by seeing more tasks.
+
+To address the above two limitations, we propose a novel bottom-up lifelong pruning approach, which allows for re-growing the model capacity to compensate for any excessive pruning. It therefore flexibly calibrates between increasing and decreasing tickets throughout the entire learning process, alleviating the intrinsic greedy bias caused by the top-down pruning. We additionally introduce lottery teaching to overcome forgetting, which regularizes previous task models’ soft logit outputs by using free unlabeled data. That is inspired by lifelong knowledge preservation techniques (Castro et al., 2018; He et al., 2018; Javed & Shafait, 2018; Rebuffi et al., 2017).
+
+For validating our proposal, we conduct extensive experiments on CIFAR-10, CIFAR-100, and TinyImageNet datasets for class-incremental learning (Rebuffi et al., 2017). The results demonstrate the existence and the high competitiveness of lifelong tickets. Our best lifelong tickets (found by bottom-up pruning and lottery teaching) achieve comparable or better performance across all sequential tasks, with as few as $3 . 6 4 \%$ parameters, compared to state-of-the-art dense models. Our contributions can be summarized as:
+
+• The problem of lottery tickets is formulated and studied in lifelong learning (class incremental learning) for the first time.   
+• Top-down pruning: a generalization of iterative weight magnitude pruning used in the original LTH over continual learning tasks.   
+• Bottom-up pruning: a novel pruning method, which is unique to allow for re-growing model capacity, throughout the lifelong process.   
+• Extensive experiments and analyses demonstrating the promise of lifelong tickets, in achieving superior yet extremely light-weight lifelong learners.
+
+# 2 RELATED WORK
+
+Lifelong Learning A lifelong learning system aims to continually learn sequential tasks and accommodate new information while maintaining previously learned knowledge (Thrun & Mitchell, 1995). One of its major challenges is called catastrophic forgetting (McCloskey & Cohen, 1989; Kirkpatrick et al., 2017; Hayes & Kanan, 2020), i.e., the network cannot maintain expertise on tasks that they have not experienced for a long time.
+
+This paper’s study subject is class-incremental learning (CIL) (Rebuffi et al., 2017; Elhoseiny et al., 2018): a popular, realistic, albeit challenging setting of lifelong learning. CIL requires the model to recognize new classes emerging over time while maintaining recognizing ability over old classes without access to the previous data. Typical solutions are based on regularization (Li & Hoiem, 2017; Kirkpatrick et al., 2017; Zenke et al., 2017; Aljundi et al., 2018a; Ebrahimi et al., 2019), for example, knowledge distillation (Hinton et al., 2015) is a common regularizer to inherit previous knowledge through preserving soft logits of those samples (Li & Hoiem, 2017) while learning new tasks. Besides, several approaches are learning with memorized data (Castro et al., 2018; Javed & Shafait, 2018; Rebuffi et al., 2017; Belouadah & Popescu, 2019; 2020; Lopez-Paz & Ranzato, 2017; Chaudhry et al., 2018). And some generative lifelong learning methods (Liu et al., 2020; Shin et al., 2017) mitigate catastrophic forgetting by generating simulated data of previous tasks. There also exist a few architecture-manipulation-based lifelong learning methods (Rajasegaran et al., 2019; Aljundi et al., 2018b; Hung et al., 2019; Abati et al., 2020; Rusu et al., 2016; Kemker & Kanan, 2017), while their target is dividing a dense model into task-specific parts for lifelong learning, rather than localizing sparse networks and the lottery tickets.
+
+Pruning and Lottery Ticket Hypothesis It is well-known that deep networks could be pruned of excess capacity (LeCun et al., 1990b). Pruning algorithms can be categorized into unstructured (Han et al., 2015b; LeCun et al., 1990a; Han et al., 2015a) and structured pruning (Liu et al., 2017; He et al., 2017; Zhou et al., 2016). The former sparsifies weight elements based on magnitudes, while the latter removes network sub-structures such as channels for more hardware friendliness.
+
+LTH (Frankle & Carbin, 2019) advocates the existence of an independently trainable sparse subnetwork from a dense network. In addition to image classification (Frankle & Carbin, 2019; Liu et al., 2019; Wang et al., 2020; Evci et al., 2019; Frankle et al., 2020; Savarese et al., 2020; You et al., 2020; Ma et al., 2021; Chen et al., 2020a), LTH has been explored widely in numerous contexts, such as natural language processing (Gale et al., 2019; Chen et al., 2020b), reinforcement learning (Yu et al., 2019), generative adversarial networks (Chen et al., 2021b), graph neural networks (Chen et al., 2021a), and adversarial robustness (Cosentino et al., 2019). Most of them adopt unstructured weight magnitude pruning (Han et al., 2015a; Frankle & Carbin, 2019) to obtain the ticket, which we also follow in this work. (Frankle et al., 2019) analyzes large models and datasets, and presents a rewinding technique that re-initializes ticket training from the early training stage rather than from scratch. (Renda et al., 2020) further compares different retraining techniques and endorses the effectiveness of rewinding. (Mehta, 2019; Morcos et al., 2019; Desai et al., 2019) pioneer to study the transferability of the ticket identified on one source task to another target task, which delivers insights on one-shot transferability of LTH.
+
+One latest work (Golkar et al., 2019) aimed at lifelong learning in fixed-capacity models based on pruning neurons of low activity. The authors observed that a controlled way of “graceful forgetting” after training each task can regain network capacity for new tasks, meanwhile not suffering from forgetting. Sokar et al. (2020) further compresses the sparse connections of each task during training, which reduces the interference between tasks and alleviates forgetting.
+
+# 3 LOTTERY TICKET FROM SINGLE-TASK LEARNING TO CIL
+
+# 3.1 PROBLEM SETUP
+
+In CIL, a model continuously learns from a sequential data stream in which new tasks (namely, classification tasks with new classes) are added over time, as shown in Figure 1. At the inference stage, the model can operate without having access to the information of task IDs. Following (Castro et al., 2018; He et al., 2018; Rebuffi et al., 2017), a handful of samples from previous classes are stored in a fixed memory buffer.
+
+![](images/d9cf46adc494e3cda7d85097c2c1e58dce4a092f28f887e850ecc2bee9097a4b.jpg)  
+Figure 1: Basic CIL Setting.
+
+More formally, let $\mathcal { T } _ { 1 } , \mathcal { T } _ { 2 } , \cdots$ represent a sequence of tasks, and the ith task $\mathcal { T } _ { i }$ contains data that fall into $\left( k _ { i } - k _ { i - 1 } \right)$ classes $\mathcal { C } _ { i } = \{ c _ { k _ { i - 1 } + 1 } , c _ { k _ { i - 1 } + 2 } , \cdot \cdot \cdot , c _ { k _ { i } } \}$ , where $k _ { 0 } = 0$ by convention. Let $\Theta ^ { ( i ) } = \{ \pmb { \theta } ^ { ( i ) } , \pmb { \theta } _ { \mathrm { c } } ^ { ( i ) } \}$ denote the model of the learner used at task $i$ , where $\pmb \theta ^ { ( i ) }$ corresponds to the base model cross all tasks from $\mathcal { T } _ { 1 }$ to $\mathcal { T } _ { i }$ , and $\pmb { \theta } _ { \mathrm { c } } ^ { ( i ) }$ denotes the task-specific classification head at $\mathcal { T } _ { i }$ .
+
+Thus, the size of $\pmb \theta ^ { ( i ) }$ is fixed, but the dimension of $\theta _ { \mathrm { c } } ^ { ( i ) }$ aligns with the number of classes, which have been seen at $\mathcal { T } _ { i }$ . In general, the learner has access to two types of information at task $i$ : the current training data $\mathcal { D } ^ { ( i ) }$ , and certain previous information $\mathscr { P } ^ { ( i ) }$ . The latter includes a small amount of data from previous tasks $\{ \mathcal T _ { j } \} _ { 1 } ^ { i - 1 }$ stored in the memory buffer, and the previous model $\Theta ^ { ( i - 1 ) }$ at task $\mathcal { T } _ { i - 1 }$ . This is commonly used to overcome the catastrophic forgetting issue of the current task $i$ against the previous tasks. Based on the aforementioned setting, we state the CIL problem as below.
+
+Problem of CIL. At the current task $i$ , we aim to learn a full model $\Theta ^ { ( i ) } = \{ \pmb { \theta } ^ { ( i ) } , \pmb { \theta } _ { \mathrm { c } } ^ { ( i ) } \}$ based on the information $( \mathcal { D } ^ { ( i ) } , \mathcal { P } ^ { ( i ) } )$ such that $\Theta ^ { ( i ) }$ not only $( I )$ yields the generalization ability to the newly added data at task $\mathcal { T } _ { i }$ but also $( I I )$ does not lose its power to the previous tasks $\{ \mathcal { T } _ { j } \} _ { 1 } ^ { i - 1 }$ .
+
+We note that the aforementioned problem statement applies to CIL with any fixed-length learning period. That is, for $n$ time stamps (one task per time), the validity of the entire trajectory $\{ \Theta ^ { ( i ) } \} _ { 1 } ^ { n }$ is justified by each $\Theta ^ { ( i ) }$ from the CIL criteria $( I )$ and $( I I )$ stated in ‘Problem of CIL’.
+
+# 3.2 LIFELONG LOTTERY TICKETS
+
+It was shown by LTH (Frankle & Carbin, 2019) that a standard (unstructured) pruning technique can uncover the so-called winning ticket, namely, a sparse sub-network together with proper initialization that can be trained in isolation and reach similar performance as the dense network. In this paper, we aim to prune the base model $\pmb \theta ^ { ( i ) }$ over time. And we ask: Do there exist winning tickets in lifelong learning? If yes, how to obtain them? To answer these questions, a prerequisite is to define the notion of lottery tickets in lifelong learning, which we call lifelong lottery tickets.
+
+Following LTH (Frankle & Carbin, 2019), a lottery ticket consists of two parts: 1) a binary mask $\mathbf { m } \in \{ 0 , 1 \} ^ { \| \pmb { \theta } ^ { ( i ) } \| _ { 0 } }$ obtained from a one-shot or iterative pruning algorithm, and 2) initial weights or rewinding weights $\theta _ { 0 }$ . The ticket $( \mathbf { m } , \theta _ { 0 } )$ is a winning ticket if training the subnetwork $\mathbf { m } \odot \pmb { \theta } _ { 0 }$ ( $\odot$ denotes element-wise product), identified by the sparse pattern m with initialization $\pmb { \theta } _ { 0 }$ , wins the initialization lottery to match the performance of the original (fully trained) network. In CIL, at the presence of sequential tasks $\{ \mathcal { T } ^ { ( i ) } \} _ { i = 1 , 2 , \dots }$ , we define lifelong lottery tickets $( \mathbf { m } ^ { ( i ) } , \pmb { \theta } _ { 0 } ^ { ( i ) } )$ recursively from the perspective of dynamical system:
+
+$$
+\begin{array} { r } { \mathbf { m } ^ { ( i ) } = \mathbf { m } ^ { ( i - 1 ) } + A ( \mathcal { D } ^ { ( i ) } , \mathcal { P } ^ { ( i ) } , \mathbf { m } ^ { ( i - 1 ) } ) , \quad \mathrm { a n d } \quad \pmb { \theta } _ { 0 } ^ { ( i ) } \in \{ \pmb { \theta } ^ { ( 0 ) } , \pmb { \theta } _ { \mathrm { r w } } ^ { ( i ) } \} , } \end{array}
+$$
+
+where $\mathcal { A }$ denotes a pruning algorithm used at the current task $\mathscr { T } ^ { ( i ) }$ based on the information $\mathcal { D } ^ { ( i ) }$ , $\mathscr { P } ^ { ( i ) }$ and $\mathbf { m } ^ { ( i - 1 ) }$ , $\pmb { \theta } ^ { ( 0 ) }$ denotes the initialization prior to training the model at $\tau ^ { ( 1 ) }$ , and $\theta _ { \mathrm { r w } } ^ { ( i ) }$ denotes a rewinding point at $\mathscr { T } ^ { ( i ) }$ . In Eq. (1), we interpret the (non-trivial) pruning operation $\mathcal { A }$ by weight perturbations, with values drawn from $\{ - 1 , 0 , 1 \}$ , to the previous binary mask. Here $- 1$ denotes the removal of a weight, 0 signifies to keep a weight intact, and 1 represents the addition of a weight. Moreover, the introduction of weight rewinding is spurred by the so-called rewinding ticket (Renda et al., 2020; Frankle et al., 2020). For example, if $\begin{array} { r } { \bar { \pmb { \theta } } _ { \mathrm { r w } } ^ { ( i ) } = \bar { \pmb { \theta } } ^ { ( i - 1 ) } } \end{array}$ , then we pick the model weights learnt at the previous task $\mathcal { T } ^ { ( i - 1 ) }$ to initialize the training at $\mathscr { T } ^ { ( i ) }$ . We also note that $\pmb { \theta } ^ { ( 0 ) }$ can be regarded as the point rewound to the earliest stage of the lifelong learning. Based on Eq. (1), we then state the definition of winning tickets in CIL.
+
+Lifelong winning tickets. Given a sequence of tasks $\{ \mathcal { T } _ { i } \} _ { 1 } ^ { n }$ , the lifelong lottery tickets $\{ ( \mathbf { m } ^ { ( i ) } , \pmb { \theta } _ { 0 } ^ { ( i ) } ) \} _ { 1 } ^ { n }$ given by $( l )$ are winning tickets if they can be trained in isolation to match the CIL performance (i.e., criteria I and II) of the corresponding full model $\{ \pmb { \theta } ^ { ( i ) } \} _ { 1 } ^ { n }$ , where $n \in \mathbb { N } ^ { + }$ .
+
+In the next section, we will design the lifelong pruning algorithm $\mathcal { A }$ , together with ticket initialization schemes formulated in Eq. (1)
+
+# 4 PROPOSED PRUNING METHOD TO FIND LIFELONG WINNING TICKETS
+
+4.1 REVISITING IMP OVER SEQUENTIAL TASKS: TOP-DOWN (TD) PRUNING
+
+In order to find the potential tickets at the current task $\mathscr { T } ^ { ( i ) }$ , it is natural to specify $\mathcal { A }$ in Eq. (1) as the iterative magnitude pruning (IMP) algorithm (Han et al., 2015a) to prune the model from $\mathbf { m } ^ { ( i - 1 ) } \odot \pmb \theta ^ { ( i - 1 ) }$ . Following (Frankle & Carbin, 2019; Renda et al., 2020), IMP iteratively prunes $p ^ { \frac { 1 } { n ^ { ( i ) } } }$ $( \% )$ non-zero weights of $\mathbf { m } ^ { ( i - 1 ) } \odot \pmb \theta ^ { ( i - 1 ) }$ over $\boldsymbol { n } ^ { ( i ) }$ rounds at $\mathscr { T } ^ { ( i ) }$ . Thus, the number of nonzero weights in the obtained mask $\mathbf { m } ^ { ( i ) }$ is given by $( ( 1 - p ^ { \frac { 1 } { n ^ { ( i ) } } } ) ^ { n ^ { ( i ) } } \cdot \| \mathbf { m } ^ { ( i - 1 ) } \| _ { 0 } )$ . However, in the application of IMP to the sequential tasks $\{ \mathcal T ^ { ( i ) } \}$ , we find that the schedule of IMP over sequential tasks, in terms of $\{ n ^ { ( i ) } \}$ , is critical to make pruning successful in lifelong learning. We refer readers to Appendix A2.1 for detailed justifications.
+
+Curriculum schedule of TD pruning is a key to success The conventional method is to set $\{ n ^ { ( i ) } \}$ as a uniform schedule, namely, IMP prunes a fixed portion of non-zeros at each task. However, this direct application fails quickly as the number of incremental tasks increases, implying that “not all tasks are created equal” in the learning/pruning schedule. Inspired by the recent observation that training with more classes helps consolidate a more robust sparse model (Morcos et al., 2019), we propose a curriculum pruning schedule, in which IMP is conducted more aggressively for new tasks arriving later, with $n ^ { ( \bar { i } ) } \geq n ^ { ( i - 1 ) }$ , until reaching the desired sparsity. For example, if there are 12 times of pruning on five sequentially arrived tasks, we arrange them in a linearly increasing way, i.e., $(  { T _ { 1 } } \colon 1 ,  { T _ { 2 } } \colon 1 ,  { T _ { 3 } } \colon 2 ,  { T _ { 4 } } \colon 3 ,  { T _ { 5 } } \colon 5 )$ . Note that TD pruning relies on the heuristic curriculum schedule, and thus inevitably greedy and suboptimal over continual learning tasks. In what follows, we propose a more advanced pruning scheme, bottom-up (BU) pruning, that obeys a different principle of design.
+
+# 4.2 BOTTOM-UP (BU) LIFELONG PRUNING: AN ADVANCED SCHEME
+
+![](images/c6ec4317eb1e436f789b4037ab8f44024c168c66b9879914363d6730646509fe.jpg)  
+Figure 2: Framework of our proposed bottom-up (BU) lifelong pruning which is based on sparse model consolidation. Tickets founded by BU pruning keep expanding for each newly added task.
+
+Why we need more than top-down pruning? TD pruning is inevitably greedy and suboptimal. Earlier added tasks contribute more to shaping the final mask, due to the nested dependency between intermediate masks. In the later training stage, we often observe the network is already too heavily pruned to learn more tasks. Inspired by the recently proposed model consolidation (Zhang et al., 2020), we propose the BU alternative of lifelong pruning, to dynamically compensate for the excessive pruning by re-growing previously reduced networks.
+
+Full reference model & rewinding point For BU lifelong pruning, we maintain a full (unpruned) model $\theta _ { \mathrm { r e f } } ^ { ( i ) }$ as a reference throughout lifelong learning. First, $\theta _ { \mathrm { r e f } } ^ { ( i ) }$ provides a reference performance $\mathcal { R } _ { \mathrm { r e f } } ^ { ( i ) }$ obtained at $\mathscr { T } ^ { ( i ) }$ . Once the validation accuracy of the current sparse model is no worse than the reference performance, the sparse model is considered to still have sufficient capacity and can be further pruned. Otherwise, capacity expansion is needed. On the other hand, the reference model offers a rewinding point for network parameters, which preserves knowledge of all previous tasks prior to $\mathscr { T } ^ { ( i ) }$ . It naturally extends the rewinding concept (Frankle et al., 2019) to lifelong learning.
+
+BU pruning method BU lifelong pruning expands the previous mask $\mathbf { \delta } _ { m } ( i - 1 )$ to $\mathbf { m } ^ { ( i ) }$ . Different from TD pruning, the model size grows along the task sequence, namely, $\| \mathbf { m } ^ { ( i ) } \| _ { 0 } \geq \| \mathbf { m } ^ { ( i - 1 ) } \| _ { 0 }$ . Thus, BU pruning enforces $\mathcal { A }$ in Eq. (1) to draw non-negative perturbations. As illustrated in Figure 2, for each newly added $\tau _ { i }$ , we first re-train the previous sparse model $\mathbf { m } ^ { ( i - 1 ) } \odot \pmb \theta ^ { ( i - 1 ) }$ under the current information $( \mathcal { D } ^ { ( i ) } , \mathcal { P } ^ { ( i ) } )$ and calculate the validation accuracy $\mathcal { R } ^ { ( i ) }$ . If $\mathcal { R } ^ { ( i ) }$ is above than the reference performance $\mathcal { R } _ { \mathrm { r e f } } ^ { ( i ) }$ , we proceed to keep the sparse mask $\mathbf { m } ^ { ( i ) } = \mathbf { m } ^ { ( i - 1 ) }$ intact and use re-trained $\pmb \theta ^ { ( i - 1 ) }$ as $\pmb \theta ^ { ( i ) }$ at $\mathcal { T } _ { i }$ . Otherwise, an expansion from $\mathbf { m } ^ { ( i - 1 ) }$ is required to ensure sufficient learning capacity. To do so, we restart from the full reference model $\theta _ { \mathrm { r e f } } ^ { ( i ) }$ and iteratively prune its weights using IMP until the performance gets just below $\mathcal { R } _ { \mathrm { r e f } } ^ { ( i ) }$ . Here the previous non-zero weights localized by $\mathbf { m } ^ { ( i - 1 ) }$ are excluded from the pruning scope of IMP but the values of those non-zero weights could be re-trained. As a result, IMP will yield the updated mask $\mathbf { m } ^ { ( i ) }$ with a larger size than $\mathbf { m } ^ { ( i - 1 ) }$ . We repeat the aforementioned BU pruning method when a new task arrives.
+
+Although never observed in our CIL experiments, a potential corner case of expansion is that the ticket size may hit the size of the full model. We consider this as an artifact of limited model capacity and suggest future work of combining lifelong tickets with (full) model growing (Wang et al., 2017).
+
+Ticket initialization Given the pruning mask found by the BU (or TD) pruning method, we next determine the initialization scheme of a lifelong ticket. We consider three specifications of $\pmb { \theta } _ { 0 } ^ { ( i ) }$ in Eq. (1) to initialize the sparse model $\mathbf { m } ^ { ( i ) }$ for re-training the found tickets. They include: (I) $\pmb { \theta } _ { 0 } ^ { ( i ) } = \pmb { \theta } ^ { ( 0 ) }$ , i.e., the original “from the same random” initialization (Frankle & Carbin, 2019), (II) a random re-initialization $\theta _ { \mathrm { r e i n i t } }$ which is independent of $\pmb { \theta } ^ { ( 0 ) }$ , and (III) previous-task rewinding, i.e., $\pmb { \theta } _ { 0 } ^ { ( i ) } = \pmb { \theta } ^ { ( i - 1 ) }$ . The initialization schemes I-III together with $\mathbf { m } ^ { ( i ) }$ yield the following tickets $\mathbf { m } ^ { ( i ) }$ at $\mathscr { T } ^ { ( i ) }$ : (1) BU (or TD) tickets, namely, $\mathbf { m } ^ { ( i ) }$ found by BU (or TD) pruning with initialization I; (2) random BU (or TD) tickets, namely, $\mathbf { m } ^ { ( i ) }$ with initialization II; (3) task-rewinding BU (or TD) tickets, namely, $\mathbf { m } ^ { ( i ) }$ with initialization III. In experiments, we will show that both $B U \left( o r T D \right)$ tickets and their task-rewinding $( T R )$ counterparts are winning tickets, which outperform unpruned full CIL models. Compared BU with TD pruning, TR-BU tickets surpass the best $T D$ tickets.
+
+# 4.3 LOTTERY TEACHING: A PLUG-IN REGULARIZATION
+
+Catastrophic forgetting poses a severe challenge to class-incremental learning, especially for compact models. (Castro et al., 2018; He et al., 2018; Javed & Shafait, 2018; Rebuffi et al., 2017) are early attempts for undertaking the forgetting dilemma by introducing knowledge distillation regularization (Hinton et al., 2015), which employs a handful of stored previous data in addition to new task data. (Zhang et al., 2020) takes advantage of unlabeled data to handle the forgetting quandary.
+
+We adapt their philosophy (Li & Hoiem, 2017; Hinton et al., 2015; Zhang et al., 2020) to presenting lottery teaching, enforcing previous information into the new tickets via a knowledge distillation term on external unlabeled data. Lottery teaching consists of two steps: i) we query more similar unlabeled data “for free” from a public source, by utilizing a small number of prototype samples from previous tasks’ training data. In this way, the storage required for previous tasks could be minimal, while the queried surrogate data functions similarly for our purpose; ii) we then enforce the output soft logits of the current subnetwork $\{ \mathbf { m } ^ { ( i ) } { \odot } \pmb { \theta } ^ { ( i ) } , \pmb { \theta } _ { \mathrm { c } } ^ { ( i ) } \}$ on each queried unlabeled sample $\mathbf { x }$ to be close to the logits from previously trained subnetwork $\{ \mathbf { m } ^ { ( i - 1 ) } \odot \pmb \theta ^ { ( i - 1 ) } , \pmb \theta _ { \mathrm { c } } ^ { ( i - 1 ) } \}$ , via knowledge distillation (KD) regularization based on the ${ \mathrm { K } } { \mathrm { - } } { \mathrm { L } }$ divergence. For all experiments of our methods hereinafter, we by default append the lottery teaching as it is widely beneficial. An ablation study will also follow in Section 5.3.
+
+# 5 EXPERIMENTS
+
+Experimental Setup We briefly discuss the key facts used in our experiments and refer readers to Appendix A2.3 for more implementation details. We evaluate our proposed lifelong tickets on three datasets: CIFAR-10, CIFAR-100, and Tiny-ImageNet. We adopt ResNet18 (He et al., 2016) as our backbone. We evaluate the model performance by standard testing accuracy (SA) averaged over three independent runs.
+
+CIL baseline: We consider a strong baseline framework derived from (Zhang et al., 2019), a recent state-of-the-art (SOTA) method introduced for imbalanced data training (see more illustrations in Appendix A1.1). We implement (Zhang et al., 2019) for CIL, and compare with two latest CIL
+
+SOTAs: iCaRL (Rebuffi et al., 2017) and IL2M (Belouadah & Popescu, 2019)1. Our results demonstrate the adapted CIL method from (Zhang et al., 2019) outperforms the others significantly, $( 1 . 6 5 \%$ SA better than IL2M and $4 . 8 8 \%$ SA better than iCaRL on CIFAR-10)2, establishing a new SOTA bar. The proposed lottery teaching further improves the performance of the baseline adapted from Zhang et al. (2019), given by $4 . 4 \%$ SA improvements on CIFAR-10. Thus, we use (Zhang et al., 2019), combined with/without lottery teaching, to train the original (unpruned) CIL model.
+
+CIL pruning: To the best of our knowledge, we are not aware of any effective CIL pruning baseline comparable to ours. Thus, we focus on the comparison among different variants of our methods. We also compare the proposal with the ordinary IMP, showing its incapability in CIL pruning. Furthermore, we demonstrate that given our proposed pruning frameworks, standard pruning methods such as IMP and $\ell _ { 1 }$ pruning (by imposing $\ell _ { 1 }$ sparsity regularization) then turn to be successful.
+
+Results on TD tickets We begin by showing that TD pruning is non-trivial in CIL. We find that the ordinary IMP (Han et al., 2015a) fails: It leads to $1 0 . 2 1 \%$ SA degradation (from $7 2 . 7 9 \%$ to $6 2 . 5 8 \%$ for SA) with $4 . 4 0 \%$ parameters left. By contrast, our proposed lifelong tickets yield substantially better performance which even surpasses the full dense model, with fewer parameters left than the ordinary IMP (Han et al., 2015a).
+
+In what follows, We evaluate TD lifelong pruning using different weight rewindings, namely, i) $T D$ tickets; ii) random TD tickets; iii) task-rewinding TD tickets; iv) late-rewinding $T D$ tickets; and v) Fine-tuning. The late-rewinding tickets is a strong baseline claimed in Mehta (2019).
+
+Figure 3 and Table A4 demonstrate the high competitiveness of our proposed TD ticket (blue lines). It matches and most of the time outperforms the full model3 (black dash lines). Even with only $6 . 8 7 \%$ model parameters left, the TD ticket still surpasses the dense model by $0 . 4 9 \%$ SA. The task-rewinding tickets, in second place, exceeds the dense model until reaching the extreme sparsity of $4 . 4 0 \%$ . Moreover, we see late-rewinding TD tickets dominate over other rewinding/fine-tuning options, echoing the finding in single-task learning (Frankle et al., 2019).
+
+![](images/3f6d94fed7b2352c8af1c35f8bf439e1373ad7eb94a94845c8beb96e781a8135.jpg)  
+Figure 3: Evaluation performance (standard accuracy) of top-down lifelong tickets on CIFAR-10.
+
+However, TD pruning cannot afford a lot more incremental tasks due to its greedy weight (over)pruning. Our results show that $T D$ tickets pruned from only tasks $\mathcal { T } _ { 1 }$ and $\mathcal { T } _ { 2 }$ clearly overfit the first two tasks, even after incrementally learning the remaining three tasks. In this inappropriate pruning schedule (in contrast to $\mathcal { T } _ { 1 } \sim \mathcal { T } _ { 5 }$ scheme), the resultant ticket drops to $5 9 . 2 8 \%$ SA which is $1 3 . 5 1 \%$ lower than the dense model, as shown in Table A3. More results can be found in the appendix. Therefore, bottom-up lifelong pruning is proposed, as a remedy for relieving laborious tuning of pruning schedules.
+
+Results on BU lifelong tickets The bottom-up lifelong pruning allows the sparse network to regret if they could not deal with the newly added tasks, which compensates for the excessive pruning and reaches a substantially better trade-off between sparsity and generalization ability. Compared to TD pruning, it does not require any heuristic pruning schedules.
+
+In Table 1, we first present the performance of $B U$ tickets, random BU tickets, and task-rewinding BU (TR-BU) tickets, as mentioned in Section 4.2. As we can see, TR-BU tickets obtain the supreme performance. A possible explanation is that task-rewinding (i.e., $\pmb { \theta } _ { 0 } ^ { ( i ) } = \pmb { \theta } ^ { ( i - 1 ) } )$ maintains full information of learned tasks which mitigates the catastrophic forgetting, while other weight rewinding points lack sufficient task information to prevent compact models from forgetting. Next, we observe that TR-BU tickets significantly outperform the full dense model by $0 . 5 \hat { 2 } \%$ SA with only $3 . 6 4 \%$ parameters left and $\ell _ { 1 }$ BU tickets obtain matched performance to the full dense model with $5 . 1 6 \%$ remaining parameters. It suggests that IMP, $\ell _ { 1 }$ and even other adequate pruning algorithms can be plugged into our proposed BU pruning framework to identify the lifelong tickets.
+
+Table 1: Comparison results across full dense model, BU Tickets with different ticket initialization, and $\ell _ { 1 } \ : B U$ Tickets when training incrementally on CIFAR-10. $\mathcal { T } _ { 1 \sim i }$ denotes the learned sequential tasks $\mathcal { T } _ { 1 } \sim \mathcal { T } _ { i }$ .   
+
+<table><tr><td>Dataset Settings</td><td colspan="5">CIFAR-10 (Standard Accuracy /Remaining Weights </td></tr><tr><td></td><td>Ti (%)/100%</td><td>Ti~2 (%)/100%</td><td>Ti~3 (%)/100%</td><td>T1~4 (%)/100%</td><td>Ti~5 (%)/100%</td></tr><tr><td>Full Dense Model</td><td>97.75</td><td>89.10</td><td>82.83</td><td>76.99</td><td>72.79</td></tr><tr><td></td><td>Ti (%) / 2.81%</td><td>T1~2 (%)/3.11%</td><td>T1~3 (%)/3.40%</td><td>T1~4 (%)/3.64%</td><td>T1~5 (%)/3.64%</td></tr><tr><td rowspan="3">BU tickets random BU tickets TR-BU tickets</td><td>98.05</td><td>86.77</td><td>75.87</td><td>70.81</td><td>68.77</td></tr><tr><td>96.55</td><td>82.08</td><td>77.97</td><td>72.84</td><td>71.17</td></tr><tr><td>98.05</td><td>88.90</td><td>81.37</td><td>74.66</td><td>73.31</td></tr><tr><td></td><td>T1 (%)/1.80%</td><td>T1~2 (%)/2.93%</td><td>T1~3 (%) / 2.93%</td><td>T1~4 (%)/4.05%</td><td>T1~5 (%)/5.16%</td></tr><tr><td>lBU tickets</td><td>96.80</td><td>87.05</td><td>77.58</td><td>74.53</td><td>72.88</td></tr></table>
+
+![](images/39849fa0ef64a304f33b29374e876717a62ec85988db50e4cb18091f46a8f135.jpg)  
+Figure 4: Performance and sparsity comparison between TR-BU tickets and $T D$ tickets when training models incrementally. Left: CIFAR-10. Right: CIFAR-100. Upper: Comparison of SA. Bottom: Comparison of remaining weights in tickets. Above all, tickets located by TD pruning continue to shrink with the growth of incremental tasks. On the contrary, tickets founded by BU pruning keep expanding for each newly added task.
+
+In Figure 4, we present the performance comparison between TR-BU tickets (the best subnetworks in Table 1) and TD tickets. TR-BU tickets are identified through bottom-up lifelong pruning, whose sparse masks continue to subtly grow along with the incremental tasks, from sparsity $2 . 8 \mathrm { i } \%$ at the first task to sparsity $3 . 6 4 \%$ at the last task. As we can see, at any incremental learning stage, TR-BU tickets attain a superior performance with significantly fewer parameters. Particularly, after learning all tasks, TR-BU tickets surpass $T D$ tickets by $1 . 0 1 \%$ SA with $0 . 7 6 \%$ fewer weights on CIFAR-10; $3 . 0 7 \%$ with $2 . 4 6 \%$ fewer weights on CIFAR-100. Results demonstrate TR-BU tickets have a better generalization ability and parameter-efficiency compared with $T D$ tickets. In addition, on TinyImageNet in Table A7, TR-BU tickets outperform full model with only $1 2 . 0 8 \%$ remaining weights. It is worth to mention that both TR-BU tickets and TD tickets have a superior performance than full dense model. We refer readers to Table A5 and A6 in the appendix for more detailed results.
+
+From the above results, we further observe that TR-BU tickets achieve comparable accuracy to full models which have more than $\mathbf { 3 0 } \times$ times in network capacity, implying that bottom-up lifelong pruning successfully discovers extremely sparse sub-networks, and yet they are powerful enough to inherit previous knowledge and generalize well on newly added tasks. Furthermore, our proposed lifelong pruning schemes can be directly plugged into other CIL models to identify the lifelong ticket, as shown in Appendix A1.
+
+Ablation studies In what follows, we summarize our results on ablation studies and refer readers to the appendix A1.2.1 for more details. In Figure 5, we show the essential role of the curriculum schedule in TD pruning compared to the uniform pruning schedule. We notice that the curriculum pruning scheme generates stronger $T D$ tickets than the uniform pruning in terms of accuracy, which confirms our motivation that pruning heavier in the late stage of lifelong learning with more classes is beneficial. In Table A8, we demonstrate the effectiveness of our proposals against different numbers of incremental tasks. In the Figure 5, we show that lottery teaching injects previous knowledge through applying knowledge distillation on external unlabeled data, and greatly alleviates the catastrophic forgetting issue in lifelong pruning (i.e., after learning all tasks, utilizing lottery teaching obtains a $\bar { 4 . 3 4 \% }$ SA improvement on CIFAR-10). It is worth mentioning that we set a buffer of fixed storage capacity to store 128 unlabeled images queried from public sources at each training iteration. We find that leveraging newly queried unlabeled data offers a better generalization-ability than storing historical data in past tasks. The latter only reaches $7 0 . 6 0 \%$ SA on CIFAR-10, which is $2 . 1 9 \%$ worse than the use of unlabeled data.
+
+![](images/b2f3e6f0534ecd30183a29f36ad23b0afbbf316203408bfe3dda3871043353e7.jpg)  
+Figure 5: Left: the results of $T D$ Tickets with/without lottery teaching. Right: the comparison of $T D$ tickets $( 1 0 . 7 4 \% )$ obtained from uniform and curriculum pruning schedule. Experiments are conducted on CIFAR-10.
+
+# 6 CONCLUSION
+
+We extend the Lottery Ticket Hypothesis to lifelong learning, in which networks incrementally learn from sequential tasks. We pose top-down and bottom-up lifelong pruning algorithms to identify lifelong tickets. Systematical experiments are conducted to validate that located tickets obtain strong(er) generalization ability across all incremental learned tasks, compared with unpruned models. Our future work aims to explore lifelong tickets with the (full) model growing approach.
+
+# REFERENCES
+
+Davide Abati, Jakub Tomczak, Tijmen Blankevoort, Simone Calderara, Rita Cucchiara, and Babak Ehteshami Bejnordi. Conditional channel gated networks for task-aware continual learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3931–3940, 2020.   
+Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 139–154, 2018a.   
+Rahaf Aljundi, Marcus Rohrbach, and Tinne Tuytelaars. Selfless sequential learning. arXiv preprint arXiv:1806.05421, 2018b.   
+Anonymous. Why lottery ticket wins? a theoretical perspective of sample complexity on sparse neural networks. In Submitted to International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ 8pz6GXZ3YT. under review.   
+Eden Belouadah and Adrian Popescu. Il2m: Class incremental learning with dual memory. In The IEEE International Conference on Computer Vision (ICCV), October 2019.   
+Eden Belouadah and Adrian Popescu. Scail: Classifier weights scaling for class incremental learning. In The IEEE Winter Conference on Applications of Computer Vision, pp. 1266–1275, 2020.   
+Francisco M Castro, Manuel J Mar´ın-Jimenez, Nicol ´ as Guil, Cordelia Schmid, and Karteek Alahari. ´ End-to-end incremental learning. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 233–248, 2018.
+
+Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with a-gem. arXiv preprint arXiv:1812.00420, 2018.
+
+Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Michael Carbin, and Zhangyang Wang. The lottery tickets hypothesis for supervised and self-supervised pre-training in computer vision models. arXiv preprint arXiv:2012.06908, 2020a.
+
+Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Zhangyang Wang, and Michael Carbin. The lottery ticket hypothesis for pre-trained bert networks. arXiv preprint arXiv:2007.12223, 2020b.
+
+Tianlong Chen, Yongduo Sui, Xuxi Chen, Aston Zhang, and Zhangyang Wang. A unified lottery ticket hypothesis for graph neural networks, 2021a.
+
+Xuxi Chen, Zhenyu Zhang, Yongduo Sui, and Tianlong Chen. $\{ \mathrm { G A N } \} \mathrm { s }$ can play lottery tickets too. In International Conference on Learning Representations, 2021b. URL https: //openreview.net/forum?id $=$ 1AoMhc_9jER.
+
+Justin Cosentino, Federico Zaiter, Dan Pei, and Jun Zhu. The search for sparse, robust neural networks. arXiv preprint arXiv:1912.02386, 2019.
+
+Shrey Desai, Hongyuan Zhan, and Ahmed Aly. Evaluating lottery tickets under distributional shifts. arXiv preprint arXiv:1910.12708, 2019.
+
+Sayna Ebrahimi, Mohamed Elhoseiny, Trevor Darrell, and Marcus Rohrbach. Uncertainty-guided continual learning with bayesian neural networks. arXiv preprint arXiv:1906.02425, 2019.
+
+Mohamed Elhoseiny, Francesca Babiloni, Rahaf Aljundi, Marcus Rohrbach, Manohar Paluri, and Tinne Tuytelaars. Exploring the challenges towards lifelong fact learning. In Asian Conference on Computer Vision, pp. 66–84. Springer, 2018.
+
+Utku Evci, Fabian Pedregosa, Aidan Gomez, and Erich Elsen. The difficulty of training sparse neural networks. arXiv preprint arXiv:1906.10732, 2019.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ rJl-b3RcF7.
+
+Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M Roy, and Michael Carbin. The lottery ticket hypothesis at scale. arXiv preprint arXiv:1903.01611, 2019.
+
+Jonathan Frankle, David J. Schwab, and Ari S. Morcos. The early phase of neural network training. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } = \underline { { \underline { { \mathbf { \delta \pi } } } } } .$ Hkl1iRNFwS.
+
+Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574, 2019.
+
+Siavash Golkar, Michael Kagan, and Kyunghyun Cho. Continual learning via neural pruning. arXiv preprint arXiv:1903.04476, 2019.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015a.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1135–1143. Curran Associates, Inc., 2015b.
+
+Tyler L Hayes and Christopher Kanan. Lifelong machine learning with deep streaming linear discriminant analysis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 220–221, 2020.
+
+Chen He, Ruiping Wang, Shiguang Shan, and Xilin Chen. Exemplar-supported generative reproduction for class incremental learning. In British Machine Vision Conference, 2018.
+
+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.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1389–1397, 2017.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Ching-Yi Hung, Cheng-Hao Tu, Cheng-En Wu, Chien-Hung Chen, Yi-Ming Chan, and Chu-Song Chen. Compacting, picking and growing for unforgetting continual learning. In Advances in Neural Information Processing Systems, pp. 13669–13679, 2019.
+
+Khurram Javed and Faisal Shafait. Revisiting distillation and incremental classifier learning. In Asian Conference on Computer Vision, pp. 3–17. Springer, 2018.
+
+Ronald Kemker and Christopher Kanan. Fearnet: Brain-inspired model for incremental learning. arXiv preprint arXiv:1711.10563, 2017.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13):3521–3526, 2017.
+
+A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. Master’s thesis, Department of Computer Science, University of Toronto, 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.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 2, pp. 598–605. Morgan-Kaufmann, 1990a. URL http://papers.nips.cc/paper/250-optimal-brain-damage.pdf.
+
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990b.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE transactions on pattern analysis and machine intelligence, 40(12):2935–2947, 2017.
+
+Xialei Liu, Chenshen Wu, Mikel Menta, Luis Herranz, Bogdan Raducanu, Andrew D Bagdanov, Shangling Jui, and Joost van de Weijer. Generative feature replay for class-incremental learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 226–227, 2020.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2736–2744, 2017.
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $=$ rJlnB3C5Ym.
+
+David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning. In Advances in neural information processing systems, pp. 6467–6476, 2017.
+
+Haoyu Ma, Tianlong Chen, Ting-Kuei Hu, Chenyu You, Xiaohui Xie, and Zhangyang Wang. Good students play big lottery better. arXiv preprint arXiv:2101.03255, 2021.
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pp. 109–165. Elsevier, 1989.
+
+Rahul Mehta. Sparse transfer learning via winning lottery tickets. arXiv preprint arXiv:1905.07785, 2019.
+
+Ari Morcos, Haonan Yu, Michela Paganini, and Yuandong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. In Advances in Neural Information Processing Systems, pp. 4933–4943, 2019.
+
+German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. Neural Networks, 2019.
+
+Jathushan Rajasegaran, Munawar Hayat, Salman H Khan, Fahad Shahbaz Khan, and Ling Shao. Random path selection for continual learning. In Advances in Neural Information Processing Systems, pp. 12669–12679, 2019.
+
+Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pp. 2001–2010, 2017.
+
+Alex Renda, Jonathan Frankle, and Michael Carbin. Comparing rewinding and fine-tuning in neural network pruning. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id ${ . } = { }$ S1gSj0NKvB.
+
+Amir Rosenfeld and John K Tsotsos. Incremental learning through deep adaptation. IEEE transactions on pattern analysis and machine intelligence, 2018.
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016.
+
+Pedro Savarese, Hugo Silva, and Michael Maire. Winning the lottery with continuous sparsification, 2020. URL https://openreview.net/forum?id ${ . } = { }$ BJe4oxHYPB.
+
+Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In Advances in Neural Information Processing Systems, pp. 2990–2999, 2017.
+
+Ghada Sokar, Decebal Constantin Mocanu, and Mykola Pechenizkiy. Spacenet: Make free space for continual learning. arXiv preprint arXiv:2007.07617, 2020.
+
+Sebastian Thrun and Tom M Mitchell. Lifelong robot learning. Robotics and autonomous systems, 15(1-2):25–46, 1995.
+
+Naftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. In 2015 IEEE Information Theory Workshop (ITW), pp. 1–5. IEEE, 2015.
+
+Antonio Torralba, Rob Fergus, and William T Freeman. 80 million tiny images: A large data set for nonparametric object and scene recognition. IEEE transactions on pattern analysis and machine intelligence, 30(11):1958–1970, 2008.
+
+Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. arXiv preprint arXiv:2002.07376, 2020.
+
+Yu-Xiong Wang, Deva Ramanan, and Martial Hebert. Growing a brain: Fine-tuning by increasing model capacity. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2471–2480, 2017.
+
+Haoran You, Chaojian Li, Pengfei Xu, Yonggan Fu, Yue Wang, Xiaohan Chen, Richard G. Baraniuk, Zhangyang Wang, and Yingyan Lin. Drawing early-bird tickets: Toward more efficient training of deep networks. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id $=$ BJxsrgStvr.
+
+Haonan Yu, Sergey Edunov, Yuandong Tian, and Ari S Morcos. Playing the lottery with rewards and multiple languages: lottery tickets in rl and nlp. arXiv preprint arXiv:1906.02768, 2019.
+
+Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. Proceedings of machine learning research, 70:3987, 2017.
+
+Junjie Zhang, Lingqiao Liu, Peng Wang, and Chunhua Shen. To balance or not to balance: A simple-yet-effective approach for learning with long-tailed distributions. arXiv, pp. arXiv–1912, 2019.
+
+Junting Zhang, Jie Zhang, Shalini Ghosh, Dawei Li, Serafettin Tasci, Larry Heck, Heming Zhang, and C-C Jay Kuo. Class-incremental learning via deep model consolidation. In The IEEE Winter Conference on Applications of Computer Vision, pp. 1131–1140, 2020.
+
+Hao Zhou, Jose M Alvarez, and Fatih Porikli. Less is more: Towards compact cnns. In European Conference on Computer Vision, pp. 662–677. Springer, 2016.
+
+# A1 MORE EXPERIMENT RESULTS
+
+# A1.1 MORE BASELINE RESULTS
+
+Comparison with the Latest CIL SOTAs We find (Zhang et al., 2019) can be naturally introduced to class-incremental learning, which tackles the intrinsic training bias between a handful of previously stored data and a large amount of newly added data. It adopts random and class-balanced sampling strategies, combined with an auxiliary classifier, to alleviate the negative impact from imbalanced classes. Extensive results, shown in Table A2, demonstrates that adopting (Zhang et al., 2019) as the simple baseline surpasses previous SOTAs iCaRL (Rebuffi et al., 2017) and IL2M (Belouadah & Popescu, 2019) by a significant performance margin $( 1 . 6 5 \% / 0 . 5 7 \%$ SA better than IL2M and $4 . 8 8 \% / 7 . 6 0 \%$ SA better than iCaRL on CIFAR-10/CIFAR-100, respectively)4, establishing a new SOTA bar. With the assistance of lottery teaching, (Zhang et al., 2019) obtains an extra performance boost, $4 . 4 \%$ SA on CIFAR-10 and $7 . 3 4 \%$ SA on CIFAR-100.
+
+It is worth mentioning that a lifelong ticket also exists in other CIL models. Take IL2M on CIFAR-10 as an example, bottom-up (BU) ticket achieves accuracy $6 8 . 9 2 \%$ with $1 1 . 9 7 \%$ parameters vs. the dense unpruned model with an accuracy of $6 6 . 7 4 \%$ .
+
+Table A2: Comparison between our dense model and two previous SOTA CIL methods on CIFAR10 and CIFAR-100. Reported performance it the final accuracy for each task $\tau$ . Simple baseline donates the dense CIL model (Zhang et al., 2019). Full model represents our proposed framework which combines lottery teaching technique with the simple baseline.   
+
+<table><tr><td colspan="3">Methods</td><td>T1 (%)</td><td>T2 (%)</td><td>T(%)</td><td></td><td>T4 (%)</td><td>T5 (%)</td><td>Average (%)</td><td></td></tr><tr><td colspan="3"></td><td>76.45 78.20</td><td>79.00 64.05</td><td>75.70 60.40</td><td></td><td>50.85 38.95</td><td>35.55 92.10</td><td>63.51 66.74</td><td></td></tr><tr><td colspan="3">Simple Baseline Full Model</td><td>75.05</td><td>71.50</td><td>54.25</td><td></td><td>52.05</td><td>89.10</td><td>68.39</td><td></td></tr><tr><td colspan="3">CIFAR-100</td><td>79.70</td><td>79.12</td><td></td><td>68.23</td><td>63.45</td><td>73.43</td><td>72.79</td><td></td></tr><tr><td colspan="2">Methods iCaRL</td><td>T1(%) T(%)</td><td>T (%)</td><td>T4(%)</td><td>T5(%)</td><td>T6(%)</td><td>T7(%)</td><td>T8 (%)</td><td>Tg(%) T10 (%)</td><td>Average (%)</td></tr><tr><td colspan="2">IL2M</td><td>5.90 7.50 19.90</td><td>4.50</td><td>2.80</td><td>9.00</td><td>8.00</td><td>28.20</td><td>38.50</td><td>59.60 80.20 40.30</td><td>24.42 31.45</td></tr><tr><td colspan="2">Simple Baseline</td><td>24.10</td><td>19.80</td><td>12.90</td><td>21.30</td><td>21.70</td><td>29.90</td><td>34.80</td><td>89.80</td><td></td></tr><tr><td colspan="2">Full Model</td><td>21.20 32.10 29.04</td><td>23.00</td><td>22.70</td><td>21.70</td><td>31.70</td><td>39.60</td><td>33.80</td><td>54.30</td><td>32.02</td></tr><tr><td colspan="2"></td><td></td><td></td><td></td><td></td><td></td><td></td><td>40.20</td><td></td><td></td></tr><tr><td colspan="2"></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td colspan="2"></td><td></td><td></td><td></td><td>32.74</td><td>29.64</td><td></td><td></td><td></td><td></td></tr><tr><td colspan="2"></td><td>33.94</td><td>32.54</td><td>27.94</td><td></td><td></td><td>47.94</td><td>45.34 47.24</td><td>67.24</td><td>39.36</td></tr></table>
+
+Pruning Schedule is Important As shown in Table A3, an inappropriate pruning schedule across $\mathcal { T } _ { 1 } \sim \mathcal { T } _ { 2 }$ , the resultant ticket drops to $5 9 . 2 8 \%$ accuracy which is $1 3 . 5 1 \%$ lower than the dense model. On the contrary, the adequate scheme across $\mathcal { T } _ { 1 } \sim \mathcal { T } _ { 5 }$ in Table A3, generates a TD winning ticket with a higher test accuracy $( + 0 . 4 9 \%$ SA) and extreme fewer parameters $( 6 . 8 7 \% )$ , compared with the dense CIL model.
+
+Table A3: Evaluation performance of TD tickets $( 6 . 8 7 \% )$ ) pruned from different task ranges.   
+
+<table><tr><td rowspan="2">Pruning Schedule</td><td colspan="6">TD Tickets (6.87%) on CIFAR-10</td></tr><tr><td>T1(%)</td><td>T(%)</td><td>T(%)</td><td>T4(%)</td><td>T5(%)</td><td>Average (%)</td></tr><tr><td>Prune acrossT1 ~ T2</td><td>74.05</td><td>88.80</td><td>78.25</td><td>28.40</td><td>26.90</td><td>59.28</td></tr><tr><td>Prune acrossT1 ~ T5</td><td>78.90</td><td>82.15</td><td>71.55</td><td>63.80</td><td>70.00</td><td>73.28</td></tr></table>
+
+# A1.2 MORE LIFELONG TICKETS RESULTS
+
+Top-down Lifelong Tickets We also report several performance reference baselines: (a) Full model, denoting the achievable performance of the dense CIL model (Zhang et al., 2019) combined with lottery teaching. (b) $\mathrm { C I L } _ { \mathrm { l o w e r } }$ denoting a vanilla CIL model without using lottery teaching nor storing/utilizing previous data in any form; (c) $\mathbf { M T } _ { \mathrm { u p p e r } }$ training a dense model using full data from all tasks simultaneously in a multi-task learning scheme. While it is not CIL (and much easier to learn), we consider $\mathbf { M T } _ { \mathrm { u p p e r } }$ as an accuracy “upper bound” for (dense) CIL ; (d) $\mathbf { M T } _ { \mathrm { L T } }$ by directly pruning $\mathbf { M T } _ { \mathrm { u p p e r } }$ to obtain its lottery ticket (Frankle & Carbin, 2019). The detailed evaluation performance of $T D$ tickets at different sparsity levels on CIFAR-10 are collected in Table A4.
+
+![](images/758d9ce1988f728c5714ac7574846153a66bc7c07159187cff47a34b8abd6ef3.jpg)  
+Figure A6: Evaluation performance (standard accuracy) of top-down lifelong tickets. The right figure zooms in the red dash-line box in the left figure.
+
+Table A4: Evaluation performance of $T D$ tickets at different sparsity levels on CIFAR-10. Reported performance is the final accuracy for each task $\tau$ . Differences $( + / - )$ are calculated w.r.t. the full/dense model performance.   
+
+<table><tr><td rowspan="2">Remaining Weights</td><td colspan="6">TD Tickets on CIFAR-10</td></tr><tr><td>T1 (%)</td><td>T2 (%)</td><td>T (%)</td><td>T4 (%)</td><td>T5 (%)</td><td>Average (%)</td></tr><tr><td>MTupper : (100.00%)</td><td>97.48</td><td>97.48</td><td>93.33</td><td>90.83</td><td>94.03</td><td>94.63</td></tr><tr><td>CILlower (100.00%)</td><td>0.00</td><td>0.00</td><td>0.00</td><td>0.00</td><td>93.70</td><td>18.74</td></tr><tr><td>100.00%</td><td>79.70</td><td>79.12</td><td>68.23</td><td>63.45</td><td>73.43</td><td>72.79</td></tr><tr><td>32.77%</td><td>84.30</td><td>80.05</td><td>70.70</td><td>67.75</td><td>69.55</td><td>74.47 + 1.68</td></tr><tr><td>10.74%</td><td>78.90</td><td>77.75</td><td>76.30</td><td>63.55</td><td>71.05</td><td>73.51 + 0.72</td></tr><tr><td>6.87%</td><td>78.90</td><td>82.15</td><td>71.55</td><td>63.80</td><td>70.00</td><td>73.28 + 0.49</td></tr><tr><td>4.40%</td><td>82.25</td><td>78.55</td><td>65.10</td><td>65.38</td><td>70.23</td><td>72.30 - 0.49</td></tr><tr><td>2.25%</td><td>78.20</td><td>78.30</td><td>69.50</td><td>58.20</td><td>65.00</td><td>69.84 - 2.45</td></tr></table>
+
+Bottom-up Lifelong Tickets As shown in Table A5 and Table A6, even compared with the best TD tickets in terms of the trade-off between sparsity and accuracy, TR-BU tickets consistently remain prominent on both CIFAR-10 (a slightly higher accuracy and ${ \mathrm { { \bar { 3 } . 2 3 \% } } }$ fewer weights) and CIFAR100 $( 2 . 3 7 \%$ higher accuracy and $4 . { \bar { 8 } } 8 \%$ fewer weights). From the results, we further observe that TR-BU tickets achieve comparable accuracy to full models which have more than $\mathbf { 3 0 } \times$ times in network capacity, implying that bottom-up lifelong pruning successfully discovers extremely sparse sub-networks, and yet they are powerful enough to inherit previous knowledge and generalize well on newly added tasks.
+
+# A1.2.1 MORE ABLATION RESULTS
+
+Uniform v.s. Curriculum Lifelong Pruning We discuss different pruning schedules of top-down lifelong pruning, which play an essential role in the performance of $T D$ tickets. From the right figure in Figure A7, we notice that the curriculum pruning scheme generates stronger $T D$ tickets than the uniform pruning in terms of accuracy, which confirms our motivation that pruning heavier in the late stage of lifelong learning with more classes is beneficial.
+
+The Number of Incremental Tasks Here we study the influence of increment times in our lifelong learning settings. Table A8 shows the results of $T R \mathrm { - } B U _ { \mathrm { 2 0 } }$ tickets incrementally learn from 20 tasks (5 classes per task); Table A6 presents the results of $T R \mathrm { - } B U _ { 1 0 }$ tickets incrementally learn from 10 tasks (10 classes per task). Comparing between two tickets, $T R \mathrm { - } B U _ { 1 0 }$ tickets reach $6 . 5 5 \%$ higher accuracy at the expense of $1 . 7 7 \%$ more parameters. Possible reasons behind it are that: i) the increasing of incremental learning times aggravates the forgetting issue, which causes $T R \mathrm { - } B U _ { 2 0 }$ tickets fall in a
+
+Table A5: Evaluation performance of TR-BU/TD tickets on CIFAR-10. $\mathcal { T } _ { 1 \sim i }$ , $i \in \{ 1 , 2 , 3 , 4 , 5 \}$ donates that models have learned from $\tau _ { 1 } , \cdots , \tau _ { i }$ incrementally. $\frac { | | { \pmb m } | | _ { 0 } } { | | { \pmb \theta } | | _ { 0 } }$ represents the current network sparsity.   
+
+<table><tr><td rowspan="2">Compact Weights</td><td colspan="10">CIFAR-10</td></tr><tr><td>T1(%)</td><td>mlle Tllo</td><td>T1~2(%)</td><td>mlle Tllo</td><td>T1~3(%)</td><td>mllo T0llo</td><td>T1~4 (%)</td><td>mllo Tllo</td><td>T1~5 (%)</td><td>Umllo T0ll</td></tr><tr><td>MTupper</td><td>=</td><td>-</td><td>=</td><td>-</td><td>=</td><td>-</td><td>-</td><td>-</td><td>94.63</td><td>100.00%</td></tr><tr><td>CILlower</td><td>97.60</td><td>100.00%</td><td>49.80</td><td>100.00%</td><td>32.57</td><td>100.00%</td><td>23.23</td><td>100.00%</td><td>18.74</td><td>100.00%</td></tr><tr><td>Full Model</td><td>97.75</td><td>100.00%</td><td>89.10</td><td>100.00%</td><td>82.83</td><td>100.00%</td><td>76.99</td><td>100.00%</td><td>72.79</td><td>100.00%</td></tr><tr><td>TD tickets (6.87%)</td><td>98.05</td><td>80.00%</td><td>87.55</td><td>64.00%</td><td>80.20</td><td>40.96%</td><td>73.21</td><td>16.78%</td><td>73.28</td><td>6.87%</td></tr><tr><td>TD tickets (4.40%)</td><td>98.10</td><td>80.00%</td><td>87.83</td><td>64.00%</td><td>79.30</td><td>32.77%</td><td>72.34</td><td>13.42%</td><td>72.30</td><td>4.40%</td></tr><tr><td>TR-BU tickets (3.64%)</td><td>96.80</td><td>2.81%</td><td>88.90</td><td>3.11%</td><td>81.37</td><td>3.40%</td><td>74.66</td><td>3.64%</td><td>73.31</td><td>3.64%</td></tr></table>
+
+Table A6: Evaluation performance of TR-BU/TD tickets when training incrementally on CIFAR-100.   
+
+<table><tr><td rowspan="2">Compact Weights</td><td colspan="9">CIFAR-100</td></tr><tr><td>T1 (%)</td><td>mllo Tl</td><td>T1~2 (%)</td><td>mlle Tl</td><td>T1~3 (%)</td><td>mlle T101l</td><td>T1~4 (%)</td><td>mlle Tl</td><td>T1~5 (%) mll T0ll</td></tr><tr><td>MTupper</td><td>-</td><td>-</td><td>=</td><td>=</td><td>=</td><td></td><td>- =</td><td></td><td></td></tr><tr><td>CILlower</td><td>87.40</td><td>100.00%</td><td>44.65</td><td>100.00%</td><td>28.67 100.00%</td><td>20.08</td><td>100.00%</td><td>17.44</td><td>100.00%</td></tr><tr><td>Full Model</td><td>88.30</td><td>100.00%</td><td>74.90</td><td>100.00%</td><td>63.70</td><td>100.00% 53.58</td><td>100.00%</td><td>48.52</td><td>100.00%</td></tr><tr><td>TD Tickets (12.08%)</td><td>88.34</td><td>80.00%</td><td>71.60</td><td>64.00%</td><td>58.80</td><td>51.2% 48.88</td><td>40.96%</td><td>43.60</td><td>32.77%</td></tr><tr><td>TD Tickets (9.66%)</td><td>88.20</td><td>80.00%</td><td>71.50</td><td>64.00%</td><td>58.73</td><td>51.2%</td><td>48.45 40.96%</td><td>44.08</td><td>32.77%</td></tr><tr><td>BU Tickets (7.20%)</td><td>85.70</td><td>5.50%</td><td>74.75</td><td>5.78%</td><td>65.93</td><td>6.07%</td><td>53.15 6.07%</td><td>48.18</td><td>6.07%</td></tr><tr><td>Compact Weights</td><td>T1~6 (%)</td><td></td><td>T~7(%)</td><td>事</td><td>T1~8(%)</td><td>喜 T~9(%)</td><td>事</td><td>T1~10 (%)</td><td></td></tr><tr><td>MTupper</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>74.11</td><td>100.00%</td></tr><tr><td>CILlower</td><td>14.07</td><td>100.00%</td><td>12.64</td><td>100.00%</td><td>10.91</td><td>- 100.00% 9.66</td><td>100.00%</td><td>8.64</td><td>100.00%</td></tr><tr><td>Full Model</td><td>45.82</td><td>100.00%</td><td>44.07</td><td>100.00%</td><td>42.35</td><td>100.00% 40.93</td><td>100.00%</td><td>39.36</td><td>100.00%</td></tr><tr><td>TD Tickets (12.08%)</td><td>41.50</td><td>26.21%</td><td>38.19</td><td>20.97%</td><td>37.28</td><td>16.78% 37.63</td><td>13.42%</td><td>37.42</td><td>12.08%</td></tr><tr><td>TD Tickets (9.66%)</td><td>41.18</td><td>26.21%</td><td>39.37</td><td>20.97%</td><td>38.06</td><td>16.78%</td><td>37.30 13.42%</td><td>36.72</td><td>9.66%</td></tr><tr><td>BU Tickets (7.20%)</td><td>47.58</td><td>6.35%</td><td>43.59</td><td>6.63%</td><td>41.35</td><td>6.63%</td><td>39.80</td><td>6.92%</td><td>39.79 7.20%</td></tr></table>
+
+Table A7: Evaluation performance of TR-BU/TD tickets when training incrementally on TinyImageNet.   
+
+<table><tr><td rowspan="2">Compact Weights</td><td colspan="10">CIFAR-100</td></tr><tr><td>T1 (%)</td><td>喜</td><td>T1~2(%)</td><td>d</td><td>T1~3(%)</td><td></td><td>T1~4 (%)</td><td>事</td><td>T1~5 (%)</td><td></td></tr><tr><td>Full Model</td><td>73.70</td><td>100.00%</td><td>59.60</td><td>100.00%</td><td>52.07</td><td>100.00%</td><td>43.85</td><td>100.00%</td><td>41.32</td><td>100.00%</td></tr><tr><td>BU Tickets (12.08%)</td><td>75.00</td><td>10.74%</td><td>58.60</td><td>11.01%</td><td>54.93</td><td>11.28%</td><td>47.23</td><td>11.28%</td><td>43.36</td><td>11.28%</td></tr><tr><td>Compact Weights</td><td>T1~6(%)</td><td>mlle T0lo</td><td>T1~7 (%)</td><td></td><td>T1~8(%)</td><td></td><td>T1~9 (%)</td><td></td><td>T1~10 (%)</td><td>ml </td></tr><tr><td>Full Model</td><td>37.32</td><td>100.00%</td><td>34.69</td><td>100.00%</td><td>30.23</td><td>100.00%</td><td>29.94</td><td>100.00%</td><td>28.29</td><td>100.00%</td></tr><tr><td>BU Tickets (12.08%)</td><td>36.93</td><td>11.28%</td><td>36.43</td><td>11.54%</td><td>32.41</td><td>11.54%</td><td>29.16</td><td>11.81%</td><td>28.33</td><td>12.08%</td></tr></table>
+
+![](images/744281757d994928d90ae5e3ee90096255c6094a423b39d4dc1c75f2c43c5418.jpg)  
+Figure A7: Left: the results of $T D$ Tickets with/without lottery teaching. Right: the comparison of $T D$ tickets $( 1 0 . 7 4 \% )$ obtained from uniform and curriculum pruning schedule. Experiments are conducted on CIFAR-10.
+
+Table A8: Evaluation performance of TR-BU Tickets when models incrementally learn 20 tasks on CIFAR-100.   
+
+<table><tr><td rowspan="2">Compact Weights</td><td colspan="10">CIFAR-100</td></tr><tr><td>Ti (%)</td><td>mllo T</td><td>T1~2(%)</td><td>Imlle Tl。</td><td>T1~3(%)</td><td>Imlle Tlo</td><td>T1~4 (%)</td><td>lmllo Tl</td><td>T1~5 (%)</td><td>mlle T10ll</td></tr><tr><td>Full Model</td><td>89.20</td><td>100.00%</td><td>73.60</td><td>100.00%</td><td>67.33</td><td>100.00%</td><td>59.40</td><td>100.00%</td><td>52.16</td><td>100.00%</td></tr><tr><td>TR-BU Tickets (5.43%)</td><td>86.80</td><td>2.81%</td><td>75.20</td><td>3.11%</td><td>66.47</td><td>3.40%</td><td>60.75</td><td>3.40%</td><td>53.68</td><td>3.40%</td></tr><tr><td>Compact Weights</td><td>T1~6 (%)</td><td>事</td><td>T1~7(%)</td><td></td><td>T~8(%)</td><td>喜</td><td>T1~9(%)</td><td></td><td>T1~10(%)</td><td></td></tr><tr><td>Full Model TR-BU Tickets (5.43%)</td><td>50.10 50.40</td><td>100.00%</td><td>46.80</td><td>100.00%</td><td>43.35</td><td>100.00%</td><td>41.71</td><td>100.00%</td><td>38.62</td><td>100.00%</td></tr><tr><td></td><td></td><td>3.40%</td><td>47.11</td><td>3.69%</td><td>44.10</td><td>3.98%</td><td>43.29</td><td>4.27%</td><td>38.70</td><td>4.27% mlle</td></tr><tr><td>Compact Weights</td><td>T1~11 (%)</td><td></td><td>T1~12 (%)</td><td>Lmlle 1101l</td><td>T1~13 (%)</td><td></td><td>T1~14 (%)</td><td>mlle 10lo</td><td>T~15(%)</td><td>10</td></tr><tr><td>FullModel TR-BU Tickets (5.43%)</td><td>36.38</td><td>100.00%</td><td>35.77</td><td>100.00%</td><td>35.14</td><td>100.00%</td><td>34.66</td><td>100.00%</td><td>35.41</td><td>100.00%</td></tr><tr><td></td><td>37.35</td><td>4.27%</td><td>35.88</td><td>4.27%</td><td>34.62</td><td>4.27%</td><td>33.87</td><td>4.27%</td><td>35.48</td><td>4.56%</td></tr><tr><td>Compact Weights</td><td>T1~16 (%)</td><td>lmllo T101l</td><td>T1~17 (%)</td><td>mll T0</td><td>T1~18 (%)</td><td>mle 1101l0</td><td>T1~19 (%)</td><td>mllo T10l</td><td>T1~20 (%)</td><td>mllo 10l</td></tr><tr><td>Full Model TR-BU Tickets (5.43%)</td><td>34.43 34.64</td><td>100.00% 4.56%</td><td>33.98 34.13</td><td>100.00% 4.85%</td><td>34.14 33.69</td><td>100.00% 5.14%</td><td>32.65 31.84</td><td>100.00% 5.14%</td><td>33.13 33.24</td><td>100.00% 5.43%</td></tr></table>
+
+worse accuracy decay; ii) at each incremental stage, $T R \mathrm { - } B U _ { 1 0 }$ tickets learn more knowledge (10 v.s.   
+5 classes per task), which requires a large network capacity.
+
+With v.s. Without Lottery Teaching Comparison results between $T D$ tickets with lottery teaching and the ones without lottery teaching are collected in this section. As shown in Figure A7 (left figure), the performance of $T D$ tickets without lottery teaching (black dash curves), quickly falls into a worse decay along with the times of incremental learning increase. After learning all tasks, utilizing lottery teaching obtains a $4 . 3 4 \%$ accuracy improvement on CIFAR-10. It suggests that our proposed lottery teaching injects previous knowledge through applying knowledge distillation on external unlabeled data, and greatly alleviates the catastrophic forgetting issue.
+
+# A2 MORE METHODOLOGY AND IMPLEMENTATION DETAILS
+
+# A2.1 MORE LIFELONG PRUNING DETAILS
+
+![](images/edbf98c405193b3d28322a824338ef390b6e252bb7c52d743cf43f6a199c2aef.jpg)  
+Figure A8: Framework of our proposed top-down lifelong pruning algorithms. The top-down (TD) lifelong pruning performs like iterative magnitude pruning (IMP) by unrolling the sequential tasks. Tickets located by TD pruning continue to shrink with the growth of incremental tasks.
+
+More Technical Details of Top-down Pruning In our implementation, we set $p ^ { \frac { 1 } { n ^ { ( i ) } } } = 2 0 \%$ as (Frankle & Carbin, 2019; Renda et al., 2020) and adjust $\bar { \{ n ^ { ( i ) } \} }$ to control the pruning schedule of IMP over sequential tasks. The aforementioned lifelong pruning method is illustrated in Figure A8, and we call it top-down lifelong pruning since the model size is sequentially reduced, namely, $\| \mathbf { m } ^ { ( i ) } \| _ { 0 } \leq \| \mathbf { m } ^ { ( i - 1 ) } \| _ { 0 }$ .
+
+Pruning Algorithms We summarize the workflow of the top-down pruning and bottom-up pruning in Algorithm 1 and 2, respectively. For pruning hyperparameters, we follow the original LTH’s setting (Frankle & Carbin, 2019), i.e. $\Delta p \overset { \cdot } { = } 2 0 \%$ . If we change $\Delta p$ to $4 0 \%$ , it will drop $2 . 0 4 \%$ accuracy at the same sparsity level on CIFAR-10.
+
+# A2.2 MORE CLASS-INCREMENTAL LEARNING DETAILS
+
+Lottery teaching regularization In order to mitigate the catastrophic forgetting effect, we apply knowledge distillation (Hinton et al., 2015) ${ \mathcal { R } } _ { \mathrm { K D } }$ to enforce the similarity between previous $\hat { \pmb { y } }$ and
+
+current $\textbf {  { y } }$ soft logits on unlabeled data. We state ${ \mathcal { R } } _ { \mathrm { K D } }$ as follows:
+
+$$
+\begin{array} { r l } { \mathcal { R } _ { \mathrm { K D } } ( { \pmb y } , \hat { \pmb y } ) = - \mathcal { H } ( t ( \pmb { y } ) , t ( \hat { \pmb y } ) ) } & { { } } \\ { = - \displaystyle \sum _ { j } t ( \pmb { y } ) _ { j } \log t ( \hat { \pmb y } ) _ { j } } \end{array}
+$$
+
+where $\begin{array} { r } { t ( \pmb { y } ) _ { i } = \frac { ( \pmb { y } _ { i } ) ^ { 1 / \operatorname { T } } } { \sum _ { j } ( \pmb { y } _ { j } ) ^ { 1 / \operatorname { T } } } } \end{array}$ = (yi)1/TPj (yj )1/T , T = 2 in our case, following the standard setting in (Hinton et al., 2015;   
+Li & Hoiem, 2017).
+
+# Algorithm 1: Top-Down Pruning
+
+Input: Full dense model $f ( \pmb { \theta } _ { 0 } , \pmb { \theta } _ { \mathrm { c } } ^ { ( 0 ) } ; { \bf x } )$ , a desired sparsity $P _ { m }$ , samples $\mathbf { x }$ from a storage $s$ and sequential tasks $\mathcal { T } _ { 1 \sim n }$ , soft logits from previous model on queried unlabeled data, pruning ratio $\Delta p$ Output: An updated sparse model $f ( \pmb \theta \odot m , \pmb \theta _ { \mathrm { c } } ^ { ( n ) } ; \mathbf x )$   
+1 Set $i = 1$ and mask $m = \mathbf { 1 } \in \mathbb { R } ^ { | | \pmb \theta | | _ { 0 } }$   
+2 Train $f ( \pmb { \theta } _ { 0 } \odot \pmb { m } , \pmb { \theta } _ { \mathrm { c } } ^ { ( 0 ) } ; \mathbf { x } )$ with data from $s$ and $\mathcal { T } _ { 1 }$ .   
+3 while $\begin{array} { r } { 1 - \frac { | | { \boldsymbol m } | | _ { 0 } } { | | { \boldsymbol \theta } | | _ { 0 } } \leq P _ { m } } \end{array}$ and $i \leq n$ do   
+4 Iterative weight magnitude (IMP) pruning $\Delta p$ and obtaining new mask $\tilde { m }$ , where $| | \tilde { m } | | _ { 0 } < | | m | | _ { 0 }$   
+5 Rewind weight to $\pmb { \theta } _ { 0 }$   
+6 $\scriptstyle { m = m }$   
+7 Retrain $f ( \pmb { \theta } _ { 0 } \odot \pmb { m } , \pmb { \theta } _ { \mathrm { c } } ^ { ( i ) } ; \mathbf { x } )$ on the current task $\mathcal { T } _ { i }$ and $s$ . Lottery teaching is applied (A knowledge distillation constrain with soft logits)   
+8 Set $i = i + 1$   
+9 end
+
+# Algorithm 2: Bottom-Up Pruning
+
+Input: $f ( \pmb { \theta } _ { 0 } , \pmb { \theta } _ { \mathrm { c } } ^ { ( 0 ) } ; { \bf x } )$ , $P _ { m }$ , x, soft logits and $\Delta p$ defined in Algorithm 1, $f ( \pmb \theta _ { i } , \pmb \theta _ { \mathrm { c } } ^ { ( i ) } ; { \bf x } )$ has learned $\mathcal { T } _ { 1 \sim i }$ and has performance $\mathcal { R } _ { i } ^ { * }$ , $i \in \{ 1 , \cdots , n \}$ Output: An updated sparse model $f ( \pmb \theta \odot \tilde { m } , \pmb \theta _ { \mathrm { c } } ^ { ( \bar { n } ) } ; { \bf x } )$ 1 Set i = 1 and mask m˜ = 0 ∈ R||θ||0 2 Train $f ( \pmb { \theta } _ { 0 } \odot \tilde { m } , \pmb { \theta } _ { \mathrm { c } } ^ { ( 0 ) } ; \mathbf { x } )$ with data from $s$ and $\mathcal { T } _ { 1 }$ . Calculate accuracy $\mathcal { R } _ { 1 }$ . 3 while $i \leq n$ and $| | \tilde { m } | | _ { 0 } < | | \pmb { \theta } | | _ { 0 } \ \mathbf { d o }$ 4 if $\mathcal { R } _ { i } \geq \mathcal { R } _ { i } ^ { * }$ or $| | \tilde { m } | | _ { 0 } = | | \pmb { \theta } | | _ { 0 }$ then 5 Continue 6 else 7 Start from $f ( \pmb { \theta } _ { i } , \pmb { \theta } _ { \mathrm { c } } ^ { ( i ) } ; \mathbf { x } ) , \pmb { m } = 1$ 8 repeat 9 pruning $\Delta p$ of $\pmb { \theta } _ { i } \odot ( \pmb { m } - \tilde { \pmb { m } } )$ , obtain new mask $m ^ { * }$ , where $| | m ^ { * } | | _ { 0 } \geq | | \tilde { m } | | _ { 0 }$ and $\tilde { \pmb { m } } \in \ b { m } ^ { * }$ 10 Retrain $f ( \pmb { \theta } _ { i - 1 } \odot \pmb { m } ^ { * } , \pmb { \theta } _ { \mathrm { c } } ^ { ( i ) } ; \mathbf { x } )$ and calculate accuracy $\mathcal { R } _ { i }$ 11 m = m∗ 12 until $\mathcal { R } _ { i } \sim \mathcal { R } _ { i } ^ { * }$ and set $\tilde { m } = m ^ { * }$ ; 13 end 14 Set $i = i + 1$ 15 end
+
+Our Dense Full CIL Model We consider a strong baseline framework derived from (Zhang et al., 2019) with our proposed lottery teaching as our dense full CIL model. It adopts random and classbalanced sampling strategies, an auxiliary classifier, and the knowledge distillation regularizer ${ \mathcal { R } } _ { \mathrm { K D } }$ . For incrementally learning task $\mathcal { T } _ { i }$ , the training objective is depicted as:
+
+$$
+\mathcal { L } _ { \mathrm { C I L } } ( \pmb { \theta } , \pmb { \theta } _ { c } ^ { ( i ) } , \pmb { \theta } _ { a } ^ { ( i ) } ) = \gamma _ { 2 } \times \mathcal { L } ( \pmb { \theta } , \pmb { \theta } _ { c } ^ { ( i ) } ) + \mathcal { L } ( \pmb { \theta } , \pmb { \theta } _ { a } ^ { ( i ) } )
+$$
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \pmb { \theta } , \pmb { \theta } _ { c } ^ { ( i ) } ) = \mathbb { E } _ { ( \mathbf { x } , \mathbf { y } ) \in \mathcal { D } _ { b } } \left[ \mathcal { L } _ { \mathrm { X E } } ( f ( \pmb { \theta } , \pmb { \theta } _ { c } ^ { ( i ) } , \mathbf { x } ) , \mathbf { y } ) \right] } \\ & { \quad \quad \quad \quad + \gamma _ { 1 } \times \mathbb { E } _ { \mathbf { x } \in \mathcal { D } _ { u } } \left[ \mathcal { R } _ { \mathrm { K D } } ( f ( \pmb { \theta } , \pmb { \theta } _ { c } ^ { ( i ) } , \mathbf { x } ) , \hat { \pmb { y } } _ { c } ) \right] , } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \pmb { \theta } , \pmb { \theta } _ { a } ^ { ( i ) } ) = \mathbb { E } _ { ( \mathbf { x } , \mathbf { y } ) \in \mathcal { D } _ { r } } \left[ \mathcal { L } _ { \mathrm { X E } } ( f ( \pmb { \theta } , \pmb { \theta } _ { a } ^ { ( i ) } , \mathbf { x } ) , \mathbf { y } ) \right] } \\ & { ~ + ~ \gamma _ { 1 } \times \mathbb { E } _ { \mathbf { x } \in \mathcal { D } _ { u } } \left[ \mathcal { R } _ { \mathrm { K D } } ( f ( \pmb { \theta } , \pmb { \theta } _ { a } ^ { ( i ) } , \mathbf { x } ) , \hat { \pmb { y } } _ { a } ) \right] , } \end{array}
+$$
+
+where $\mathcal { D } _ { b }$ is the class-balanced sampled dataset, $\mathcal { D } _ { r }$ represents the randomly sampled dataset, and $\mathcal { D } _ { u }$ stands for the queried unlabeled dataset. $\theta _ { c } ^ { ( i ) }$ ) and θ(i)a are the main and auxiliary classifiers. $\hat { y } _ { c }$ and $\hat { { \bf y } } _ { a }$ are soft logits on previous tasks of the main and auxiliary classifiers. We adopt $\gamma _ { 1 } = 1 , \gamma _ { 2 } =$ 0.5 in our experiment according to grid search.
+
+# A2.3 MORE OTHER IMPLEMENTATION DETAILS
+
+Datasets and Task Splittings We evaluate our proposed lifelong tickets on CIFAR-10, CIFAR100, and Tiny-ImageNet datasets, all being standard and state-of-the-art benchmarks for CIL (Krizhevsky & Hinton, 2009). For all three datasets, we randomly split the original training dataset into training and validation with a ratio of $9 : 1$ . On CIFAR-10, we divide the 10 classes into splits of 2 classes with a random order $( 1 0 / 2 = 5$ tasks); On CIFAR-100, we divide the 100 classes into splits of 10 classes with a random order $( 1 0 0 / 1 0 = 1 0 $ tasks); On Tiny-Imagenet, we divide the 200 classes into splits of 20 classes with a random order $( 2 0 0 / 2 0 = 1 0 $ tasks). In this way, when models learn a new incoming task, the dimension of classifiers will increase by 2 for CIFAR-10, 10 for CIFAR-100, and 20 for Tiny-ImageNet. Additionally, 100 images, 10 images, and 5 images per class of learned tasks will be stored for CIFAR-10, CIFAR-100, and Tiny-ImageNet respectively.
+
+Unlabeled Dataset All queried unlabeled data for CIFAR-10/CIFAR-100 are from 80 Million Tiny Image dataset (Torralba et al., 2008), and for Tiny-ImageNet are from ImageNet dataset (Krizhevsky et al., 2012). At each incremental learning stage, 4, 500, 450 and 450 images per class of learned tasks will be queried, based on the feature similarity with stored prototypes $\{ \mathbf { m } ^ { ( i - 1 ) } \odot { \pmb \theta } ^ { ( i - 1 ) } , { \pmb \theta } _ { \mathrm { c } } ^ { ( i - 1 ) } \}$ in top-down Pruning and $\{ \pmb \theta ^ { ( i - 1 ) } , \pmb \theta _ { \mathrm { c } } ^ { ( i - 1 ) } \}$ in bottom-up Pruning at the $i ^ { \mathrm { t h } }$ CIL stage for CIFAR-10, CIFAR-100, and Tiny-ImageNet respectively. The feature similarity is defined by $\ell _ { 2 }$ norm distance.
+
+Training and Evaluation Models are trained using Stochastic Gradient Descent (SGD) with 0.9 momentum and $5 \times 1 0 ^ { - 4 }$ weight decay. For 100 epochs training, a multi-step learning rate schedule is conducted, starting from 0.01, then decayed by 10 times at epochs 60 and 80. During the iterative pruning, we retrain the model for 30 epochs using a fixed learning rate of $1 0 ^ { - 4 }$ . The batch size for both labeled and unlabeled data is 128. We pick the trained model of the highest validation accuracy and report their performance on the hold-out testing set.
+
+Other Training Details (i) CIFAR-10 and CIFAR-100 can be download at https://www.cs. toronto.edu/˜kriz/cifar.html. (ii) 80 Million Tiny Image dataset is referred to http: //horatio.cs.nyu.edu/mit/tiny/data/index.html. (iii) All of our experiments are conducted on NVIDIA GTX 1080-Ti GPUs.
+
+# A3 DISCUSSION
+
+Challenges of Theoretical Analysis and Future Work The theoretical justification of the lottery ticket hypothesis is very limited, except for very shallow networks (Anonymous, 2021). In the meantime, class-incremental learning makes the theoretical analysis more difficult. It is a challenging lifelong learning problem, and the current progress lies in the empirical side rather than the theoretical side. The theoretical analysis is out of scope for this paper and we would like to explore it in the future.

parse/train/RUQ1zwZR8_/RUQ1zwZR8_.md

@@ -0,0 +1,200 @@
+# Differentially Private Learning with Adaptive Clipping
+
+Galen Andrew galenandrew@google.com
+
+Om Thakkar omthkkr@google.com
+
+H. Brendan McMahan mcmahan@google.com
+
+Swaroop Ramaswamy swaroopram@google.com
+
+# Abstract
+
+Existing approaches for training neural networks with user-level differential privacy (e.g., DP Federated Averaging) in federated learning (FL) settings involve bounding the contribution of each user’s model update by clipping it to some constant value. However there is no good a priori setting of the clipping norm across tasks and learning settings: the update norm distribution depends on the model architecture and loss, the amount of data on each device, the client learning rate, and possibly various other parameters. We propose a method wherein instead of a fixed clipping norm, one clips to a value at a specified quantile of the update norm distribution, where the value at the quantile is itself estimated online, with differential privacy. The method tracks the quantile closely, uses a negligible amount of privacy budget, is compatible with other federated learning technologies such as compression and secure aggregation, and has a straightforward joint DP analysis with DP-FedAvg. Experiments demonstrate that adaptive clipping to the median update norm works well across a range of realistic federated learning tasks, sometimes outperforming even the best fixed clip chosen in hindsight, and without the need to tune any clipping hyperparameter.
+
+# 1 Introduction
+
+Deep learning has become ubiquitous, with applications as diverse as image processing, natural language translation, and music generation [27, 13, 28, 7]. Deep models are able to perform well in part due to their ability to utilize vast amounts of data for training. However, recent work has shown that it is possible to extract information about individual training examples using only the parameters of a trained model [12, 30, 26, 8, 19]. When the training data potentially contains privacy-sensitive user information, it becomes imperative to use learning techniques that limit such memorization.
+
+Differential privacy (DP) [10, 11] is widely considered a gold standard for bounding and quantifying the privacy leakage of sensitive data when performing learning tasks. Intuitively, DP prevents an adversary from confidently making any conclusions about whether some user’s data was used in training a model, even given access to arbitrary side information. The formal definition of DP depends on the notion of neighboring datasets: we will refer to a pair of datasets $D , D ^ { \prime } \in \mathcal { D }$ as neighbors if $D ^ { \prime }$ can be obtained from $D$ by adding or removing one element.
+
+Definition 1.1 (Differential Privacy). A (randomized) algorithm $M : { \mathcal { D } }  { \mathcal { R } }$ with input domain $\mathcal { D }$ and output range $\mathcal { R }$ is $( \varepsilon , \delta )$ -differentially private if for all pairs of neighboring datasets $D , D ^ { \prime } \in \mathcal { D }$ , and every measurable $S \subseteq \mathcal { R }$ , we have $\operatorname* { P r } \left( M ( D ) \in S \right) \leq e ^ { \varepsilon } \cdot \operatorname* { P r } \left( M ( D ^ { \prime } ) \in S \right) + \delta$ , where probabilities are with respect to the coin flips of $M$ .
+
+Following McMahan et al. [18], we define two common settings of privacy corresponding to two different definitions of neighboring datasets. In example-level DP, datasets are considered neighbors when they differ by the addition or removal of a single example [9, 4, 2, 22, 31, 23, 15]. In user-level DP, neighboring datasets differ by the addition or removal of all of the data of one user [18]. Userlevel DP is the stronger form, and is preferred when one user may contribute many training examples to the learning task, as privacy is protected even if the same privacy-sensitive information occurs in all the examples from one user. In this paper, we will describe the technique and perform experiments in terms of the stronger user-level form, but we note that example-level DP can be achieved by simply giving each user a single example.
+
+To achieve user-level DP, we employ the Federated Averaging algorithm [17], introduced as a decentralized approach to model training in which the training data is left distributed on user devices, and each training round aggregates updates that are computed locally. On each round, a sample of devices are selected for training, and then each selected device performs potentially many steps of local SGD over minibatches of its own data, sending back the model delta as its update.
+
+Bounding the influence of any user in Federated Averaging is both necessary for privacy and often desirable for stability. One popular way to do this to cap the $L _ { 2 }$ norm of its model update by projecting larger updates back to the ball of norm $C$ . Since such clipping also effectively bounds the $L _ { 2 }$ sensitivity of the aggregate with respect to the addition or removal of any user’s data, adding Gaussian noise to the aggregate is sufficient to obtain a central differential privacy guarantee for the update [9, 4, 2]. Standard composition techniques can then be used to extend the per-update guarantee to the final model [20].
+
+Setting an appropriate value for the clipping threshold $C$ is crucial for the utility of the private training mechanism. Setting it too low can result in high bias since we discard information contained in the magnitude of the gradient. However setting it too high entails the addition of more noise, because the amount of Gaussian noise necessary for a given level of privacy must be proportional to the norm bound (the $L _ { 2 }$ sensitivity), and this will eventually destroy model utility. The clipping bias-variance trade-off was observed empirically by McMahan et al. [18], and was theoretically analyzed and shown to be an inherent property of differentially private learning by Amin et al. [3].
+
+Learning large models using the Federated Averaging/SGD algorithm [17, 18] can take thousands of rounds of interaction between the central server and the clients. The norms of the updates can vary as the rounds progress. Prior work [18] has shown that decreasing the value of the clipping threshold after training a language model for some initial number of rounds can improve model accuracy. However, the behavior of the norms can be difficult to predict without prior knowledge about the system, and if it is difficult to choose a fixed clipping norm for a given learning task, it is even more difficult to choose a parameterized clipping norm schedule.
+
+While there has been substantial work on DP techniques for learning, almost every technique has hyperparameters which need to be set appropriately for obtaining good utility. Besides the clipping norm, learning techniques have other hyperparameters which might interact with privacy hyperparameters. For example, the server learning rate in DP SGD might need to be set to a high value if the clipping threshold is very low, and vice-versa. Such tuning for large networks can have an exorbitant cost in computation and efficiency, which can be a bottleneck for real-world systems that involve communicating with millions of samples for training a single network. Tuning may also incur an additional cost for privacy, which needs to be accounted for when providing a privacy guarantee for the released model with tuned hyperparameters (though in some cases, hyperparameters can be tuned using the same model and algorithm on a sufficiently-similar public proxy dataset).
+
+Related Work The heuristic of clipping to the median update norm was suggested by Abadi et al. [1], but no method for doing so privately was proposed, nor was the heuristic empirically tested. One possibility would be to estimate the median unclipped update norm at each round privately by adding noise calibrated to the smooth sensitivity as defined by Nissim et al. [21]. However this approach has several drawbacks compared to the algorithm we will present. It would require the clients to send their unclipped updates to the server at each round,1 which is incompatible with the foundational principle of federated learning to transmit only focused, minimal updates, and precluding the use of secure aggregation [5] and certain forms of compression [16, 6]. Also, by incorporating information across multiple rounds, our method is able to track the underlying quantile closely, with less jitter associated with sampling at each round, and using only a negligible fraction of the privacy budget.
+
+![](images/57b22a692fa6898eae5a74218e1b3d2cc146c07e465d86897df33e1e2eafc421.jpg)  
+Figure 1: Loss functions to estimate the 0.01-, 0.5-, 0.75-, and 0.99-quantiles for a random variable $X$ that uniformly takes values in $\{ 1 5 , 2 5 , 2 8 , 4 0 , 4 5 , 4 8 \}$ . The loss function is the average of convex piecewise-linear functions, one for each value. For instance, for the median $( \gamma = 0 . 5 )$ , this is just $\begin{array} { r } { \dot { \ell } _ { \gamma } ( C ; X ) = \frac { 1 } { 2 } | X - C | } \end{array}$ , where $X$ is the random value, and $C$ is the estimate. When we average these functions, we arrive at the yellow function in the plot showing the average loss, which indeed is minimized by any value between the central two elements, i.e., in the interval [28, 40]. The function for $\gamma = 0 . 7 5$ is minimized at $C = 4 5$ because $\operatorname* { P r } ( X \leq C ) < 0 . 7 5$ for values $C$ in [40, 45), while $\operatorname* { P r } ( X \leq C ) > 0 . 7 5$ for values $C$ in (45, 48].
+
+Contributions In this paper, we describe a method for adaptively and privately tuning the clipping threshold to track a given quantile of the update norm distribution during training. The method uses a negligible amount of privacy budget, and is compatible with other FL technologies such as compression and secure aggregation [5, 6]. We perform a careful empirical comparison of our adaptive clipping method to a highly optimized fixed-clip baseline on a suite of realistic and publicly available FL tasks to demonstrate that high-utility and high-privacy models—sometimes exceeding any fixed clipping norm in utility—can be trained using our method without the need to tune any clipping hyperparameter.
+
+# 2 Private adaptive quantile clipping
+
+In this section, we will describe the adaptive strategy that can be used for adjusting the clipping threshold so that it comes to approximate the value at a specified quantile.
+
+Let $X \in \mathbb { R }$ be a random variable, let $\gamma \in [ 0 , 1 ]$ be a quantile to be matched. For any $C$ , define
+
+$$
+\ell _ { \gamma } ( C ; X ) = { \left\{ \begin{array} { l l } { ( 1 - \gamma ) ( C - X ) } & { { \mathrm { i f ~ } } X \leq C , } \\ { \gamma ( X - C ) } & { { \mathrm { o t h e r w i s e , } } } \end{array} \right. }
+$$
+
+so
+
+$$
+\ell _ { \gamma } ^ { \prime } ( C ; X ) = { \left\{ \begin{array} { l l } { ( 1 - \gamma ) } & { { \mathrm { i f ~ } } X \leq C , } \\ { - \gamma } & { { \mathrm { o t h e r w i s e . } } } \end{array} \right. }
+$$
+
+Hence, $\begin{array} { r } { \mathbb { E } [ \ell _ { \gamma } ^ { \prime } ( C ; X ) ] = ( 1 - \gamma ) \operatorname* { P r } [ X \leq C ] - \gamma \operatorname* { P r } [ X > C ] = \operatorname* { P r } [ X \leq C ] - \gamma } \end{array}$ . For $C ^ { * }$ such that $\mathbb { E } [ \ell _ { \gamma } ^ { \prime } ( C ^ { * } ; X ) ] = 0$ , we have $\operatorname* { P r } ( X \leq C ^ { * } ) = \gamma$ . Thus, $C ^ { * }$ is the $\gamma ^ { \mathrm { t h } }$ quantile of $X$ . Because the loss is convex and has gradients bounded by 1, we can get an online estimate of $C$ that converges to the $\gamma ^ { \mathrm { t h } }$ quantile of $X$ using online gradient descent (see, e.g., Shalev-Shwartz [25]). See Figure 1 for a plot of the loss for a random variable that takes six values with equal probability.
+
+Suppose at some round we have $m$ samples of $X$ , with values $( x _ { 1 } , \ldots , x _ { m } )$ . The average derivative of the loss for that round is
+
+$$
+\begin{array} { r l } & { \bar { \ell } _ { \gamma } ^ { \prime } ( C ; X ) = \displaystyle \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \{ \displaystyle { ( 1 - \gamma ) \quad \mathrm { i f } \ x _ { i } \le C } ,  } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  = \displaystyle \frac { 1 } { m } \bigg ( ( 1 - \gamma ) \sum _ { i \in [ m ] } \mathbb { I } _ { x _ { i } \le C } - \gamma \sum _ { i \in [ m ] } \mathbb { I } _ { x _ { i } > C } \bigg ) = \bar { b } - \gamma , } \end{array}
+$$
+
+where $\begin{array} { r } { \bar { b } \triangleq \frac { 1 } { m } \sum _ { i \in [ m ] } \mathbb { I } _ { x _ { i } \leq C } } \end{array}$ is the empirical fraction of samples with value at most $C$ . For a given learning rate $\eta _ { C }$ , we can perform the update: $C \gets C - \eta _ { C } ( \bar { b } - \gamma )$ .
+
+Geometric updates. Since $\bar { b }$ and $\gamma$ take values in $[ 0 , 1 ]$ , the linear update rule above changes $C$ by a maximum of $\eta _ { C }$ at each step. This can be slow if $C$ is on the wrong order of magnitude. At the other extreme, if the optimal value of $C$ is orders of magnitude smaller than $\eta _ { C }$ , the update can be very coarse, and may overshoot to become negative. To remedy such issues, we propose the following geometric update rule: $C \gets C \cdot \exp ( - \eta _ { C } ( \bar { b } - \gamma ) )$ . This update rule converges quickly to the true quantile even if the initial estimate is off by orders of magnitude. It also has the attractive property that the variance of the estimate around the true quantile at convergence is proportional to the value at that quantile. In our experiments, we use the geometric update rule with $\eta _ { C } = 0 . 2$ .
+
+# 2.1 DP-FedAvg with adaptive quantile clipping
+
+Let $m$ be the number of users in a round and let $\gamma \in [ 0 , 1 ]$ denote the target quantile of the norm distribution at which we want to clip. For iteration $t \in [ T ]$ , let $C ^ { t }$ be the clipping threshold, and $\eta _ { C }$ be the learning rate. Let $\mathcal { Q } ^ { t }$ be set of users sampled in round $t$ . Each user $i \in \mathcal { Q } ^ { t }$ will send the bit $b _ { i } ^ { t }$ along with the usual model delta update $\Delta _ { i } ^ { t }$ , where $b _ { i } ^ { t } = \mathbb { I } _ { | | \Delta _ { i } ^ { t } | | _ { 2 } \leq C ^ { t } }$ . Defining $\begin{array} { r } { \bar { b } ^ { t } = \frac { 1 } { m } \sum _ { i \in \mathcal { Q } ^ { t } } b _ { i } ^ { t } } \end{array}$ we would like to apply the update $C \gets C \cdot \exp ( - \eta _ { C } ( \bar { b } - \gamma ) )$ . However, we can’t use ${ \bar { b } } ^ { t }$ directly, since it may reveal private information about the magnitude of users’ updates. To remedy this, we add Gaussian noise to the sum: $\begin{array} { r } { \tilde { b } ^ { t } = \frac { 1 } { m } \left( \sum _ { i \in \mathcal { Q } ^ { t } } \bar { b } _ { i } ^ { t } + \mathcal { N } ( O , \sigma _ { b } ^ { 2 } ) \right) } \end{array}$ . The DPFedAvg algorithm with adaptive clipping is shown in Algorithm 1. We augment basic federated averaging with server momentum, which improves convergence [14, 24].2
+
+# Algorithm 1 DPFedAvg-M with adaptive clipping
+
+function $\mathrm { T r a i n } ( m , \gamma , \eta _ { c } , \eta _ { s } , \eta _ { C } , z , \sigma _ { b } , \beta )$ Initialize model $\theta ^ { 0 }$ , clipping bound $C ^ { 0 }$ z∆ ← z−2 − (2σb)−2
−1/2 for each round $t = 0 , 1 , 2 , \ldots { \dot { \mathbf { c } } }$ o ${ \mathcal { Q } } ^ { t } \gets$ (sample $m$ users uniformly) for each user $i \in \mathcal { Q } ^ { t }$ in parallel do $\begin{array} { r l } & { \quad ( \Delta _ { i } ^ { t } , b _ { i } ^ { t } ) \gets \mathrm { ~ F e d A v g } ( i , \theta ^ { t } , \eta _ { c } , C ^ { t } ) } \\ & { \sigma _ { \Delta } \gets z _ { \Delta } C ^ { t } } \\ & { \tilde { \Delta } ^ { t } = \frac { 1 } { m } \left( \sum _ { i \in \mathcal { Q } ^ { t } } \Delta _ { i } ^ { t } + \mathcal { N } ( 0 , I \sigma _ { \Delta } ^ { 2 } ) \right) } \\ & { \bar { \Delta } ^ { t } = \beta \bar { \Delta } ^ { t - 1 } + ( 1 - \beta ) \tilde { \Delta } ^ { t } } \\ & { \theta ^ { t + 1 } \gets \theta ^ { t } + \eta _ { s } \bar { \Delta } ^ { t } } \\ & { \tilde { b } ^ { t } = \frac { 1 } { m } \left( \sum _ { i \in \mathcal { Q } ^ { t } } b _ { i } ^ { t } + \mathcal { N } ( O , \sigma _ { b } ^ { 2 } ) \right) } \end{array}$
+
+$C ^ { t + 1 } \gets C ^ { t } \cdot \exp \left( - \eta _ { C } ( \tilde { b } ^ { t } - \gamma ) \right)$ function FedAvg(i, θ0, η, C) θ ← θ0 $\mathcal { G } $ (user i’s local data split into batches) for batch $g \in { \mathcal { G } }$ do $\begin{array} { r l } & { \quad \theta \gets \theta - \eta \nabla \ell ( \theta ; g ) } \\ & { \Delta \gets \theta - \theta ^ { 0 } } \\ & { b \gets \mathbb { I } _ { | | \Delta | | \leq C } } \\ & { \Delta ^ { \prime } \gets \Delta \cdot \operatorname* { m i n } \left( 1 , \frac { C } { | | \Delta | | } \right) } \\ & { \mathrm { ~ r e t u r n } \left( \Delta ^ { \prime } , b \right) } \end{array}$
+
+![](images/d1f5d3ef5dfde7726538c717f8da8f80339ce3990f0c0907a44973a4dd5dbc83.jpg)  
+Figure 2: Evolution of the quantile estimate on data drawn from log-normal distributions. The three plots use data drawn from the exponential of $\mathcal { N } ( 0 . 0 , 1 . 0 )$ , $\mathcal { N } ( \bar { 0 . 0 } , 0 . 1 )$ , and $\mathcal { N } ( \log { 1 0 } , 1 . 0 )$ , respectively. Curves are shown for each of five quantiles: (0.1, 0.3, 0.5, 0.7, 0.9), and the dashed lines show the true value at each quantile. Hyperparameters are as discussed in the text and used in the experiments of Section 3: $\eta _ { C } = 0 . 2 , C ^ { 0 } \stackrel { \sim } { = } 0 . \dot { 1 } , m = 1 0 0 , \sigma _ { b } = m / 2 0$ . After an initial phase of exponential growth, the true quantile is fairly closely tracked. A smaller value of $\eta _ { C }$ would allow more accurate tracking at the cost of slower convergence, but since the quantile value is only used as a heuristic for clipping, a small amount of noise is tolerable. The entire sequence of values estimated for each target quantile satisfy $( 0 . 0 3 4 , n ^ { - 1 . 1 } )$ -differential privacy using RDP composition across the 200 rounds assuming fixed-size samples of $m = 1 0 0$ out of a total population of $\bar { n } = 1 0 ^ { 6 }$ [29].
+
+Theorem 1. One step of $D P$ -FedAvg with adaptive clipping using $\sigma _ { b }$ noise standard deviation on the clipped counts $\sum b _ { i } ^ { t }$ and $z _ { \Delta }$ noise multiplier on the vector sums $\sum \Delta _ { i } ^ { t }$ is equivalent (so far as privacy accounting is concerned) to one step of non-adaptive $D P$ -FedAvg with noise multiplier $z$ if we set z∆ = z−2 − (2σb)−2
−1/2.
+
+Proof. We make a conceptual change to the algorithm that does not change the behavior or privacy properties but allows us to analyze each step as if it were a single private Gaussian sum. Instead of sending $( \Delta _ { i } ^ { t } , b _ { i } ^ { t } )$ , each user sends $( \hat { \Delta } _ { i } ^ { t } , \hat { b } _ { i } ^ { t } ) \triangleq \big ( \Delta _ { i } ^ { t } / \sigma _ { \Delta } , ( b _ { i } ^ { t } - \scriptscriptstyle 1 / 2 ) / \sigma _ { b } \big )$ . The server adds noise with covariance $I$ and averages, then reverses the transformation so $\begin{array} { r } { \tilde { \Delta } ^ { t } = \frac { \sigma _ { \Delta } } { m } \biggl ( \sum _ { i \in \mathcal { Q } ^ { t } } \hat { \Delta } _ { i } ^ { t } + \mathcal { N } ( 0 , I ) \biggr ) } \end{array}$ and $\begin{array} { r } { \tilde { b } ^ { t } = \frac { \sigma _ { b } } { m } \left( \sum _ { i \in \mathcal { Q } ^ { t } } \hat { b } _ { i } ^ { t } + \mathcal { N } ( 0 , 1 ) \right) + 1 / 2 } \end{array}$ . Noting that $\vert \vert ( \hat { \Delta } _ { i } ^ { t } , \hat { b } _ { i } ^ { t } ) \vert \vert \leq S \triangleq \left( ( C ^ { t } / \sigma _ { \Delta } ) ^ { 2 } + \left( 1 / 2 \sigma _ { b } \right) ^ { 2 } \right) ^ { 1 / 2 }$ , it is clear that the two Gaussian sum queries of Algorithm 1 are equivalent to pre- and post-processing of a single query with sensitivity $S$ and covariance $I$ , or noise multiplier $z = { \overset { \cdot } { 1 } } / s = \overset { \cdot } { \left( z _ { \Delta } ^ { - 2 } + ( 2 \sigma _ { b } ) ^ { - 2 } \right) ^ { - 1 / 2 } }$ Rearranging yields the result.
+
+In practice, we recommend using a value of $\sigma _ { b } = m / 2 0$ . Since the noise is Gaussian, this implies that the error $| \tilde { b } ^ { t } - \bar { b } ^ { t } |$ will be less than 0.1 with $9 5 . 4 \%$ probability, and will be no more than 0.15 with $9 9 . 7 \%$ probability. Even in this unlikely case, assuming a geometric update and a learning rate of $\eta _ { C } = 0 . 2$ , the error on the update would be a factor of $\exp ( 0 . 2 \times 0 . 1 5 ) = 1 . 0 3$ , a small deviation. So this default gives high privacy for an acceptable amount of noise in the quantile estimation process. Using Thm. 1, we can compute that to achieve an effective combined noise multiplier of $z = 1$ , with $m = 1 0 0$ clients per round, the noise multiplier $z _ { \Delta }$ is approximately 1.005. So we are paying only a factor of $0 . 5 \%$ more noise on the updates for adaptive clipping with the same privacy guarantee (a quantity which only gets smaller with increasing $m$ ). These constants $\zeta \sigma _ { b } = m / 2 0$ and $\eta _ { C } = 0 . 2 $ ) are what we use in the experiments of Section 3.
+
+The clipping norm can be initialized to any value $C ^ { 0 }$ that is safely on the low end of the expected norm distribution. If it is too high and needs to adapt downward, a lot of noise may be added at the beginning of model training, which may swamp the model. However there is little danger in setting it quite low, since the geometric update will make it grow exponentially until it matches the true quantile. In our experiments we use an initial clip of 0.1 for all tasks. It is easy to compute that with a learning rate of $\eta _ { C } = 0 . 2$ and a target quantile of $\gamma = 0 . 5$ , if every update is clipped, the quantile estimate will increase by a factor of ten every 23 iterations. In order to show the effectiveness of the algorithm at tracking a known quantile, we ran it on simulated data for which we can compute the true quantile exactly. Figure 2 shows the result of this experiment.
+
+<table><tr><td>Task</td><td>model</td><td>N</td><td>n</td><td>T</td><td>2</td><td>m</td><td>nc</td><td>ns</td><td>Cmin</td><td>Cmax</td></tr><tr><td>CIFAR-100</td><td>ResNet</td><td>11M</td><td>500</td><td>4000</td><td>0.669</td><td>2231</td><td>0.1</td><td>0.32</td><td>0.75</td><td>2.2</td></tr><tr><td>EMNIST-CR</td><td>CNN</td><td>1.2M</td><td>3400</td><td>1500</td><td>0.513</td><td>513</td><td>0.032</td><td>1.0</td><td>0.28</td><td>0.85</td></tr><tr><td>EMNIST-AE</td><td>Deep AE</td><td>2.8M</td><td>3400</td><td>3000</td><td>0.659</td><td>2197</td><td>3.2</td><td>1.78</td><td>0.22</td><td>0.95</td></tr><tr><td>SHAKESPEARE</td><td>C-LSTM</td><td>820k</td><td>715</td><td>1200</td><td>0.510</td><td>510</td><td>1.0</td><td>0.32</td><td>0.25</td><td>3.6</td></tr><tr><td>SO-NWP</td><td>W-LSTM</td><td>4.1M</td><td>342k</td><td>1500</td><td>1.396</td><td>13958</td><td>0.18</td><td>1.78</td><td>0.30</td><td>1.6</td></tr><tr><td>SO-LR</td><td>Multi-LR</td><td>5M</td><td>342k</td><td>1500</td><td>1.396</td><td>13958</td><td>320.0</td><td>1.78</td><td>16.0</td><td>135.0</td></tr></table>
+
+Table 1: Dataset statistics and chosen hyperparameters. Left: model type, number of trainable parameters $N$ , number of training clients $n$ , and the number of training rounds $T$ used (following Reddi et al. [24]). Middle: the noise multiplier $z$ and number of clients per round $m$ necessary to achieve $( 5 , n ^ { - 1 . 1 } )$ -DP with less than $5 \%$ model performance loss if each task had a population of $n = 1 0 ^ { 6 }$ [29]. Right: the optimal unclipped baseline client and server learning rates (Sec. 3.1) for each task and chosen values of minimum and maximum fixed clips (Sec. 3.2).
+
+# 3 Experiments
+
+To empirically validate the approach, we examine the behavior of our algorithm on six of the public benchmark federated learning tasks defined by Reddi et al. [24], which are to our knowledge the most realistic and representative publicly available federated learning tasks that exist to date. All six tasks are non-i.i.d. with respect to user partitioning: indeed with the exception of CIFAR-100, the data is partitioned according to the actual human user who generated the data, for example the writer of the EMNIST characters or the Stack Overflow user who asked or answered a question. Table 1 (left) lists the characteristics of the datasets.
+
+Two of the tasks derived from Stack Overflow data (SO-NWP and SO-LR) are ideal for DP research due to the very high number of users (342k) making it possible to train models with good user-level privacy without sacrificing accuracy. The other four tasks (CIFAR-100, EMNIST-AE, EMNISTCR, SHAKESPEARE) are representative learning tasks, but not representative population sizes for real world cross-device FL applications. Therefore we focus on establishing that adaptive clipping works well with 100 clients per round on these tasks in the regime where the noise is at a level such that utility is just beginning to degrade. Under the assumption that a larger population were available, one could increase $m$ , $\sigma _ { \Delta }$ , and $\sigma _ { b }$ proportionally to achieve comparable utility with high privacy. This should not significantly affect convergence (indeed, it might be beneficial) since the only effect is to increase the number of users in the average $\tilde { \Delta } ^ { t }$ , reducing the variance. Table 1 (middle) shows the number of clients per round with which our experiments indicate we could achieve $( 5 , n ^ { - 1 . 1 } )$ -DP for each dataset with acceptable model performance loss (less than $5 \%$ relative to non-private training, as discussed later) if each dataset had $n = 1 0 ^ { 6 }$ clients, using RDP composition with fixed-size subsampling [29].3
+
+# 3.1 Baseline client and server learning rates
+
+Reddi et al. [24] provide optimized client and server learning rates for federated averaging with momentum that serve as a starting point for our experimental setup. For almost all hyperparameters (model configuration, evaluation metrics, client batch size, total rounds, etc.) we replicate their experiments, but with two changes. First, we increase the number of clients per round to 100 for all tasks. This reduces the variance in the updates to a level where we can reasonably assume that adding more clients is unlikely to significantly change convergence properties [18]. Second, as shown in Algorithm 1 we use unweighted federated averaging, thus eliminating the need to set yet another difficult-to-fit hyperparameter: the expected total weight of clients in a round. Since these changes might require different settings, we reoptimize the client and server learning rates for our baseline with no clipping or noise. We ran a small grid of 25 configurations for each task jointly exploring client and server learning rates whose logarithm (base-10) differs from the values in Table 10 of Reddi et al. [24] by $\{ \ - \% , - \% , 0 , \% , \% \}$ . The optimal baseline client and server learning rates for our experimental setup are shown in Table 1 (right).
+
+![](images/2ec1b01a4de94b8799a7e8fb558e4a9eaaff48f80e1394d63db50c5946bcdebb.jpg)  
+Figure 3: Impact of clipping without noise. Performance of the unclipped baseline compared to five settings of $\gamma$ , from $\gamma = 0 . 1$ (aggressive clipping) to $\gamma = 0 . 9$ (mild clipping). The values shown are the evaluation metrics on the validation set averaged over the last 100 rounds. Note that the $y$ -axes have been compressed to show small differences, and that for EMNIST-AE lower values are better.
+
+Because clipping (whether fixed or adaptive) reduces the average norm of the client updates, it may be necessary to use a higher server learning rate to compensate. Therefore, for all approaches with clipping—fixed or adaptive—we search over a small grid of five server learning rates, scaling the values in Table 1 by $\{ 1 , \bar { 1 0 } ^ { 1 / 4 } , 1 0 ^ { 1 / 2 } , 1 0 ^ { 3 / 4 } , 1 0 \}$ . For all configurations, we report the best performing model whose server learning rate was chosen from this small grid on the validation set.4
+
+We first examine the impact of adaptive clipping without noise to see how it affects model performance. Figure 3 compares baseline performance without clipping to adaptive clipping with five different quantiles. For each quantile, we show the best model after tuning over the five server learning rates mentioned above on the validation set. On three tasks (CIFAR-100, EMNIST-AE, SO-NWP), clipping improves performance relative to the unclipped baseline. On SHAKESPEARE and SO-LR performance is slightly worse, but we can conclude that adaptive clipping to the median generally fares well compared to not using clipping across tasks. Note that for our primary goal of training with DP, it is essential to limit the sensitivity one way or another, so the modest decrease in performance observed from clipping on some tasks may be part of the inevitable tension between privacy and utility.
+
+# 3.2 Fixed-clip baselines
+
+We would like to compare our adaptive clipping approach to a fixed clipping baseline, but comparing to just one fixed-clip baseline may not be enough to demonstrate that adaptive clipping consistently performs well. Instead, our strategy will be to show that quantile-based adaptive clipping performs as well or nearly as well as any fixed clip chosen in hindsight. If we can first identify clipping norms that span the range of normal values during training on each problem/configuration, we can compare adaptive clipping to fixed clipping with those norms.
+
+To that end, we first use adaptive clipping without noise to discover the value of the update norm distribution at the following five quantiles: $\{ 0 . 1 , 0 . 3 , 0 . 5 , 0 . 7 , 0 . 9 \}$ . Then we choose as the minimum of our fixed clipping range the smallest value at the 0.1 quantile over the course of training, and as the maximum the largest value at the 0.9 quantile. Plots of the update norms during training on each of the tasks are shown in Figure 4.
+
+On each task there is a ramp up period where the clipping norm, initialized to 0.1 for all tasks, catches up to the correct norm distribution. Thus we disregard norm values collected until the actual fraction of clipped counts ${ \bar { b } } ^ { t }$ on some round is within 0.05 of the target quantile $\gamma$ . The chosen values for the minimum and maximum fixed clips for each task are shown in Table 1 (right). Our fixed-clipping baseline uses five fixed clipping norms logarithmically spaced in that range. Here we are taking advantage of having already run adaptive clipping to minimize the number of fixed clip settings we need to explore for each task. If we had to explore over the entire range knowing only the endpoints across all tasks (0.22, 135.0) at the same resolution, we would need nearly four times as many clip values per task.
+
+![](images/9e360036a130b659110b98cc143adc5ef96360edab933f3e124db82ccad6d299.jpg)  
+0.10.3  0.10.3  0.10.3Figure 4: Evolution of the adaptive clipping norm at five different quantiles (0.1, 0.3, 0.5, 0.7, 0.9) 0.50.70.9 0.50.70.9 0.70.9on each task with no noise. The norms are estimated using geometric updates with $\eta _ { C } = 0 . 2$ and an initial value $C ^ { 0 } = 0 . 1$ . With the possible exception of SO-LR, the estimated quantiles appear to closely track an evolving update norm distribution. Note that each task has a unique shape to its update norm evolution, which further motivates an adaptive approach.
+
+For each value of noise multiplier $z \in \{ 0 , 0 . 0 1 , 0 . 0 3 , 0 . 1 \}$ we trained using the five fixed clipping norms and compare to adaptive clipping with the five quantiles (0.1, 0.3, 0.5, 0.7, 0.9). Note that for the fixed clipping runs $z _ { \Delta } = z$ ; that is, for fixed clip $C$ , the noise applied to the the updates has standard deviation $z C$ . As discussed in section 2.1, on the adaptive clipping runs $z _ { \Delta }$ is slightly higher due to the need to account for privacy when estimating the clipped counts.
+
+# 3.3 Comparison of fixed and adaptive clipping
+
+Validation set results with adaptive clipping are shown in Figure 5 and with fixed clipping in Figure 6. These charts show that we have identified the noise regime in which performance is beginning to degrade. There is always a tension between privacy and utility: as the amount of noise increases, eventually performance will go down. For the purpose of this study we consider more than a $5 \%$ relative reduction in evaluation metric to be unacceptable. Therefore for each task, we look at the level of noise $z ^ { * }$ at which the evaluation metric on the validation set is still within $5 \%$ of the value with no noise, but adding more noise would degrade performance beyond $5 \%$ . Given $z ^ { * }$ for each task, we then choose $C ^ { * }$ to be the fixed clip value that gives best performance on the validation set. The values of $z ^ { * }$ and $C ^ { * }$ are shown in Figure 7 (left).
+
+For our final test set evaluation, we compare adaptive clipping to the median to fixed clipping at $C ^ { * }$ . The results are in Figure 7 (right). We show the average test set performance and bootstrapped $9 5 \%$ confidence interval over 20 runs varying the random seed used for client selection and DP noise. On three of the tasks (CIFAR-100, EMNIST-AE, SHAKESPEARE), clipping to the median actually outperforms fixed clipping to the best fixed clip chosen in hindsight, and on two more (EMNIST-CR, SO-NWP), the performance is comparable. Only on SO-LR the best fixed clip does perform somewhat better. This task seems to be unusual in that best performance comes from aggressive clipping, so a small fixed clip fares better than adaptive clipping to the median. However, looking at Figure 6 (and noting the scale of the $y$ axis), on this task more than the others, getting the exact right fixed clip is important. The development set recall $\textcircled { \alpha } 5$ value of 55.1 corresponds to the optimal fixed clip of 16.0. The next larger fixed clip of 27.3 gave a recall of only 51.8, and larger clips fared even worse. So an expensive hyperparameter search may be necessary to even get close to this high-performing fixed clip value.
+
+![](images/53e99813dd6e47f2ef8cdf8e52ff20869a841ff40598f9094b77d1d1af5cf8f4.jpg)  
+Figure 5: Evaluation metric performance of adaptive clipping with five settings of $\gamma$ for each of four effective noise multipliers $z$ . Note that the $y$ -axes have been compressed to show small differences, and that for EMNIST-AE lower values are better.
+
+![](images/66d05bcbf3595cea6fcd34c16e335ce974eff59db6a7ecca7d82b928cda32070.jpg)  
+Figure 6: Evaluation metric performance of fixed clipping with five settings of $C$ for each of four noise multipliers $z$ . Note that the $y \cdot$ -axes have been compressed to show small differences, and that for EMNIST-AE lower values are better.
+
+# 4 Conclusions and implications for practice
+
+In our experiments, we started with a high-performing non-private baseline with optimized client and server learning rates. We then searched over a small grid of larger server learning rates for our experiments with clipping (adaptive or fixed). This is one way to proceed in practice, if such non-private baseline results are available. More often, such baseline learning rates are not available, which will necessitate a search over client learning rates as well. In that case, it would be beneficial to enable adaptive clipping to the median during that hyperparameter search. The advantage of clipping relative to the unclipped baseline observed on some tasks could only increase if the other hyperparameters such as client learning rate were also chosen conditioned on the presence of clipping.
+
+Although the experiments indicate that adaptive clipping to the median yields generally good results, on some problems (like SO-LR in our study) there may be gains from tuning the target quantile. It would require adding another dimension to the hyperparameter grid, exponentially increasing the tuning effort, but even this would be preferable to tuning the fixed clipping norm from scratch, since the grid can be smaller: we obtained good results on all problems by exploring only five quantiles, but the update norms in the experiments range over four orders of magnitude, from 0.22 to 135.
+
+![](images/68088de0535ad1d84284f11c49d90e30f5aa861d6f22bb4a98037e279246bd40.jpg)  
+Figure 7: Left: for each task, the maximum noise possible before performance begins to significantly degrade $( z ^ { * } )$ , and the best fixed clip $( C ^ { * } )$ chosen on the development set. Right: average test set performance and bootstrapped $9 5 \%$ confidence interval over 20 runs. In practice, finding the best fixed clipping norm would require substantial additional hyperparameter tuning.
+
+Combining our results with the lessons taken from [18] and [24], the following strategy emerges for training a high-performing model with user-level differential privacy. We assume some non-private proxy data is available that may have comparatively few users $n ^ { \prime }$ , as well as that the true private data has enough users $n$ that the desired level of privacy is achievable.
+
+1. With adaptive clipping to the median enabled, using a relatively small number of clients per round $m \approx 1 0 0 ^ { \circ } ,$ ), and a small amount of noise $z = 0 . 0 1$ ), search over client and server learning rates on non-private proxy data.   
+2. Fix the client and server learning rates. Using the non-private data and low value of $m$ , train several models increasing the level of noise $z$ until model performance at convergence begins to degrade.   
+3. To train the final model on private data, if $( m , z )$ is too small for the desired level of privacy even given $n$ , set $( m , z )  \alpha \cdot ( m , z )$ for some $\alpha > 1$ such that the privacy target $( \epsilon , \delta )$ is achieved.5 Finally, train the private model using that value of $m$ and $z$ .
+
+By eliminating the need to tune the fixed clipping norm hyperparameter which interacts significantly with the client and server learning rates, the adaptive clipping method proposed in this work exponentially reduces the work necessary to perform the expensive first step of this procedure.
+
+# References
+
+[1] Martin Abadi, Andy Chu, Ian Goodfellow, Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In 23rd ACM Conference on Computer and Communications Security (ACM CCS), 2016.   
+[2] Martin Abadi, Andy Chu, Ian Goodfellow, H. Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, CCS ’16, pages 308–318, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4139-4. doi: 10.1145/2976749.2978318.   
+[3] Kareem Amin, Alex Kulesza, Andres Munoz, and Sergei Vassilvtiskii. Bounding user contributions: A bias-variance trade-off in differential privacy. In International Conference on Machine Learning, pages 263–271. PMLR, 2019.   
+[4] Raef Bassily, Adam Smith, and Abhradeep Thakurta. Private empirical risk minimization: Efficient algorithms and tight error bounds. In Foundations of Computer Science (FOCS), 2014 IEEE 55th Annual Symposium on, pages 464–473. IEEE, 2014.   
+[5] Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for federated learning on user-held data. arXiv preprint arXiv:1611.04482, 2016. [6] Keith Bonawitz, Fariborz Salehi, Jakub Konecnˇ y, Brendan McMahan, and Marco Gruteser. \` Federated learning with autotuned communication-efficient secure aggregation. In 2019 53rd Asilomar Conference on Signals, Systems, and Computers, pages 1222–1226. IEEE, 2019.   
+[7] Jean-Pierre Briot, Gaëtan Hadjeres, and François-David Pachet. Deep Learning Techniques for Music Generation - A Survey. arXiv e-prints, art. arXiv:1709.01620, Sep 2017.   
+[8] Nicholas Carlini, Chang Liu, Jernej Kos, Úlfar Erlingsson, and Dawn Song. The secret sharer: Measuring unintended neural network memorization & extracting secrets. CoRR, abs/1802.08232, 2018. URL http://arxiv.org/abs/1802.08232.   
+[9] Kamalika Chaudhuri, Claire Monteleoni, and Anand D Sarwate. Differentially private empirical risk minimization. Journal of Machine Learning Research, 12(Mar):1069–1109, 2011.   
+[10] Cynthia Dwork, Krishnaram Kenthapadi, Frank McSherry, Ilya Mironov, and Moni Naor. Our data, ourselves: Privacy via distributed noise generation. In EUROCRYPT, 2006.   
+[11] Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. Calibrating noise to sensitivity in private data analysis. In Theory of Cryptography Conference, pages 265–284. Springer, 2006.   
+[12] Matt Fredrikson, Somesh Jha, and Thomas Ristenpart. Model inversion attacks that exploit confidence information and basic countermeasures. In Proceedings of the 22Nd ACM SIGSAC Conference on Computer and Communications Security, CCS ’15, pages 1322–1333, New York, NY, USA, 2015. ACM. ISBN 978-1-4503-3832-5. doi: 10.1145/2810103.2813677.   
+[13] K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In 2015 IEEE International Conference on Computer Vision (ICCV), pages 1026–1034, Dec 2015. doi: 10.1109/ICCV.2015.123.   
+[14] Tzu-Ming Harry Hsu, Hang Qi, and Matthew Brown. Measuring the effects of non-identical data distribution for federated visual classification, 2019.   
+[15] Roger Iyengar, Joseph P. Near, Dawn Song, Om Thakkar, Abhradeep Thakurta, and Lun Wang. Towards practical differentially private convex optimization. In S&P 2019, 2019.   
+[16] Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richtárik, Ananda Theertha Suresh, \` and Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016.
+
+[17] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, AISTATS 2017, 20-22 April 2017, Fort Lauderdale, FL, USA, pages 1273–1282, 2017. URL http://proceedings.mlr. press/v54/mcmahan17a.html.
+
+[18] H. Brendan McMahan, Daniel Ramage, Kunal Talwar, and Li Zhang. Learning differentially private recurrent language models. In ICLR 2018, 2018.
+
+[19] Luca Melis, Congzheng Song, Emiliano De Cristofaro, and Vitaly Shmatikov. Exploiting Unintended Feature Leakage in Collaborative Learning. arXiv e-prints, art. arXiv:1805.04049, May 2018.
+
+[20] Ilya Mironov. Rényi differential privacy. In 2017 IEEE 30th Computer Security Foundations Symposium (CSF), pages 263–275. IEEE, 2017.
+
+[21] Kobbi Nissim, Sofya Raskhodnikova, and Adam Smith. Smooth sensitivity and sampling in private data analysis. In Proceedings of the thirty-ninth annual ACM symposium on Theory of computing, pages 75–84, 2007.
+
+[22] Nicolas Papernot, Martın Abadi, Úlfar Erlingsson, Ian Goodfellow, and Kunal Talwar. Semisupervised knowledge transfer for deep learning from private training data. stat, 1050, 2017.
+
+[23] Nicolas Papernot, Shuang Song, Ilya Mironov, Ananth Raghunathan, Kunal Talwar, and Úlfar Erlingsson. Scalable private learning with pate. arXiv preprint arXiv:1802.08908, 2018.
+
+[24] Sashank Reddi, Zachary Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konecný, ˇ Sanjiv Kumar, and H. Brendan McMahan. Adaptive federated optimization, 2020.
+
+[25] Shai Shalev-Shwartz. Online learning and online convex optimization. Foundations and Trends in Machine Learning, 2012.
+
+[26] R. Shokri, M. Stronati, C. Song, and V. Shmatikov. Membership inference attacks against machine learning models. In 2017 IEEE Symposium on Security and Privacy (SP), pages 3–18, May 2017. doi: 10.1109/SP.2017.41.
+
+[27] C. Szegedy, , , P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1–9, June 2015. doi: 10.1109/CVPR.2015.7298594.
+
+[28] Oriol Vinyals, Lukasz Kaiser, Terry Koo, Slav Petrov, Ilya Sutskever, and Geoffrey Hinton. Grammar as a foreign language. In Proceedings of the 28th International Conference on Neural Information Processing Systems - Volume 2, NIPS’15, pages 2773–2781, Cambridge, MA, USA, 2015. MIT Press. URL http://dl.acm.org/citation.cfm?id=2969442.2969550.
+
+[29] Yu-Xiang Wang, Borja Balle, and Shiva Prasad Kasiviswanathan. Subsampled rényi differential privacy and analytical moments accountant. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 1226–1235. PMLR, 2019.
+
+[30] X. Wu, M. Fredrikson, S. Jha, and J. F. Naughton. A methodology for formalizing modelinversion attacks. In 2016 IEEE 29th Computer Security Foundations Symposium (CSF), pages 355–370, June 2016. doi: 10.1109/CSF.2016.32.
+
+[31] Xi Wu, Fengan Li, Arun Kumar, Kamalika Chaudhuri, Somesh Jha, and Jeffrey Naughton. Bolton differential privacy for scalable stochastic gradient descent-based analytics. In Proceedings of the 2017 ACM International Conference on Management of Data, SIGMOD ’17, pages 1307–1322, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4197-4. doi: 10.1145/ 3035918.3064047.

parse/train/RUQ1zwZR8_/RUQ1zwZR8__content_list.json

@@ -0,0 +1,1041 @@
+[
+    {
+        "type": "text",
+        "text": "Differentially Private Learning with Adaptive Clipping ",
+        "text_level": 1,
+        "bbox": [
+            223,
+            122,
+            776,
+            174
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Galen Andrew galenandrew@google.com ",
+        "bbox": [
+            207,
+            226,
+            397,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Om Thakkar omthkkr@google.com ",
+        "bbox": [
+            436,
+            226,
+            593,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "H. Brendan McMahan mcmahan@google.com ",
+        "bbox": [
+            632,
+            226,
+            790,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Swaroop Ramaswamy swaroopram@google.com ",
+        "bbox": [
+            408,
+            275,
+            589,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            339,
+            535,
+            356
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Existing approaches for training neural networks with user-level differential privacy (e.g., DP Federated Averaging) in federated learning (FL) settings involve bounding the contribution of each user’s model update by clipping it to some constant value. However there is no good a priori setting of the clipping norm across tasks and learning settings: the update norm distribution depends on the model architecture and loss, the amount of data on each device, the client learning rate, and possibly various other parameters. We propose a method wherein instead of a fixed clipping norm, one clips to a value at a specified quantile of the update norm distribution, where the value at the quantile is itself estimated online, with differential privacy. The method tracks the quantile closely, uses a negligible amount of privacy budget, is compatible with other federated learning technologies such as compression and secure aggregation, and has a straightforward joint DP analysis with DP-FedAvg. Experiments demonstrate that adaptive clipping to the median update norm works well across a range of realistic federated learning tasks, sometimes outperforming even the best fixed clip chosen in hindsight, and without the need to tune any clipping hyperparameter. ",
+        "bbox": [
+            232,
+            375,
+            766,
+            594
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            310,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has become ubiquitous, with applications as diverse as image processing, natural language translation, and music generation [27, 13, 28, 7]. Deep models are able to perform well in part due to their ability to utilize vast amounts of data for training. However, recent work has shown that it is possible to extract information about individual training examples using only the parameters of a trained model [12, 30, 26, 8, 19]. When the training data potentially contains privacy-sensitive user information, it becomes imperative to use learning techniques that limit such memorization. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            746
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Differential privacy (DP) [10, 11] is widely considered a gold standard for bounding and quantifying the privacy leakage of sensitive data when performing learning tasks. Intuitively, DP prevents an adversary from confidently making any conclusions about whether some user’s data was used in training a model, even given access to arbitrary side information. The formal definition of DP depends on the notion of neighboring datasets: we will refer to a pair of datasets $D , D ^ { \\prime } \\in \\mathcal { D }$ as neighbors if $D ^ { \\prime }$ can be obtained from $D$ by adding or removing one element. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            835
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Definition 1.1 (Differential Privacy). A (randomized) algorithm $M : { \\mathcal { D } }  { \\mathcal { R } }$ with input domain $\\mathcal { D }$ and output range $\\mathcal { R }$ is $( \\varepsilon , \\delta )$ -differentially private if for all pairs of neighboring datasets $D , D ^ { \\prime } \\in \\mathcal { D }$ , and every measurable $S \\subseteq \\mathcal { R }$ , we have $\\operatorname* { P r } \\left( M ( D ) \\in S \\right) \\leq e ^ { \\varepsilon } \\cdot \\operatorname* { P r } \\left( M ( D ^ { \\prime } ) \\in S \\right) + \\delta$ , where probabilities are with respect to the coin flips of $M$ . ",
+        "bbox": [
+            174,
+            840,
+            825,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Following McMahan et al. [18], we define two common settings of privacy corresponding to two different definitions of neighboring datasets. In example-level DP, datasets are considered neighbors when they differ by the addition or removal of a single example [9, 4, 2, 22, 31, 23, 15]. In user-level DP, neighboring datasets differ by the addition or removal of all of the data of one user [18]. Userlevel DP is the stronger form, and is preferred when one user may contribute many training examples to the learning task, as privacy is protected even if the same privacy-sensitive information occurs in all the examples from one user. In this paper, we will describe the technique and perform experiments in terms of the stronger user-level form, but we note that example-level DP can be achieved by simply giving each user a single example. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To achieve user-level DP, we employ the Federated Averaging algorithm [17], introduced as a decentralized approach to model training in which the training data is left distributed on user devices, and each training round aggregates updates that are computed locally. On each round, a sample of devices are selected for training, and then each selected device performs potentially many steps of local SGD over minibatches of its own data, sending back the model delta as its update. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Bounding the influence of any user in Federated Averaging is both necessary for privacy and often desirable for stability. One popular way to do this to cap the $L _ { 2 }$ norm of its model update by projecting larger updates back to the ball of norm $C$ . Since such clipping also effectively bounds the $L _ { 2 }$ sensitivity of the aggregate with respect to the addition or removal of any user’s data, adding Gaussian noise to the aggregate is sufficient to obtain a central differential privacy guarantee for the update [9, 4, 2]. Standard composition techniques can then be used to extend the per-update guarantee to the final model [20]. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Setting an appropriate value for the clipping threshold $C$ is crucial for the utility of the private training mechanism. Setting it too low can result in high bias since we discard information contained in the magnitude of the gradient. However setting it too high entails the addition of more noise, because the amount of Gaussian noise necessary for a given level of privacy must be proportional to the norm bound (the $L _ { 2 }$ sensitivity), and this will eventually destroy model utility. The clipping bias-variance trade-off was observed empirically by McMahan et al. [18], and was theoretically analyzed and shown to be an inherent property of differentially private learning by Amin et al. [3]. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning large models using the Federated Averaging/SGD algorithm [17, 18] can take thousands of rounds of interaction between the central server and the clients. The norms of the updates can vary as the rounds progress. Prior work [18] has shown that decreasing the value of the clipping threshold after training a language model for some initial number of rounds can improve model accuracy. However, the behavior of the norms can be difficult to predict without prior knowledge about the system, and if it is difficult to choose a fixed clipping norm for a given learning task, it is even more difficult to choose a parameterized clipping norm schedule. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While there has been substantial work on DP techniques for learning, almost every technique has hyperparameters which need to be set appropriately for obtaining good utility. Besides the clipping norm, learning techniques have other hyperparameters which might interact with privacy hyperparameters. For example, the server learning rate in DP SGD might need to be set to a high value if the clipping threshold is very low, and vice-versa. Such tuning for large networks can have an exorbitant cost in computation and efficiency, which can be a bottleneck for real-world systems that involve communicating with millions of samples for training a single network. Tuning may also incur an additional cost for privacy, which needs to be accounted for when providing a privacy guarantee for the released model with tuned hyperparameters (though in some cases, hyperparameters can be tuned using the same model and algorithm on a sufficiently-similar public proxy dataset). ",
+        "bbox": [
+            174,
+            608,
+            825,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related Work The heuristic of clipping to the median update norm was suggested by Abadi et al. [1], but no method for doing so privately was proposed, nor was the heuristic empirically tested. One possibility would be to estimate the median unclipped update norm at each round privately by adding noise calibrated to the smooth sensitivity as defined by Nissim et al. [21]. However this approach has several drawbacks compared to the algorithm we will present. It would require the clients to send their unclipped updates to the server at each round,1 which is incompatible with the foundational principle of federated learning to transmit only focused, minimal updates, and precluding the use of secure aggregation [5] and certain forms of compression [16, 6]. Also, by incorporating information across multiple rounds, our method is able to track the underlying quantile closely, with less jitter associated with sampling at each round, and using only a negligible fraction of the privacy budget. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/57b22a692fa6898eae5a74218e1b3d2cc146c07e465d86897df33e1e2eafc421.jpg",
+        "image_caption": [
+            "Figure 1: Loss functions to estimate the 0.01-, 0.5-, 0.75-, and 0.99-quantiles for a random variable $X$ that uniformly takes values in $\\{ 1 5 , 2 5 , 2 8 , 4 0 , 4 5 , 4 8 \\}$ . The loss function is the average of convex piecewise-linear functions, one for each value. For instance, for the median $( \\gamma = 0 . 5 )$ , this is just $\\begin{array} { r } { \\dot { \\ell } _ { \\gamma } ( C ; X ) = \\frac { 1 } { 2 } | X - C | } \\end{array}$ , where $X$ is the random value, and $C$ is the estimate. When we average these functions, we arrive at the yellow function in the plot showing the average loss, which indeed is minimized by any value between the central two elements, i.e., in the interval [28, 40]. The function for $\\gamma = 0 . 7 5$ is minimized at $C = 4 5$ because $\\operatorname* { P r } ( X \\leq C ) < 0 . 7 5$ for values $C$ in [40, 45), while $\\operatorname* { P r } ( X \\leq C ) > 0 . 7 5$ for values $C$ in (45, 48]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            821,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            400,
+            825,
+            457
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Contributions In this paper, we describe a method for adaptively and privately tuning the clipping threshold to track a given quantile of the update norm distribution during training. The method uses a negligible amount of privacy budget, and is compatible with other FL technologies such as compression and secure aggregation [5, 6]. We perform a careful empirical comparison of our adaptive clipping method to a highly optimized fixed-clip baseline on a suite of realistic and publicly available FL tasks to demonstrate that high-utility and high-privacy models—sometimes exceeding any fixed clipping norm in utility—can be trained using our method without the need to tune any clipping hyperparameter. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            585
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Private adaptive quantile clipping ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            606,
+            488,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will describe the adaptive strategy that can be used for adjusting the clipping threshold so that it comes to approximate the value at a specified quantile. ",
+        "bbox": [
+            171,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $X \\in \\mathbb { R }$ be a random variable, let $\\gamma \\in [ 0 , 1 ]$ be a quantile to be matched. For any $C$ , define ",
+        "bbox": [
+            171,
+            672,
+            787,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64d625ebc93f26e68c7e3ced5a440d61531e0b81d0d418fcd590344fed09570f.jpg",
+        "text": "$$\n\\ell _ { \\gamma } ( C ; X ) = { \\left\\{ \\begin{array} { l l } { ( 1 - \\gamma ) ( C - X ) } & { { \\mathrm { i f ~ } } X \\leq C , } \\\\ { \\gamma ( X - C ) } & { { \\mathrm { o t h e r w i s e , } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            715,
+            647,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "so ",
+        "bbox": [
+            173,
+            763,
+            192,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8530c23ebe8eff4610d31c5ab501e152dadd24fbd7152806729c31446aef044.jpg",
+        "text": "$$\n\\ell _ { \\gamma } ^ { \\prime } ( C ; X ) = { \\left\\{ \\begin{array} { l l } { ( 1 - \\gamma ) } & { { \\mathrm { i f ~ } } X \\leq C , } \\\\ { - \\gamma } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            786,
+            586,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hence, $\\begin{array} { r } { \\mathbb { E } [ \\ell _ { \\gamma } ^ { \\prime } ( C ; X ) ] = ( 1 - \\gamma ) \\operatorname* { P r } [ X \\leq C ] - \\gamma \\operatorname* { P r } [ X > C ] = \\operatorname* { P r } [ X \\leq C ] - \\gamma } \\end{array}$ . For $C ^ { * }$ such that $\\mathbb { E } [ \\ell _ { \\gamma } ^ { \\prime } ( C ^ { * } ; X ) ] = 0$ , we have $\\operatorname* { P r } ( X \\leq C ^ { * } ) = \\gamma$ . Thus, $C ^ { * }$ is the $\\gamma ^ { \\mathrm { t h } }$ quantile of $X$ . Because the loss is convex and has gradients bounded by 1, we can get an online estimate of $C$ that converges to the $\\gamma ^ { \\mathrm { t h } }$ quantile of $X$ using online gradient descent (see, e.g., Shalev-Shwartz [25]). See Figure 1 for a plot of the loss for a random variable that takes six values with equal probability. ",
+        "bbox": [
+            173,
+            837,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Suppose at some round we have $m$ samples of $X$ , with values $( x _ { 1 } , \\ldots , x _ { m } )$ . The average derivative of the loss for that round is ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c2369a027f13b7afd028cd41523897d3d7d4d668d9db4649ff3b7da4056c0eb.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\bar { \\ell } _ { \\gamma } ^ { \\prime } ( C ; X ) = \\displaystyle \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } \\{ \\displaystyle { ( 1 - \\gamma ) \\quad \\mathrm { i f } \\ x _ { i } \\le C } ,  } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad  = \\displaystyle \\frac { 1 } { m } \\bigg ( ( 1 - \\gamma ) \\sum _ { i \\in [ m ] } \\mathbb { I } _ { x _ { i } \\le C } - \\gamma \\sum _ { i \\in [ m ] } \\mathbb { I } _ { x _ { i } > C } \\bigg ) = \\bar { b } - \\gamma , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            123,
+            714,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\bar { b } \\triangleq \\frac { 1 } { m } \\sum _ { i \\in [ m ] } \\mathbb { I } _ { x _ { i } \\leq C } } \\end{array}$ is the empirical fraction of samples with value at most $C$ . For a given learning rate $\\eta _ { C }$ , we can perform the update: $C \\gets C - \\eta _ { C } ( \\bar { b } - \\gamma )$ . ",
+        "bbox": [
+            176,
+            214,
+            823,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Geometric updates. Since $\\bar { b }$ and $\\gamma$ take values in $[ 0 , 1 ]$ , the linear update rule above changes $C$ by a maximum of $\\eta _ { C }$ at each step. This can be slow if $C$ is on the wrong order of magnitude. At the other extreme, if the optimal value of $C$ is orders of magnitude smaller than $\\eta _ { C }$ , the update can be very coarse, and may overshoot to become negative. To remedy such issues, we propose the following geometric update rule: $C \\gets C \\cdot \\exp ( - \\eta _ { C } ( \\bar { b } - \\gamma ) )$ . This update rule converges quickly to the true quantile even if the initial estimate is off by orders of magnitude. It also has the attractive property that the variance of the estimate around the true quantile at convergence is proportional to the value at that quantile. In our experiments, we use the geometric update rule with $\\eta _ { C } = 0 . 2$ . ",
+        "bbox": [
+            173,
+            261,
+            825,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 DP-FedAvg with adaptive quantile clipping ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            390,
+            513,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $m$ be the number of users in a round and let $\\gamma \\in [ 0 , 1 ]$ denote the target quantile of the norm distribution at which we want to clip. For iteration $t \\in [ T ]$ , let $C ^ { t }$ be the clipping threshold, and $\\eta _ { C }$ be the learning rate. Let $\\mathcal { Q } ^ { t }$ be set of users sampled in round $t$ . Each user $i \\in \\mathcal { Q } ^ { t }$ will send the bit $b _ { i } ^ { t }$ along with the usual model delta update $\\Delta _ { i } ^ { t }$ , where $b _ { i } ^ { t } = \\mathbb { I } _ { | | \\Delta _ { i } ^ { t } | | _ { 2 } \\leq C ^ { t } }$ . Defining $\\begin{array} { r } { \\bar { b } ^ { t } = \\frac { 1 } { m } \\sum _ { i \\in \\mathcal { Q } ^ { t } } b _ { i } ^ { t } } \\end{array}$ we would like to apply the update $C \\gets C \\cdot \\exp ( - \\eta _ { C } ( \\bar { b } - \\gamma ) )$ . However, we can’t use ${ \\bar { b } } ^ { t }$ directly, since it may reveal private information about the magnitude of users’ updates. To remedy this, we add Gaussian noise to the sum: $\\begin{array} { r } { \\tilde { b } ^ { t } = \\frac { 1 } { m } \\left( \\sum _ { i \\in \\mathcal { Q } ^ { t } } \\bar { b } _ { i } ^ { t } + \\mathcal { N } ( O , \\sigma _ { b } ^ { 2 } ) \\right) } \\end{array}$ . The DPFedAvg algorithm with adaptive clipping is shown in Algorithm 1. We augment basic federated averaging with server momentum, which improves convergence [14, 24].2 ",
+        "bbox": [
+            173,
+            415,
+            826,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 DPFedAvg-M with adaptive clipping ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            560,
+            504,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "function $\\mathrm { T r a i n } ( m , \\gamma , \\eta _ { c } , \\eta _ { s } , \\eta _ { C } , z , \\sigma _ { b } , \\beta )$ Initialize model $\\theta ^ { 0 }$ , clipping bound $C ^ { 0 }$ z∆ ← \u0000z−2 − (2σb)−2\u0001−1/2 for each round $t = 0 , 1 , 2 , \\ldots { \\dot { \\mathbf { c } } }$ o ${ \\mathcal { Q } } ^ { t } \\gets$ (sample $m$ users uniformly) for each user $i \\in \\mathcal { Q } ^ { t }$ in parallel do $\\begin{array} { r l } & { \\quad ( \\Delta _ { i } ^ { t } , b _ { i } ^ { t } ) \\gets \\mathrm { ~ F e d A v g } ( i , \\theta ^ { t } , \\eta _ { c } , C ^ { t } ) } \\\\ & { \\sigma _ { \\Delta } \\gets z _ { \\Delta } C ^ { t } } \\\\ & { \\tilde { \\Delta } ^ { t } = \\frac { 1 } { m } \\left( \\sum _ { i \\in \\mathcal { Q } ^ { t } } \\Delta _ { i } ^ { t } + \\mathcal { N } ( 0 , I \\sigma _ { \\Delta } ^ { 2 } ) \\right) } \\\\ & { \\bar { \\Delta } ^ { t } = \\beta \\bar { \\Delta } ^ { t - 1 } + ( 1 - \\beta ) \\tilde { \\Delta } ^ { t } } \\\\ & { \\theta ^ { t + 1 } \\gets \\theta ^ { t } + \\eta _ { s } \\bar { \\Delta } ^ { t } } \\\\ & { \\tilde { b } ^ { t } = \\frac { 1 } { m } \\left( \\sum _ { i \\in \\mathcal { Q } ^ { t } } b _ { i } ^ { t } + \\mathcal { N } ( O , \\sigma _ { b } ^ { 2 } ) \\right) } \\end{array}$ ",
+        "bbox": [
+            184,
+            597,
+            464,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$C ^ { t + 1 } \\gets C ^ { t } \\cdot \\exp \\left( - \\eta _ { C } ( \\tilde { b } ^ { t } - \\gamma ) \\right)$ function FedAvg(i, θ0, η, C) θ ← θ0 $\\mathcal { G } $ (user i’s local data split into batches) for batch $g \\in { \\mathcal { G } }$ do $\\begin{array} { r l } & { \\quad \\theta \\gets \\theta - \\eta \\nabla \\ell ( \\theta ; g ) } \\\\ & { \\Delta \\gets \\theta - \\theta ^ { 0 } } \\\\ & { b \\gets \\mathbb { I } _ { | | \\Delta | | \\leq C } } \\\\ & { \\Delta ^ { \\prime } \\gets \\Delta \\cdot \\operatorname* { m i n } \\left( 1 , \\frac { C } { | | \\Delta | | } \\right) } \\\\ & { \\mathrm { ~ r e t u r n } \\left( \\Delta ^ { \\prime } , b \\right) } \\end{array}$ ",
+        "bbox": [
+            519,
+            592,
+            816,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1f5d3ef5dfde7726538c717f8da8f80339ce3990f0c0907a44973a4dd5dbc83.jpg",
+        "image_caption": [
+            "Figure 2: Evolution of the quantile estimate on data drawn from log-normal distributions. The three plots use data drawn from the exponential of $\\mathcal { N } ( 0 . 0 , 1 . 0 )$ , $\\mathcal { N } ( \\bar { 0 . 0 } , 0 . 1 )$ , and $\\mathcal { N } ( \\log { 1 0 } , 1 . 0 )$ , respectively. Curves are shown for each of five quantiles: (0.1, 0.3, 0.5, 0.7, 0.9), and the dashed lines show the true value at each quantile. Hyperparameters are as discussed in the text and used in the experiments of Section 3: $\\eta _ { C } = 0 . 2 , C ^ { 0 } \\stackrel { \\sim } { = } 0 . \\dot { 1 } , m = 1 0 0 , \\sigma _ { b } = m / 2 0$ . After an initial phase of exponential growth, the true quantile is fairly closely tracked. A smaller value of $\\eta _ { C }$ would allow more accurate tracking at the cost of slower convergence, but since the quantile value is only used as a heuristic for clipping, a small amount of noise is tolerable. The entire sequence of values estimated for each target quantile satisfy $( 0 . 0 3 4 , n ^ { - 1 . 1 } )$ -differential privacy using RDP composition across the 200 rounds assuming fixed-size samples of $m = 1 0 0$ out of a total population of $\\bar { n } = 1 0 ^ { 6 }$ [29]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            823,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. One step of $D P$ -FedAvg with adaptive clipping using $\\sigma _ { b }$ noise standard deviation on the clipped counts $\\sum b _ { i } ^ { t }$ and $z _ { \\Delta }$ noise multiplier on the vector sums $\\sum \\Delta _ { i } ^ { t }$ is equivalent (so far as privacy accounting is concerned) to one step of non-adaptive $D P$ -FedAvg with noise multiplier $z$ if we set z∆ = \u0000z−2 − (2σb)−2\u0001−1/2. ",
+        "bbox": [
+            173,
+            391,
+            826,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof. We make a conceptual change to the algorithm that does not change the behavior or privacy properties but allows us to analyze each step as if it were a single private Gaussian sum. Instead of sending $( \\Delta _ { i } ^ { t } , b _ { i } ^ { t } )$ , each user sends $( \\hat { \\Delta } _ { i } ^ { t } , \\hat { b } _ { i } ^ { t } ) \\triangleq \\big ( \\Delta _ { i } ^ { t } / \\sigma _ { \\Delta } , ( b _ { i } ^ { t } - \\scriptscriptstyle 1 / 2 ) / \\sigma _ { b } \\big )$ . The server adds noise with covariance $I$ and averages, then reverses the transformation so $\\begin{array} { r } { \\tilde { \\Delta } ^ { t } = \\frac { \\sigma _ { \\Delta } } { m } \\biggl ( \\sum _ { i \\in \\mathcal { Q } ^ { t } } \\hat { \\Delta } _ { i } ^ { t } + \\mathcal { N } ( 0 , I ) \\biggr ) } \\end{array}$ and $\\begin{array} { r } { \\tilde { b } ^ { t } = \\frac { \\sigma _ { b } } { m } \\left( \\sum _ { i \\in \\mathcal { Q } ^ { t } } \\hat { b } _ { i } ^ { t } + \\mathcal { N } ( 0 , 1 ) \\right) + 1 / 2 } \\end{array}$ . Noting that $\\vert \\vert ( \\hat { \\Delta } _ { i } ^ { t } , \\hat { b } _ { i } ^ { t } ) \\vert \\vert \\leq S \\triangleq \\left( ( C ^ { t } / \\sigma _ { \\Delta } ) ^ { 2 } + \\left( 1 / 2 \\sigma _ { b } \\right) ^ { 2 } \\right) ^ { 1 / 2 }$ , it is clear that the two Gaussian sum queries of Algorithm 1 are equivalent to pre- and post-processing of a single query with sensitivity $S$ and covariance $I$ , or noise multiplier $z = { \\overset { \\cdot } { 1 } } / s = \\overset { \\cdot } { \\left( z _ { \\Delta } ^ { - 2 } + ( 2 \\sigma _ { b } ) ^ { - 2 } \\right) ^ { - 1 / 2 } }$ Rearranging yields the result. ",
+        "bbox": [
+            173,
+            469,
+            826,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, we recommend using a value of $\\sigma _ { b } = m / 2 0$ . Since the noise is Gaussian, this implies that the error $| \\tilde { b } ^ { t } - \\bar { b } ^ { t } |$ will be less than 0.1 with $9 5 . 4 \\%$ probability, and will be no more than 0.15 with $9 9 . 7 \\%$ probability. Even in this unlikely case, assuming a geometric update and a learning rate of $\\eta _ { C } = 0 . 2$ , the error on the update would be a factor of $\\exp ( 0 . 2 \\times 0 . 1 5 ) = 1 . 0 3$ , a small deviation. So this default gives high privacy for an acceptable amount of noise in the quantile estimation process. Using Thm. 1, we can compute that to achieve an effective combined noise multiplier of $z = 1$ , with $m = 1 0 0$ clients per round, the noise multiplier $z _ { \\Delta }$ is approximately 1.005. So we are paying only a factor of $0 . 5 \\%$ more noise on the updates for adaptive clipping with the same privacy guarantee (a quantity which only gets smaller with increasing $m$ ). These constants $\\zeta \\sigma _ { b } = m / 2 0$ and $\\eta _ { C } = 0 . 2 $ ) are what we use in the experiments of Section 3. ",
+        "bbox": [
+            173,
+            638,
+            826,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The clipping norm can be initialized to any value $C ^ { 0 }$ that is safely on the low end of the expected norm distribution. If it is too high and needs to adapt downward, a lot of noise may be added at the beginning of model training, which may swamp the model. However there is little danger in setting it quite low, since the geometric update will make it grow exponentially until it matches the true quantile. In our experiments we use an initial clip of 0.1 for all tasks. It is easy to compute that with a learning rate of $\\eta _ { C } = 0 . 2$ and a target quantile of $\\gamma = 0 . 5$ , if every update is clipped, the quantile estimate will increase by a factor of ten every 23 iterations. In order to show the effectiveness of the algorithm at tracking a known quantile, we ran it on simulated data for which we can compute the true quantile exactly. Figure 2 shows the result of this experiment. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/fd577b28e1ccdec052af3fb9803ea5c992696e0c9c7f517012f4ae8110b31c19.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>model</td><td>N</td><td>n</td><td>T</td><td>2</td><td>m</td><td>nc</td><td>ns</td><td>Cmin</td><td>Cmax</td></tr><tr><td>CIFAR-100</td><td>ResNet</td><td>11M</td><td>500</td><td>4000</td><td>0.669</td><td>2231</td><td>0.1</td><td>0.32</td><td>0.75</td><td>2.2</td></tr><tr><td>EMNIST-CR</td><td>CNN</td><td>1.2M</td><td>3400</td><td>1500</td><td>0.513</td><td>513</td><td>0.032</td><td>1.0</td><td>0.28</td><td>0.85</td></tr><tr><td>EMNIST-AE</td><td>Deep AE</td><td>2.8M</td><td>3400</td><td>3000</td><td>0.659</td><td>2197</td><td>3.2</td><td>1.78</td><td>0.22</td><td>0.95</td></tr><tr><td>SHAKESPEARE</td><td>C-LSTM</td><td>820k</td><td>715</td><td>1200</td><td>0.510</td><td>510</td><td>1.0</td><td>0.32</td><td>0.25</td><td>3.6</td></tr><tr><td>SO-NWP</td><td>W-LSTM</td><td>4.1M</td><td>342k</td><td>1500</td><td>1.396</td><td>13958</td><td>0.18</td><td>1.78</td><td>0.30</td><td>1.6</td></tr><tr><td>SO-LR</td><td>Multi-LR</td><td>5M</td><td>342k</td><td>1500</td><td>1.396</td><td>13958</td><td>320.0</td><td>1.78</td><td>16.0</td><td>135.0</td></tr></table>",
+        "bbox": [
+            174,
+            88,
+            823,
+            179
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Dataset statistics and chosen hyperparameters. Left: model type, number of trainable parameters $N$ , number of training clients $n$ , and the number of training rounds $T$ used (following Reddi et al. [24]). Middle: the noise multiplier $z$ and number of clients per round $m$ necessary to achieve $( 5 , n ^ { - 1 . 1 } )$ -DP with less than $5 \\%$ model performance loss if each task had a population of $n = 1 0 ^ { 6 }$ [29]. Right: the optimal unclipped baseline client and server learning rates (Sec. 3.1) for each task and chosen values of minimum and maximum fixed clips (Sec. 3.2). ",
+        "bbox": [
+            174,
+            179,
+            825,
+            261
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            300,
+            312,
+            318
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To empirically validate the approach, we examine the behavior of our algorithm on six of the public benchmark federated learning tasks defined by Reddi et al. [24], which are to our knowledge the most realistic and representative publicly available federated learning tasks that exist to date. All six tasks are non-i.i.d. with respect to user partitioning: indeed with the exception of CIFAR-100, the data is partitioned according to the actual human user who generated the data, for example the writer of the EMNIST characters or the Stack Overflow user who asked or answered a question. Table 1 (left) lists the characteristics of the datasets. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Two of the tasks derived from Stack Overflow data (SO-NWP and SO-LR) are ideal for DP research due to the very high number of users (342k) making it possible to train models with good user-level privacy without sacrificing accuracy. The other four tasks (CIFAR-100, EMNIST-AE, EMNISTCR, SHAKESPEARE) are representative learning tasks, but not representative population sizes for real world cross-device FL applications. Therefore we focus on establishing that adaptive clipping works well with 100 clients per round on these tasks in the regime where the noise is at a level such that utility is just beginning to degrade. Under the assumption that a larger population were available, one could increase $m$ , $\\sigma _ { \\Delta }$ , and $\\sigma _ { b }$ proportionally to achieve comparable utility with high privacy. This should not significantly affect convergence (indeed, it might be beneficial) since the only effect is to increase the number of users in the average $\\tilde { \\Delta } ^ { t }$ , reducing the variance. Table 1 (middle) shows the number of clients per round with which our experiments indicate we could achieve $( 5 , n ^ { - 1 . 1 } )$ -DP for each dataset with acceptable model performance loss (less than $5 \\%$ relative to non-private training, as discussed later) if each dataset had $n = 1 0 ^ { 6 }$ clients, using RDP composition with fixed-size subsampling [29].3 ",
+        "bbox": [
+            173,
+            439,
+            825,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 Baseline client and server learning rates ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            490,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Reddi et al. [24] provide optimized client and server learning rates for federated averaging with momentum that serve as a starting point for our experimental setup. For almost all hyperparameters (model configuration, evaluation metrics, client batch size, total rounds, etc.) we replicate their experiments, but with two changes. First, we increase the number of clients per round to 100 for all tasks. This reduces the variance in the updates to a level where we can reasonably assume that adding more clients is unlikely to significantly change convergence properties [18]. Second, as shown in Algorithm 1 we use unweighted federated averaging, thus eliminating the need to set yet another difficult-to-fit hyperparameter: the expected total weight of clients in a round. Since these changes might require different settings, we reoptimize the client and server learning rates for our baseline with no clipping or noise. We ran a small grid of 25 configurations for each task jointly exploring client and server learning rates whose logarithm (base-10) differs from the values in Table 10 of Reddi et al. [24] by $\\{ \\ - \\% , - \\% , 0 , \\% , \\% \\}$ . The optimal baseline client and server learning rates for our experimental setup are shown in Table 1 (right). ",
+        "bbox": [
+            174,
+            684,
+            825,
+            864
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2ec1b01a4de94b8799a7e8fb558e4a9eaaff48f80e1394d63db50c5946bcdebb.jpg",
+        "image_caption": [
+            "Figure 3: Impact of clipping without noise. Performance of the unclipped baseline compared to five settings of $\\gamma$ , from $\\gamma = 0 . 1$ (aggressive clipping) to $\\gamma = 0 . 9$ (mild clipping). The values shown are the evaluation metrics on the validation set averaged over the last 100 rounds. Note that the $y$ -axes have been compressed to show small differences, and that for EMNIST-AE lower values are better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            823,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Because clipping (whether fixed or adaptive) reduces the average norm of the client updates, it may be necessary to use a higher server learning rate to compensate. Therefore, for all approaches with clipping—fixed or adaptive—we search over a small grid of five server learning rates, scaling the values in Table 1 by $\\{ 1 , \\bar { 1 0 } ^ { 1 / 4 } , 1 0 ^ { 1 / 2 } , 1 0 ^ { 3 / 4 } , 1 0 \\}$ . For all configurations, we report the best performing model whose server learning rate was chosen from this small grid on the validation set.4 ",
+        "bbox": [
+            174,
+            381,
+            825,
+            452
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first examine the impact of adaptive clipping without noise to see how it affects model performance. Figure 3 compares baseline performance without clipping to adaptive clipping with five different quantiles. For each quantile, we show the best model after tuning over the five server learning rates mentioned above on the validation set. On three tasks (CIFAR-100, EMNIST-AE, SO-NWP), clipping improves performance relative to the unclipped baseline. On SHAKESPEARE and SO-LR performance is slightly worse, but we can conclude that adaptive clipping to the median generally fares well compared to not using clipping across tasks. Note that for our primary goal of training with DP, it is essential to limit the sensitivity one way or another, so the modest decrease in performance observed from clipping on some tasks may be part of the inevitable tension between privacy and utility. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 Fixed-clip baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            348,
+            628
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We would like to compare our adaptive clipping approach to a fixed clipping baseline, but comparing to just one fixed-clip baseline may not be enough to demonstrate that adaptive clipping consistently performs well. Instead, our strategy will be to show that quantile-based adaptive clipping performs as well or nearly as well as any fixed clip chosen in hindsight. If we can first identify clipping norms that span the range of normal values during training on each problem/configuration, we can compare adaptive clipping to fixed clipping with those norms. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To that end, we first use adaptive clipping without noise to discover the value of the update norm distribution at the following five quantiles: $\\{ 0 . 1 , 0 . 3 , 0 . 5 , 0 . 7 , 0 . 9 \\}$ . Then we choose as the minimum of our fixed clipping range the smallest value at the 0.1 quantile over the course of training, and as the maximum the largest value at the 0.9 quantile. Plots of the update norms during training on each of the tasks are shown in Figure 4. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            799
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On each task there is a ramp up period where the clipping norm, initialized to 0.1 for all tasks, catches up to the correct norm distribution. Thus we disregard norm values collected until the actual fraction of clipped counts ${ \\bar { b } } ^ { t }$ on some round is within 0.05 of the target quantile $\\gamma$ . The chosen values for the minimum and maximum fixed clips for each task are shown in Table 1 (right). Our fixed-clipping baseline uses five fixed clipping norms logarithmically spaced in that range. Here we are taking advantage of having already run adaptive clipping to minimize the number of fixed clip settings we need to explore for each task. If we had to explore over the entire range knowing only the endpoints across all tasks (0.22, 135.0) at the same resolution, we would need nearly four times as many clip values per task. ",
+        "bbox": [
+            176,
+            805,
+            820,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e360036a130b659110b98cc143adc5ef96360edab933f3e124db82ccad6d299.jpg",
+        "image_caption": [
+            "0.10.3  0.10.3  0.10.3Figure 4: Evolution of the adaptive clipping norm at five different quantiles (0.1, 0.3, 0.5, 0.7, 0.9) 0.50.70.9 0.50.70.9 0.70.9on each task with no noise. The norms are estimated using geometric updates with $\\eta _ { C } = 0 . 2$ and an initial value $C ^ { 0 } = 0 . 1$ . With the possible exception of SO-LR, the estimated quantiles appear to closely track an evolving update norm distribution. Note that each task has a unique shape to its update norm evolution, which further motivates an adaptive approach. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            87,
+            823,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            463,
+            825,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For each value of noise multiplier $z \\in \\{ 0 , 0 . 0 1 , 0 . 0 3 , 0 . 1 \\}$ we trained using the five fixed clipping norms and compare to adaptive clipping with the five quantiles (0.1, 0.3, 0.5, 0.7, 0.9). Note that for the fixed clipping runs $z _ { \\Delta } = z$ ; that is, for fixed clip $C$ , the noise applied to the the updates has standard deviation $z C$ . As discussed in section 2.1, on the adaptive clipping runs $z _ { \\Delta }$ is slightly higher due to the need to account for privacy when estimating the clipped counts. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 Comparison of fixed and adaptive clipping ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            642,
+            509,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Validation set results with adaptive clipping are shown in Figure 5 and with fixed clipping in Figure 6. These charts show that we have identified the noise regime in which performance is beginning to degrade. There is always a tension between privacy and utility: as the amount of noise increases, eventually performance will go down. For the purpose of this study we consider more than a $5 \\%$ relative reduction in evaluation metric to be unacceptable. Therefore for each task, we look at the level of noise $z ^ { * }$ at which the evaluation metric on the validation set is still within $5 \\%$ of the value with no noise, but adding more noise would degrade performance beyond $5 \\%$ . Given $z ^ { * }$ for each task, we then choose $C ^ { * }$ to be the fixed clip value that gives best performance on the validation set. The values of $z ^ { * }$ and $C ^ { * }$ are shown in Figure 7 (left). ",
+        "bbox": [
+            173,
+            669,
+            826,
+            794
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For our final test set evaluation, we compare adaptive clipping to the median to fixed clipping at $C ^ { * }$ . The results are in Figure 7 (right). We show the average test set performance and bootstrapped $9 5 \\%$ confidence interval over 20 runs varying the random seed used for client selection and DP noise. On three of the tasks (CIFAR-100, EMNIST-AE, SHAKESPEARE), clipping to the median actually outperforms fixed clipping to the best fixed clip chosen in hindsight, and on two more (EMNIST-CR, SO-NWP), the performance is comparable. Only on SO-LR the best fixed clip does perform somewhat better. This task seems to be unusual in that best performance comes from aggressive clipping, so a small fixed clip fares better than adaptive clipping to the median. However, looking at Figure 6 (and noting the scale of the $y$ axis), on this task more than the others, getting the exact right fixed clip is important. The development set recall $\\textcircled { \\alpha } 5$ value of 55.1 corresponds to the optimal fixed clip of 16.0. The next larger fixed clip of 27.3 gave a recall of only 51.8, and larger clips fared even worse. So an expensive hyperparameter search may be necessary to even get close to this high-performing fixed clip value. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/53e99813dd6e47f2ef8cdf8e52ff20869a841ff40598f9094b77d1d1af5cf8f4.jpg",
+        "image_caption": [
+            "Figure 5: Evaluation metric performance of adaptive clipping with five settings of $\\gamma$ for each of four effective noise multipliers $z$ . Note that the $y$ -axes have been compressed to show small differences, and that for EMNIST-AE lower values are better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            93,
+            821,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/66d05bcbf3595cea6fcd34c16e335ce974eff59db6a7ecca7d82b928cda32070.jpg",
+        "image_caption": [
+            "Figure 6: Evaluation metric performance of fixed clipping with five settings of $C$ for each of four noise multipliers $z$ . Note that the $y \\cdot$ -axes have been compressed to show small differences, and that for EMNIST-AE lower values are better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            362,
+            821,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            641,
+            825,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Conclusions and implications for practice ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            550,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we started with a high-performing non-private baseline with optimized client and server learning rates. We then searched over a small grid of larger server learning rates for our experiments with clipping (adaptive or fixed). This is one way to proceed in practice, if such non-private baseline results are available. More often, such baseline learning rates are not available, which will necessitate a search over client learning rates as well. In that case, it would be beneficial to enable adaptive clipping to the median during that hyperparameter search. The advantage of clipping relative to the unclipped baseline observed on some tasks could only increase if the other hyperparameters such as client learning rate were also chosen conditioned on the presence of clipping. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although the experiments indicate that adaptive clipping to the median yields generally good results, on some problems (like SO-LR in our study) there may be gains from tuning the target quantile. It would require adding another dimension to the hyperparameter grid, exponentially increasing the tuning effort, but even this would be preferable to tuning the fixed clipping norm from scratch, since the grid can be smaller: we obtained good results on all problems by exploring only five quantiles, but the update norms in the experiments range over four orders of magnitude, from 0.22 to 135. ",
+        "bbox": [
+            174,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/68088de0535ad1d84284f11c49d90e30f5aa861d6f22bb4a98037e279246bd40.jpg",
+        "image_caption": [
+            "Figure 7: Left: for each task, the maximum noise possible before performance begins to significantly degrade $( z ^ { * } )$ , and the best fixed clip $( C ^ { * } )$ chosen on the development set. Right: average test set performance and bootstrapped $9 5 \\%$ confidence interval over 20 runs. In practice, finding the best fixed clipping norm would require substantial additional hyperparameter tuning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            89,
+            826,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            304,
+            825,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Combining our results with the lessons taken from [18] and [24], the following strategy emerges for training a high-performing model with user-level differential privacy. We assume some non-private proxy data is available that may have comparatively few users $n ^ { \\prime }$ , as well as that the true private data has enough users $n$ that the desired level of privacy is achievable. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. With adaptive clipping to the median enabled, using a relatively small number of clients per round $m \\approx 1 0 0 ^ { \\circ } ,$ ), and a small amount of noise $z = 0 . 0 1$ ), search over client and server learning rates on non-private proxy data.   \n2. Fix the client and server learning rates. Using the non-private data and low value of $m$ , train several models increasing the level of noise $z$ until model performance at convergence begins to degrade.   \n3. To train the final model on private data, if $( m , z )$ is too small for the desired level of privacy even given $n$ , set $( m , z )  \\alpha \\cdot ( m , z )$ for some $\\alpha > 1$ such that the privacy target $( \\epsilon , \\delta )$ is achieved.5 Finally, train the private model using that value of $m$ and $z$ . ",
+        "bbox": [
+            210,
+            433,
+            825,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "By eliminating the need to tune the fixed clipping norm hyperparameter which interacts significantly with the client and server learning rates, the adaptive clipping method proposed in this work exponentially reduces the work necessary to perform the expensive first step of this procedure. ",
+        "bbox": [
+            174,
+            579,
+            823,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Martin Abadi, Andy Chu, Ian Goodfellow, Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In 23rd ACM Conference on Computer and Communications Security (ACM CCS), 2016.   \n[2] Martin Abadi, Andy Chu, Ian Goodfellow, H. Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, CCS ’16, pages 308–318, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4139-4. doi: 10.1145/2976749.2978318.   \n[3] Kareem Amin, Alex Kulesza, Andres Munoz, and Sergei Vassilvtiskii. Bounding user contributions: A bias-variance trade-off in differential privacy. In International Conference on Machine Learning, pages 263–271. PMLR, 2019.   \n[4] Raef Bassily, Adam Smith, and Abhradeep Thakurta. Private empirical risk minimization: Efficient algorithms and tight error bounds. In Foundations of Computer Science (FOCS), 2014 IEEE 55th Annual Symposium on, pages 464–473. IEEE, 2014.   \n[5] Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for federated learning on user-held data. arXiv preprint arXiv:1611.04482, 2016. [6] Keith Bonawitz, Fariborz Salehi, Jakub Konecnˇ y, Brendan McMahan, and Marco Gruteser. \\` Federated learning with autotuned communication-efficient secure aggregation. In 2019 53rd Asilomar Conference on Signals, Systems, and Computers, pages 1222–1226. IEEE, 2019.   \n[7] Jean-Pierre Briot, Gaëtan Hadjeres, and François-David Pachet. Deep Learning Techniques for Music Generation - A Survey. arXiv e-prints, art. arXiv:1709.01620, Sep 2017.   \n[8] Nicholas Carlini, Chang Liu, Jernej Kos, Úlfar Erlingsson, and Dawn Song. The secret sharer: Measuring unintended neural network memorization & extracting secrets. CoRR, abs/1802.08232, 2018. URL http://arxiv.org/abs/1802.08232.   \n[9] Kamalika Chaudhuri, Claire Monteleoni, and Anand D Sarwate. Differentially private empirical risk minimization. Journal of Machine Learning Research, 12(Mar):1069–1109, 2011.   \n[10] Cynthia Dwork, Krishnaram Kenthapadi, Frank McSherry, Ilya Mironov, and Moni Naor. Our data, ourselves: Privacy via distributed noise generation. In EUROCRYPT, 2006.   \n[11] Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. Calibrating noise to sensitivity in private data analysis. In Theory of Cryptography Conference, pages 265–284. Springer, 2006.   \n[12] Matt Fredrikson, Somesh Jha, and Thomas Ristenpart. Model inversion attacks that exploit confidence information and basic countermeasures. In Proceedings of the 22Nd ACM SIGSAC Conference on Computer and Communications Security, CCS ’15, pages 1322–1333, New York, NY, USA, 2015. ACM. ISBN 978-1-4503-3832-5. doi: 10.1145/2810103.2813677.   \n[13] K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In 2015 IEEE International Conference on Computer Vision (ICCV), pages 1026–1034, Dec 2015. doi: 10.1109/ICCV.2015.123.   \n[14] Tzu-Ming Harry Hsu, Hang Qi, and Matthew Brown. Measuring the effects of non-identical data distribution for federated visual classification, 2019.   \n[15] Roger Iyengar, Joseph P. Near, Dawn Song, Om Thakkar, Abhradeep Thakurta, and Lun Wang. Towards practical differentially private convex optimization. In S&P 2019, 2019.   \n[16] Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richtárik, Ananda Theertha Suresh, \\` and Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016. ",
+        "bbox": [
+            171,
+            94,
+            828,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, AISTATS 2017, 20-22 April 2017, Fort Lauderdale, FL, USA, pages 1273–1282, 2017. URL http://proceedings.mlr. press/v54/mcmahan17a.html. ",
+        "bbox": [
+            173,
+            90,
+            828,
+            161
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] H. Brendan McMahan, Daniel Ramage, Kunal Talwar, and Li Zhang. Learning differentially private recurrent language models. In ICLR 2018, 2018. ",
+        "bbox": [
+            171,
+            169,
+            821,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Luca Melis, Congzheng Song, Emiliano De Cristofaro, and Vitaly Shmatikov. Exploiting Unintended Feature Leakage in Collaborative Learning. arXiv e-prints, art. arXiv:1805.04049, May 2018. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Ilya Mironov. Rényi differential privacy. In 2017 IEEE 30th Computer Security Foundations Symposium (CSF), pages 263–275. IEEE, 2017. ",
+        "bbox": [
+            173,
+            258,
+            823,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Kobbi Nissim, Sofya Raskhodnikova, and Adam Smith. Smooth sensitivity and sampling in private data analysis. In Proceedings of the thirty-ninth annual ACM symposium on Theory of computing, pages 75–84, 2007. ",
+        "bbox": [
+            173,
+            296,
+            823,
+            339
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Nicolas Papernot, Martın Abadi, Úlfar Erlingsson, Ian Goodfellow, and Kunal Talwar. Semisupervised knowledge transfer for deep learning from private training data. stat, 1050, 2017. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            378
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Nicolas Papernot, Shuang Song, Ilya Mironov, Ananth Raghunathan, Kunal Talwar, and Úlfar Erlingsson. Scalable private learning with pate. arXiv preprint arXiv:1802.08908, 2018. ",
+        "bbox": [
+            174,
+            388,
+            826,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Sashank Reddi, Zachary Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konecný, ˇ Sanjiv Kumar, and H. Brendan McMahan. Adaptive federated optimization, 2020. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            455
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Shai Shalev-Shwartz. Online learning and online convex optimization. Foundations and Trends in Machine Learning, 2012. ",
+        "bbox": [
+            171,
+            463,
+            825,
+            492
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] R. Shokri, M. Stronati, C. Song, and V. Shmatikov. Membership inference attacks against machine learning models. In 2017 IEEE Symposium on Security and Privacy (SP), pages 3–18, May 2017. doi: 10.1109/SP.2017.41. ",
+        "bbox": [
+            174,
+            501,
+            823,
+            544
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] C. Szegedy, , , P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1–9, June 2015. doi: 10.1109/CVPR.2015.7298594. ",
+        "bbox": [
+            173,
+            553,
+            823,
+            595
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Oriol Vinyals, Lukasz Kaiser, Terry Koo, Slav Petrov, Ilya Sutskever, and Geoffrey Hinton. Grammar as a foreign language. In Proceedings of the 28th International Conference on Neural Information Processing Systems - Volume 2, NIPS’15, pages 2773–2781, Cambridge, MA, USA, 2015. MIT Press. URL http://dl.acm.org/citation.cfm?id=2969442.2969550. ",
+        "bbox": [
+            176,
+            604,
+            823,
+            661
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Yu-Xiang Wang, Borja Balle, and Shiva Prasad Kasiviswanathan. Subsampled rényi differential privacy and analytical moments accountant. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 1226–1235. PMLR, 2019. ",
+        "bbox": [
+            171,
+            669,
+            821,
+            712
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] X. Wu, M. Fredrikson, S. Jha, and J. F. Naughton. A methodology for formalizing modelinversion attacks. In 2016 IEEE 29th Computer Security Foundations Symposium (CSF), pages 355–370, June 2016. doi: 10.1109/CSF.2016.32. ",
+        "bbox": [
+            171,
+            720,
+            821,
+            763
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Xi Wu, Fengan Li, Arun Kumar, Kamalika Chaudhuri, Somesh Jha, and Jeffrey Naughton. Bolton differential privacy for scalable stochastic gradient descent-based analytics. In Proceedings of the 2017 ACM International Conference on Management of Data, SIGMOD ’17, pages 1307–1322, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4197-4. doi: 10.1145/ 3035918.3064047. ",
+        "bbox": [
+            173,
+            772,
+            826,
+            842
+        ],
+        "page_idx": 11
+    }
+]

parse/train/SJeHwJSYvH/SJeHwJSYvH.md

@@ -0,0 +1,372 @@
+# LEARNING DE-BIASED REPRESENTATIONS WITH BIASED REPRESENTATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Many machine learning algorithms are trained and evaluated by splitting data from a single source into training and test sets. While such focus on in-distribution learning scenarios has led interesting advances, it has not been able to tell if models are relying on dataset biases as shortcuts for successful prediction (e.g., using snow cues for recognising snowmobiles). Such biased models fail to generalise when the bias shifts to a different class. The cross-bias generalisation problem has been addressed by de-biasing training data through augmentation or re-sampling, which are often prohibitive due to the data collection cost (e.g., collecting images of a snowmobile on a desert) and the difficulty of quantifying or expressing biases in the first place. In this work, we propose a novel framework to train a de-biased representation by encouraging it to be different from a set of representations that are biased by design. This tactic is feasible in many scenarios where it is much easier to define a set of biased representations than to define and quantify bias. Our experiments and analyses show that our method discourages models from taking bias shortcuts, resulting in improved performances on de-biased test data.
+
+# 1 INTRODUCTION
+
+Most machine learning algorithms are trained and evaluated by randomly splitting a single source of data into training and test sets. Although this is a standard protocol, it is blind to a critical problem: the existence of dataset bias (Torralba & Efros, 2011). For instance, many frog images are taken in swamp scenes, but swamp itself is not a frog. Nonetheless, a neural network will exploit this bias (i.e., take “shortcuts”) if it yields correct predictions for the majority of training examples. If bias is sufficient to achieve high accuracy, there is little motivation for models to learn the complexity of the intended task, despite its full capacity to do so. Consequently, a model that relies on bias will achieve high in-distribution accuracy, yet fail to generalise when the bias shifts.
+
+We tackle this “cross-bias generalisation” problem where a model does not exploit its full capacity due to the “sufficiency” of bias cues for prediction of the target label in training data. For example, language models make predictions based on the presence of certain words (e.g., “not” for “contradiction”) (Gururangan et al., 2018) without much reasoning on the actual meaning of sentences, even if they are in principle capable of sophisticated reasoning. Similarly, convolutional neural networks (CNNs) achieve high accuracies on image classification by using local texture cues as shortcut, as opposed to more reliable global shape cues (Geirhos et al., 2019; Brendel & Bethge, 2019).
+
+Existing methods attempt to remove a model’s dependency on bias by de-biasing the training data through data augmentation (Geirhos et al., 2019) or re-sampling tactics (Li & Vasconcelos, 2019). Others have introduced a pre-defined set of biases that a model is trained to be independent against (Wang et al., 2019). These prior works assume that bias can easily be defined or quantified, but real-world biases often do not (e.g., texture bias above).
+
+To address this limitation, we propose a novel framework to train a de-biased representation by encouraging it to be “different” from a set of representations that are biased by design. Our insight is that biased representations can easily be obtained by utilising models of smaller capacity (e.g., bag of words for word bias and CNNs of small receptive fields for texture bias). Experiments show that our method is effective in reducing a model’s dependency on “shortcuts” in training data, as evidenced by improved accuracies in test data where the bias is either shifted or removed.
+
+![](images/8375729b067b4a597293f825730a5eed14703c3a1ca1e8f5c1f3af18e153d79b.jpg)  
+Figure 1: Learning scenarios. Different distributional gaps may take place between training and test distributions. Our work is addressing the cross-bias generalisation problem. Background colours on the right three figures indicate the decision boundaries of models trained on given training data.
+
+# 2 PROBLEM DEFINITION
+
+We provide a rigorous definition of our over-arching goal: overcoming the bias in models trained on biased data. We show that the problem we tackle is novel and realistic.
+
+# 2.1 CROSS-BIAS GENERALISATION
+
+We first define random variables, signal $S$ and bias $B$ as cues for the recognition of an input $X$ as certain target variable $Y$ . Signals $S$ are the cues essential for the recognition of $X$ as $Y$ ; examples include the shape and skin patterns of frogs for frog image classification. Biases $B$ ’s, on the other hand, are cues not essential for the recognition but correlated with the target $Y$ ; many frog images are taken in swamp scenes, so swamp scenes can be considered as $B$ . A key property of $B$ is that intervening on $B$ should not change $Y$ ; moving a frog from swamp to a dessert scene does not change the “frogness”. We assume that the true predictive distribution $p ( Y | X )$ factorises as $\hat { \int _ { } p ( Y | S , B ) p ( S , B | \bar { X } ) }$ , signifying the sufficiency of $p ( S , B | X )$ for recognition.
+
+Under this framework, three learning scenarios are identified depending on the change of relationship $p ( S , B , Y )$ across training and test distributions, $p ( S ^ { \mathrm { t r } } , B ^ { \mathrm { t r } } , Y ^ { \mathrm { t r } } )$ and $p ( S ^ { \mathrm { t e } } , B ^ { \mathrm { t e } } , Y ^ { \mathrm { t e } } )$ , respectively: in-distribution, cross-domain, and cross-bias generalisation. See Figure 1 for a summary.
+
+In-distribution. $p ( S ^ { \mathrm { t r } } , B ^ { \mathrm { t r } } , Y ^ { \mathrm { t r } } ) = p ( S ^ { \mathrm { t e } } , B ^ { \mathrm { t e } } , Y ^ { \mathrm { t e } } )$ . This is the standard learning setup utilised in many benchmarks by splitting data from a single source into training and test data at random.
+
+Cross-domain. $p ( S ^ { \mathrm { t r } } , B ^ { \mathrm { t r } } , Y ^ { \mathrm { t r } } ) \neq p ( S ^ { \mathrm { t e } } , B ^ { \mathrm { t e } } , Y ^ { \mathrm { t e } } )$ and furthermore $p ( B ^ { \mathrm { t r } } ) \neq p ( B ^ { \mathrm { t e } } )$ . $B$ in this case is often referred to as “domain”. For example, training data consist of images with $Y ^ { \mathrm { t r } } { = } \mathrm { f r o g }$ , $B ^ { \mathrm { t r } } =$ wilderness) and $Y ^ { \mathrm { t r } } { = } \mathrm { b i r d }$ , $B ^ { \mathrm { t r } } =$ wilderness), while test data contain $Y ^ { \mathrm { t e } } =$ frog, $B ^ { \mathrm { t e } }$ =indoors) and $Y ^ { \mathrm { t e } } { = }$ bird, $B ^ { \mathrm { t e } }$ =indoors). This scenario is typically simulated by training and testing on different datasets (Ben-David et al., 2007).
+
+Cross-bias. $p ( B ^ { \mathrm { t r } } ) \not \equiv p ( Y ^ { \mathrm { t r } } ) ^ { 1 }$ and the dependency changes across training and test distributions: $p ( B ^ { \mathrm { t r } } , Y ^ { \mathrm { t r } } ) \ \ne \ p ( B ^ { \mathrm { t e } } , Y ^ { \mathrm { t e } } )$ . We further assume that $p ( B ^ { \mathrm { { \bar { t } } } } ) ~ = ~ p ( B ^ { \mathrm { { t e } } } )$ , to clearly distinguish the scenario from the cross-domain generalisation. For example, training data only contain images of two types $Y ^ { \mathrm { t r } } { = } \mathrm { f r o g }$ , $B ^ { \mathrm { t r } } { = } \mathrm { s w a m p }$ ) and $Y ^ { \mathrm { t r } } { = } \mathrm { b i r d }$ , $B ^ { \mathrm { t r } } { = } \mathrm { s k y } ,$ ), but test data contain unusual class-bias combinations $Y ^ { \mathrm { t e } } =$ frog, $B ^ { \mathrm { t e } } { = } \mathrm { s k y }$ ) and ( $Y ^ { \mathrm { t e } } { = }$ bird, $B ^ { \mathrm { t e } } { = } \mathrm { s w a m p }$ ). Our work addresses this scenario.
+
+# 2.2 EXISTING CROSS-BIAS GENERALISATION METHODS AND THEIR ASSUMPTIONS
+
+Under cross-bias generalisation scenarios, the dependency $p ( B ^ { \mathrm { t r } } )$ 6⊥⊥ $p ( Y ^ { \mathrm { t r } } )$ makes bias $B$ a viable cue for recognition. The model trained on such data becomes susceptible to interventions on $B$ , limiting its generalisabililty when the bias is changed or removed in the test data. There exist prior approaches to this problem, but with different types and amounts of assumptions on $B$ . We briefly recap the approaches based on the assumptions they require. In the next part $\ S 2 . 3$ , we will define our novel problem setting that requires an assumption distinct from the ones in prior approaches.
+
+When an algorithm to disentangle bias $B$ and signal $S$ exists. Being able to disentangle $B$ and $S$ lets one collapse the feature space corresponding to $B$ in both training and test data. A model trained on such normalised data then becomes free of biases. As ideal as it is, building a model to perfectly disentangle $B$ and $S$ is often unrealistic.
+
+When a generative algorithm or data collection procedure for $p ( X | B )$ exists. When additional examples can be supplied through $p ( X | B )$ , the training dataset itself can be de-biased, i.e., $B \perp \perp Y$ . For example, one can either collect or synthesise unusual images like frogs in sky and birds in swamp to balance out the bias. Such a data augmentation strategy is indeed a valid solution adopted by many prior studies (Panda et al., 2018; Geirhos et al., 2019; Shetty et al., 2019). However, collecting unusual inputs can be expensive (Peyre et al., 2017), and building a generative model with pre-defined bias types (Geirhos et al., 2019) may suffer from bias mis-specification and the lack of realism.
+
+When a predictive algorithm or ground truth for $p ( B | X )$ exists. Conversely, when one can tell the bias $B$ for every input $X$ , two approaches are feasible. (1) The first is a data re-weighting solution: we give greater weights on frogs in sky than frogs in swamps to even out the correlation in $p ( B , Y )$ (Li et al., 2018; Li & Vasconcelos, 2019). (2) The second approach removes the dependency between the model predictions $f ( X )$ and the bias $B$ . Many existing approaches for fairness in machine learning have proposed independence-based regularisers to encourage $f ( X ) \ \bot \bot B$ (Zemel et al., 2013) or the conditional independence $f ( X ) \ \bot \bot \ B \mid Y$ (called the “separation” constraint, Hardt et al. (2016)). Other approaches have proposed to remove predictability of $p ( B | X )$ based on $f ( X )$ through domain adversarial losses (Li & Vasconcelos, 2019; Wang et al., 2019) or projection (Wang et al., 2019; Quadrianto et al., 2019).
+
+The knowledge on $p ( B | X )$ is provided in many realistic scenarios. For example, when the aim is to remove gender biases $B$ in a job application process $p ( Y | X )$ , applicants’ genders $p ( B | X )$ are supplied as ground truths. However, there exist cases when $B$ is difficult to even be defined or quantified but can only be indirectly specified. We tackle such a scenario in the next part.
+
+# 2.3 OUR SCENARIO: CAPTURING BIAS WITH A PARTICULAR SET OF MODELS
+
+Under the cross-bias generalisation scenario, certain types of biases are not easily addressed by the above methods. Take texture bias as an example (§1, Geirhos et al. (2019)): (1) texture $B$ and shape $S$ cannot easily be disentangled, (2) building a generative model $p ( X | B )$ or collecting unusual images is expensive, (3) building the predictive model $p ( B | X )$ for texture requires enumeration (classifier) or embedding (regression) of all possible textures, which is not feasible.
+
+However, slightly modifying the third assumption results in a problem setting that allows interesting application scenarios. Instead of assuming explicit knowledge on $p ( B | X )$ , we approximate $B$ by defining a set of models $G$ that are biased towards $B$ by design. For texture biases, for example, we define $G$ to be the set of convolutional neural network (CNN) architectures with $\leq 5 \times 5$ overall receptive fields. Then, any learned model $g \in G$ can by design make predictions $g ( x )$ based on the patterns that can only be captured with small receptive fields (i.e., textures).
+
+More precisely, we define $G$ to be a bias-characterising model class for the bias-signal pair $( B , S )$ if for every possible joint distribution $p ( B , X )$ there exists a $g \in G$ such that $p ( B | X ) \approx g ( X )$ (recall condition) and every $g \in G$ satisfies $g ( X ) \perp \perp S \mid B$ (precision condition). In practice, $G$ may not necessarily include all biases and may also capture important signals (i.e., imperfect recall and precision). With this in mind, our framework is formulated so that $f ( X )$ does not ignore signals captured by $G - \mathrm { w e }$ do not require $\mathbf { G }$ to be perfect. Further detail is provided in $\ S 2 . 3$ .
+
+There exist many scenarios when such $G$ can be defined, as we are given several evidence for the type of bias. For instance, action recognition models have been reported to rely heavily on static cues without learning temporal cues (Li et al., 2018; Li & Vasconcelos, 2019); though the actual bias may not precisely be any static cue, we can still regularise the 3D convolutional networks towards better generalisation across static cue biases by defining $\mathbf { G }$ to be the set of 2D convolutional architectures. It has been argued that visual question answering (VQA) models, too, rely overly on language biases rather than the visual cues (e.g. without looking at the image, one knows the answer to what colour is the banana is yellow) (Agrawal et al., 2018). We can define G as the set of models looking at the language modality only. Entailment models are biased towards the presence of certain words (e.g. when there are many nots, the sentence is contradictory), rather than really understanding the underlying meaning of sentences (McCoy et al., 2019; Niven & Kao, 2019). We can design G to be the set of bag-of-words classifiers (He et al., 2019; Clark et al., 2019). Generally, these scenarios exemplify situations when the added architectural capacity is not fully utilised due to the sufficiency of simpler cues for solving the task in the given training set.
+
+# 3 PROPOSED METHOD
+
+We present a solution for the cross-bias generalisation when the bias-characterising model class $G$ is known (see $\ S 2 . 3 )$ ; the method is referred to as $\mathrm { R E B I ^ { \prime } } \mathrm { S } ^ { 2 }$ . The solution consists of training a model $f$ for the task $p ( Y | X )$ with a regularisation term encouraging the independence between the prediction $f ( X )$ and the set of all possible biased predictions $\{ g ( X ) \mid g \in G \}$ . We will introduce the precise definition of the regularisation term and discuss why and how it leads to the unbiased model.
+
+# 3.1 REBI’S: REMOVING BIAS WITH BIAS
+
+If $p ( B | X )$ is fully known, we can directly encourage $f ( X ) \ \bot \bot B$ . Since we only have access to the set of biased models $G$ (§2.3), we seek to promote $f ( X ) \perp \perp g ( X )$ for every $g \in G$ . Simply put, we de-bias a representation $f \in F$ by designing a set of biased models $G$ and letting $f$ run away from $G$ . This leads to the independence from bias cues $B$ while leaving signal cues $S$ as valid recognition cues; see $\ S 2 . 3$ . We will specify REBI $^ \prime \mathrm { ~ S ~ }$ learning objective after introducing our independence criterion, HSIC.
+
+Hilbert-Schmidt Independence Criterion (HSIC). Since we need to measure degree of independence between continuous random variables $f ( X )$ and $g ( X )$ in high dimensional spaces, it is infeasrando o resoiables $U$ to hiand $V$ gram-basedand kernels $k$ easuand $l$ es; we use HSIC (G, HSIC is defined as $\mathrm { H S I C } ^ { k , l } ( U , V ) : = | | C _ { U V } ^ { k , l } | | _ { \mathrm { H S } } ^ { 2 }$ $C ^ { k , l }$ $k$ and $l$ (Gretton et al., 2005), an RKHS analogue of covariance matrices. $| | \cdot | | _ { \mathrm { H S } }$ is the HilbertSchmidt norm, a Hilbert-space analogue of the Frobenius norm. It is known that for two random variables $U$ and $V$ and radial basis function (RBF) kernels $k$ and $l$ , $\mathrm { H S I C } ^ { k , l } ( U , V ) = 0$ if and only if $U \perp \perp V$ . A finite-sample estimate $\mathrm { H S I C } _ { 0 } ^ { k , l } ( U , V )$ has been used in practice for statistical testing (Gretton et al., 2005; 2008), feature similarity measurement (Kornblith et al., 2019), and model regularisation (Quadrianto et al., 2019; Zhang et al., 2018). $\mathrm { H S I C } _ { 0 } ^ { k , l } ( U , V )$ with $m$ samples is defined as $( m - 1 ) ^ { - 2 } \mathrm { t r } ( \widetilde { U } \widetilde { V } ^ { T } )$ where $\widetilde { U }$ is a mean-subtracted matrix of pairwise kernel similarities $\begin{array} { r } { \widetilde { U } _ { i j } = k ( u _ { i } , u _ { j } ) - m ^ { - 1 } \sum _ { j ^ { \prime } } k ( u _ { i } , u _ { j ^ { \prime } } ) } \end{array}$ among samples $\{ u _ { i } \} \sim U$ . $\widetilde { V }$ is defined similarly.
+
+Minimax optimisation for bias removal. In our case, we compute
+
+$$
+\mathrm { H S I C } _ { 0 } ^ { k } ( f ( X ) , G ( X ) ) : = \operatorname* { m a x } _ { g \in G } \mathrm { H S I C } _ { 0 } ^ { k } ( f ( X ) , g ( X ) )
+$$
+
+with an RBF kernel $k$ for the degree of independence between representation $f \in F$ and the biased representations $G$ . We write $\mathrm { H S I C } _ { 0 } ( f , \mathbf { \bar { G } } )$ and $\mathrm { H S I C } _ { 0 } ( f , g )$ as shorthands. Since the problem $\operatorname* { m i n } _ { f }$ $\mathrm { H S I C } _ { 0 } ( f , G )$ allows trivial solutions $f =$ const, we use the canonical kernel alignment (CKA) (Shawe-Taylor $\&$ Cristianini, 2004; Kornblith et al., 2019) criterion defined by $\Gamma \mathrm { K A } _ { 0 } ( f , g ) = \mathrm { H S I C } _ { 0 } ( f , g ) / ( \mathrm { H S I C } _ { 0 } ( f , f ) ^ { \frac { 1 } { 2 } } \mathrm { H S I C } _ { 0 } ( g , g ) ^ { \frac { 1 } { 2 } } )$ . The learning objective for $f$ is then defined as
+
+$$
+\operatorname* { m i n } _ { f \in F } \left\{ { \mathcal { L } } ( f , X , Y ) + \lambda \operatorname* { m a x } _ { g \in G } { \bf C } { \bf K } { \bf A } _ { 0 } ( f , g ) \right\} ,
+$$
+
+where $\mathcal { L } ( f , X , Y )$ is the loss for the main task $p ( Y | X )$ and $\lambda > 0$ . We consider replacing the inner optimisation with $L _ { 2 }$ minimisation $\textstyle \operatorname* { m i n } _ { g \in G } ~ | | f - g | | _ { 2 }$ , while retaining the CKA regularisation for the outer optimisation for $f$ . Intuitively, $L _ { 2 }$ minimisation poses a stronger similarity condition between $f$ and $g$ (in fact identity) than does $C K A$ , leading to better de-biasing performances (§4.2.3).
+
+Independence versus separation. The CKA regularisation in equation 2 encourages $f ( X ) ~ \bot$ $\perp \ g ( X )$ . This may lead to less stable optimisation as removing bias often increases the main task loss $\mathcal { L }$ . Furthermore, $g ( X )$ may also capture signals along with bias (imperfect precision), and suppressing important signals is not desirable. To avoid such cases, we formulate our objective as conditional independence $f ( X ) \perp \perp g ( X ) \mid Y$ by computing the separation CKA, $\begin{array} { r } { \mathrm { S C K A } _ { 0 } ( f , g ) \ : = \ : | \mathcal { V } | ^ { - 1 } \sum _ { y \in \mathcal { V } } \mathrm { \ C K A } _ { 0 } ( f ( X | Y = y ) , g ( X | Y = y ) ) } \end{array}$ , where the term “separation” (or “equalised odds”) comes from the fairness literature (Hardt et al., 2016). Unlike independence that requires $f ( X )$ to ignore $g ( X )$ altogether, conditional independence allows $f ( X )$ to utilise cues captured by $g ( X )$ (i.e., whether it is bias or signal) if it highly correlates with ${ \mathrm { Y } } .$ In other words, $\mathbb { R E B I ^ { \prime } S }$ encourages $f ( X )$ to learn features beyond those already captured by $g ( X )$ , so that it can generalise well to test sets with different biases (i.e., cross-bias generalisation).
+
+The final learning objective for REBI $^ \prime \mathrm { ~ S ~ }$ is then
+
+$$
+\operatorname* { m i n } _ { f \in { \cal F } } \left\{ { \mathcal { L } } ( f , X , Y ) + \lambda \operatorname* { m a x } _ { g \in { \cal G } } { \mathrm { S C K A } } _ { 0 } ( f , g ) \right\} .
+$$
+
+# 3.2 WHY AND HOW DOES IT WORK?
+
+Independence describes relationships between random variables, but we use it for function pairs. Which functional relationship does statistical independence translate to? In this part, we argue with proofs and observations that the answer to the above question is the dissimilarity of invariance types learned by a pair of models.
+
+Linear case: Equivalence between independence and orthogonality. We study the set of function pairs $( f , g )$ satisfying $f ( X ) \perp \perp g ( { \bar { X } } )$ for suitable random variable $X \sim p ( X )$ . Assuming linearity of involved functions and the normality of $X$ , we obtain the equivalence between statistical independence and functional orthogonality.
+
+Lemma 1. Assume that $f$ and $g$ are affine mappings $f ( x ) = A x + a$ and $g ( x ) = B x + b$ where $A \in \mathbb { R } ^ { m \times n }$ and $B \in \mathbb { R } ^ { l \times n }$ . Assume further that $X$ is a normal distribution with mean $\mu$ and covariance matrix $\Sigma$ . Then, $f ( X )$ ⊥⊥ $g ( X )$ if and only if $\ker ( A ) ^ { \perp } \perp _ { \Sigma } \ker ( B ) ^ { \perp }$ . For a positive semi-definite matrix $\Sigma$ , we define $\langle r , s \rangle _ { \Sigma } = \langle r , { \Sigma } s \rangle$ , and the set orthogonality $\perp _ { \Sigma }$ likewise. Proof in $\ S \mathbf { A }$ .
+
+In particular, when $f$ and $g$ have 1-dimensional outputs, the independence condition is translated to the orthogonality of their weight vectors and decision boundaries. From a machine learning point of view, $f$ and $g$ are models with orthogonal invariance types.
+
+Non-linear case: HSIC as a metric learning objective. We lack theories to fully characterise general, possibly non-linear, function pairs $( f , g )$ achieving $f ( X ) \perp \perp g ( X )$ ; it is an interesting open question. For now, we make a set of observations in this general case, using the finite-sample independence criterion $\mathrm { H S I C } _ { 0 } ( f , g ) : = ( m - 1 ) ^ { - 2 } \mathrm { t r } ( \widetilde { f } \widetilde { g } ^ { T } ) \stackrel {  } { = } 0$ , where $\widetilde { f }$ is the mean-subtracted kernel matrix $\begin{array} { r } { \widetilde { f } _ { i j } = k ( f ( x _ { i } ) , f ( x _ { j } ) ) - m ^ { - 1 } \sum _ { k } k ( f ( x _ { i } ) , f ( x _ { k } ) ) } \end{array}$ and likewise for $\widetilde g$ (see $\ S 3 . 1 \rrangle$ .
+
+Note that $\operatorname { t r } ( \widetilde { f } \ \widetilde { g } ^ { T } )$ is an inner product between flattened matrices $\widetilde { f }$ and $\widetilde g$ . We consider the inner eproduct minimising solution for $f$ on an input pair $x _ { 0 } \neq x _ { 1 }$ egiven a fixed $g$ . The problem can be written as $\begin{array} { r } { \operatorname* { m i n } _ { f ( x _ { 0 } ) , f ( x _ { 1 } ) } \ \mathrm { t r } ( \widetilde { f } \widetilde { g } ^ { T } ) } \end{array}$ , which is equivalent to $\begin{array} { r } { \operatorname* { m i n } _ { f ( x _ { 0 } ) , f ( x _ { 1 } ) } \ \widetilde { f } _ { 0 1 } \cdot \widetilde { g } _ { 1 0 } } \end{array}$ .
+
+Suppose $\widetilde { g } _ { 1 0 } ~ > ~ 0$ . It indicates a relative invariance of $g$ on $( x _ { 1 } , x _ { 0 } )$ , since $k ( g ( x _ { 1 } ) , g ( x _ { 0 } ) ) \ >$ $\begin{array} { r } { m ^ { - 1 } \sum _ { i } k ( g ( x _ { 1 } ) , g ( x _ { i } ) ) } \end{array}$ . Then, the above problem boils down to $\mathrm { m i n } _ { f ( x _ { 0 } ) , f ( x _ { 1 } ) } \stackrel { \triangledown } { f _ { 0 1 } }$ , signifying the relative variance of $f$ on $( x _ { 0 } , x _ { 1 } )$ . Following a similar argument, we obtain the converse statement: if $g$ is relatively variant on a pair of inputs, invariance of $f$ on the pair minimises the objective.
+
+We conclude that $\operatorname* { m i n } _ { f }$ $\mathrm { H S I C } _ { 0 } ( f , g )$ against a fixed $g$ is a metric-learning objective for the embedding $f$ , where ground truth pairwise matches and mismatches are relative mismatches and matches for $g$ , respectively. As a result, $f$ and $g$ learn different sorts of invariances.
+
+Effect of HSIC regularisation on toy data. We have established that HSIC regularisation encourages the difference in model invariances. To see how it helps to de-bias a model, we have prepared synthetic two-dimensional training data following the cross-domain generalisation case in Figure 1: $\dot { \boldsymbol X } = ( B , S ) \in \mathbb { R } ^ { 2 }$ and $Y \in$ {red, yellow, green}. Since the training data is perfectly biased, a multi-layer perceptron (MLP) trained on the data only shows $5 5 \%$ accuracy on de-biased test data (see decision boundary figure in Appendix $\ S \mathbf { B }$ ). To overcome the bias, we have trained another MLP with equation 3 where the bias-characterising class $G$ is defined as the set of MLPs that take only the bias dimension as input. This model exhibits de-biased decision boundaries (Appendix $\ S \mathbf { B }$ ) with improved accuracy of $89 \%$ on the de-biased test data.
+
+# 4 EXPERIMENTS
+
+In the previous section, REBI $^ \prime \mathrm { ~ S ~ }$ has been introduced and theoretically justified. In this section, we present experimental results of REBI’S. We first introduce the setup, including the biases tackled in the experiments, difficulties inherent to the cross-bias evaluation, and the implementation details (§4.1). Results on Biased MNIST (§4.2) and ImageNet (§4.3) are shown afterwards.
+
+# 4.1 EXPERIMENTAL SETUP
+
+Which biases do we tackle? There is a broad spectrum of bias types to be addressed under the cross-bias generalisation setting. Our work is targeting the biases that arise due to the existence of shortcut cues that are sufficient for recognition in training data. In the experiments, we tackle a representative bias of such type: “local pattern” biases for image classification. Even if a CNN image classifier has wide receptive fields, empirical evidence indicates that they heavily rely on local patterns (i.e., color and texture) as opposed to global shape cues (Geirhos et al., 2019).
+
+While it is difficult to precisely define and quantify all local pattern biases, it is easy to capture it through a class of CNN architectures: those with smaller receptive fields. This is precisely the setting where we benefit from REBI’S.
+
+Evaluating cross-bias generalisation is difficult. To measure the performance of a model across real-world biases, one requires an unbiased dataset or one where the types and degrees of biases can be controlled. Unfortunately, data in real world arise with biases. To de-bias a frog and bird image dataset with swamp and sky backgrounds (see $\ S 2 . 1 )$ , either rare data samples must be collected (search for photos of a frog on sky) or one must intervene with the data generation process (throw a frog into the sky and take a photo). Either way, it is an expensive procedure (Peyre et al., 2017).
+
+Preparing an unbiased data is feasible in some cases when the bias type is simple (e.g., collecting natural language corpus of unbiased gender pronouns, Webster et al. (2018)). However, we are addressing biases that are expressed in terms of a class of representations but perhaps are difficult to precisely express in language, such as texture bias of image classifiers (§2.3).
+
+We thus evaluate our method along two axes: (1) Biased MNIST and (2) ImageNet. Biased MNIST contains synthetic biases (colour and texture) which we freely control in training and test data for indepth analysis of REBI’S. In particular, we can measure its performance on perfectly unbiased test data. On ImageNet, we evaluate our method against realistic biases. Due to the difficulty of defining and obtaining bias labels on real images, we use proxy ground truths for the local pattern bias to measure the cross-bias generalisability. MNIST and ImageNet experiments complement each other in terms of experimental control and realism.
+
+Implementation of REBI’S. We describe the specific design choices in REBI’S implementation (equation 3) in our experiments. We will open source the code and data.
+
+To train a model that overcomes local pattern biases, we first define biased model architecture families $G$ such that they precisely and sufficiently encode biased representations: CNNs with relatively small receptive fields (RFs). The biased models in $G$ will by design learn to predict the target class of an image through only local cues. On the other hand, we define a larger search space $F$ with larger RFs for our unbiased representations.
+
+In our work, all networks $f$ and $g$ are fully convolutional networks. $f ( x )$ and $g ( x )$ denote the final convolutional layer outputs (feature maps), on which we compute the independence measures like
+
+HSIC, CKA, and SCKA (§3.1). We perform global average pooling and a learnable linear classifier on $f ( x )$ , trained along with the outer optimisation, to compute the cross-entropy loss in equation 3.
+
+For Biased MNIST, $F$ is the LeNet $F$ (LeCun et al., 1998) architecture with RF 28. It has two 5- convs3, after each of which max-pooling layers of $2 \times 2$ kernels are applied, followed by three linear layers. $G$ has the same number of layers but either with all convolutional layers of $1 \times 1$ kernels and without max-pooling operations, called BlindNet1, or with one 3-conv and one 1-conv, called BlindNet3, each with a RFs of 1 and 3, respectively. On ImageNet, we use ResNet (He et al., 2016) architecture for $F$ (either ResNet18 with RF of 435 or ResNet50 with RF of 427). $G$ is defined as BagNet (Brendel & Bethge, 2019) architectures with the same depth as ResNet’s (either BagNet18 with RF of 43 or BagNet50 with RF of 91). More implementation details are provided in $\mathrm { \ S C }$ .
+
+# 4.2 BIASED MNIST
+
+We first verify our model on a dataset where we have full control over the type and amount of bias during training and evaluation. We describe the dataset and present the experimental results.
+
+# 4.2.1 DATASET AND EVALUATION
+
+We construct a new dataset called Biased MNIST designed to measure the extent to which models generalise to bias shift. We modify MNIST (LeCun et al., 1998) by introducing two types of bias $B$ – colour and texture – that highly correlate with the label $Y$ during training. With $B$ alone, a CNN can achieve high accuracy without
+
+![](images/90c62aee8b79de2af1881e480cd150832dbcec2ca705144ec6452c844ec95e19.jpg)  
+Figure 2: Biased MNIST. We construct a synthetic dataset with two types of biases – colour and texture – which highly correlate with the label during training. Upper row: colour bias. Lower row: colour and texture biases.
+
+having to learn inherent signals for digit recognition $S$ , such as shape, providing little motivation for the model to learn beyond these superficial cues.
+
+We inject colour and texture biases by adding colour or texture patterns on training image backgrounds (see Figure 2). We pre-select 10 distinct colour or $3 \times 3$ texture patterns $b ( y )$ for each digit $\bar { y } \in \{ 0 , \cdots , 9 \}$ . Then, for each image of digit $y$ , we assign the pre-defined pattern $b ( y )$ with probability $\rho \in [ 0 , 1 ]$ and any other pattern (pre-defined for other digits) with probability $( 1 - \rho )$ . $\rho$ then controls the bias-target correlation in the training data: $\rho = 1 . 0$ leads to complete bias and $\rho = 0 . 1$ leads to an unbiased dataset. We consider two datasets: Single-bias MNIST with only colour bias and Multi-bias MNIST with both colour and texture biases ${ \bf \zeta } _ { \rho } = 0 . 9 9$ in all the experiments).
+
+We evaluate the models generalisability to bias shift by evaluating under the following criterion:
+
+Biased. $p ( S ^ { \mathrm { t e } } , B ^ { \mathrm { t e } } , Y ^ { \mathrm { t e } } ) \ = \ p ( S ^ { \mathrm { t r } } , B ^ { \mathrm { t r } } , Y ^ { \mathrm { t r } } )$ (an in-distribution case in $\ S 2 . 1 \ r ,$ ). Whatever bias the training set contains, it is replicated in the test set. This measures the ability of de-biased models to maintain high in-distribution performance while generalising to unbiased settings.
+
+Unbiased. $B ^ { \mathrm { t e } } ~ \bot \bot ~ Y ^ { \mathrm { t e } }$ . We assign biases on test images independently of the labels. Bias is no longer predictive of $Y$ and a model needs to utilise actual signals $S$ to yield correct predictions.
+
+We have additional fine-grained measures on Multi-bias MNIST: removed colour bias (colour; texture bias remains) and removed texture bias (texture; colour bias remains) cases. Colour and texture biases are marginalised out in the test set, respectively, to factorise generalisability across different types of bias.
+
+# 4.2.2 RESULTS
+
+Results on Single- and Multi-bias MNIST are shown in Table 1.
+
+REBI’S lets a model overcome bias. We observe that vanilla LeNet $F$ achieves $100 \%$ accuracy under the “biased” metric (the same bias between training and test data) in Single- and Multi-bias MNIST. This is how most machine learning tasks are evaluated, yet this does not show the extent to which the model depends on bias for prediction. When the bias cues are randomly assigned to the label at evaluation, vanilla LeNet accuracy collapses to $2 7 . 5 \%$ and $2 9 . 6 \%$ under the “unbiased” metric on Single- and Multi-bias MNIST, respectively. The intentionally biased BlindNet models $G$ result in an even lower accuracy of $1 0 . 8 \%$ on Single-bias MNIST, close to the random chance $10 \%$ . This reveals that the seemingly high-performing model has in fact overfitted to bias and has not learned beyond this fallible strategy.
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Description</td><td colspan="2">Single-bias MNIST</td><td colspan="4">Multi-bias MNIST</td></tr><tr><td>biased</td><td>unbiased</td><td>biased</td><td>colour</td><td>texture</td><td>unbiased</td></tr><tr><td>F</td><td>Vanilla</td><td>100.</td><td>27.5</td><td>100.</td><td>45.1</td><td>85.8</td><td>29.6</td></tr><tr><td>G</td><td>Biased</td><td>100.</td><td>10.8</td><td>100.</td><td>10.0</td><td>58.5</td><td>4.7</td></tr><tr><td>FHEX</td><td>Wang et al. (2019)</td><td>97.2</td><td>14.7</td><td>95.0</td><td>31.1</td><td>91.1</td><td>18.1</td></tr><tr><td>FIG</td><td>REBI&#x27;S (ours)</td><td>96.1</td><td>74.9</td><td>94.7</td><td>91.9</td><td>90.9</td><td>88.6</td></tr></table>
+
+Table 1: Biased MNIST results. Architecture families are set as $\begin{array} { r } { F = \mathrm { L e N e t } } \end{array}$ and $G =$ BlindNet1 for Single-bias and BlindNet3 for Multi-bias MNIST. Accuracy results are shown.
+
+REBI $^ \prime \mathrm { ~ S ~ }$ , on the other hand, achieves robust generalisation across all settings by learning to be different from BlindNet representations $G$ . REBI $^ \prime \mathrm { ~ S ~ }$ achieves a $+ 4 7 . 4$ pp (Single) and $+ 5 9 . 0$ pp (Multi) higher performances than the vanilla model under the cross-bias generalisation setup (the unbiased metric), with a slight degradation in original accuracies $( - 3 . 9 \mathrm { p p }$ and $- 5 . 3 \mathrm { p p }$ , respectively).
+
+Comparison against HEX. Previously, HEX (Wang et al., 2019) has attempted to reduce the dependency of a model on “superficial statistics”, or high-frequency textural information. HEX measures texture via neural grey-level co-occurrence matrices (NGLCM) and projects out the NGLCM feature from the output of the model of interest. We observe that $F _ { \mathrm { H E X } }$ , where HEX is applied on $F$ , is effective in removing texture biases $( 8 5 . 8 \%$ to $9 1 . 1 \%$ cross-texture accuracy), but still vulnerable to colour biases (accuracy drops from $4 5 . 1 \%$ to $3 1 . 1 \%$ ). Hand-crafting texture features as done by HEX has resulted in its limited applicability beyond the hand-crafted bias type. By designing the model family architecture, instead of a specific feature extractor, REBI’S achieved a representation free of broader types of biases.
+
+# 4.2.3 FACTOR ANALYSIS
+
+Some design choices exist, leading to our final model (§3.1). We examine how the factors contribute to the final performance. See Table 2 for ablative studies on the Single-bias MNIST.
+
+Impact of the independence criterion. Three independence measures, HSIC, CKA, and SCKA, have been considered. SCKA, the separation CKA, used in $\mathrm { R E B I ^ { \prime } } \mathrm { S }$ , shows a superior de-biasing performance $( 7 4 . 9 \% )$ against baseline choices. It improves upon HSIC by avoiding the trivial solution (a constant function), and upon CKA via more stable optimisation due to the milder conditional independence $f ( X ) \ { \stackrel { \cdot \cdot } { \bot } } \ B \mid Y$ that does not contradict the classification objective.
+
+Impact of the $L _ { 2 }$ objective in the inner optimisation. We then study the effect of our choice to replace the inner SCKA optimisation with the $L _ { 2 }$ objective. $L _ { 2 }$ is considered, as it poses a stronger convergence condition than SCKA does. We confirm indeed that the $L _ { 2 }$ objective results in a better de-biasing performance.
+
+Table 2: Factor analysis. Default REBI’S parameters: last rows.   
+
+<table><tr><td>Indep.</td><td colspan="2">biased unbiased</td></tr><tr><td>HSIC</td><td>83.5</td><td>51.1</td></tr><tr><td>CKA</td><td>97.4</td><td>22.0</td></tr><tr><td>SCKA</td><td>96.1</td><td>74.9</td></tr><tr><td>Inner opt.</td><td>biased</td><td>unbiased</td></tr><tr><td>SCKA</td><td>95.8</td><td>62.4</td></tr><tr><td>L2</td><td>96.1</td><td>74.9</td></tr><tr><td>Updating g</td><td>biased</td><td>unbiased</td></tr><tr><td>Fixed g</td><td>94.6</td><td>44.7</td></tr><tr><td>Multiple g</td><td>95.9</td><td>58.1</td></tr><tr><td>Updated g</td><td>96.1</td><td>74.9</td></tr></table>
+
+Impact of updating $g \in G$ . The advantage of specifying a class of models $G$ instead of a single, fixed model $g _ { 0 }$ is that $\operatorname { H S I C } ( f , G )$ can be computed more precisely (§3.1). We quantify this benefit. Fixing the biased representation to $g _ { 0 }$ results in sub-optimal de-biasing performance, $4 4 . 7 \%$ . By including multiple fixed biased models $\{ g _ { 0 } , \cdot \cdot \cdot , g _ { 7 } \} \subset { \overline { { G } } }$ , de-biasing improves to $5 8 . 1 \%$ , but is not as good as the updated $g$ case, $7 4 . 9 \%$ . It is thus important to precisely compute the representationto-set independence. More detailed analysis around the receptive field sizes of models in $G$ is in Appendix $\mathrm { \ S E }$ .
+
+<table><tr><td>Model</td><td>Description</td><td>Biased</td><td>Unbiased</td><td>IN-A</td></tr><tr><td>F</td><td>ResNet18</td><td>93.3</td><td>85.8</td><td>30.5</td></tr><tr><td>G</td><td>BagNet18</td><td>72.4</td><td>58.6</td><td>19.5</td></tr><tr><td>FIG</td><td>REBI&#x27;S</td><td>93.7</td><td>88.4</td><td>31.7</td></tr><tr><td>F</td><td>Geirhos et al.</td><td>92.5</td><td>87.6</td><td>29.7</td></tr><tr><td>F</td><td>ResNet50</td><td>91.7</td><td>78.3</td><td>29.5</td></tr><tr><td>G</td><td>BagNet50</td><td>73.0</td><td>60.9</td><td>21.4</td></tr><tr><td>FIG</td><td>REBI&#x27;S</td><td>88.7</td><td>89.2</td><td>31.3</td></tr></table>
+
+Table 3: ImageNet results. We show results with $F$ and $F _ { \bot \bot G }$ corresponding to $F$ is ResNet18 and $G$ is BagNet18) and ( $F$ is ResNet50 and $G$ is BagNet50). IN-A indicates ImageNet-A.
+
+# 4.3 IMAGENET
+
+In ImageNet experiments, we further validate the applicability of $\mathbb { R E B I ^ { \prime } S }$ on the local pattern bias in realistic images (i.e,, objects in natural scenes). The local pattern bias often lets a model achieve good in-distribution performances by exploiting the local cue shortcuts (e.g, determining a turtle class by not seeing its shape but the background texture).
+
+# 4.3.1 DATASET AND EVALUATION
+
+We construct 9-Class ImageNet, a subset of ImageNet (Russakovsky et al., 2015) containing 9 super-classes as done in Ilyas et al. (2019), since full-scale analysis on ImageNet is not scalable. We additionally balance the ratios of sub-class images for each super-class to solely focus on the effect of the local pattern bias.
+
+Since it is difficult to evaluate cross-bias generalisability on realistic unbiased data ( 4.1), we settle for alternative evaluations:
+
+Biased. $p ( S ^ { \mathrm { t e } } , B ^ { \mathrm { t e } } , Y ^ { \mathrm { t e } } ) = p ( S ^ { \mathrm { t r } } , B ^ { \mathrm { t r } } , Y ^ { \mathrm { t r } } )$ Accuracy is measured on the in-distribution validation set. Though widely-used, this metric is blind to a model’s generalisability to unseen bias-target combinations.
+
+Unbiased. $B ^ { \mathrm { t e } } \perp \perp Y ^ { \mathrm { t e } }$ As a proxy to the perfectly de-biased test data, which is difficult to collect ( 4.1), we use texture clusters IDs $\dot { c } \in \{ 1 , \dot { \cdot } \cdot \cdot , K \} \dot $ as the ground truth labels for local pattern bias. For full details of texture clustering algorithm, see Appendix $\mathrm { \ S F }$ . For an unbiased accuracy measurement, we compute accuracies for every set of images corresponding to a target-texture combination $( c , y )$ . The combination-wise accuracy $A _ { c , y }$ is computed by $\mathrm { C o r r } ( c , y ) / \mathrm { P o p } ( c , y )$ , where $\operatorname { C o r r } ( c , y )$ is the number of correctly predicted samples in $( c , y )$ and $\mathrm { P o p } ( c , y )$ is the total number of samples in $( c , y )$ , called the population at $( c , y )$ . The unbiased accuracy is then the mean accuracy over all $A _ { c , y }$ where the population is non-zero $\dot { \operatorname { P o p } } ( c , y ) \neq 0$ . This measure gives more weights on samples of unusual texture-class combinations (smaller $\mathrm { P o p } ( c , y ) )$ that are less represented in the usual biased accuracies. Under this unbiased metric, a biased model basing its recognition on textures is likely to show sub-optimal results on unusual combinations, leading to a drop in the unbiased accuracy.
+
+ImageNet-A. ImageNet-A (Hendrycks et al., 2019) contains failure cases of ImageNet pre-trained ResNet50 among web images. The images consist of many failure modes of networks when “frequently appearing background elements” become erroneous cues for recognition (e.g. a bee image feeding on hummingbird feeder is recognised as a hummingbird). Improved performance on ImageNet-A is an indirect signal that the model learns beyond the bias shortcuts.
+
+# 4.3.2 RESULTS
+
+We measure performances of ResNet18 and ResNet50, each trained to be different from BagNet18 and BagNet50 respectively using REBI’S, under the metrics in the previous part. Results are shown in Table 3.
+
+Vanilla models are biased. Both ResNet18 and ResNet50 show good performances on the biased accuracy $( 9 3 . 3 \%$ and $9 1 . 7 \%$ , respectively), but dropped performances on the texture-unbiased accuracies $8 5 . 8 \%$ and $78 . 3 \%$ , respectively). BagNet18 and BagNet50 perform worse than the vanilla ResNets as they are heavily biased towards texture by design (i.e., small receptive field size). The drop signifies the biases of vanilla models towards texture cues; by basing their predictions on texture cues they obtain generally better accuracies on texture-class pairs $( c , y )$ that are represented more. The drop also shows the limitation of current evaluation schemes where cross-bias generalisation is not measured.
+
+REBI’S leads to less biased models. When REBI $^ \prime \mathrm { ~ S ~ }$ is applied on ResNet18 and ResNet50 to encourage them to unlearn cues learnable by BagNet18 and BagNet50, respectively, we observe general boost in unbiased accuracies. ResNet18 improves from $8 5 . 8 \%$ to $8 8 . 4 \%$ ; ResNet50 from $7 8 . 3 \%$ to $8 9 . 2 \%$ . Our method thus robustly generalises to less represented texturetarget combinations at test time. We observe that our method also shows improvement on the challenging ImageNet-A subset (e.g. from $2 9 . 5 \%$ to $3 1 . 3 \%$ for ResNet50), which further shows our superiority on generalisability to unusual texture-class combinations. Similarly, data augmentation via Stylised ImageNet (Geirhos et al., 2019) attempts to reduce a model’s dependency on texture by augmenting data with texturised images. While it shows improvements in reducing texture bias $( 8 7 . 6 \%$ for unbiased accuracy), it does not increase the generalisability to the challenging natural adversarial examples $( 2 9 . 7 \%$ for ImageNet-A). More detailed analysis on per-texture and per-class accuracies are included in Appendix $\ S \mathbf G$ ; learning curves for the baseline and $\mathrm { R E B I ^ { \prime } } \mathrm { S }$ are in Appendix $\mathrm { \ S H }$ .
+
+Qualitative analysis. We qualitatively present the cases where our method successfully de-biases a texture-target dependency. Figure 3 shows examples of common and uncommon texture-target combinations for “grass” and “close-up” texture clusters. The shown uncommon instances are the ones ResNet18 has incorrectly predicted the class. For example, crab in the grass has been predicted as turtle, presumably because turtles co-occur a lot with grass backgrounds in training data. On the other hand, REBI’S (ours) robustly generalises to unusual texture-class combinations.
+
+# 5 CONCLUSION
+
+We have identified a practical problem faced by many machine learning algorithms that the learned models exploit bias shortcuts to recognise the target (cross-bias generalisation problem in $\ S 2$ ). In particular, models tend to under-utilise its capacity to extract non-bias signals (e.g. global shapes for object recognition) when bias shortcuts provide sufficient cues for recognition in the training data (e.g. local patterns and background cues for object recognition) (Geirhos et al., 2019). We have addressed this problem with the $\mathrm { R E B I ^ { \prime } } \mathrm { S }$ framework, which does not rely on expensive, if not infeasible, training data debiasing schemes. Given an identified set of models $G$ that encodes the bias to be removed, REBI’S encourages a model $f$ to be statistically independent of $G$ (§3). We have provided theoretical justifications for the use of statistical independence in $\ S 3 . 2$ , and have validated the superiority of REBI’S in removing biases from models through experiments on modified MNIST and ImageNet (§4).
+
+![](images/47a9cb8557fc014ad500bcef9c17c282fcc67255b46820a0e3861d6d9d66b902.jpg)  
+Figure 3: Qualitative results. Common and uncommon images are shown according to class-texture relationship. Predictions of ResNet18 and REBI’S are shown as well.
+
+# REFERENCES
+
+Aishwarya Agrawal, Dhruv Batra, Devi Parikh, and Aniruddha Kembhavi. Don’t just assume; look and answer: Overcoming priors for visual question answering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4971–4980, 2018.   
+Shai Ben-David, John Blitzer, Koby Crammer, and Fernando Pereira. Analysis of representations for domain adaptation. In Advances in neural information processing systems, pp. 137–144, 2007.   
+Wieland Brendel and Matthias Bethge. Approximating CNNs with bag-of-local-features models works surprisingly well on imagenet. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id=SkfMWhAqYQ.
+
+Christopher Clark, Mark Yatskar, and Luke Zettlemoyer. Don’t take the easy way out: Ensemble based methods for avoiding known dataset biases. EMNLP, 2019.
+
+Leon Gatys, Alexander S Ecker, and Matthias Bethge. Texture synthesis using convolutional neural networks. In Advances in neural information processing systems, pp. 262–270, 2015.
+
+Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and Wieland Brendel. Imagenet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id $_ { \cdot } =$ Bygh9j09KX.
+
+Arthur Gretton, Olivier Bousquet, Alex Smola, and Bernhard Scholkopf. Measuring statistical dependence with ¨ hilbert-schmidt norms. In International conference on algorithmic learning theory, pp. 63–77. Springer, 2005.
+
+Arthur Gretton, Kenji Fukumizu, Choon H Teo, Le Song, Bernhard Scholkopf, and Alex J Smola. A kernel ¨ statistical test of independence. In Advances in neural information processing systems, pp. 585–592, 2008.
+
+Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel Bowman, and Noah A. Smith. Annotation artifacts in natural language inference data. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics, pp. 107–112, New Orleans, Louisiana, June 2018. Association for Computational Linguistics. URL https://www.aclweb.org/ anthology/N18-2017.
+
+Moritz Hardt, Eric Price, Nati Srebro, et al. Equality of opportunity in supervised learning. In Advances in neural information processing systems, pp. 3315–3323, 2016.
+
+He He, Sheng Zha, and Haohan Wang. Unlearn dataset bias in natural language inference by fitting the residual. EMNLP, 2019.
+
+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.
+
+Dan Hendrycks, Kevin Zhao, Steven Basart, Jacob Steinhardt, and Dawn Song. Natural adversarial examples. arXiv preprint arXiv:1907.07174, 2019.
+
+Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. arXiv preprint arXiv:1905.02175, 2019.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and superresolution. In European conference on computer vision, pp. 694–711. Springer, 2016.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey Hinton. Similarity of neural network representations revisited. In International Conference on Machine Learning, 2019.
+
+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.
+
+Yi Li and Nuno Vasconcelos. Repair: Removing representation bias by dataset resampling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9572–9581, 2019.
+
+Yingwei Li, Yi Li, and Nuno Vasconcelos. Resound: Towards action recognition without representation bias. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 513–528, 2018.
+
+R Thomas McCoy, Ellie Pavlick, and Tal Linzen. Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference. ACL, 2019.
+
+Timothy Niven and Hung-Yu Kao. Probing neural network comprehension of natural language arguments. ACL, 2019.
+
+Rameswar Panda, Jianming Zhang, Haoxiang Li, Joon-Young Lee, Xin Lu, and Amit K Roy-Chowdhury. Contemplating visual emotions: Understanding and overcoming dataset bias. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 579–595, 2018.
+
+Julia Peyre, Josef Sivic, Ivan Laptev, and Cordelia Schmid. Weakly-supervised learning of visual relations. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5179–5188, 2017.
+
+Novi Quadrianto, Viktoriia Sharmanska, and Oliver Thomas. Discovering fair representations in the data domain. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8227–8236, 2019.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.
+
+John Shawe-Taylor and Nello Cristianini. Kernel methods for pattern analysis. Cambridge university press, 2004.
+
+Rakshith Shetty, Bernt Schiele, and Mario Fritz. Not using the car to see the sidewalk–quantifying and controlling the effects of context in classification and segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8218–8226, 2019.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+A. Torralba and A. A. Efros. Unbiased look at dataset bias. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1521–1528, June 2011.
+
+Haohan Wang, Zexue He, and Eric P. Xing. Learning robust representations by projecting superficial statistics out. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id ${ } = 1$ rJEjjoR9K7.
+
+Kellie Webster, Marta Recasens, Vera Axelrod, and Jason Baldridge. Mind the gap: A balanced corpus of gendered ambiguous pronouns. Transactions of the Association for Computational Linguistics, 6:605–617, 2018.
+
+Rich Zemel, Yu Wu, Kevin Swersky, Toni Pitassi, and Cynthia Dwork. Learning fair representations. In International Conference on Machine Learning, pp. 325–333, 2013.
+
+Changqing Zhang, Yeqinq Liu, Yue Liu, Qinghua Hu, Xinwang Liu, and Pengfei Zhu. Fish-mml: Fisher-hsic multi-view metric learning. In IJCAI, pp. 3054–3060, 2018.
+
+# A STATISTICAL INDEPENDENCE IS EQUIVALENT TO FUNCTIONAL ORTHOGONALITY FOR LINEAR MAPS.
+
+We provide a proof for the following lemma in $\ S 3 . 2$ .
+
+Lemma 1. Assume that $f$ and $g$ are affine mappings $f ( x ) = A x + a$ and $g ( x ) = B x + b$ where $A \in \mathbb { R } ^ { m \times n }$ and $B \in \mathbb { R } ^ { \tilde { l } \times n }$ . Assume further that $X$ is a normal distribution with mean $\mu$ and covariance matrix $\Sigma$ . Then, $f ( X ) \ \bot \bot \ g ( X )$ if and only if $\ker ( A ) ^ { \perp } \perp _ { \Sigma } \ker ( B ) ^ { \perp }$ . For a positive semi-definite matrix $\Sigma$ , we define $\langle r , s \rangle _ { \Sigma } = \langle r , { \Sigma } s \rangle$ , and the set orthogonality $\perp _ { \Sigma }$ likewise.
+
+Proof. Due to linearity and normality, the independence $f ( X ) \ \bot \bot g ( X )$ is equivalent to the covariance condition $\operatorname { C o v } ( f ( X ) , g ( X ) ) = 0$ . Covariance is computed as:
+
+$$
+\operatorname { C o v } ( f ( X ) , g ( X ) ) = \operatorname { \mathbb { E } } _ { X } A ( X - x ^ { 0 } ) ( X - x ^ { 0 } ) ^ { T } B ^ { T } = A \Sigma B ^ { T }
+$$
+
+Note that
+
+$$
+\begin{array} { r l } & { A \Sigma B ^ { T } = 0 \iff \langle v , A \Sigma B ^ { T } w \rangle = 0 \forall v , w \iff \langle A ^ { T } v , B ^ { T } w \rangle _ { \Sigma } = 0 \forall v , w } \\ & { \qquad \iff \mathrm { i m } ( A ^ { T } ) \perp _ { \Sigma } \mathrm { i m } ( B ^ { T } ) \iff \mathrm { k e r } ( A ) ^ { \perp } \perp _ { \Sigma } \mathrm { k e r } ( B ) ^ { \perp } \sqsupset \sqcap } \end{array}
+$$
+
+# B DECISION BOUNDARY VISUALISATION FOR TOY EXPERIMENT
+
+We show the decision boundaries of the toy experiment in $\ S 3 . 2$ . See Figure 4. GIF animations of decision boundary changes over training can be found at anonymous link.
+
+![](images/1ec2ff46074b4cc758b51dc6e06169e40a666aa68a879ecc7d5a839a5998fbdf.jpg)  
+Figure 4: Decision boundaries. Left to right: training data, baseline model, and our model.
+
+# C IMPLEMENTATION DETAILS
+
+We solve the minimax problem in equation 3 through alternating stochastic gradient descents (ADAM Kingma & Ba (2014)), where we alternate between 5 epochs for the outer problem and 5 epochs for the inner one. The regularisation parameter $\lambda$ is set to 7, 000 for CKA and 100 for $L _ { 2 }$ minimisation on MNIST and 0.05 for ImageNet. Note that we use a large $\lambda$ for MNIST as the degree of synthetic bias is excessively large (bias-target correlation set to $\rho = 0 . 9 9 ,$ ) compared to the degree of bias in realistic settings. We have used batch sizes 256 (32 for ResNet50) and learning rates 0.001 with linear decay. We train all models for 80 epochs for Biased MNIST. For 9-class ImageNet, we train ResNet18 for 200 epochs and ResNet50 for 100 epochs.
+
+BagNet18 and BagNet50 have 18 and 50 convolutional layers which are the same structure (Basic or Bottleneck blocks) as ResNet18 and ResNet50, respectively. The internal kernel sizes of BagNets are set to $1 \times 1$ following the original paper’s philosophy (Brendel & Bethge (2019)).
+
+# D PERFORMANCE BY BIAS AND LABEL ON BIASED MNIST.
+
+In the Biased MNIST experiments (§4.2), we have shown either biased or unbiased set statistics. In this section, we provide more detailed results where model accuracies are computed per bias class
+
+$B = b$ and per target label $Y = y$ . We visualise the case-wise accuracies of the baseline LeNet and the $\mathrm { R E B I ^ { \prime } S }$ trained LeNet⊥⊥BlindNet in Figure 5. The diagonals in each matrix indicate the pre-defined bias-target pair $( \ S 4 . 2 . 1 )$ . Thus, the biased accuracies can be computed by taking the mean of diagonal entries in each matrix and the unbiased accuracies through the mean of all entries in each matrix.
+
+The vanilla LeNet’s tendency to have higher accuracies on diagonal entries and near-zero performances on many other off-diagonal entries indicate the fact that $\mathtt { I } { \in } \mathtt { N } { \in } \mathtt { t }$ is relying a lot on the colour (bias) cues. REBI’S successfully resolves this tendency in the vanilla model, exhibiting more uniform performances across all bias-target pairs $( b , y )$ . Note that accuracies below the main diagonal are relatively high as they are the classes that pre-defined patterns are assigned to at probability $( 1 - \rho )$ . Figure 6 demonstrates that our method is successful across different degrees of bias in a given training data.
+
+![](images/3b5b7e31ba88d42c82f21a5bd9d09be62e3c1ad02ded8d2340452b54ed8c1d83.jpg)  
+Figure 5: Bias-target-wise accuracies. We show accuracies for each bias $B = b$ and target $Y = y$ pair in Single-bias MNIST.
+
+![](images/62ac71da57a171f7c55096911422fa3d7929338d332af9d7ae3fd01ce63ec454.jpg)  
+Figure 6: Impact of $\rho .$ . REBI $^ \prime \mathrm { ~ S ~ }$ is effective in de-biasing across different degree of bias in data.
+
+# E IMPACT OF RECEPTIVE FIELDS OF $G$ FOR BIASED MNIST
+
+It is conceptually important to design a the set of biased models $G$ that encode the bias $B$ as precisely as possible. See precision and recall conditional for $G$ in $\ S 2 . 3 )$ . To see if this is empirically true, we have measured the performance of $\mathrm { R E B I ^ { \prime } } \mathrm { S }$ with $\boldsymbol { F } = \mathrm { L e N e t }$ and $G = \mathtt { B } \bot$ indNet, where the BlindNet receptive fields are controlled by replacing convolutional layers with $1 \times 1$ convolutions, resulting in receptive fields $\{ 1 , 5 , 7 , 2 8 \}$ . The $2 8 \times 2 8$ receptive field indicate the case when LeNet is used as $G$ . We measure the biased and unbiased set performances on Single-bias MNIST $( \ S 4 . 2 . 1 )$ .
+
+![](images/dd7a45c278afcafd8eed2954f9751defbf4927f338d5195cb9d7ab15647e44d8.jpg)  
+Figure 7: Receptive fields of $G$ . Biased and unbiased accuracies of REBI $^ \prime \mathrm { ~ S ~ }$ with $F = \tt L e N e t$ and $G =$ BlindNet with varying receptive fields.
+
+![](images/7c763e6c90309ee611b7e8615b1019304c10137f7968bd6f20ab0307958963a5.jpg)  
+Figure 8: Texture-class correlation. We show samples from each texture cluster. For each cluster, we visualise its top-3 correlated classes in rows.
+
+Results are shown in Figure 7. We observe relatively stable biased set performances and decreasing unbiased set performances. The decrease in de-biasing ability is attributed to the violation of the precision condition for $G$ $( \ S 2 . 3 )$ : $1 \times 1$ receptive fields are sufficient to capture any colour bias variations, and de-biasing against models of larger receptive fields will further make $f$ not see the meaningful signal $S$ (cues beyond $1 \times 1$ -expressible colours). In the extreme case, when $F =$ LeNet is trained to be independent against itself $G = { \mathrm { L e N e t } }$ , the de-biasing performance drops significantly.
+
+# F TEXTURE CLUSTERING
+
+In our ImageNet experiments (§4.3), we obtained proxy ground truths for the local pattern bias using texture clustering. We extract texture information from images by clustering the gram matrices of low-layer feature maps as done in standard texturisation methods (Gatys et al., 2015; Johnson et al., 2016); we use feature maps from layer relu1 2 of a pre-trained VGG16 (Simonyan & Zisserman, 2014). As we intend to evaluate whether a given model is biased towards local pattern cues, we only utilise features from the lower layer encoding lower layer features like edges and colours rather than high-level semantics. Figure 8 shows that each cluster effectively captures similar local patterns across different classes. For each cluster, we visualise its top-3 correlated classes. We can see that certain classes share a common texture: cat, monkey, and dog share a “face”-like texture. If a certain class is biased towards a particular texture during training, a model can take the shortcut to utilise texture cues for recognising the target class, leading to a sub-optimal cross-bias generalisation to unusual class-texture combinations (e.g. crab on grass).
+
+![](images/d46a5210a6dddc3658752aa4ad2ed572cfc97adb397589beee30601a8509134f.jpg)  
+Figure 9: More clustering samples. Extended version of Figure 8.
+
+![](images/d4986fddef32f57f8f6a36d5c611662b5270e0fa5a319a6c134a925ae7ac4e8f.jpg)  
+Figure 10: Data and model bias. Rows correspond to image labels and columns correspond to texture clusters. Cells are colour-coded according to the population of samples of corresponding texture-class pair. In each cell, ResNet18 and REBI $^ \prime \mathrm { ~ S ~ }$ accuracies are shown in pairs.
+
+![](images/e3eb49053c2d4ae1b7cce23ea668afdb3234a11899236ba3f6ddf0b7d76dc8aa.jpg)  
+Figure 11: Learning curve. De-biased ImageNet accuracies of vanilla $\mathtt { R e s N e t } 5 0$ and REBI’S trained against BagNet50.
+
+# G BIAS IN DATA AND MODELS
+
+We study the bias in the 9-class ImageNet data and the models trained on them (§4.3). Figure 10 shows the statistics of texture biases in data and the model biases that result from them. To measure the dataset bias, we empirically observe correlations between texture and target classes by counting the number of samples for each texture-class pair $( c , y )$ (denoted “population” $\mathrm { P o p } ( c , y )$ in the main paper). We observe indeed that there does exist a strong correlation between texture clusters and class labels. We say that a class has a dominant texture cluster if the largest cluster for the class contains more than half of the class samples. 6 out of 9 classes considered has the dominant texture cluster: (“Dog”, “Dog”), (“Cat”, “Face”), (“Monkey”, “Mammal”), (“Frog”, “Spotted”), (“Crab”, “Shell”) and (“Insect”, “Close-up”).
+
+Figure 10 further shows the accuracies of the baseline ResNet18 and $\mathrm { R E B I ^ { \prime } } \mathrm { S }$ to indicate the presence of bias in the models, and how REBI’S overcomes the bias despite the bias in data itself. We measure the average of accuracies in classes with dominant texture clusters (biased classes) and the average in less biased classes. We observe that ResNet18 shows higher accuracy on biased classes $( \bar { 8 9 } . 4 \% )$ than on less biased classes (83.9), signifying its bias towards texture. On the other hand, REBI’S achieves similar accuracies $8 8 . 7 \%$ (biased classes) and $8 8 . 2 \%$ (unbiased classes). We stress that REBI $^ \prime \mathrm { ~ S ~ }$ overcomes the bias even if the training data itself is biased.
+
+# H LEARNING CURVES ON IMAGENET
+
+We visualise the learning curves for the baseline vanilla ResNet50 and REBI’S trained ResNet50 against BagNet50 in Figure 11. We observe that REBI’S gradually de-biases a representation beyond the baseline model.

parse/train/SJfWKsC5K7/SJfWKsC5K7.md

@@ -0,0 +1,341 @@
+# EXPLAINING NEURAL NETWORKS SEMANTICALLY AND QUANTITATIVELY
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+This paper presents a method to explain the knowledge encoded in a convolutional neural network (CNN) quantitatively and semantically. The analysis of the specific rationale of each prediction made by the CNN presents a key issue of understanding neural networks, but it is also of significant practical values in certain applications. In this study, we propose to distill knowledge from the CNN into an explainable additive model, so that we can use the explainable model to provide a quantitative explanation for the CNN prediction. We analyze the typical bias-interpreting problem of the explainable model and develop prior losses to guide the learning of the explainable additive model. Experimental results have demonstrated the effectiveness of our method.
+
+# 1 INTRODUCTION
+
+Convolutional neural networks (CNNs) (LeCun et al., 1998; Krizhevsky et al., 2012; He et al., 2016) have achieved superior performance in various tasks, such as object classification and detection. Besides the discrimination power of neural networks, the interpretability of neural networks has received an increasing attention in recent years.
+
+In this paper, we focus on a new problem, i.e. explaining the specific rationale of each network prediction semantically and quantitatively. “Semantic explanations” and “quantitative explanations” are two core issues of understanding neural networks.
+
+1. Semantic explanations: We hope to explain the logic of each network prediction using clear visual concepts, instead of using middle-layer features without clear meanings or simply extracting pixel-level correlations between network inputs and outputs. We believe that semantic explanations may satisfy specific demands in real applications.
+
+2. Quantitative explanations: In contrast to traditional qualitative explanations for neural networks, quantitative explanations enable people to diagnose feature representations inside neural networks and help neural networks earn trust from people. We expect the neural network to provide the quantitative rationale of the prediction, i.e. clarifying which visual concepts activate the neural network and how much they contribute to the prediction score.
+
+Above two requirements present significant challenges to state-of-the-art algorithms. To the best of our knowledge, no previous studies simultaneously explained network predictions using clear visual concepts and quantitatively decomposed the prediction score into value components of these visual concepts.
+
+Task: Therefore, in this study, we propose to learn another neural network, namely an explainer network, to explain CNN predictions. Accordingly, we can call the target CNN a performer network. Besides the performer, we also require a set of models that are pre-trained to detect different visual concepts. These visual concepts will be used to explain the logic of the performer’s prediction. We are also given input images of the performer, but we do not need any additional annotations on the images. Then, the explainer is learned to mimic the logic inside the performer, i.e. the explainer receives the same features as the performer and is expected to generate similar prediction scores.
+
+As shown in Fig. 1, the explainer uses pre-trained visual concepts to explain each prediction. The explainer is designed as an additive model, which decomposes the prediction score into the sum of multiple value components. Each value component is computed based on a specific visual concept. In this way, we can roughly consider these value components as quantitative contributions of the visual concepts to the final prediction score.
+
+![](images/ae6d0295f173a176cd50c2415980375f8f15a79643f284f03f4d855df9324649.jpg)  
+Figure 1: Explainer. We distill knowledge of a performer into an explainer as a paraphrase of the performer’s representations. The explainer decomposes the prediction score into value components of semantic concepts, thereby obtaining quantitative semantic explanations for the performer.
+
+More specifically, we learn the explainer via knowledge distillation. Note that we do not use any ground-truth annotations on input images to supervise the explainer. It is because the task of the explainer is not to achieve a high prediction accuracy, but to mimic the performer’s logic in prediction, no matter whether the performer’s prediction is correct or not.
+
+Thus, the explainer can be regarded as a semantic paraphrase of feature representations inside the performer, and we can use the explainer to understand the logic of the performer’s prediction. Theoretically, the explainer usually cannot recover the exact prediction score of the performer, owing to the limit of the representation capacity of visual concepts. The difference of the prediction score between the performer and the explainer corresponds to the information that cannot be explained by the visual concepts.
+
+Challenges: Distilling knowledge from a pre-trained neural network into an additive model usually suffers from the problem of bias-interpreting. When we use a large number of visual concepts to explain the logic inside the performer, the explainer may biasedly select very few visual concepts, instead of all visual concepts, as the rationale of the prediction (Fig. 4 in the appendix visualizes the bias-interpreting problem). Just like the typical over-fitting problem, theoretically, the bias interpreting is an ill-defined problem. To overcome this problem, we propose two types of losses for prior weights of visual concepts to guide the learning process. The prior weights push the explainer to compute a similar Jacobian of the prediction score w.r.t. visual concepts as the performer in early epochs, in order to avoid bias-interpreting.
+
+Originality: Our “semantic-level” explanation for CNN predictions has essential differences from traditional studies of “pixel-level” interpreting neural networks, such as the visualization of features in neural networks (Zeiler & Fergus, 2014; Mahendran & Vedaldi, 2015; Simonyan et al., 2013; Dosovitskiy & Brox, 2016; Fong & Vedaldi, 2017; Selvaraju et al., 2017), the extraction of pixellevel correlations between network inputs and outputs (Koh & Liang, 2017; Ribeiro et al., 2016; Lundberg & Lee, 2017), and the learning of neural networks with interpretable middle-layer features (Zhang et al., 2018b; Sabour et al., 2017).
+
+In particular, the explainer explains the performer without affecting the original discrimination power of the performer. As discussed in (Bau et al., 2017), the interpretability of features is not equivalent to, and usually even conflicts with the discrimination power of features. Compared to forcing the performer to learn interpretable features, our strategy of explaining the performer solves the dilemma between the interpretability and the discriminability. In addition, our quantitative explanation has special values beyond the qualitative analysis of CNN predictions (Zhang et al., 2018c).
+
+Potential values of the explainer: Quantitatively and semantically explaining a performer is of considerable practical values when the performer needs to earn trust from people in critical applications. As mentioned in (Zhang et al., 2018a), owing to the potential bias in datasets and feature representations, a high testing accuracy still cannot fully ensure correct feature representations in neural networks. Thus, semantically and quantitatively clarifying the logic of each network prediction is a direct way to diagnose feature representations of neural networks. Fig. 3 shows example explanations for the performer’s predictions. Predictions whose explanations conflict people’s common sense may reflect problematic feature representations inside the performer.
+
+Contributions of this study are summarized as follows. (i) In this study, we focus on a new task, i.e. semantically and quantitatively explaining CNN predictions. (ii) We propose a new method to explain neural networks, i.e. distilling knowledge from a pre-trained performer into an interpretable additive explainer. Our strategy of using the explainer to explain the performer avoids hurting the discrimination power of the performer. (iii) We develop novel losses to overcome the typical biasinterpreting problem. Preliminary experimental results have demonstrated the effectiveness of the proposed method. (iv) Theoretically, the proposed method is a generic solution to the problem of interpreting neural networks. We have applied our method to different benchmark CNNs for different applications, which has proved the broad applicability of our method.
+
+# 2 RELATED WORK
+
+In this paper, we limit our discussion within the scope of understanding feature representations of neural networks.
+
+Network visualization: The visualization of feature representations inside a neural network is the most direct way of opening the black-box of the neural network. Related techniques include gradient-based visualization (Zeiler & Fergus, 2014; Mahendran & Vedaldi, 2015; Simonyan et al., 2013; Yosinski et al., 2015) and up-convolutional nets (Dosovitskiy & Brox, 2016) to invert feature maps of conv-layers into images. However, recent visualization results with clear semantic meanings were usually generated with strict constraints. These constraints made visualization results biased towards people’s preferences. Subjectively visualizing all information of a filter usually produced chaotic results. Thus, there is still a considerable gap between network visualization and semantic explanations for neural networks.
+
+Network diagnosis: Some studies diagnose feature representations inside a neural network. (Yosinski et al., 2014) measured features transferability in intermediate layers of a neural network. (Aubry & Russell, 2015) visualized feature distributions of different categories in the feature space. (Ribeiro et al., 2016; Lundberg & Lee, 2017; Kindermans et al., 2018; Fong & Vedaldi, 2017; Selvaraju et al., 2017) extracted rough pixel-level correlations between network inputs and outputs, i.e. estimating image regions that directly contribute the network output. Network-attack methods (Koh & Liang, 2017; Szegedy et al., 2014) computed adversarial samples to diagnose a CNN. (Lakkaraju et al., 2017) discovered knowledge blind spots of a CNN in a weakly-supervised manner. (Zhang et al., 2018a) examined representations of conv-layers and automatically discover biased representations of a CNN due to the dataset bias. However, above methods usually analyzed a neural network at the pixel level and did not summarize the network knowledge into clear visual concepts.
+
+(Bau et al., 2017) defined six types of semantics for CNN filters, i.e. objects, parts, scenes, textures, materials, and colors. Then, (Zhou et al., 2015) proposed a method to compute the image-resolution receptive field of neural activations in a feature map. Other studies retrieved middle-layer features from CNNs representing clear concepts. (Simon & Rodner, 2015) retrieved features to describe objects from feature maps, respectively. (Zhou et al., 2015; 2016) selected neural units to describe scenes. Note that strictly speaking, each CNN filter usually represents a mixture of multiple semantic concepts. Unlike previous studies, we are more interested in analyzing the quantitative contribution of each semantic concept to each prediction, which was not discussed in previous studies.
+
+Learning interpretable representations: A new trend in the scope of network interpretability is to learn interpretable feature representations in neural networks (Hu et al., 2016; Stone et al., 2017; Liao et al., 2016) in an un-/weakly-supervised manner. Capsule nets (Sabour et al., 2017) and interpretable RCNN (Wu et al., 2017b) learned interpretable features in intermediate layers. InfoGAN (Chen et al., 2016) and $\beta$ -VAE (Higgins et al., 2017) learned well-disentangled codes for generative networks. Interpretable CNNs (Zhang et al., 2018b) learned filters in intermediate layers to represent object parts without given part annotations. However, as mentioned in (Bau et al., 2017; Zhang et al., 2018c), interpretable features usually do not have a high discrimination power. Therefore, we use the explainer to interpret the pre-trained performer without hurting the discriminability of the performer.
+
+Explaining neural networks via knowledge distillation: Distilling knowledge from a black-box model into an explainable model is an emerging direction in recent years. (Zhang et al., 2018d) used a tree structure to summarize the inaccurate1 rationale of each CNN prediction into generic decision-making models for a number of samples. In contrast, we pursue the explicitly quantitative explanation for each CNN prediction. (Choi et al., 2017) learned an explainable additive model, and (Vaughan et al., 2018) distilled knowledge of a network into an additive model. (Frosst & Hinton, 2017; Tan et al., 2018; Che et al., 2016; Wu et al., 2017a) distilled representations of neural networks into tree structures. These methods did not explain the network knowledge using humaninterpretable semantic concepts. More crucially, compared to previous additive models (Vaughan et al., 2018), our research successfully overcomes the bias-interpreting problem, which is the core challenge when there are lots of visual concepts for explanation.
+
+# 3 ALGORITHM
+
+In this section, we distill knowledge from a pre-trained performer $f$ to an explainable additive model. We are given a performer $f$ and $n$ neural networks $\{ f _ { i } | i = 1 , 2 , \dots , n \}$ that are pre-trained to detect $n$ different visual concepts. We learn the $n$ neural networks along with the performer, and the $n$ neural networks are expected to share low-layer features with the performer. Our method also requires a set of training samples for the performer $f$ . The goal of the explainer is to use inference values of the $n$ visual concepts to explain prediction scores of the performer. Note that we do not need any annotations on training samples w.r.t. the task, because additional supervision will push the explainer towards a good performance of the task, instead of objectively reflecting the knowledge in the performer.
+
+Given an input image $I$ , let ${ \hat { y } } = f ( I )$ denote the output of the performer. Without loss of generality, we assume that $\hat { y }$ is a scalar. If the performer has multiple outputs (e.g. a neural network for multicategory classification), we can learn an explainer to interpret each scalar output of the performer. In particular, when the performer takes a softmax layer as the last layer, we use the feature score before the softmax layer as $\hat { y }$ , so that $\hat { y }$ ’s neighboring scores will not affect the value of $\hat { y }$ .
+
+We design the following additive explainer model, which uses a mixture of visual concepts to approximate the function of the performer. The explainer decomposes the prediction score $\hat { y }$ into value components of pre-defined visual concepts.
+
+$$
+\begin{array} { r l } { \hat { y } \approx \ } & { { } \underset { \mathcal { S } } { \underbrace { \alpha _ { 1 } ( I ) \cdot y _ { 1 } } } + \alpha _ { 2 } ( I ) \cdot y _ { 2 } + \ldots + \alpha _ { n } ( I ) \cdot y _ { n } + b , \quad y _ { i } = f _ { i } ( I ) , \quad i = 1 , 2 , \ldots , n } \end{array}
+$$
+
+| {z }Quantitative contribution from the first visual concept
+
+where $y _ { i }$ and $\alpha _ { i } ( I )$ denote the scalar value and the weight for the $i$ -th visual concept, respectively. $b$ is a bias term. $y _ { i }$ is given as the strength or confidence of the detection of the $i$ -th visual concept. We can regard the value of $\alpha _ { i } ( I ) \cdot y _ { i }$ as the quantitative contribution of the $i$ -th visual concept to the final prediction. In most cases, the explainer cannot recover all information of the performer. The prediction difference between the explainer and the performer reflects the limit of the representation capacity of visual concepts.
+
+According to the above equation, the core task of the explainer is to estimate a set of weights $_ { \alpha } =$ $[ \alpha _ { 1 } , \alpha _ { 2 } , \ldots , \alpha _ { n } ]$ , which minimizes the difference of the prediction score between the performer and the explainer. Different input images may obtain different weights $_ { \pmb { \alpha } }$ , which correspond to different decision-making modes of the performer. For example, a performer may mainly use head patterns to classify a standing bird, while it may increase the weight for the wing concept to classify a flying bird. Therefore, we design another neural network $g$ with parameters $\theta _ { g }$ (i.e. the explainer), which uses the input image $I$ to estimate the $n$ weights. We learn the explainer with the following knowledge-distillation loss.
+
+$$
+\pmb { \alpha } = g ( I ) , \qquad L = \| \hat { \boldsymbol y } - \sum _ { i = 1 } ^ { n } \boldsymbol { \alpha } _ { i } \cdot \boldsymbol { y } _ { i } - b \| ^ { 2 }
+$$
+
+However, without any prior knowledge about the distribution of the weight $\alpha _ { i }$ , the learning of $g$ usually suffers from the problem of bias-interpreting. The neural network $g$ may biasedly select very few visual concepts to approximate the performer as a shortcut solution, instead of sophisticatedly learning relationships between the performer output and all visual concepts.
+
+Thus, to overcome the bias-interpreting problem, we use a loss $\mathcal { L }$ for priors of $_ { \pmb { \alpha } }$ to guide the learning process in early epochs.
+
+$$
+\operatorname* { m i n } _ { \theta _ { g } , b } L o s s , \quad \quad L o s s = L + \lambda ( t ) \cdot \mathcal { L } ( \alpha , \mathbf { w } ) , \quad \quad \mathrm { s . t . } \operatorname* { l i m } _ { t \to \infty } \lambda ( t ) = 0
+$$
+
+![](images/e5b5085d1094ee9474a45ab266fffddd73d8fc08f80cb155ab1b9697bbd68db9.jpg)  
+Figure 2: Two typical types of neural networks. (left) A performer models interpretable visual concepts in its intermediate layers. For example, each filter in a certain conv-layer represents a specific visual concept. (right) The performer and visual concepts are jointly learned, and they share features in intermediate layers.
+
+where w denotes prior weights, which represent a rough relationship between the performer’s prediction value and $n$ visual concepts. Just like $_ { \pmb { \alpha } }$ , different input images also have different prior weights w. The loss $\mathcal { L } ( \alpha , \mathbf { w } )$ penalizes the dissimilarity between $_ { \pmb { \alpha } }$ and w.
+
+Note that the prior weights w are approximated with strong assumptions (we will introduce two different ways of computing w later). We use inaccurate w to avoid significant bias-interpreting, rather than pursue a high accuracy. Thus, we set a decreasing weight for $\mathcal { L }$ , i.e. $\begin{array} { r } { \lambda ( t ) = \frac { \beta } { \sqrt { t } } } \end{array}$ , where $\beta$ is a scalar constant, and $t$ denotes the epoch number. In this way, we mainly apply the prior loss $\mathcal { L }$ in early epochs. Then, in late epochs, the influence of $\mathcal { L }$ gradually decreases, and our method gradually shifts its attention to the distillation loss for a high distillation accuracy.
+
+We design two types of losses for prior weights, as follows.
+
+$$
+\mathcal { L } ( \alpha , \mathbf { w } ) = \left\{ \begin{array} { l l } { c r o s s { E n t r o p y } \big ( \frac { \alpha } { \lVert \alpha \rVert _ { 1 } } , \frac { \mathbf { w } } { \lVert \mathbf { w } \rVert _ { 1 } } \big ) , } & { \forall i , \alpha _ { i } , w _ { i } \ge 0 } \\ { \lVert \frac { \alpha } { \lVert \alpha \rVert _ { 2 } } - \frac { \mathbf { w } } { \lVert \mathbf { w } \rVert _ { 2 } } \lVert _ { 2 } ^ { 2 } , } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+Some applications require a positive relationship between the prediction of the performer and each visual concept, i.e. each weight $\alpha _ { i }$ must be a positive scalar. In this case, we use the cross-entropy between $_ { \pmb { \alpha } }$ and $\mathbf { w }$ as the prior loss. In other cases, the MSE loss between $_ { \pmb { \alpha } }$ and $\mathbf { w }$ is used as the loss. $\| \cdot \| _ { 1 }$ and $\| \cdot \| _ { 2 }$ denote the L-1 norm and L-2 norm, respectively.
+
+In particular, in order to ensure $\alpha _ { i } \geq 0$ in certain applications, we add a non-linear activation layer as the last layer of $g$ , i.e. $\alpha = \log [ 1 + \exp ( x ) ]$ , where $x$ is the output of the last conv-layer.
+
+# 3.1 COMPUTATION OF PRIOR WEIGHTS w
+
+In this subsection, we will introduce two techniques to efficiently compute rough prior weights w, which are oriented to the following two cases in application.
+
+Case 1, filters in intermediate conv-layers of the performer are interpretable: As shown in Fig. 2(left), learning a neural network with interpretable filters is an emerging research direction in recent years. For example, (Zhang et al., 2018b) proposed a method to learn CNNs for object classification, where each filter in a high conv-layer is exclusively triggered by the appearance of a specific object part (see Fig. 10 in the appendix for the visualization of filters). Thus, we can interpret the classification score of an object as a linear combination of elementary scores for the detection of object parts. Because such interpretable filters are automatically learned without part annotations, the quantitative explanation for the CNN (i.e. the performer) can be divided into the following two tasks: (i) annotating the name of the object part that is represented by each filter, and (ii) learning an explainer to disentangle the exact additive contribution of each filter (or each object part) to the performer output.
+
+In this way, each $f _ { i }$ , $i = 1 , 2 , \ldots , n$ , is given as an interpretable filter of the performer. According to (Zhang et al., 2018a), we can roughly represent the network prediction as
+
+$$
+{ \hat { y } } \approx \sum _ { i } w _ { i } y _ { i } + b , \qquad { \mathrm { s . t . } } \quad { \left\{ \begin{array} { l l } { y _ { i } } & { = \sum _ { h , w } x _ { h w i } } \\ { w _ { i } } & { = { \frac { 1 } { Z } } \sum _ { h , w } { \frac { \partial { \hat { y } } } { \partial x _ { h w i } } } } \end{array} \right. }
+$$
+
+where $\boldsymbol { x } \in \mathbb { R } ^ { H \times W \times n }$ denotes a feature map of the interpretable conv-layer, and $x _ { h w i }$ is referred to as the activation unit in the location $( h , w )$ of the $i$ -th channel. $y _ { i }$ measures the confidence of detecting the object part corresponding to the $i$ -th filter. Here, we can roughly use the Jacobian of the network output w.r.t. the filter to approximate the weight $w _ { i }$ of the filter. $Z$ is for normalization. Considering that the normalization operation in Equation (4) eliminates Z, we can directly use Ph,w ∂yˆ∂xhwi as prior weights w in Equation (4) without a need to compute the exact value of .
+
+Case 2, neural networks for visual concepts share features in intermediate layers with the performer: As shown in Fig. 2(right), given a neural network for the detection of multiple visual concepts, using certain visual concepts to explain a new visual concept is a generic way to interpret network predictions with broad applicability. Let us take the detection of a certain visual concept as the target $\hat { y }$ and use other visual concepts as $\{ y _ { i } \}$ to explain $\hat { y }$ . All visual concepts share features in intermediate layers.
+
+Then, we estimate a rough numerical relationship between $\hat { y }$ and the score of each visual concept $y _ { i }$ . Let $x$ be a middle-layer feature shared by both the target and the $i$ -th visual concept. When we modify the feature $x$ , we can represent the value change of $y _ { i }$ using a Taylor series, $\Delta y _ { i } =$ $\begin{array} { r } { \frac { \partial y _ { i } } { \partial x } \otimes \Delta x + O ( \Delta ^ { 2 } x ) } \end{array}$ , where $\otimes$ denotes the convolution operation. Thus, when we push the feature ∂x towards the direction of boosting $y _ { i }$ , i.e. $\Delta x = \epsilon \frac { \partial y _ { i } } { \partial x }$ $\epsilon$ is a small constant), the change of the $i$ -th visual concept can be approximated as $\Delta y _ { i } = \epsilon \| \frac { \partial y _ { i } } { \partial x } \| _ { F } ^ { 2 }$ , where $\| \cdot \| _ { F }$ denotes the Frobenius norm. Meanwhile, ∆x also affects the target concept by ∆ˆy =  ∂yˆ∂x ∂yi∂x . Thus, we can roughly estimate the weight as wi = ∆ˆy∆yi .
+
+# 4 EXPERIMENTS
+
+We designed two experiments to use our explainers to interpret different benchmark CNNs oriented to two different applications, in order to demonstrate the broad applicability of our method. In the first experiment, we used the detection of object parts to explain the detection of the entire object. In the second experiment, we used various face attributes to explain the prediction of another face attribute. We evaluated explanations obtained by our method qualitatively and quantitatively.
+
+# 4.1 EXPERIMENT 1: USING OBJECT PARTS TO EXPLAIN OBJECT CLASSIFICATION
+
+In this experiment, we used the method proposed in (Zhang et al., 2018b) to learn a CNN, where each filter in the top conv-layer represents a specific object part. We followed exact experimental settings in (Zhang et al., 2018b), which used the Pascal-Part dataset (Chen et al., 2014) to learn six CNNs for the six animal2 categories in the dataset. Each CNN was learned to classify the target animal from random images. We considered each CNN as a performer and regarded its interpretable filters in the top conv-layer as visual concepts to interpret the classification score.
+
+Four types of CNNs as performers: Following experimental settings in (Zhang et al., 2018b), we applied our method to four types of CNNs, including the AlexNet (Krizhevsky et al., 2012), the VGG-M, VGG-S, and VGG-16 networks (Simonyan & Zisserman, 2015), i.e. we learned CNNs for six categories based on each network structure. Note that as discussed in (Zhang et al., 2018b), skip connections in residual networks (He et al., 2016) increased the difficulty of learning part features, so they did not learn interpretable filters in residual networks.
+
+Learning the explainer: The AlexNet/VGG-M/VGG-S/VGG-16 performer had 256/512/512/512 filters in its top conv-layer, so we set $n = 2 5 6$ , 512, 512, 512 for these networks. We used the masked output of the top conv-layer as $x$ and plugged $x$ to Equation (5) to compute $\{ y _ { i } \} ^ { 1 }$ . We used the 152- layer ResNet (He et al., $2 0 1 6 ) ^ { 3 }$ as $g$ to estimate weights of visual concepts4. We set $\beta = 1 0$ for the learning of all explainers. Note that all interpretable filters in the performer represented object parts of the target category on positive images, instead of describing random (negative) images.
+
+Table 1: Entropy of contribution distributions estimated by the explainer. A lower entropy of contribution distributions reflects more significant bias-interpreting. Our method suffered much less from the bias-interpreting problem than the baseline. Please see the appendix for more results.   
+
+<table><tr><td rowspan="2"></td><td colspan="4">Experiment1</td><td colspan="5">Experiment 2</td></tr><tr><td>AlexNet</td><td>VGG-M</td><td>VGG-S</td><td>VGG-16</td><td>attractive</td><td>makeup</td><td>male</td><td>young</td><td>Avg.</td></tr><tr><td>Baseline</td><td>3.636</td><td>4.957</td><td>3.962</td><td>4.218</td><td>3.185</td><td>3.120</td><td>3.139</td><td>3.100</td><td>3.136</td></tr><tr><td>Ours</td><td>5.199</td><td>5.908</td><td>5.913</td><td>6.054</td><td>3.216</td><td>3.134</td><td>3.139</td><td>3.160</td><td>3.162</td></tr></table>
+
+<table><tr><td rowspan="2" colspan="2"></td><td colspan="4">Experiment 1</td><td colspan="5">Experiment 2</td></tr><tr><td>AlexNet</td><td>VGG-M</td><td>VGG-S</td><td>VGG-16</td><td>attractive</td><td>makeup</td><td>male</td><td>young</td><td>Avg.</td></tr><tr><td>Classification</td><td>Performer</td><td>93.9</td><td>94.2</td><td>95.5</td><td>95.4</td><td>81.5</td><td>92.3</td><td>98.7</td><td>88.3</td><td>90.2</td></tr><tr><td>accuracy</td><td>Explainer</td><td>93.6</td><td>94.0</td><td>94.9</td><td>96.6</td><td>76.0</td><td>88.8</td><td>97.6</td><td>82.8</td><td>87.1</td></tr><tr><td>Relative</td><td>Performer</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>deviation</td><td>Explainer</td><td>0.045</td><td>0.040</td><td>0.041</td><td>0.038</td><td>0.163</td><td>0.100</td><td>0.067</td><td>0.139</td><td>0.117</td></tr></table>
+
+Table 2: Classification accuracy and relative deviations of the explainer and the performer. We used relative deviations and the decrease of the classification accuracy to measure the information that could not be explained by pre-defined visual concepts. Please see the appendix for more results.
+
+Intuitively, we needed to ensure a positive relationship between $\hat { y }$ and $y _ { i }$ . Thus, we filtered out negative prior weights $w _ { i } \gets \operatorname* { m a x } \{ w _ { i } , 0 \}$ and applied the cross-entropy loss in Equation (4) to learn the explainer.
+
+Evaluation metric: The evaluation has two aspects. Firstly, we evaluated the correctness of the estimated explanation for the performer prediction. In fact, there is no ground truth about exact reasons for each prediction. We showed example explanations of for a qualitative evaluation of explanations. We also used grad-CAM visualization (Selvaraju et al., 2017) of feature maps to prove the correctness of our explanations (see the appendix). In addition, we normalized the absolute contribution from each visual concept as a distribution of contributions $c _ { i } = | \alpha _ { i } y _ { i } | / \sum _ { j } | \alpha _ { j } y _ { j } |$ . We used the entropy of contribution distribution $H ( \mathbf { c } )$ as an indirect evaluation metric for biasinterpreting. A biased explainer usually used very few visual concepts, instead of using most visual concepts, to approximate the performer, which led to a low entropy $H ( \mathbf { c } )$ .
+
+Secondly, we also measured the performer information that could not be represented by the visual concepts, which was unavoidable. We proposed two metrics for evaluation. The first metric is the prediction accuracy. We compared the prediction accuracy of the performer with the prediction accuracy of using the explainer’s output $\sum _ { i } ^ { - } \alpha _ { i } y _ { i } + b$ . Another metric is the relative deviation, which measures a normalized output difference between the performer and the explainer. The relative deviation of the image $I$ is normalized as $\begin{array} { r } { \vert \hat { y } _ { I } - \sum _ { i } \bar { \alpha _ { I , i } } y _ { I , i } - b \vert / \big ( \mathrm { { m a x } } _ { I ^ { \prime } \in \mathbf { I } } \hat { y } _ { I ^ { \prime } } - \mathrm { { m i n } } _ { I ^ { \prime } \in \mathbf { I } } \hat { y } _ { I ^ { \prime } } \big ) } \end{array}$ , where $\hat { y } _ { I ^ { \prime } }$ denotes the performer’s output for the image $I ^ { \prime }$ .
+
+Considering the limited representation power of visual concepts, the relative deviation on an image reflected inference patterns, which were not modeled by the explainer. The average relative deviation over all images was reported to evaluate the overall representation power of visual concepts. Note that our objective was not to pursue an extremely low relative deviation, because the limit of the representation power is an objective existence.
+
+# 4.2 EXPERIMENT 2: EXPLAINING FACE ATTRIBUTES BASED ON FACE ATTRIBUTES
+
+In this experiment, we learned a CNN based on the VGG-16 structure to estimate face attributes. We used the Large-scale CelebFaces Attributes (CelebA) dataset (Liu et al., 2015) to train a CNN to estimate 40 face attributes. We selected a certain attribute as the target and used its prediction score as $\hat { y }$ . Other 39 attributes were taken as visual concepts to explain the score of $\hat { y }$ $\left( n = 3 9 \right.$ ). The target attribute was selected from those representing global features of the face, i.e. attractive, heavy makeup, male, and young. It is because global features can usually be described by local visual concepts, but the inverse is not. We learned an explainer for each target attribute. We used the same 152-layer ResNet structure as in Experiment 1 (expect for $n = 3 9$ ) as $g$ to estimate weights. We followed the Case-2 implementation in Section 3.1 to compute prior weights $\mathbf { w }$ , in which we used the 4096-dimensional output of the first fully-connected layer as the shared feature $x$ . We set $\beta = 0 . 2$ and used the L-2 norm loss in Equation (4) to learn all explainers. We used the same evaluation metric as in Experiment 1.
+
+![](images/b961339d6b26f9c459eec8f0c4ff38eb80ba0ef4d7451bf8a9bf4659fe095da6.jpg)  
+Figure 3: Quantitative explanations for the object classification (top) and the face-attribution prediction (bottom) made by performers. For performers oriented to object classification, we annotated the part that was represented by each interpretable filter in the performer, and we assigned contributions of filters $\alpha _ { i } y _ { i }$ to object parts (see the appendix). Thus, this figure illustrates contributions of different object parts. All object parts made positive contributions to the classification score. Note that in the bottom, bars indicate elementary contributions $\alpha _ { i } y _ { i }$ from features of different face attributes, rather than prediction values $y _ { i }$ of these attributes. For example, the network predicts a negative goatee attribute $y _ { \mathrm { g o a t e e } } < 0$ , and this information makes a positive contribution to the target attractive attribute, $\alpha _ { i } y _ { i } > 0$ . Please see the appendix for more results.
+
+# 4.3 EXPERIMENTAL RESULTS AND ANALYSIS
+
+We compared our method with the traditional baseline of only using the distillation loss to learn the explainer. Table 1 evaluates bias-interpreting of explainers that were learned using our method and the baseline. In addition, Table 2 uses the classification accuracy and relative deviations of the explainer to measure the representation capacity of visual concepts. Our method suffered much less from the bias-interpreting problem than the baseline.
+
+Fig. 3 shows examples of quantitative explanations for the prediction made by the performer. We also used the grad-CAM visualization (Selvaraju et al., 2017) of feature maps of the performer to demonstrate the correctness of our explanations in Fig. 9 in the appendix. In particular, Fig. 4 in the appendix illustrates the distribution of contributions of visual concepts $\left\{ c _ { i } \right\}$ when we learned the explainer using different methods. Compared to our method, the distillation baseline usually used very few visual concepts for explanation and ignored most strongly activated interpretable filters, which could be considered as bias-interpreting.
+
+# 5 CONCLUSION AND DISCUSSIONS
+
+In this paper, we focus on a new task, i.e. explaining the logic of each CNN prediction semantically and quantitatively, which presents considerable challenges in the scope of understanding neural networks. We propose to distill knowledge from a pre-trained performer into an interpretable additive explainer. We can consider that the performer and the explainer encode similar knowledge. The additive explainer decomposes the prediction score of the performer into value components from semantic visual concepts, in order to compute quantitative contributions of different concepts. The strategy of using an explainer for explanation avoids decreasing the discrimination power of the performer. In preliminary experiments, we have applied our method to different benchmark CNN performers to prove the broad applicability.
+
+Note that our objective is not to use pre-trained visual concepts to achieve super accuracy in classification/prediction. Instead, the explainer uses these visual concepts to mimic the logic of the performer and produces similar prediction scores as the performer.
+
+In particular, over-interpreting is the biggest challenge of using an additive explainer to interpret another neural network. In this study, we design two losses to overcome the bias-interpreting problems. Besides, in experiments, we also measure the amount of the performer knowledge that could not be represented by visual concepts in the explainer.
+
+# REFERENCES
+
+Mathieu Aubry and Bryan C. Russell. Understanding deep features with computer-generated imagery. In ICCV, 2015.
+
+David Bau, Bolei Zhou, Aditya Khosla, Aude Oliva, and Antonio Torralba. Network dissection: Quantifying interpretability of deep visual representations. In CVPR, 2017.
+
+Zhengping Che, Sanjay Purushotham, Robinder Khemani, and Yan Liu. Interpretable deep models for icu outcome prediction. In American Medical Informatics Association (AMIA) Annual Symposium, 2016.
+
+X. Chen, R. Mottaghi, X. Liu, S. Fidler, R. Urtasun, and A. Yuille. Detect what you can: Detecting and representing objects using holistic models and body parts. In CVPR, 2014.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In NIPS, 2016.
+
+Edward Choi, Mohammad Taha Bahadori, Joshua A. Kulas, Andy Schuetz, Walter F. Stewart, and Jimeng Sun. Retain: an interpretable predictive model for healthcare using reverse time attention mechansim. in arXiv:1608.05745v4, 2017.
+
+Alexey Dosovitskiy and Thomas Brox. Inverting visual representations with convolutional networks. In CVPR, 2016.
+
+Ruth C. Fong and Andrea Vedaldi. Interpretable explanations of black boxes by meaningful perturbation. In arXiv:1704.03296v1, 2017.
+
+Nicholas Frosst and Geoffrey Hinton. Distilling a neural network into a soft decision tree. In arXiv:1711.09784, 2017.
+
+Tommaso Furlanello, Zachary C. Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. In arXiv:1805.04770, 2018.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. $\beta$ -vae: learning basic visual concepts with a constrained variational framework. In ICLR, 2017.
+
+Zhiting Hu, Xuezhe Ma, Zhengzhong Liu, Eduard Hovy, and Eric P. Xing. Harnessing deep neural networks with logic rules. In arXiv:1603.06318v2, 2016.
+
+Pieter-Jan Kindermans, Kristof T. Schutt, Maximilian Alber, Klaus-Robert M ¨ uller, Dumitru Erhan, Been Kim,¨ and Sven Dahne. Learning how to explain neural networks: Patternnet and patternattribution. ¨ In ICLR, 2018.
+
+PangWei Koh and Percy Liang. Understanding black-box predictions via influence functions. In ICML, 2017.
+
+A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Himabindu Lakkaraju, Ece Kamar, Rich Caruana, and Eric Horvitz. Identifying unknown unknowns in the open world: Representations and policies for guided exploration. In AAAI, 2017.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document \` recognition. In Proceedings of the IEEE, 1998.
+
+Renjie Liao, Alex Schwing, Richard Zemel, and Raquel Urtasun. Learning deep parsimonious representations. In NIPS, 2016.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In ICCV, 2015.
+
+Scott M. Lundberg and Su-In Lee. A unified approach to interpreting model predictions. In NIPS, 2017.
+
+Aravindh Mahendran and Andrea Vedaldi. Understanding deep image representations by inverting them. In CVPR, 2015.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. “why should i trust you?” explaining the predictions of any classifier. In KDD, 2016.
+
+Sara Sabour, Nicholas Frosst, and Geoffrey E. Hinton. Dynamic routing between capsules. In NIPS, 2017.   
+Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In ICCV, 2017.   
+Marcel Simon and Erik Rodner. Neural activation constellations: Unsupervised part model discovery with convolutional networks. In ICCV, 2015.   
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: visualising image classification models and saliency maps. In arXiv:1312.6034, 2013.   
+Austin Stone, Huayan Wang, Yi Liu, D. Scott Phoenix, and Dileep George. Teaching compositionality to cnns. In CVPR, 2017.   
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In arXiv:1312.6199v4, 2014.   
+Sarah Tan, Rich Caruana, Giles Hooker, and Albert Gordo. Transparent model distillation. In arXiv:1801.08640, 2018.   
+Joel Vaughan, Agus Sudjianto, Erind Brahimi, Jie Chen, and Vijayan N. Nair. Explainable neural networks based on additive index models. in arXiv:1806.01933, 2018.   
+Mike Wu, Michael C. Hughes, Sonali Parbhoo, Maurizio Zazzi, Volker Roth, and Finale Doshi-Velez. Beyond sparsity: Tree regularization of deep models for interpretability. In NIPS TIML Workshop, 2017a.   
+Tianfu Wu, Xilai Li, Xi Song, Wei Sun, Liang Dong, and Bo Li. Interpretable r-cnn. In arXiv:1711.05226, 2017b.   
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NIPS, 2014.   
+Jason Yosinski, Jeff Clune, Anh Nguyen, Thomas Fuchs, and Hod Lipson. Understanding neural networks through deep visualization. In ICML Deep Learning Workshop, 2015.   
+Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014.   
+Q. Zhang, W. Wang, and S.-C. Zhu. Examining cnn representations with respect to dataset bias. In AAAI, 2018a.   
+Quanshi Zhang, Ying Nian Wu, and Song-Chun Zhu. Interpretable convolutional neural networks. In CVPR, 2018b.   
+Quanshi Zhang, Yu Yang, Yuchen Liu, Ying Nian Wu, and Song-Chun Zhu. Unsupervised learning of neural networks to explain neural networks. in arXiv:1805.07468, 2018c.   
+Quanshi Zhang, Yu Yang, Ying Nian Wu, and Song-Chun Zhu. Interpreting cnns via decision trees. In arXiv:1802.00121, 2018d.   
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. In ICRL, 2015.   
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In CVPR, 2016.
+
+# DETAILED RESULTS
+
+Table 3: Entropy of contribution distributions. The entropy of contribution distributions reflects the level of bias-interpreting. The lower entropy indicates a larger bias. Our method suffered much less from the bias-interpreting problem than the baseline.   
+
+<table><tr><td></td><td colspan="2">AlexNet</td><td colspan="2">VGG-M</td><td colspan="2">VGG-S</td><td colspan="2">VGG-16</td></tr><tr><td>bird</td><td>Baseline 3.681</td><td>Ours 5.201</td><td>Baseline 4.543</td><td>Ours 5.885</td><td>Baseline 3.988</td><td>Ours 5.870</td><td>Baseline</td><td>Ours</td></tr><tr><td></td><td>3.294</td><td>5.103</td><td>5.604</td><td></td><td>3.954</td><td>5.913</td><td>4.165</td><td>6.040</td></tr><tr><td>cat</td><td></td><td></td><td></td><td>5.902</td><td></td><td></td><td>4.894</td><td>6.056</td></tr><tr><td>Cow</td><td>3.607</td><td>5.236</td><td>4.616</td><td>5.941</td><td>3.786</td><td>5.901</td><td>3.763</td><td>6.084</td></tr><tr><td>dog</td><td>3.774</td><td>5.243</td><td>5.510</td><td>6.023</td><td>4.087</td><td>5.954</td><td>4.570</td><td>6.061</td></tr><tr><td>horse</td><td>3.745 3.716</td><td>5.278 5.135</td><td>4.722 4.747</td><td>5.921 5.773</td><td>3.802</td><td>5.973 5.869</td><td>4.064</td><td>6.060</td></tr><tr><td>sheep</td><td></td><td></td><td></td><td></td><td>4.152</td><td></td><td>3.850</td><td>6.022</td></tr><tr><td>Avg.</td><td>3.636</td><td>5.199</td><td>4.957</td><td>5.908</td><td>3.962</td><td>5.913</td><td>4.218</td><td>6.054</td></tr></table>
+
+<table><tr><td rowspan="2"></td><td colspan="3">AlexNet</td><td colspan="3">VGG-M</td><td colspan="3">VGG-S</td><td colspan="3">VGG-16</td></tr><tr><td>Performer</td><td>Baseline</td><td>Ours</td><td>Performer</td><td>Baseline</td><td>Ours</td><td>Performer</td><td>Baseline</td><td>Ours</td><td>PerformerI</td><td>Baseline</td><td>Ours</td></tr><tr><td>bird</td><td>92.8</td><td>92.8</td><td>93.8</td><td>96.8</td><td>97.3</td><td>97.8</td><td>96.5</td><td>97.0</td><td>96.0</td><td>97.3</td><td>98.5</td><td>98.8</td></tr><tr><td>cat</td><td>96.3</td><td>95.7</td><td>95.2</td><td>94.3</td><td>95.7</td><td>95.5</td><td>95.3</td><td>95.5</td><td>96.0</td><td>94.3</td><td>97.0</td><td>97.0</td></tr><tr><td>cow</td><td>93.4</td><td>92.6</td><td>93.4</td><td>95.2</td><td>94.2</td><td>94.7</td><td>94.4</td><td>94.2</td><td>93.7</td><td>91.1</td><td>97.0</td><td>95.4</td></tr><tr><td>dog</td><td>92.5</td><td>92.5</td><td>92.0</td><td>93.8</td><td>94.7</td><td>94.5</td><td>95.3</td><td>95.5</td><td>93.0</td><td>94.5</td><td>95.0</td><td>94.5</td></tr><tr><td>horse</td><td>91.4</td><td>89.1</td><td>88.1</td><td>92.9</td><td>88.9</td><td>88.9</td><td>92.9</td><td>91.7</td><td>92.7</td><td>99.2</td><td>96.5</td><td>97.7</td></tr><tr><td>sheep</td><td>97.2</td><td>97.2</td><td>99.2</td><td>92.2</td><td>92.7</td><td>92.5</td><td>98.5</td><td>97.0</td><td>98.2</td><td>96.0</td><td>95.7</td><td>96.0</td></tr><tr><td>Average</td><td>93.9</td><td>93.3</td><td>93.6</td><td>94.2</td><td>93.9</td><td>94.0</td><td>95.5</td><td>95.2</td><td>94.9</td><td>95.4</td><td>96.6</td><td>96.6</td></tr></table>
+
+<table><tr><td></td><td>Attractive</td><td>Makeup</td><td>Male</td><td>Young</td><td>Avg.</td></tr><tr><td>Performer</td><td>81.5</td><td>92.3</td><td>98.7</td><td>88.3</td><td>90.2</td></tr><tr><td>Explainer, baseline</td><td>73.2</td><td>89.0</td><td>97.6</td><td>81.8</td><td>85.4</td></tr><tr><td>Explainer, ours</td><td>76.0</td><td>88.8</td><td>97.6</td><td>82.8</td><td>86.3</td></tr></table>
+
+Table 4: Classification accuracy of the explainer and the performer. We use the the classification accuracy to measure the information loss when using an explainer to interpret the performer. Note that the additional loss for bias-interpreting successfully overcame the bias-interpreting problem, but did not decrease the classification accuracy of the explainer. Another interesting finding of this research is that sometimes, the explainer even outperformed the performer in classification. A similar phenomenon has been reported in (Furlanello et al., 2018). A possible explanation for this phenomenon is given as follows. When the student network in knowledge distillation had sufficient representation power, the student network might learn better representations than the teacher network, because the distillation process removed abnormal middle-layer features corresponding to irregular samples and maintained common features, so as to boost the robustness of the student network.
+
+Table 5: Relative deviations of the explainer. The additional loss for bias-interpreting successfully overcame the bias-interpreting problem and just increased a bit (ignorable) relative deviation of the explainer.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">AlexNet</td><td colspan="2">VGG-M</td><td colspan="2">VGG-S</td><td colspan="2">VGG-16</td></tr><tr><td>Baseline</td><td>Ours</td><td>Baseline</td><td>Ours</td><td>Baseline</td><td>Ours</td><td>Baseline</td><td>Ours</td></tr><tr><td>bird</td><td>0.050</td><td>0.045</td><td>0.033</td><td>0.035</td><td>0.030</td><td>0.031</td><td>0.040</td><td>0.034</td></tr><tr><td>cat</td><td>0.041</td><td>0.040</td><td>0.029</td><td>0.030</td><td>0.036</td><td>0.039</td><td>0.027</td><td>0.030</td></tr><tr><td>cow</td><td>0.047</td><td>0.048</td><td>0.058</td><td>0.062</td><td>0.041</td><td>0.047</td><td>0.051</td><td>0.061</td></tr><tr><td>dog</td><td>0.041</td><td>0.047</td><td>0.025</td><td>0.026</td><td>0.041</td><td>0.047</td><td>0.028</td><td>0.026</td></tr><tr><td>horse</td><td>0.044</td><td>0.043</td><td>0.051</td><td>0.049</td><td>0.045</td><td>0.043</td><td>0.036</td><td>0.034</td></tr><tr><td>sheep</td><td>0.045</td><td>0.049</td><td>0.036</td><td>0.038</td><td>0.035</td><td>0.037</td><td>0.032</td><td>0.041</td></tr><tr><td>Average</td><td>0.045</td><td>0.045</td><td>0.039</td><td>0.040</td><td>0.038</td><td>0.041</td><td>0.036</td><td>0.038</td></tr></table>
+
+# IMAGE-SPECIFIC EXPLANATIONS V.S. GENERIC EXPLANATIONS
+
+(Zhang et al., 2018d) used a tree structure to summarize the inaccurate rationale of each CNN prediction into generic decision-making models for a number of samples. This method assumed the significance of a feature to be proportional to the Jacobian w.r.t. the feature, which is quite problematic. This assumption is acceptable for (Zhang et al., 2018d), because the objective of (Zhang et al.,
+
+2018d) is to learn a generic explanation for a group of samples, and the inaccuracy in the explanation for each specific sample does not significantly affect the accuracy of the generic explanation. In comparisons, our method focuses on the quantitative explanation for each specific sample, so we design an additive model to obtain more convincing explanations.
+
+# VISUALIZATION OF BIAS-INTERPRETING
+
+![](images/5f92c5fadc46d18ef61699cae864d1f0926144a359dc405ed0fd83242c265ee8.jpg)  
+Figure 4: We compared the contribution distribution of different visual concepts (filters) that was estimated by our method and the distribution that was estimated by the baseline. The baseline usually used very few visual concepts to make predictions, which was a typical case of bias-interpreting. In comparisons, our method provided a much more reasonable contribution distribution of visual concepts.
+
+# Most important reasons
+
+No heavy makeup
+
+![](images/c933a728bd7bb68ce814d29ddf0eb4fa98e1ed3e1f23ec0e5506e2bcf97eec4c.jpg)  
+Figure 5: Quantitative explanations for the attractive attribute. Bars indicate elementary contributions $\alpha _ { i } y _ { i }$ from features of different face attributes, rather than the prediction of these attributes. For example, the network predicts a negative goatee attribute $y _ { \mathrm { g o a t e e } } < 0$ , and this information makes a positive contribution to the target attractive attribute, $\alpha _ { i } y _ { i } > 0$ .
+
+No heavy makeup
+
+# Most important reasons
+
+5‐o’clock shadow No bald No heavy makeup No earrings Not wearing lipstick Not wearing necktie
+
+No heavy makeup Not wearing earrings Not wearing lipstick Not wearing necktie
+
+No 5‐o’clock shadow   
+No goatee   
+No receding   
+hairline   
+No sideburns   
+Not wearing earrings   
+Not wearing necktie
+
+![](images/1049960310c0c07afbfa5c859e1ab50ec576d14d6136c657d28f9eb83145b140.jpg)  
+Figure 6: Quantitative explanations $\alpha _ { i } y _ { i }$ for the male attribute.
+
+No heavy makeup Not wearing earrings Not wearing lipstick Not wearing necklace
+
+No heavy makeup Not wearing earrings Not wearing lipstick
+
+# Most important reasons
+
+No goatee Not male Wearing lipstick
+
+No eyeglasses Not male No rosy cheeks Wear lipstick
+
+Not attractive High cheekbones No mustache No pointy nose No rosy cheeks Not wearing lipstick Not wearing necklace
+
+![](images/b5ffd643e2435ed49b2c437cd69e8699dac07deaba7b5b6036d3710353deb73e.jpg)  
+Figure 7: Quantitative explanations $\alpha _ { i } y _ { i }$ for the heavy makeup attribute.
+
+No eyeglasses   
+No gray hear   
+Male   
+Not wearing lipstick   
+Not wearing necklace   
+Young   
+No bangs   
+Not blurry   
+No eyeglasses   
+Male   
+No rosy cheeks   
+Wearing hat   
+Not wearing lipstick
+
+![](images/2b1fd2ce7bdbba8790a5aaf980ff839eb44add1cd860b5b1433e755fe83d18ac.jpg)  
+Figure 8: Quantitative explanations $\alpha _ { i } y _ { i }$ for the young attribute.
+
+![](images/12a2c71fa03a6de7ad7911f8a27cec5fe713a7916fdfa7939ff2d6b4026659ba.jpg)  
+Figure 9: Quantitative explanations for object classification. We assigned contributions of filters to their corresponding object parts, so that we obtained contributions of different object parts. According to top figures, we found that different images had similar explanations, i.e. the CNN used similar object parts to classify objects. Therefore, we showed the grad-CAM visualization of feature maps (Selvaraju et al., 2017) on the bottom, which proved this finding.
+
+![](images/2eabdeec6a8b771edc0406ac50d89724c8579a95359e7b610935cf93378f65ba.jpg)  
+Figure 10: We visualized interpretable filters in the top conv-layer of a CNN, which were learned based on (Zhang et al., 2018b). We projected activation regions on the feature map of the filter onto the image plane for visualization. Each filter represented a specific object part through different images.
+
+# ANNOTATIONS OF PART NAMES OF INTERPRETABLE FILTERS
+
+(Zhang et al., 2018b) learned a CNN, where each filter in the top conv-layer represented a specific object part. Thus, we annotated the name of the object part that corresponded to each filter based on visualization results (see Fig. 10 for examples). We simply annotate each filter of the top conv-layer in a performer once, so the total annotation cost was $O \bar { ( } N )$ , where $N$ is the filter number.
+
+Then, we assigned the contribution of a filter to its corresponding part, i.e. $C o n t r i _ { p a r t } ~ =$   
+$\textstyle \sum _ { i : 1 }$ -th filter represents the part $\alpha _ { i } y _ { i }$ .
+
+# DETAILS IN EXPERIMENT 1
+
+We changed the order of the ReLU layer and the mask layer after the top conv-layer, i.e. placing the mask layer between the ReLU layer and the top conv-layer. According to (Zhang et al., 2018b), this operation did not affect the performance of the pre-trained performer. We used the output of the mask layer as $x$ and plugged $x$ to Equation (5) to compute $\{ y _ { i } \}$ .
+
+Because the distillation process did not use any ground-truth class labels, the explainer’s output $\textstyle \sum _ { i } { \alpha _ { i } y _ { i } + b }$ was not sophisticatedly learned for classification. Thus, we used a threshold $\sum _ { i } \alpha _ { i } y _ { i } +$ $b \ > \ \tau \ ( \tau \ \approx \ 0 )$ , instead of 0, as the decision boundary for classification. $\tau$ was selected as the one that maximized the accuracy. Such experimental settings made a fairer comparison between the performer and the explainer.

parse/train/SJfWKsC5K7/SJfWKsC5K7_content_list.json

@@ -0,0 +1,1737 @@
+[
+    {
+        "type": "text",
+        "text": "EXPLAINING NEURAL NETWORKS SEMANTICALLY AND QUANTITATIVELY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            174,
+            398,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            239,
+            544,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper presents a method to explain the knowledge encoded in a convolutional neural network (CNN) quantitatively and semantically. The analysis of the specific rationale of each prediction made by the CNN presents a key issue of understanding neural networks, but it is also of significant practical values in certain applications. In this study, we propose to distill knowledge from the CNN into an explainable additive model, so that we can use the explainable model to provide a quantitative explanation for the CNN prediction. We analyze the typical bias-interpreting problem of the explainable model and develop prior losses to guide the learning of the explainable additive model. Experimental results have demonstrated the effectiveness of our method. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            409
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            436,
+            336,
+            452
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional neural networks (CNNs) (LeCun et al., 1998; Krizhevsky et al., 2012; He et al., 2016) have achieved superior performance in various tasks, such as object classification and detection. Besides the discrimination power of neural networks, the interpretability of neural networks has received an increasing attention in recent years. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on a new problem, i.e. explaining the specific rationale of each network prediction semantically and quantitatively. “Semantic explanations” and “quantitative explanations” are two core issues of understanding neural networks. ",
+        "bbox": [
+            176,
+            531,
+            825,
+            573
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. Semantic explanations: We hope to explain the logic of each network prediction using clear visual concepts, instead of using middle-layer features without clear meanings or simply extracting pixel-level correlations between network inputs and outputs. We believe that semantic explanations may satisfy specific demands in real applications. ",
+        "bbox": [
+            212,
+            585,
+            823,
+            641
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2. Quantitative explanations: In contrast to traditional qualitative explanations for neural networks, quantitative explanations enable people to diagnose feature representations inside neural networks and help neural networks earn trust from people. We expect the neural network to provide the quantitative rationale of the prediction, i.e. clarifying which visual concepts activate the neural network and how much they contribute to the prediction score. ",
+        "bbox": [
+            212,
+            647,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Above two requirements present significant challenges to state-of-the-art algorithms. To the best of our knowledge, no previous studies simultaneously explained network predictions using clear visual concepts and quantitatively decomposed the prediction score into value components of these visual concepts. ",
+        "bbox": [
+            176,
+            728,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Task: Therefore, in this study, we propose to learn another neural network, namely an explainer network, to explain CNN predictions. Accordingly, we can call the target CNN a performer network. Besides the performer, we also require a set of models that are pre-trained to detect different visual concepts. These visual concepts will be used to explain the logic of the performer’s prediction. We are also given input images of the performer, but we do not need any additional annotations on the images. Then, the explainer is learned to mimic the logic inside the performer, i.e. the explainer receives the same features as the performer and is expected to generate similar prediction scores. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As shown in Fig. 1, the explainer uses pre-trained visual concepts to explain each prediction. The explainer is designed as an additive model, which decomposes the prediction score into the sum of multiple value components. Each value component is computed based on a specific visual concept. In this way, we can roughly consider these value components as quantitative contributions of the visual concepts to the final prediction score. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae6d0295f173a176cd50c2415980375f8f15a79643f284f03f4d855df9324649.jpg",
+        "image_caption": [
+            "Figure 1: Explainer. We distill knowledge of a performer into an explainer as a paraphrase of the performer’s representations. The explainer decomposes the prediction score into value components of semantic concepts, thereby obtaining quantitative semantic explanations for the performer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            103,
+            802,
+            185
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            247,
+            825,
+            290
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More specifically, we learn the explainer via knowledge distillation. Note that we do not use any ground-truth annotations on input images to supervise the explainer. It is because the task of the explainer is not to achieve a high prediction accuracy, but to mimic the performer’s logic in prediction, no matter whether the performer’s prediction is correct or not. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            352
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Thus, the explainer can be regarded as a semantic paraphrase of feature representations inside the performer, and we can use the explainer to understand the logic of the performer’s prediction. Theoretically, the explainer usually cannot recover the exact prediction score of the performer, owing to the limit of the representation capacity of visual concepts. The difference of the prediction score between the performer and the explainer corresponds to the information that cannot be explained by the visual concepts. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            443
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Challenges: Distilling knowledge from a pre-trained neural network into an additive model usually suffers from the problem of bias-interpreting. When we use a large number of visual concepts to explain the logic inside the performer, the explainer may biasedly select very few visual concepts, instead of all visual concepts, as the rationale of the prediction (Fig. 4 in the appendix visualizes the bias-interpreting problem). Just like the typical over-fitting problem, theoretically, the bias interpreting is an ill-defined problem. To overcome this problem, we propose two types of losses for prior weights of visual concepts to guide the learning process. The prior weights push the explainer to compute a similar Jacobian of the prediction score w.r.t. visual concepts as the performer in early epochs, in order to avoid bias-interpreting. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Originality: Our “semantic-level” explanation for CNN predictions has essential differences from traditional studies of “pixel-level” interpreting neural networks, such as the visualization of features in neural networks (Zeiler & Fergus, 2014; Mahendran & Vedaldi, 2015; Simonyan et al., 2013; Dosovitskiy & Brox, 2016; Fong & Vedaldi, 2017; Selvaraju et al., 2017), the extraction of pixellevel correlations between network inputs and outputs (Koh & Liang, 2017; Ribeiro et al., 2016; Lundberg & Lee, 2017), and the learning of neural networks with interpretable middle-layer features (Zhang et al., 2018b; Sabour et al., 2017). ",
+        "bbox": [
+            173,
+            582,
+            825,
+            680
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In particular, the explainer explains the performer without affecting the original discrimination power of the performer. As discussed in (Bau et al., 2017), the interpretability of features is not equivalent to, and usually even conflicts with the discrimination power of features. Compared to forcing the performer to learn interpretable features, our strategy of explaining the performer solves the dilemma between the interpretability and the discriminability. In addition, our quantitative explanation has special values beyond the qualitative analysis of CNN predictions (Zhang et al., 2018c). ",
+        "bbox": [
+            174,
+            686,
+            823,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Potential values of the explainer: Quantitatively and semantically explaining a performer is of considerable practical values when the performer needs to earn trust from people in critical applications. As mentioned in (Zhang et al., 2018a), owing to the potential bias in datasets and feature representations, a high testing accuracy still cannot fully ensure correct feature representations in neural networks. Thus, semantically and quantitatively clarifying the logic of each network prediction is a direct way to diagnose feature representations of neural networks. Fig. 3 shows example explanations for the performer’s predictions. Predictions whose explanations conflict people’s common sense may reflect problematic feature representations inside the performer. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions of this study are summarized as follows. (i) In this study, we focus on a new task, i.e. semantically and quantitatively explaining CNN predictions. (ii) We propose a new method to explain neural networks, i.e. distilling knowledge from a pre-trained performer into an interpretable additive explainer. Our strategy of using the explainer to explain the performer avoids hurting the discrimination power of the performer. (iii) We develop novel losses to overcome the typical biasinterpreting problem. Preliminary experimental results have demonstrated the effectiveness of the proposed method. (iv) Theoretically, the proposed method is a generic solution to the problem of interpreting neural networks. We have applied our method to different benchmark CNNs for different applications, which has proved the broad applicability of our method. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            222,
+            341,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we limit our discussion within the scope of understanding feature representations of neural networks. ",
+        "bbox": [
+            173,
+            252,
+            823,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Network visualization: The visualization of feature representations inside a neural network is the most direct way of opening the black-box of the neural network. Related techniques include gradient-based visualization (Zeiler & Fergus, 2014; Mahendran & Vedaldi, 2015; Simonyan et al., 2013; Yosinski et al., 2015) and up-convolutional nets (Dosovitskiy & Brox, 2016) to invert feature maps of conv-layers into images. However, recent visualization results with clear semantic meanings were usually generated with strict constraints. These constraints made visualization results biased towards people’s preferences. Subjectively visualizing all information of a filter usually produced chaotic results. Thus, there is still a considerable gap between network visualization and semantic explanations for neural networks. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            412
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Network diagnosis: Some studies diagnose feature representations inside a neural network. (Yosinski et al., 2014) measured features transferability in intermediate layers of a neural network. (Aubry & Russell, 2015) visualized feature distributions of different categories in the feature space. (Ribeiro et al., 2016; Lundberg & Lee, 2017; Kindermans et al., 2018; Fong & Vedaldi, 2017; Selvaraju et al., 2017) extracted rough pixel-level correlations between network inputs and outputs, i.e. estimating image regions that directly contribute the network output. Network-attack methods (Koh & Liang, 2017; Szegedy et al., 2014) computed adversarial samples to diagnose a CNN. (Lakkaraju et al., 2017) discovered knowledge blind spots of a CNN in a weakly-supervised manner. (Zhang et al., 2018a) examined representations of conv-layers and automatically discover biased representations of a CNN due to the dataset bias. However, above methods usually analyzed a neural network at the pixel level and did not summarize the network knowledge into clear visual concepts. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            573
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(Bau et al., 2017) defined six types of semantics for CNN filters, i.e. objects, parts, scenes, textures, materials, and colors. Then, (Zhou et al., 2015) proposed a method to compute the image-resolution receptive field of neural activations in a feature map. Other studies retrieved middle-layer features from CNNs representing clear concepts. (Simon & Rodner, 2015) retrieved features to describe objects from feature maps, respectively. (Zhou et al., 2015; 2016) selected neural units to describe scenes. Note that strictly speaking, each CNN filter usually represents a mixture of multiple semantic concepts. Unlike previous studies, we are more interested in analyzing the quantitative contribution of each semantic concept to each prediction, which was not discussed in previous studies. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning interpretable representations: A new trend in the scope of network interpretability is to learn interpretable feature representations in neural networks (Hu et al., 2016; Stone et al., 2017; Liao et al., 2016) in an un-/weakly-supervised manner. Capsule nets (Sabour et al., 2017) and interpretable RCNN (Wu et al., 2017b) learned interpretable features in intermediate layers. InfoGAN (Chen et al., 2016) and $\\beta$ -VAE (Higgins et al., 2017) learned well-disentangled codes for generative networks. Interpretable CNNs (Zhang et al., 2018b) learned filters in intermediate layers to represent object parts without given part annotations. However, as mentioned in (Bau et al., 2017; Zhang et al., 2018c), interpretable features usually do not have a high discrimination power. Therefore, we use the explainer to interpret the pre-trained performer without hurting the discriminability of the performer. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Explaining neural networks via knowledge distillation: Distilling knowledge from a black-box model into an explainable model is an emerging direction in recent years. (Zhang et al., 2018d) used a tree structure to summarize the inaccurate1 rationale of each CNN prediction into generic decision-making models for a number of samples. In contrast, we pursue the explicitly quantitative explanation for each CNN prediction. (Choi et al., 2017) learned an explainable additive model, and (Vaughan et al., 2018) distilled knowledge of a network into an additive model. (Frosst & Hinton, 2017; Tan et al., 2018; Che et al., 2016; Wu et al., 2017a) distilled representations of neural networks into tree structures. These methods did not explain the network knowledge using humaninterpretable semantic concepts. More crucially, compared to previous additive models (Vaughan et al., 2018), our research successfully overcomes the bias-interpreting problem, which is the core challenge when there are lots of visual concepts for explanation. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            220,
+            312,
+            237
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we distill knowledge from a pre-trained performer $f$ to an explainable additive model. We are given a performer $f$ and $n$ neural networks $\\{ f _ { i } | i = 1 , 2 , \\dots , n \\}$ that are pre-trained to detect $n$ different visual concepts. We learn the $n$ neural networks along with the performer, and the $n$ neural networks are expected to share low-layer features with the performer. Our method also requires a set of training samples for the performer $f$ . The goal of the explainer is to use inference values of the $n$ visual concepts to explain prediction scores of the performer. Note that we do not need any annotations on training samples w.r.t. the task, because additional supervision will push the explainer towards a good performance of the task, instead of objectively reflecting the knowledge in the performer. ",
+        "bbox": [
+            173,
+            252,
+            825,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given an input image $I$ , let ${ \\hat { y } } = f ( I )$ denote the output of the performer. Without loss of generality, we assume that $\\hat { y }$ is a scalar. If the performer has multiple outputs (e.g. a neural network for multicategory classification), we can learn an explainer to interpret each scalar output of the performer. In particular, when the performer takes a softmax layer as the last layer, we use the feature score before the softmax layer as $\\hat { y }$ , so that $\\hat { y }$ ’s neighboring scores will not affect the value of $\\hat { y }$ . ",
+        "bbox": [
+            174,
+            383,
+            825,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We design the following additive explainer model, which uses a mixture of visual concepts to approximate the function of the performer. The explainer decomposes the prediction score $\\hat { y }$ into value components of pre-defined visual concepts. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f080c60179a6da10740b2bc472bd3310628fb0c7ef710b3c10cd55899da3895.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\hat { y } \\approx \\ } & { { } \\underset { \\mathcal { S } } { \\underbrace { \\alpha _ { 1 } ( I ) \\cdot y _ { 1 } } } + \\alpha _ { 2 } ( I ) \\cdot y _ { 2 } + \\ldots + \\alpha _ { n } ( I ) \\cdot y _ { n } + b , \\quad y _ { i } = f _ { i } ( I ) , \\quad i = 1 , 2 , \\ldots , n } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            508,
+            792,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "| {z }Quantitative contribution from the first visual concept ",
+        "bbox": [
+            179,
+            534,
+            426,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { i }$ and $\\alpha _ { i } ( I )$ denote the scalar value and the weight for the $i$ -th visual concept, respectively. $b$ is a bias term. $y _ { i }$ is given as the strength or confidence of the detection of the $i$ -th visual concept. We can regard the value of $\\alpha _ { i } ( I ) \\cdot y _ { i }$ as the quantitative contribution of the $i$ -th visual concept to the final prediction. In most cases, the explainer cannot recover all information of the performer. The prediction difference between the explainer and the performer reflects the limit of the representation capacity of visual concepts. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "According to the above equation, the core task of the explainer is to estimate a set of weights $_ { \\alpha } =$ $[ \\alpha _ { 1 } , \\alpha _ { 2 } , \\ldots , \\alpha _ { n } ]$ , which minimizes the difference of the prediction score between the performer and the explainer. Different input images may obtain different weights $_ { \\pmb { \\alpha } }$ , which correspond to different decision-making modes of the performer. For example, a performer may mainly use head patterns to classify a standing bird, while it may increase the weight for the wing concept to classify a flying bird. Therefore, we design another neural network $g$ with parameters $\\theta _ { g }$ (i.e. the explainer), which uses the input image $I$ to estimate the $n$ weights. We learn the explainer with the following knowledge-distillation loss. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            755
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b198913a667c346572f07d2841816ff16b32ccd475ec7f4e8d94f8e8efba78e9.jpg",
+        "text": "$$\n\\pmb { \\alpha } = g ( I ) , \\qquad L = \\| \\hat { \\boldsymbol y } - \\sum _ { i = 1 } ^ { n } \\boldsymbol { \\alpha } _ { i } \\cdot \\boldsymbol { y } _ { i } - b \\| ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            760,
+            642,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, without any prior knowledge about the distribution of the weight $\\alpha _ { i }$ , the learning of $g$ usually suffers from the problem of bias-interpreting. The neural network $g$ may biasedly select very few visual concepts to approximate the performer as a shortcut solution, instead of sophisticatedly learning relationships between the performer output and all visual concepts. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            862
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus, to overcome the bias-interpreting problem, we use a loss $\\mathcal { L }$ for priors of $_ { \\pmb { \\alpha } }$ to guide the learning process in early epochs. ",
+        "bbox": [
+            171,
+            867,
+            823,
+            897
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fdc17510e3e40157868099f1aa306061f63c259d9987219ddb68696b34784cd.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta _ { g } , b } L o s s , \\quad \\quad L o s s = L + \\lambda ( t ) \\cdot \\mathcal { L } ( \\alpha , \\mathbf { w } ) , \\quad \\quad \\mathrm { s . t . } \\operatorname* { l i m } _ { t \\to \\infty } \\lambda ( t ) = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            901,
+            723,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e5b5085d1094ee9474a45ab266fffddd73d8fc08f80cb155ab1b9697bbd68db9.jpg",
+        "image_caption": [
+            "Figure 2: Two typical types of neural networks. (left) A performer models interpretable visual concepts in its intermediate layers. For example, each filter in a certain conv-layer represents a specific visual concept. (right) The performer and visual concepts are jointly learned, and they share features in intermediate layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            101,
+            807,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where w denotes prior weights, which represent a rough relationship between the performer’s prediction value and $n$ visual concepts. Just like $_ { \\pmb { \\alpha } }$ , different input images also have different prior weights w. The loss $\\mathcal { L } ( \\alpha , \\mathbf { w } )$ penalizes the dissimilarity between $_ { \\pmb { \\alpha } }$ and w. ",
+        "bbox": [
+            174,
+            276,
+            826,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the prior weights w are approximated with strong assumptions (we will introduce two different ways of computing w later). We use inaccurate w to avoid significant bias-interpreting, rather than pursue a high accuracy. Thus, we set a decreasing weight for $\\mathcal { L }$ , i.e. $\\begin{array} { r } { \\lambda ( t ) = \\frac { \\beta } { \\sqrt { t } } } \\end{array}$ , where $\\beta$ is a scalar constant, and $t$ denotes the epoch number. In this way, we mainly apply the prior loss $\\mathcal { L }$ in early epochs. Then, in late epochs, the influence of $\\mathcal { L }$ gradually decreases, and our method gradually shifts its attention to the distillation loss for a high distillation accuracy. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We design two types of losses for prior weights, as follows. ",
+        "bbox": [
+            176,
+            420,
+            563,
+            435
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2fb2aea1a8d7cba91599953cf5cffd356a550dca6a9dc2d243f5d726b8177926.jpg",
+        "text": "$$\n\\mathcal { L } ( \\alpha , \\mathbf { w } ) = \\left\\{ \\begin{array} { l l } { c r o s s { E n t r o p y } \\big ( \\frac { \\alpha } { \\lVert \\alpha \\rVert _ { 1 } } , \\frac { \\mathbf { w } } { \\lVert \\mathbf { w } \\rVert _ { 1 } } \\big ) , } & { \\forall i , \\alpha _ { i } , w _ { i } \\ge 0 } \\\\ { \\lVert \\frac { \\alpha } { \\lVert \\alpha \\rVert _ { 2 } } - \\frac { \\mathbf { w } } { \\lVert \\mathbf { w } \\rVert _ { 2 } } \\lVert _ { 2 } ^ { 2 } , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            441,
+            696,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Some applications require a positive relationship between the prediction of the performer and each visual concept, i.e. each weight $\\alpha _ { i }$ must be a positive scalar. In this case, we use the cross-entropy between $_ { \\pmb { \\alpha } }$ and $\\mathbf { w }$ as the prior loss. In other cases, the MSE loss between $_ { \\pmb { \\alpha } }$ and $\\mathbf { w }$ is used as the loss. $\\| \\cdot \\| _ { 1 }$ and $\\| \\cdot \\| _ { 2 }$ denote the L-1 norm and L-2 norm, respectively. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In particular, in order to ensure $\\alpha _ { i } \\geq 0$ in certain applications, we add a non-linear activation layer as the last layer of $g$ , i.e. $\\alpha = \\log [ 1 + \\exp ( x ) ]$ , where $x$ is the output of the last conv-layer. ",
+        "bbox": [
+            174,
+            546,
+            823,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 COMPUTATION OF PRIOR WEIGHTS w",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            473,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we will introduce two techniques to efficiently compute rough prior weights w, which are oriented to the following two cases in application. ",
+        "bbox": [
+            173,
+            618,
+            823,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Case 1, filters in intermediate conv-layers of the performer are interpretable: As shown in Fig. 2(left), learning a neural network with interpretable filters is an emerging research direction in recent years. For example, (Zhang et al., 2018b) proposed a method to learn CNNs for object classification, where each filter in a high conv-layer is exclusively triggered by the appearance of a specific object part (see Fig. 10 in the appendix for the visualization of filters). Thus, we can interpret the classification score of an object as a linear combination of elementary scores for the detection of object parts. Because such interpretable filters are automatically learned without part annotations, the quantitative explanation for the CNN (i.e. the performer) can be divided into the following two tasks: (i) annotating the name of the object part that is represented by each filter, and (ii) learning an explainer to disentangle the exact additive contribution of each filter (or each object part) to the performer output. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this way, each $f _ { i }$ , $i = 1 , 2 , \\ldots , n$ , is given as an interpretable filter of the performer. According to (Zhang et al., 2018a), we can roughly represent the network prediction as ",
+        "bbox": [
+            171,
+            813,
+            823,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/237afb77d36ca5fcfc58c393392d854e526384e6ddd465d668fc01b8f60867b2.jpg",
+        "text": "$$\n{ \\hat { y } } \\approx \\sum _ { i } w _ { i } y _ { i } + b , \\qquad { \\mathrm { s . t . } } \\quad { \\left\\{ \\begin{array} { l l } { y _ { i } } & { = \\sum _ { h , w } x _ { h w i } } \\\\ { w _ { i } } & { = { \\frac { 1 } { Z } } \\sum _ { h , w } { \\frac { \\partial { \\hat { y } } } { \\partial x _ { h w i } } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            847,
+            673,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\boldsymbol { x } \\in \\mathbb { R } ^ { H \\times W \\times n }$ denotes a feature map of the interpretable conv-layer, and $x _ { h w i }$ is referred to as the activation unit in the location $( h , w )$ of the $i$ -th channel. $y _ { i }$ measures the confidence of detecting the object part corresponding to the $i$ -th filter. Here, we can roughly use the Jacobian of the network output w.r.t. the filter to approximate the weight $w _ { i }$ of the filter. $Z$ is for normalization. Considering that the normalization operation in Equation (4) eliminates Z, we can directly use Ph,w ∂yˆ∂xhwi as prior weights w in Equation (4) without a need to compute the exact value of . ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            162
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Case 2, neural networks for visual concepts share features in intermediate layers with the performer: As shown in Fig. 2(right), given a neural network for the detection of multiple visual concepts, using certain visual concepts to explain a new visual concept is a generic way to interpret network predictions with broad applicability. Let us take the detection of a certain visual concept as the target $\\hat { y }$ and use other visual concepts as $\\{ y _ { i } \\}$ to explain $\\hat { y }$ . All visual concepts share features in intermediate layers. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            253
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Then, we estimate a rough numerical relationship between $\\hat { y }$ and the score of each visual concept $y _ { i }$ . Let $x$ be a middle-layer feature shared by both the target and the $i$ -th visual concept. When we modify the feature $x$ , we can represent the value change of $y _ { i }$ using a Taylor series, $\\Delta y _ { i } =$ $\\begin{array} { r } { \\frac { \\partial y _ { i } } { \\partial x } \\otimes \\Delta x + O ( \\Delta ^ { 2 } x ) } \\end{array}$ , where $\\otimes$ denotes the convolution operation. Thus, when we push the feature ∂x towards the direction of boosting $y _ { i }$ , i.e. $\\Delta x = \\epsilon \\frac { \\partial y _ { i } } { \\partial x }$ $\\epsilon$ is a small constant), the change of the $i$ -th visual concept can be approximated as $\\Delta y _ { i } = \\epsilon \\| \\frac { \\partial y _ { i } } { \\partial x } \\| _ { F } ^ { 2 }$ , where $\\| \\cdot \\| _ { F }$ denotes the Frobenius norm. Meanwhile, ∆x also affects the target concept by ∆ˆy = \u000f ∂yˆ∂x ∂yi∂x . Thus, we can roughly estimate the weight as wi = ∆ˆy∆yi . ",
+        "bbox": [
+            174,
+            261,
+            825,
+            392
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            409,
+            326,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We designed two experiments to use our explainers to interpret different benchmark CNNs oriented to two different applications, in order to demonstrate the broad applicability of our method. In the first experiment, we used the detection of object parts to explain the detection of the entire object. In the second experiment, we used various face attributes to explain the prediction of another face attribute. We evaluated explanations obtained by our method qualitatively and quantitatively. ",
+        "bbox": [
+            174,
+            441,
+            825,
+            511
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENT 1: USING OBJECT PARTS TO EXPLAIN OBJECT CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            741,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we used the method proposed in (Zhang et al., 2018b) to learn a CNN, where each filter in the top conv-layer represents a specific object part. We followed exact experimental settings in (Zhang et al., 2018b), which used the Pascal-Part dataset (Chen et al., 2014) to learn six CNNs for the six animal2 categories in the dataset. Each CNN was learned to classify the target animal from random images. We considered each CNN as a performer and regarded its interpretable filters in the top conv-layer as visual concepts to interpret the classification score. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Four types of CNNs as performers: Following experimental settings in (Zhang et al., 2018b), we applied our method to four types of CNNs, including the AlexNet (Krizhevsky et al., 2012), the VGG-M, VGG-S, and VGG-16 networks (Simonyan & Zisserman, 2015), i.e. we learned CNNs for six categories based on each network structure. Note that as discussed in (Zhang et al., 2018b), skip connections in residual networks (He et al., 2016) increased the difficulty of learning part features, so they did not learn interpretable filters in residual networks. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Learning the explainer: The AlexNet/VGG-M/VGG-S/VGG-16 performer had 256/512/512/512 filters in its top conv-layer, so we set $n = 2 5 6$ , 512, 512, 512 for these networks. We used the masked output of the top conv-layer as $x$ and plugged $x$ to Equation (5) to compute $\\{ y _ { i } \\} ^ { 1 }$ . We used the 152- layer ResNet (He et al., $2 0 1 6 ) ^ { 3 }$ as $g$ to estimate weights of visual concepts4. We set $\\beta = 1 0$ for the learning of all explainers. Note that all interpretable filters in the performer represented object parts of the target category on positive images, instead of describing random (negative) images. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/2da1dda9cb738f744b0e161cd4efad98ab2d7a6a7fa681523292a2acd4e8393b.jpg",
+        "table_caption": [
+            "Table 1: Entropy of contribution distributions estimated by the explainer. A lower entropy of contribution distributions reflects more significant bias-interpreting. Our method suffered much less from the bias-interpreting problem than the baseline. Please see the appendix for more results. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"4\">Experiment1</td><td colspan=\"5\">Experiment 2</td></tr><tr><td>AlexNet</td><td>VGG-M</td><td>VGG-S</td><td>VGG-16</td><td>attractive</td><td>makeup</td><td>male</td><td>young</td><td>Avg.</td></tr><tr><td>Baseline</td><td>3.636</td><td>4.957</td><td>3.962</td><td>4.218</td><td>3.185</td><td>3.120</td><td>3.139</td><td>3.100</td><td>3.136</td></tr><tr><td>Ours</td><td>5.199</td><td>5.908</td><td>5.913</td><td>6.054</td><td>3.216</td><td>3.134</td><td>3.139</td><td>3.160</td><td>3.162</td></tr></table>",
+        "bbox": [
+            189,
+            101,
+            808,
+            152
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/fa819dd999ffe0b11653972b9f2b6a4ee0331306b32e3fefc95027fb957161a9.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Classification accuracy and relative deviations of the explainer and the performer. We used relative deviations and the decrease of the classification accuracy to measure the information that could not be explained by pre-defined visual concepts. Please see the appendix for more results. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\"></td><td colspan=\"4\">Experiment 1</td><td colspan=\"5\">Experiment 2</td></tr><tr><td>AlexNet</td><td>VGG-M</td><td>VGG-S</td><td>VGG-16</td><td>attractive</td><td>makeup</td><td>male</td><td>young</td><td>Avg.</td></tr><tr><td>Classification</td><td>Performer</td><td>93.9</td><td>94.2</td><td>95.5</td><td>95.4</td><td>81.5</td><td>92.3</td><td>98.7</td><td>88.3</td><td>90.2</td></tr><tr><td>accuracy</td><td>Explainer</td><td>93.6</td><td>94.0</td><td>94.9</td><td>96.6</td><td>76.0</td><td>88.8</td><td>97.6</td><td>82.8</td><td>87.1</td></tr><tr><td>Relative</td><td>Performer</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td>deviation</td><td>Explainer</td><td>0.045</td><td>0.040</td><td>0.041</td><td>0.038</td><td>0.163</td><td>0.100</td><td>0.067</td><td>0.139</td><td>0.117</td></tr></table>",
+        "bbox": [
+            207,
+            209,
+            792,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, we needed to ensure a positive relationship between $\\hat { y }$ and $y _ { i }$ . Thus, we filtered out negative prior weights $w _ { i } \\gets \\operatorname* { m a x } \\{ w _ { i } , 0 \\}$ and applied the cross-entropy loss in Equation (4) to learn the explainer. ",
+        "bbox": [
+            176,
+            340,
+            823,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation metric: The evaluation has two aspects. Firstly, we evaluated the correctness of the estimated explanation for the performer prediction. In fact, there is no ground truth about exact reasons for each prediction. We showed example explanations of for a qualitative evaluation of explanations. We also used grad-CAM visualization (Selvaraju et al., 2017) of feature maps to prove the correctness of our explanations (see the appendix). In addition, we normalized the absolute contribution from each visual concept as a distribution of contributions $c _ { i } = | \\alpha _ { i } y _ { i } | / \\sum _ { j } | \\alpha _ { j } y _ { j } |$ . We used the entropy of contribution distribution $H ( \\mathbf { c } )$ as an indirect evaluation metric for biasinterpreting. A biased explainer usually used very few visual concepts, instead of using most visual concepts, to approximate the performer, which led to a low entropy $H ( \\mathbf { c } )$ . ",
+        "bbox": [
+            173,
+            390,
+            825,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Secondly, we also measured the performer information that could not be represented by the visual concepts, which was unavoidable. We proposed two metrics for evaluation. The first metric is the prediction accuracy. We compared the prediction accuracy of the performer with the prediction accuracy of using the explainer’s output $\\sum _ { i } ^ { - } \\alpha _ { i } y _ { i } + b$ . Another metric is the relative deviation, which measures a normalized output difference between the performer and the explainer. The relative deviation of the image $I$ is normalized as $\\begin{array} { r } { \\vert \\hat { y } _ { I } - \\sum _ { i } \\bar { \\alpha _ { I , i } } y _ { I , i } - b \\vert / \\big ( \\mathrm { { m a x } } _ { I ^ { \\prime } \\in \\mathbf { I } } \\hat { y } _ { I ^ { \\prime } } - \\mathrm { { m i n } } _ { I ^ { \\prime } \\in \\mathbf { I } } \\hat { y } _ { I ^ { \\prime } } \\big ) } \\end{array}$ , where $\\hat { y } _ { I ^ { \\prime } }$ denotes the performer’s output for the image $I ^ { \\prime }$ . ",
+        "bbox": [
+            174,
+            525,
+            825,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Considering the limited representation power of visual concepts, the relative deviation on an image reflected inference patterns, which were not modeled by the explainer. The average relative deviation over all images was reported to evaluate the overall representation power of visual concepts. Note that our objective was not to pursue an extremely low relative deviation, because the limit of the representation power is an objective existence. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            699
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENT 2: EXPLAINING FACE ATTRIBUTES BASED ON FACE ATTRIBUTES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            751,
+            741
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we learned a CNN based on the VGG-16 structure to estimate face attributes. We used the Large-scale CelebFaces Attributes (CelebA) dataset (Liu et al., 2015) to train a CNN to estimate 40 face attributes. We selected a certain attribute as the target and used its prediction score as $\\hat { y }$ . Other 39 attributes were taken as visual concepts to explain the score of $\\hat { y }$ $\\left( n = 3 9 \\right.$ ). The target attribute was selected from those representing global features of the face, i.e. attractive, heavy makeup, male, and young. It is because global features can usually be described by local visual concepts, but the inverse is not. We learned an explainer for each target attribute. We used the same 152-layer ResNet structure as in Experiment 1 (expect for $n = 3 9$ ) as $g$ to estimate weights. We followed the Case-2 implementation in Section 3.1 to compute prior weights $\\mathbf { w }$ , in which we used the 4096-dimensional output of the first fully-connected layer as the shared feature $x$ . We set $\\beta = 0 . 2$ and used the L-2 norm loss in Equation (4) to learn all explainers. We used the same evaluation metric as in Experiment 1. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b961339d6b26f9c459eec8f0c4ff38eb80ba0ef4d7451bf8a9bf4659fe095da6.jpg",
+        "image_caption": [
+            "Figure 3: Quantitative explanations for the object classification (top) and the face-attribution prediction (bottom) made by performers. For performers oriented to object classification, we annotated the part that was represented by each interpretable filter in the performer, and we assigned contributions of filters $\\alpha _ { i } y _ { i }$ to object parts (see the appendix). Thus, this figure illustrates contributions of different object parts. All object parts made positive contributions to the classification score. Note that in the bottom, bars indicate elementary contributions $\\alpha _ { i } y _ { i }$ from features of different face attributes, rather than prediction values $y _ { i }$ of these attributes. For example, the network predicts a negative goatee attribute $y _ { \\mathrm { g o a t e e } } < 0$ , and this information makes a positive contribution to the target attractive attribute, $\\alpha _ { i } y _ { i } > 0$ . Please see the appendix for more results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            101,
+            805,
+            284
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 EXPERIMENTAL RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            496,
+            443
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compared our method with the traditional baseline of only using the distillation loss to learn the explainer. Table 1 evaluates bias-interpreting of explainers that were learned using our method and the baseline. In addition, Table 2 uses the classification accuracy and relative deviations of the explainer to measure the representation capacity of visual concepts. Our method suffered much less from the bias-interpreting problem than the baseline. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 shows examples of quantitative explanations for the prediction made by the performer. We also used the grad-CAM visualization (Selvaraju et al., 2017) of feature maps of the performer to demonstrate the correctness of our explanations in Fig. 9 in the appendix. In particular, Fig. 4 in the appendix illustrates the distribution of contributions of visual concepts $\\left\\{ c _ { i } \\right\\}$ when we learned the explainer using different methods. Compared to our method, the distillation baseline usually used very few visual concepts for explanation and ignored most strongly activated interpretable filters, which could be considered as bias-interpreting. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            631
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            475,
+            669
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on a new task, i.e. explaining the logic of each CNN prediction semantically and quantitatively, which presents considerable challenges in the scope of understanding neural networks. We propose to distill knowledge from a pre-trained performer into an interpretable additive explainer. We can consider that the performer and the explainer encode similar knowledge. The additive explainer decomposes the prediction score of the performer into value components from semantic visual concepts, in order to compute quantitative contributions of different concepts. The strategy of using an explainer for explanation avoids decreasing the discrimination power of the performer. In preliminary experiments, we have applied our method to different benchmark CNN performers to prove the broad applicability. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            813
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Note that our objective is not to use pre-trained visual concepts to achieve super accuracy in classification/prediction. Instead, the explainer uses these visual concepts to mimic the logic of the performer and produces similar prediction scores as the performer. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In particular, over-interpreting is the biggest challenge of using an additive explainer to interpret another neural network. In this study, we design two losses to overcome the bias-interpreting problems. Besides, in experiments, we also measure the amount of the performer knowledge that could not be represented by visual concepts in the explainer. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mathieu Aubry and Bryan C. Russell. Understanding deep features with computer-generated imagery. In ICCV, 2015. ",
+        "bbox": [
+            174,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Bau, Bolei Zhou, Aditya Khosla, Aude Oliva, and Antonio Torralba. Network dissection: Quantifying interpretability of deep visual representations. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            159,
+            820,
+            186
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhengping Che, Sanjay Purushotham, Robinder Khemani, and Yan Liu. Interpretable deep models for icu outcome prediction. In American Medical Informatics Association (AMIA) Annual Symposium, 2016. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "X. Chen, R. Mottaghi, X. Liu, S. Fidler, R. Urtasun, and A. Yuille. Detect what you can: Detecting and representing objects using holistic models and body parts. In CVPR, 2014. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            265,
+            823,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Edward Choi, Mohammad Taha Bahadori, Joshua A. Kulas, Andy Schuetz, Walter F. Stewart, and Jimeng Sun. Retain: an interpretable predictive model for healthcare using reverse time attention mechansim. in arXiv:1608.05745v4, 2017. ",
+        "bbox": [
+            173,
+            300,
+            823,
+            339
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy and Thomas Brox. Inverting visual representations with convolutional networks. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            347,
+            823,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ruth C. Fong and Andrea Vedaldi. Interpretable explanations of black boxes by meaningful perturbation. In arXiv:1704.03296v1, 2017. ",
+        "bbox": [
+            171,
+            382,
+            823,
+            410
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Frosst and Geoffrey Hinton. Distilling a neural network into a soft decision tree. In arXiv:1711.09784, 2017. ",
+        "bbox": [
+            173,
+            417,
+            823,
+            445
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tommaso Furlanello, Zachary C. Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. In arXiv:1805.04770, 2018. ",
+        "bbox": [
+            174,
+            453,
+            823,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            515
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. $\\beta$ -vae: learning basic visual concepts with a constrained variational framework. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            522,
+            823,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhiting Hu, Xuezhe Ma, Zhengzhong Liu, Eduard Hovy, and Eric P. Xing. Harnessing deep neural networks with logic rules. In arXiv:1603.06318v2, 2016. ",
+        "bbox": [
+            173,
+            570,
+            821,
+            598
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pieter-Jan Kindermans, Kristof T. Schutt, Maximilian Alber, Klaus-Robert M ¨ uller, Dumitru Erhan, Been Kim,¨ and Sven Dahne. Learning how to explain neural networks: Patternnet and patternattribution. ¨ In ICLR, 2018. ",
+        "bbox": [
+            173,
+            606,
+            823,
+            633
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "PangWei Koh and Percy Liang. Understanding black-box predictions via influence functions. In ICML, 2017. ",
+        "bbox": [
+            173,
+            641,
+            823,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            176,
+            664,
+            820,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Himabindu Lakkaraju, Ece Kamar, Rich Caruana, and Eric Horvitz. Identifying unknown unknowns in the open world: Representations and policies for guided exploration. In AAAI, 2017. ",
+        "bbox": [
+            174,
+            699,
+            823,
+            726
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document \\` recognition. In Proceedings of the IEEE, 1998. ",
+        "bbox": [
+            176,
+            734,
+            821,
+            761
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Renjie Liao, Alex Schwing, Richard Zemel, and Raquel Urtasun. Learning deep parsimonious representations. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            768,
+            821,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Scott M. Lundberg and Su-In Lee. A unified approach to interpreting model predictions. In NIPS, 2017. ",
+        "bbox": [
+            174,
+            839,
+            790,
+            854
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aravindh Mahendran and Andrea Vedaldi. Understanding deep image representations by inverting them. In CVPR, 2015. ",
+        "bbox": [
+            176,
+            862,
+            821,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. “why should i trust you?” explaining the predictions of any classifier. In KDD, 2016. ",
+        "bbox": [
+            173,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sara Sabour, Nicholas Frosst, and Geoffrey E. Hinton. Dynamic routing between capsules. In NIPS, 2017.   \nRamprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In ICCV, 2017.   \nMarcel Simon and Erik Rodner. Neural activation constellations: Unsupervised part model discovery with convolutional networks. In ICCV, 2015.   \nKaren Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \nKaren Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: visualising image classification models and saliency maps. In arXiv:1312.6034, 2013.   \nAustin Stone, Huayan Wang, Yi Liu, D. Scott Phoenix, and Dileep George. Teaching compositionality to cnns. In CVPR, 2017.   \nChristian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In arXiv:1312.6199v4, 2014.   \nSarah Tan, Rich Caruana, Giles Hooker, and Albert Gordo. Transparent model distillation. In arXiv:1801.08640, 2018.   \nJoel Vaughan, Agus Sudjianto, Erind Brahimi, Jie Chen, and Vijayan N. Nair. Explainable neural networks based on additive index models. in arXiv:1806.01933, 2018.   \nMike Wu, Michael C. Hughes, Sonali Parbhoo, Maurizio Zazzi, Volker Roth, and Finale Doshi-Velez. Beyond sparsity: Tree regularization of deep models for interpretability. In NIPS TIML Workshop, 2017a.   \nTianfu Wu, Xilai Li, Xi Song, Wei Sun, Liang Dong, and Bo Li. Interpretable r-cnn. In arXiv:1711.05226, 2017b.   \nJason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NIPS, 2014.   \nJason Yosinski, Jeff Clune, Anh Nguyen, Thomas Fuchs, and Hod Lipson. Understanding neural networks through deep visualization. In ICML Deep Learning Workshop, 2015.   \nMatthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014.   \nQ. Zhang, W. Wang, and S.-C. Zhu. Examining cnn representations with respect to dataset bias. In AAAI, 2018a.   \nQuanshi Zhang, Ying Nian Wu, and Song-Chun Zhu. Interpretable convolutional neural networks. In CVPR, 2018b.   \nQuanshi Zhang, Yu Yang, Yuchen Liu, Ying Nian Wu, and Song-Chun Zhu. Unsupervised learning of neural networks to explain neural networks. in arXiv:1805.07468, 2018c.   \nQuanshi Zhang, Yu Yang, Ying Nian Wu, and Song-Chun Zhu. Interpreting cnns via decision trees. In arXiv:1802.00121, 2018d.   \nBolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. In ICRL, 2015.   \nBolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In CVPR, 2016. ",
+        "bbox": [
+            171,
+            97,
+            828,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "DETAILED RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            339,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/100a8223f7fb22dd0143055d86bd15979a64e853650e930ed1d082c310136504.jpg",
+        "table_caption": [
+            "Table 3: Entropy of contribution distributions. The entropy of contribution distributions reflects the level of bias-interpreting. The lower entropy indicates a larger bias. Our method suffered much less from the bias-interpreting problem than the baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">AlexNet</td><td colspan=\"2\">VGG-M</td><td colspan=\"2\">VGG-S</td><td colspan=\"2\">VGG-16</td></tr><tr><td>bird</td><td>Baseline 3.681</td><td>Ours 5.201</td><td>Baseline 4.543</td><td>Ours 5.885</td><td>Baseline 3.988</td><td>Ours 5.870</td><td>Baseline</td><td>Ours</td></tr><tr><td></td><td>3.294</td><td>5.103</td><td>5.604</td><td></td><td>3.954</td><td>5.913</td><td>4.165</td><td>6.040</td></tr><tr><td>cat</td><td></td><td></td><td></td><td>5.902</td><td></td><td></td><td>4.894</td><td>6.056</td></tr><tr><td>Cow</td><td>3.607</td><td>5.236</td><td>4.616</td><td>5.941</td><td>3.786</td><td>5.901</td><td>3.763</td><td>6.084</td></tr><tr><td>dog</td><td>3.774</td><td>5.243</td><td>5.510</td><td>6.023</td><td>4.087</td><td>5.954</td><td>4.570</td><td>6.061</td></tr><tr><td>horse</td><td>3.745 3.716</td><td>5.278 5.135</td><td>4.722 4.747</td><td>5.921 5.773</td><td>3.802</td><td>5.973 5.869</td><td>4.064</td><td>6.060</td></tr><tr><td>sheep</td><td></td><td></td><td></td><td></td><td>4.152</td><td></td><td>3.850</td><td>6.022</td></tr><tr><td>Avg.</td><td>3.636</td><td>5.199</td><td>4.957</td><td>5.908</td><td>3.962</td><td>5.913</td><td>4.218</td><td>6.054</td></tr></table>",
+        "bbox": [
+            241,
+            148,
+            759,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/ea2ce1ce274be90b0a010b5ac67923adf89ec39c9bf677d38ad0e7a18b4d1d0d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">AlexNet</td><td colspan=\"3\">VGG-M</td><td colspan=\"3\">VGG-S</td><td colspan=\"3\">VGG-16</td></tr><tr><td>Performer</td><td>Baseline</td><td>Ours</td><td>Performer</td><td>Baseline</td><td>Ours</td><td>Performer</td><td>Baseline</td><td>Ours</td><td>PerformerI</td><td>Baseline</td><td>Ours</td></tr><tr><td>bird</td><td>92.8</td><td>92.8</td><td>93.8</td><td>96.8</td><td>97.3</td><td>97.8</td><td>96.5</td><td>97.0</td><td>96.0</td><td>97.3</td><td>98.5</td><td>98.8</td></tr><tr><td>cat</td><td>96.3</td><td>95.7</td><td>95.2</td><td>94.3</td><td>95.7</td><td>95.5</td><td>95.3</td><td>95.5</td><td>96.0</td><td>94.3</td><td>97.0</td><td>97.0</td></tr><tr><td>cow</td><td>93.4</td><td>92.6</td><td>93.4</td><td>95.2</td><td>94.2</td><td>94.7</td><td>94.4</td><td>94.2</td><td>93.7</td><td>91.1</td><td>97.0</td><td>95.4</td></tr><tr><td>dog</td><td>92.5</td><td>92.5</td><td>92.0</td><td>93.8</td><td>94.7</td><td>94.5</td><td>95.3</td><td>95.5</td><td>93.0</td><td>94.5</td><td>95.0</td><td>94.5</td></tr><tr><td>horse</td><td>91.4</td><td>89.1</td><td>88.1</td><td>92.9</td><td>88.9</td><td>88.9</td><td>92.9</td><td>91.7</td><td>92.7</td><td>99.2</td><td>96.5</td><td>97.7</td></tr><tr><td>sheep</td><td>97.2</td><td>97.2</td><td>99.2</td><td>92.2</td><td>92.7</td><td>92.5</td><td>98.5</td><td>97.0</td><td>98.2</td><td>96.0</td><td>95.7</td><td>96.0</td></tr><tr><td>Average</td><td>93.9</td><td>93.3</td><td>93.6</td><td>94.2</td><td>93.9</td><td>94.0</td><td>95.5</td><td>95.2</td><td>94.9</td><td>95.4</td><td>96.6</td><td>96.6</td></tr></table>",
+        "bbox": [
+            176,
+            330,
+            825,
+            434
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/a445fc9a667c1b82046aaa540dfa9a4b9035304e7be5885d61ac1743ea24aa9e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Attractive</td><td>Makeup</td><td>Male</td><td>Young</td><td>Avg.</td></tr><tr><td>Performer</td><td>81.5</td><td>92.3</td><td>98.7</td><td>88.3</td><td>90.2</td></tr><tr><td>Explainer, baseline</td><td>73.2</td><td>89.0</td><td>97.6</td><td>81.8</td><td>85.4</td></tr><tr><td>Explainer, ours</td><td>76.0</td><td>88.8</td><td>97.6</td><td>82.8</td><td>86.3</td></tr></table>",
+        "bbox": [
+            272,
+            446,
+            727,
+            505
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Classification accuracy of the explainer and the performer. We use the the classification accuracy to measure the information loss when using an explainer to interpret the performer. Note that the additional loss for bias-interpreting successfully overcame the bias-interpreting problem, but did not decrease the classification accuracy of the explainer. Another interesting finding of this research is that sometimes, the explainer even outperformed the performer in classification. A similar phenomenon has been reported in (Furlanello et al., 2018). A possible explanation for this phenomenon is given as follows. When the student network in knowledge distillation had sufficient representation power, the student network might learn better representations than the teacher network, because the distillation process removed abnormal middle-layer features corresponding to irregular samples and maintained common features, so as to boost the robustness of the student network. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1275ba17dd0f37654e350d997389a7fccbd81e6ae040793ce8a5578777cff8a.jpg",
+        "table_caption": [
+            "Table 5: Relative deviations of the explainer. The additional loss for bias-interpreting successfully overcame the bias-interpreting problem and just increased a bit (ignorable) relative deviation of the explainer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">AlexNet</td><td colspan=\"2\">VGG-M</td><td colspan=\"2\">VGG-S</td><td colspan=\"2\">VGG-16</td></tr><tr><td>Baseline</td><td>Ours</td><td>Baseline</td><td>Ours</td><td>Baseline</td><td>Ours</td><td>Baseline</td><td>Ours</td></tr><tr><td>bird</td><td>0.050</td><td>0.045</td><td>0.033</td><td>0.035</td><td>0.030</td><td>0.031</td><td>0.040</td><td>0.034</td></tr><tr><td>cat</td><td>0.041</td><td>0.040</td><td>0.029</td><td>0.030</td><td>0.036</td><td>0.039</td><td>0.027</td><td>0.030</td></tr><tr><td>cow</td><td>0.047</td><td>0.048</td><td>0.058</td><td>0.062</td><td>0.041</td><td>0.047</td><td>0.051</td><td>0.061</td></tr><tr><td>dog</td><td>0.041</td><td>0.047</td><td>0.025</td><td>0.026</td><td>0.041</td><td>0.047</td><td>0.028</td><td>0.026</td></tr><tr><td>horse</td><td>0.044</td><td>0.043</td><td>0.051</td><td>0.049</td><td>0.045</td><td>0.043</td><td>0.036</td><td>0.034</td></tr><tr><td>sheep</td><td>0.045</td><td>0.049</td><td>0.036</td><td>0.038</td><td>0.035</td><td>0.037</td><td>0.032</td><td>0.041</td></tr><tr><td>Average</td><td>0.045</td><td>0.045</td><td>0.039</td><td>0.040</td><td>0.038</td><td>0.041</td><td>0.036</td><td>0.038</td></tr></table>",
+        "bbox": [
+            241,
+            659,
+            761,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "IMAGE-SPECIFIC EXPLANATIONS V.S. GENERIC EXPLANATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            838,
+            697,
+            853
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(Zhang et al., 2018d) used a tree structure to summarize the inaccurate rationale of each CNN prediction into generic decision-making models for a number of samples. This method assumed the significance of a feature to be proportional to the Jacobian w.r.t. the feature, which is quite problematic. This assumption is acceptable for (Zhang et al., 2018d), because the objective of (Zhang et al., ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2018d) is to learn a generic explanation for a group of samples, and the inaccuracy in the explanation for each specific sample does not significantly affect the accuracy of the generic explanation. In comparisons, our method focuses on the quantitative explanation for each specific sample, so we design an additive model to obtain more convincing explanations. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "VISUALIZATION OF BIAS-INTERPRETING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            181,
+            513,
+            195
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f92c5fadc46d18ef61699cae864d1f0926144a359dc405ed0fd83242c265ee8.jpg",
+        "image_caption": [
+            "Figure 4: We compared the contribution distribution of different visual concepts (filters) that was estimated by our method and the distribution that was estimated by the baseline. The baseline usually used very few visual concepts to make predictions, which was a typical case of bias-interpreting. In comparisons, our method provided a much more reasonable contribution distribution of visual concepts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            210,
+            785,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Most important reasons ",
+        "text_level": 1,
+        "bbox": [
+            704,
+            141,
+            781,
+            161
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            696,
+            180,
+            774,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            697,
+            325,
+            769,
+            377
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "No heavy makeup ",
+        "bbox": [
+            697,
+            431,
+            781,
+            515
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/c933a728bd7bb68ce814d29ddf0eb4fa98e1ed3e1f23ec0e5506e2bcf97eec4c.jpg",
+        "image_caption": [
+            "Figure 5: Quantitative explanations for the attractive attribute. Bars indicate elementary contributions $\\alpha _ { i } y _ { i }$ from features of different face attributes, rather than the prediction of these attributes. For example, the network predicts a negative goatee attribute $y _ { \\mathrm { g o a t e e } } < 0$ , and this information makes a positive contribution to the target attractive attribute, $\\alpha _ { i } y _ { i } > 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            154,
+            753,
+            787
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "No heavy makeup ",
+        "bbox": [
+            697,
+            550,
+            782,
+            642
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            697,
+            666,
+            767,
+            776
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Most important reasons ",
+        "text_level": 1,
+        "bbox": [
+            709,
+            103,
+            785,
+            123
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5‐o’clock shadow No bald No heavy makeup No earrings Not wearing lipstick Not wearing necktie ",
+        "bbox": [
+            702,
+            160,
+            787,
+            220
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "No heavy makeup Not wearing earrings Not wearing lipstick Not wearing necktie ",
+        "bbox": [
+            702,
+            295,
+            789,
+            333
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "No 5‐o’clock shadow   \nNo goatee   \nNo receding   \nhairline   \nNo sideburns   \nNot wearing earrings   \nNot wearing necktie ",
+        "bbox": [
+            700,
+            401,
+            789,
+            473
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/1049960310c0c07afbfa5c859e1ab50ec576d14d6136c657d28f9eb83145b140.jpg",
+        "image_caption": [
+            "Figure 6: Quantitative explanations $\\alpha _ { i } y _ { i }$ for the male attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            116,
+            692,
+            750
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "No heavy makeup Not wearing earrings Not wearing lipstick Not wearing necklace ",
+        "bbox": [
+            702,
+            541,
+            790,
+            580
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "No heavy makeup Not wearing earrings Not wearing lipstick ",
+        "bbox": [
+            700,
+            670,
+            789,
+            699
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Most important reasons ",
+        "text_level": 1,
+        "bbox": [
+            705,
+            103,
+            782,
+            123
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "No goatee Not male Wearing lipstick ",
+        "bbox": [
+            699,
+            174,
+            774,
+            205
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "No eyeglasses Not male No rosy cheeks Wear lipstick ",
+        "bbox": [
+            699,
+            291,
+            771,
+            333
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Not attractive High cheekbones No mustache No pointy nose No rosy cheeks Not wearing lipstick Not wearing necklace ",
+        "bbox": [
+            699,
+            398,
+            789,
+            470
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5ffd643e2435ed49b2c437cd69e8699dac07deaba7b5b6036d3710353deb73e.jpg",
+        "image_caption": [
+            "Figure 7: Quantitative explanations $\\alpha _ { i } y _ { i }$ for the heavy makeup attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            119,
+            689,
+            746
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "No eyeglasses   \nNo gray hear   \nMale   \nNot wearing lipstick   \nNot wearing necklace   \nYoung   \nNo bangs   \nNot blurry   \nNo eyeglasses   \nMale   \nNo rosy cheeks   \nWearing hat   \nNot wearing lipstick ",
+        "bbox": [
+            699,
+            527,
+            789,
+            587
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            699,
+            643,
+            781,
+            718
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            704,
+            169,
+            781,
+            210
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            704,
+            292,
+            781,
+            335
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b1fd2ce7bdbba8790a5aaf980ff839eb44add1cd860b5b1433e755fe83d18ac.jpg",
+        "image_caption": [
+            "Figure 8: Quantitative explanations $\\alpha _ { i } y _ { i }$ for the young attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            116,
+            763,
+            751
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            702,
+            637,
+            789,
+            734
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/12a2c71fa03a6de7ad7911f8a27cec5fe713a7916fdfa7939ff2d6b4026659ba.jpg",
+        "image_caption": [
+            "Figure 9: Quantitative explanations for object classification. We assigned contributions of filters to their corresponding object parts, so that we obtained contributions of different object parts. According to top figures, we found that different images had similar explanations, i.e. the CNN used similar object parts to classify objects. Therefore, we showed the grad-CAM visualization of feature maps (Selvaraju et al., 2017) on the bottom, which proved this finding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            821,
+            570
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/2eabdeec6a8b771edc0406ac50d89724c8579a95359e7b610935cf93378f65ba.jpg",
+        "image_caption": [
+            "Figure 10: We visualized interpretable filters in the top conv-layer of a CNN, which were learned based on (Zhang et al., 2018b). We projected activation regions on the feature map of the filter onto the image plane for visualization. Each filter represented a specific object part through different images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            155,
+            787,
+            837
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "ANNOTATIONS OF PART NAMES OF INTERPRETABLE FILTERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            673,
+            118
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "(Zhang et al., 2018b) learned a CNN, where each filter in the top conv-layer represented a specific object part. Thus, we annotated the name of the object part that corresponded to each filter based on visualization results (see Fig. 10 for examples). We simply annotate each filter of the top conv-layer in a performer once, so the total annotation cost was $O \\bar { ( } N )$ , where $N$ is the filter number. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            189
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Then, we assigned the contribution of a filter to its corresponding part, i.e. $C o n t r i _ { p a r t } ~ =$   \n$\\textstyle \\sum _ { i : 1 }$ -th filter represents the part $\\alpha _ { i } y _ { i }$ . ",
+        "bbox": [
+            176,
+            195,
+            823,
+            227
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "DETAILS IN EXPERIMENT 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            246,
+            403,
+            261
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We changed the order of the ReLU layer and the mask layer after the top conv-layer, i.e. placing the mask layer between the ReLU layer and the top conv-layer. According to (Zhang et al., 2018b), this operation did not affect the performance of the pre-trained performer. We used the output of the mask layer as $x$ and plugged $x$ to Equation (5) to compute $\\{ y _ { i } \\}$ . ",
+        "bbox": [
+            173,
+            276,
+            825,
+            333
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Because the distillation process did not use any ground-truth class labels, the explainer’s output $\\textstyle \\sum _ { i } { \\alpha _ { i } y _ { i } + b }$ was not sophisticatedly learned for classification. Thus, we used a threshold $\\sum _ { i } \\alpha _ { i } y _ { i } +$ $b \\ > \\ \\tau \\ ( \\tau \\ \\approx \\ 0 )$ , instead of 0, as the decision boundary for classification. $\\tau$ was selected as the one that maximized the accuracy. Such experimental settings made a fairer comparison between the performer and the explainer. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            410
+        ],
+        "page_idx": 18
+    }
+]