Add files using upload-large-folder tool

parse/train/9GsFOUyUPi/9GsFOUyUPi.md

@@ -0,0 +1,406 @@
+# PROGRESSIVE SKELETONIZATION: TRIMMING MORE FAT FROM A NETWORK AT INITIALIZATION
+
+Pau de Jorge∗ University of Oxford & NAVER LABS Europe†
+
+Amartya Sanyal University of Oxford & The Alan Turing Institute, London, UK
+
+Harkirat S. Behl University of Oxford
+
+Philip H. S. Torr University of Oxford
+
+Grégory Rogez NAVER LABS Europe
+
+Puneet K. Dokania University of Oxford & Five AI Limited
+
+# ABSTRACT
+
+Recent studies have shown that skeletonization (pruning parameters) of networks at initialization provides all the practical benefits of sparsity both at inference and training time, while only marginally degrading their performance. However, we observe that beyond a certain level of sparsity (approx $9 5 \%$ ), these approaches fail to preserve the network performance, and to our surprise, in many cases perform even worse than trivial random pruning. To this end, we propose an objective to find a skeletonized network with maximum foresight connection sensitivity (FORCE) whereby the trainability, in terms of connection sensitivity, of a pruned network is taken into consideration. We then propose two approximate procedures to maximize our objective (1) Iterative SNIP: allows parameters that were unimportant at earlier stages of skeletonization to become important at later stages; and (2) FORCE: iterative process that allows exploration by allowing already pruned parameters to resurrect at later stages of skeletonization. Empirical analysis on a large suite of experiments show that our approach, while providing at least as good a performance as other recent approaches on moderate pruning levels, provide remarkably improved performance on higher pruning levels (could remove up to $9 9 . 5 \%$ parameters while keeping the networks trainable).
+
+# 1 INTRODUCTION
+
+The majority of pruning algorithms for Deep Neural Networks require training dense models and often fine-tuning sparse sub-networks in order to obtain their pruned counterparts. In Frankle & Carbin (2019), the authors provide empirical evidence to support the hypothesis that there exist sparse sub-networks that can be trained from scratch to achieve similar performance as the dense ones. However, their method to find such sub-networks requires training the full-sized model and intermediate sub-networks, making the process much more expensive.
+
+Recently, Lee et al. (2019) presented SNIP. Building upon almost a three decades old saliency criterion for pruning trained models (Mozer & Smolensky, 1989), they are able to predict, at initialization, the importance each weight will have later in training. Pruning at initialization methods are much cheaper than conventional pruning methods. Moreover, while traditional pruning methods can help accelerate inference tasks, pruning at initialization may go one step further and provide the same benefits at train time Elsen et al. (2020).
+
+Wang et al. (2020) (GRASP) noted that after applying the pruning mask, gradients are modified due to non-trivial interactions between weights. Thus, maximizing SNIP criterion before pruning might be sub-optimal. They present an approximation to maximize the gradient norm after pruning, where they treat pruning as a perturbation on the weight matrix and use the first order Taylor’s approximation. While they show improved performance, their approximation involves computing a Hessian-vector product which is expensive both in terms of memory and computation.
+
+![](images/ba3922794f20bd64c31072a7397cfcfc21be6a6c4358b48849b4ca9f0c55dffa.jpg)  
+Figure 1: Test accuracies on CIFAR-10 (ResNet50) for different pruning methods. Each point is the average over 3 runs of prune-train-test. The shaded areas denote the standard deviation of the runs (too small to be visible in some cases). Random corresponds to removing connections uniformly.
+
+We argue that both SNIP and GRASP approximations of the gradients after pruning do not hold for high pruning levels, where a large portion of the weights are removed at once. In this work, while we rely on the saliency criteria introduced by Mozer & Smolensky (1989), we optimize what this saliency would be after pruning, rather than before. Hence, we name our criteria Foresight Connection sEnsitivity (FORCE). We introduce two approximate procedures to progressively optimize our objective. The first, which turns out to be equivalent to applying SNIP iteratively, removes a small fraction of weights at each step and re-computes the gradients after each pruning round. This allows to take into account the intricate interactions between weights, re-adjusting the importance of connections at each step. The second procedure, which we name FORCE, is also iterative in nature, but contrary to the first, it allows pruned parameters to resurrect. Hence, it supports exploration, which otherwise is not possible in the case of iterative SNIP. Moreover, one-shot SNIP can be viewed as a particular case of using only one iteration. Empirically, we find that both SNIP and GRASP have a sharp drop in performance when targeting higher pruning levels. Surprisingly, they perform even worse than random pruning as can be seen in Fig 1. In contrast, our proposed pruning procedures prove to be significantly more robust on a wide range of pruning levels.
+
+# 2 RELATED WORK
+
+Pruning trained models Most of the pruning works follow the train – prune – fine-tune cycle (Mozer & Smolensky, 1989; LeCun et al., 1990; Hassibi et al., 1993; Han et al., 2015; Molchanov et al., 2017; Guo et al., 2016), which requires training the dense network until convergence, followed by multiple iterations of pruning and fine-tuning until a target sparsity is reached. Particularly, Molchanov et al. (2017) present a criterion very similar to Mozer & Smolensky (1989) and therefore similar to Lee et al. (2019) and our FORCE, but they focus on pruning whole neurons, and involve training rounds while pruning. Frankle & Carbin (2019) and Frankle et al. (2020) showed that it was possible to find sparse sub-networks that, when trained from scratch or an early training iteration, were able to match or even surpass the performance of their dense counterparts. Nevertheless, to find them they use a costly procedure based on Han et al. (2015). All these methods rely on having a trained network, thus, they are not applicable before training. In contrast, our algorithm is able to find a trainable sub-network with randomly initialized weights. Making the overall pruning cost much cheaper and presenting an opportunity to leverage the sparsity during training as well.
+
+Induce sparsity during training Another popular approach has been to induce sparsity during training. This can be achieved by modifying the loss function to consider sparsity as part of the optimization (Chauvin, 1989; Carreira-Perpiñán & Idelbayev, 2018; Louizos et al., 2018) or by dynamically pruning during training (Bellec et al., 2018; Mocanu et al., 2018; Mostafa & Wang, 2019; Dai et al., 2019; Dettmers & Zettlemoyer, 2020; Lin et al., 2020; Kusupati et al., 2020; Evci et al., 2019). These methods are usually cheaper than pruning after training, but they still need to train the network to select the final sparse sub-network. We focus on finding sparse sub-networks before any weight update, which is not directly comparable.
+
+Pruning at initialization These methods present a significant leap with respect to other pruning methods. While traditional pruning mechanisms focused on bringing speed-up and memory reduction at inference time, pruning at initialization methods bring the same gains both at training and inference time. Moreover, they can be seen as a form of Neural Architecture Search (Zoph & Le, 2016) to find more efficient network topologies. Thus, they have both a theoretical and practical interest.
+
+Lee et al. (2019) presented SNIP, a method to estimate, at initialization, the importance that each weight could have later during training. SNIP analyses the effect of each weight on the loss function when perturbed at initialization. In Lee et al. (2020), the authors studied pruning at initialization from a signal propagation perspective, focusing on the initialization scheme. Recently, Wang et al. (2020) proposed GRASP, a different method based on the gradient norm after pruning and showed a significant improvement for higher levels of sparsity. However, neither SNIP nor GRASP perform sufficiently well when larger compressions and speed-ups are required and a larger fraction of the weights need to be pruned. In this paper, we analyse the approximations made by SNIP and GRASP, and present a more suitable solution to maximize the saliency after pruning.
+
+# 3 PROBLEM FORMULATION: PRUNING AT INITIALIZATION
+
+Given a dataset $\mathbf { \mathcal { D } } = \{ ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ) \} _ { i = 1 } ^ { n }$ , the training of a neural network $f$ parameterized by $\pmb { \theta } \in \mathbb { R } ^ { m }$ can be written as minimizing the following empirical risk:
+
+$$
+\underset { \pmb { \theta } } { \arg \operatorname* { m i n } } \ \frac { 1 } { n } \sum _ { i } \mathcal { L } ( ( f ( \mathbf { x } _ { i } ; \pmb { \theta } ) ) , \mathbf { y } _ { i } ) \quad \mathrm { s . t . } \pmb { \theta } \in \mathcal { C } ,
+$$
+
+where $\mathcal { L }$ and $\mathcal { C }$ denote the loss function and the constraint set, respectively. Unconstrained (standard) training corresponds to ${ \mathcal { C } } = \mathbb { R } ^ { m }$ . Assuming we have access to the gradients (batch-wise) of the empirical risk, an optimization algorithm (e.g. SGD) is generally used to optimize the above objective, that, during the optimization process, produces a sequence of iterates $\textcircled { \pmb { \theta } } _ { i } \rbrace _ { i = 0 } ^ { T }$ , where $\pmb { \theta } _ { 0 }$ and $\pmb { \theta } _ { T }$ denote the initial and the final (optimal) parameters, respectively. Given a target sparsity level of $k < m$ , the general parameter pruning problem involves $\mathcal { C }$ with a constraint $\lVert \pmb { \theta } _ { T } \rVert _ { 0 } \leq k$ , i.e., the final optimal iterate must have a maximum of $k$ non-zero elements. Note that there is no such constraint with the intermediate iterates.
+
+Pruning at initialization, the main focus of this work, adds further restrictions to the above mentioned formulation by constraining all the iterates to lie in a fixed subspace of $\mathcal { C }$ . Precisely, the constraints are to find an initialization $\pmb { \theta } _ { 0 }$ such that $\lVert \pmb \theta _ { 0 } \rVert _ { 0 } \le k ^ { 1 }$ , and the intermediate iterates are $\pmb { \theta } _ { i } \in \bar { \mathcal { C } } \subset \mathcal { C }$ , $\forall i \in$ $\{ 1 , \ldots , T \}$ , where $\bar { \mathcal { C } }$ is the subspace of $\mathbb { R } ^ { m }$ spanned by the natural basis vectors $\{ \mathbf { e } _ { j } \} _ { j \in \mathtt { s u p p } ( \pmb { \theta } _ { 0 } ) }$ Here, ${ \tt s u p p } ( \pmb { \theta } _ { 0 } )$ denotes the support of $\pmb { \theta } _ { 0 }$ , i.e., the set of indices with non-zero entries. The first condition defines the sub-network at initialization with $k$ parameters, and the second fixes its topology throughout the training process. Since there are $\binom { m } { k }$ such possible sub-spaces, exhaustive search to find the optimal sub-space to optimize (1) is impractical as it would require training $\binom { m } { k }$ neural networks. Below we discuss two recent approaches that circumvent this problem by maximizing a hand-designed data-dependent objective function. These objectives are tailored to preserve some relationships between the parameters, the loss, and the dataset, that might be sufficient to obtain a reliable $\pmb { \theta } _ { 0 }$ . For the ease of notation, we will use $\pmb \theta$ to denote the dense initialization.
+
+SNIP Lee et al. (2019) present a method based on the saliency criterion from Mozer & Smolensky (1989). They add a key insight and show this criteria works surprisingly well to predict, at initialization, the importance each connection will have during training. The idea is to preserve the parameters that will have maximum impact on the loss when perturbed. Let $\pmb { c } \in \{ 0 , 1 \} ^ { m }$ be a binary vector, and $\odot$ the Hadamard product. Then, the connection sensitivity in SNIP is computed as:
+
+$$
+\pmb { \mathscr { g } } ( \pmb { \theta } ) : = \left. \frac { \partial \mathcal { L } ( \pmb { \theta } \odot \pmb { c } ) } { \partial \pmb { c } } \right| _ { \pmb { c } = 1 } = \frac { \partial \mathcal { L } ( \pmb { \theta } ) } { \partial \pmb { \theta } } \odot \pmb { \theta } .
+$$
+
+Once $\pmb { g } ( \pmb { \theta } )$ is obtained, the parameters corresponding to the top- $k$ values of $| g ( \pmb \theta ) _ { i } |$ are then kept. Intuitively, SNIP favors those weights that are far from the origin and provide high gradients (irrespective of the direction). We note that SNIP objective can be written as the following problem:
+
+$$
+\operatorname* { m a x } _ { c } S ( \pmb { \theta } , { \pmb { c } } ) : = \sum _ { i \in \mathrm { s u p p } ( { \pmb { c } } ) } | \theta _ { i } \nabla \mathcal { L } ( \pmb { \theta } ) _ { i } | \mathrm { s . t . } { \pmb { c } } \in \{ 0 , 1 \} ^ { m } , \| { \pmb { c } } \| _ { 0 } = k .
+$$
+
+It is trivial to note that the optimal solution to the above problem can be obtained by selecting the indices corresponding to the top- $k$ values of $| \theta _ { i } \nabla \mathcal { L } ( \theta ) _ { i } |$ .
+
+GRASP Wang et al. (2020) note that the SNIP saliency is measuring the connection sensitivity of the weights before pruning, however, it is likely to change after pruning. Moreover, they argue that, at initialization, it is more important to preserve the gradient signal than the loss itself. They propose to use as saliency the gradient norm of the loss $\Delta \mathcal { L } ( \mathbf { \bar { \boldsymbol { \theta } } } ) = \nabla \mathcal { L } ( \mathbf { \bar { \boldsymbol { \theta } } } ) ^ { T } \nabla \mathcal { L } ( \mathbf { \boldsymbol { \theta } } )$ , but measured after pruning. To maximize it, Wang et al. (2020) adopt the same approximation introduced in LeCun et al. (1990) and treat pruning as a perturbation on the initial weights. Their method is equivalent to solving:
+
+$$
+\operatorname* { m a x } _ { c } G ( \theta , c ) : = \sum _ { \left\{ i : c _ { i } = 0 \right\} } - \theta _ { i } \left[ \mathbf { H } \mathbf { g } \right] _ { i } \mathrm { ~ s . t . ~ } c \in \{ 0 , 1 \} ^ { m } , \| c \| _ { 0 } = k .
+$$
+
+Where $\mathbf { H }$ and $\mathbf { g }$ denote the Hessian and the gradient of the loss respectively.
+
+# 4 FORESIGHT CONNECTION SENSITIVITY
+
+Since removing connections of a neural network will have significant impact on its forward and backward signals, we are interested in obtaining a pruned network that is easy to train. We use connection sensitivity of the loss function as a proxy for the so-called trainability of a network. To this end, we first define connection sensitivity after pruning which we name Foresight Connection sEnsitivity (FORCE), and then propose two procedures to optimize it in order to obtain the desired pruned network. Let $\bar { \pmb { \theta } } = \pmb { \theta } \odot \bar { \pmb { c } }$ denotes the pruned parameters once a binary mask $^ c$ with $\| \boldsymbol { c } \| _ { 0 } =$ $k \leq m$ is applied. The FORCE at $\bar { \pmb { \theta } }$ for a given mask $\hat { c }$ is then obtained as:
+
+$$
+g ( \bar { \theta } ) : = \left. \frac { \partial \mathcal { L } ( \bar { \theta } ) } { \partial c } \right| _ { c = \hat { c } } = \left. \frac { \partial \mathcal { L } ( \bar { \theta } ) } { \partial \bar { \theta } } \right| _ { c = \hat { c } } \odot \left. \frac { \partial \bar { \theta } } { \partial c } \right| _ { c = \hat { c } } = \left. \frac { \partial \mathcal { L } ( \bar { \theta } ) } { \partial \bar { \theta } } \right| _ { c = \hat { c } } \odot \theta .
+$$
+
+The last equality is obtained by rewriting $\bar { \pmb { \theta } }$ as $\mathrm { d i a g } ( \pmb { \theta } ) \pmb { c }$ , where $\operatorname { d i a g } ( \pmb \theta )$ is a diagonal matrix with $\pmb \theta$ as its elements, and then differentiating w.r.t. $^ c$ . Note, when $k < m$ , the sub-network $\bar { \pmb { \theta } }$ is obtained by removing connections corresponding to all the weights for which the binary variable is zero. Therefore, only the weights corresponding to the indices for which $\mathbf { \boldsymbol { c } } ( i ) = 1$ contribute in equation (5), all other weights do not participate in forward and backward propagation and are to be ignored. We now discuss the crucial differences between our formulation (5), SNIP (2) and GRASP (4).
+
+• When $\hat { c } = { \bf 1 }$ , the formulation is exactly the same as the connection sensitivity used in SNIP. However, $\hat { c } = { \bf 1 }$ is too restrictive in the sense that it assumes that all the parameters are active in the network and they are removed one by one with replacement, therefore, it fails to capture the impact of removing a group of parameters. Our formulation uses weights and gradients corresponding to $\bar { \pmb { \theta } }$ thus, compared to SNIP, provides a better indication of the training dynamics of the pruned network. However, GRASP formulation is based on the assumption that pruning is a small perturbation on the Gradient Norm which, also shown experimentally, is not always a reliable assumption. When $\left\| \hat { \pmb { c } } \right\| _ { 0 } \ll \| \mathbf { 1 } \| _ { 0 }$ , i.e., extreme pruning, the gradients before and after pruning will have very different values as $\lVert \pmb \theta \odot \hat { \pmb c } \rVert _ { 2 } \ll \lVert \pmb \theta \rVert _ { 2 }$ , making SNIP and GRASP unreliable (empirically we find SNIP and GRASP fail in the case of high sparsity).
+
+FORCE saliency Note FORCE (5) is defined for a given sub-network which is unknown a priori, as our objective itself is to find the sub-network with maximum connection sensitivity. Similar to the reformulation of SNIP in (3), the objective to find such sub-network corresponding to the foresight connection sensitivity can be written as:
+
+$$
+\operatorname* { m a x } _ { c } S ( \pmb { \theta } , \pmb { c } ) : = \sum _ { i \in \mathrm { s u p p } ( \pmb { c } ) } \left| \theta _ { i } \nabla \mathcal { L } ( \pmb { \theta } \odot \pmb { c } ) _ { i } \right| \mathrm { ~ s . t . ~ } \pmb { c } \in \{ 0 , 1 \} ^ { m } , \| \pmb { c } \| _ { 0 } = k .
+$$
+
+Here $\nabla { \mathcal { L } } ( \pmb { \theta } \odot \mathbf { c } ) _ { i }$ represents the $i$ -th index of $\left. \frac { \partial \mathcal { L } ( \bar { \pmb { \theta } } ) } { \partial \bar { \pmb { \theta } } } \right| _ { c }$ . As opposed to (3), finding the optimal solution of (6) is non trivial as it requires computing the gradients of all possible $\binom { m } { k }$ sub-networks in order to find the one with maximum sensitivity. To this end, we present two approximate solutions to the above problem that primarily involve (i) progressively increasing the degree of pruning, and (ii) solving an approximation of (6) at each stage of pruning.
+
+Progressive Pruning (Iterative SNIP) Let $k$ be the number of parameters to be kept after pruning. Let us assume that we know a schedule (will be discussed later) to divide $k$ into a set of natural numbers $\{ k _ { t } \} _ { t = 1 } ^ { T }$ such that $k _ { t } > k _ { t + 1 }$ and $k _ { T } = k$ . Now, given the mask $c _ { t }$ corresponding to $k _ { t }$ , pruning from $k _ { t }$ to $k _ { t + 1 }$ can be formulated using the connection sensitivity (5) as:
+
+$$
+\begin{array} { r } { c _ { t + 1 } = \underset { c } { \arg \operatorname* { m a x } } \ S ( \bar { \theta } , c ) \mathrm { ~ s . t . ~ } c \in \{ 0 , 1 \} ^ { m } , \ \left. c \right. _ { 0 } = k _ { t + 1 } , \ c \odot c _ { t } = c , } \end{array}
+$$
+
+where $\bar { \pmb { \theta } } = \pmb { \theta } \odot \pmb { c } _ { t }$ . The additional constraint $\mathbf { \boldsymbol { c } } \odot \mathbf { \boldsymbol { c } } _ { t } = \mathbf { \boldsymbol { c } }$ ensures that no parameter that had been pruned earlier is activated again. Assuming that the pruning schedule ensures a smooth transition from one topology to another $( \left\| \pmb { c } _ { t } \right\| _ { 0 } \approx \left\| \pmb { c } _ { t + 1 } \right\| _ { 0 } )$ such that the gradient approximation $\begin{array} { r } { \left. \frac { \partial \mathcal { L } ( \bar { \pmb { \theta } } ) } { \partial \bar { \pmb { \theta } } } \right| _ { \pmb { c } _ { t } } \approx \left. \frac { \partial \mathcal { L } ( \bar { \pmb { \theta } } ) } { \partial \bar { \pmb { \theta } } } \right| _ { \pmb { c } _ { t + 1 } } } \end{array}$ is valid, (7) can be approximated as solving (3) at $\bar { \pmb { \theta } }$ . Thus, for a given schedule over $k$ , our first approximate solution to (6) involves solving (3) iteratively. This allows re-assessing the importance of connections after changing the sub-network. For a schedule with $T = 1$ , we recover SNIP where a crude gradient approximation between the dense network $\mathbf { c } _ { 0 } = \mathbf { 1 }$ and the final mask $^ c$ is being used. This approach of ours turns out to be algorithmically similar to a concurrent work (Verdenius et al., 2020). However, our motivation comes from a novel objective function (5) which also gives place to our second approach (FORCE). Tanaka et al. (2020) also concurrently study the effect of iterative pruning and report, similar to our findings, pruning progressively is needed for high sparsities.
+
+Progressive Sparsification (FORCE) The constraint $\mathbf { \boldsymbol { c } } \odot \mathbf { \boldsymbol { c } } _ { t } = \mathbf { \boldsymbol { c } }$ in (7) (Iterative SNIP) might be restrictive in the sense that while re-assessing the importance of unpruned parameters, it does not allow previously pruned parameters to resurrect (even if they could become important). This hinders exploration which can be unfavourable in finding a suitable sub-network. Here we remove this constraint, meaning, the weights for which $\boldsymbol { c } ( i ) = \bar { 0 }$ are not removed from the network, rather they are assigned a value of zero. Therefore, while not contributing to the forward signal, they might have a non-zero gradient. This relaxation modifies the saliency in (5) whereby the gradient is now computed at a sparsified network instead of a pruned network. Similar to the above approach, we sparsify the network progressively and once the desired sparsity is reached, all connections with $\bar { \mathbf { \Psi } } \bar { \mathbf { c } } ( i ) = \mathbf { \bar { 0 } }$ are pruned. Note, the step of removing zero weights is valid if removing such connections does not adversely impact the gradient flow of the unpruned parameters. We, in fact, found it to be true in our experiments shown in Fig 7 (Appendix). However, this assumption might not hold always.
+
+An overview of Iterative SNIP and FORCE is presented in Algorithm 1.
+
+Sparsity schedule Both the above discussed iterative procedures approximately optimize (5), however, they depend on a sparsity/pruning schedule favouring small steps to be able to reliably apply the mentioned gradient approximation. One such valid schedule would be where the portion of newly removed weights with respect to the remaining weights is small. We find a simple exponential decay schedule, defined below, to work very well on all our experiments:
+
+$$
+{ \mathrm { p ~ m o d e : ~ } } k _ { t } = \exp \left\{ \alpha \log k + ( 1 - \alpha ) \log m \right\} , \ \alpha = { \frac { t } { T } } .
+$$
+
+In section 5.3 we empirically show that these methods are very robust to the hyperparameter $T$ .
+
+Some theoretical insights When pruning weights gradually, we are looking for the best possible sub-network in a neighbourhood defined by the previous mask and the amount of weights removed at that step. The problem being non-convex and non-smooth makes it challenging to prove if the mask
+
+Algorithm 1 FORCE/Iter SNIP algorithms to find a pruning mask
+
+1: Inputs: Training set $\mathcal { D }$ , final sparsity $k$ , number of steps $T$ , weights $\pmb { \theta } _ { 0 } \in \mathbb { R } ^ { m }$ .   
+2: Obtain $\{ k _ { t } \} _ { t = 1 : T }$ using the chosen schedule (refer to Eq (8))   
+3: Define intial mask $\mathbf { c _ { 0 } = 1 }$   
+4: for $t = 0 , \ldots , T - 1$ do   
+5: Sample mini-batch $\{ z _ { i } \} _ { i = 1 } ^ { n }$ from $\mathcal { D }$   
+6: Define $\bar { \pmb { \theta } } = \pmb { \theta } \odot \pmb { c } _ { t }$ (as sparsified (FORCE) vs pruned (Iter SNIP) network)   
+7: Compute $\pmb { g } ( \bar { \pmb { \theta } } )$ (refer to Eq (5) )   
+8: $I = \{ i _ { 1 } , \dots , i _ { k _ { t + 1 } } \}$ are top- $k _ { t + 1 }$ values of $\left| g _ { i } \right|$   
+9: Build $c _ { t + 1 }$ by setting to 0 all indices not included in $I$ .   
+10: end for   
+11: Return: $c _ { T }$ .
+
+obtained by our method is globally optimal. However, in Appendix D we prove that each intermediate mask obtained with Iterative SNIP is indeed an approximate local minima, where the degree of sub-optimality increases with the pruning step size. This gives some validation on why SNIP fails on higher sparsity. We can not provide the same guarantees for FORCE (there is no obvious link between the step size and the distance between masks), nevertheless, we empirically observe that FORCE is quite robust and more often than not improves over the performance of Iterative SNIP, which is not able to recover weights once pruned. We present further analysis in Appendix C.4.
+
+# 5 EXPERIMENTS
+
+In the following we evaluate the efficacy of our approaches accross different architectures and datasets.   
+Training settings, architecture descriptions, and implementation details are provided in Appendix A.
+
+# 5.1 RESULTS ON CIFAR-10
+
+Fig 2 compares the accuracy of the described iterative approaches with both SNIP and GRASP. We also report the performance of a dense and a random pruning baseline. Both SNIP and GRASP consider a single batch to approximate the saliencies, while we employ a different batch of data at each stage of our gradual skeletonization process. For a fair comparison, and to understand how the number of batches impacts performance, we also run these methods averaging the saliencies over $T$ batches, where $T$ is the number of iterations. SNIP-MB and GRASP-MB respectively refer to these multi-batch (MB) counterparts. In these experiments, we use $T = 3 0 0$ . We study the hyper-parameter robustness regarding $T$ later in section 5.3.
+
+![](images/32ae3d8e970d3d96e95e4913d95d9fce042a50161dfcde406b9c09285a092db6.jpg)  
+Figure 2: Test accuracies on CIFAR-10 for different pruning methods. With increased number of batches (-MB) one-shot methods are more robust at higher sparsity levels, but our gradual pruning approaches can go even further. Moreover, FORCE consistently reaches higher accuracy than other methods across most sparsity levels. Each point is an average of $\geq 3$ runs of prune-train-test. The shaded areas denote the standard deviation of the runs (too small to be visible in some cases). Note that in (b), GRASP and GRASP-MB overlap.
+
+We observe that for moderate sparsity levels, one batch is sufficient for both SNIP and GRASP as reported in Lee et al. (2019); Wang et al. (2020). However, as we increase the level of sparsity, the performance of SNIP and GRASP degrades dramatically. For example, at $9 9 . 0 \%$ sparsity, SNIP drops down to $1 0 \%$ accuracy for both ResNet50 and VGG19, which is equivalent to random guessing as there are 10 classes. Note, in the case of randomly pruned networks, accuracy is nearly $\bar { 7 } 5 \%$ and $8 2 \%$ for ResNet50 and VGG19, respectively, which is significantly better than the performance of SNIP. However, to our surprise, just using multiple batches to compute the connection sensitivity used in SNIP improves it from $1 0 \%$ to almost $9 0 \%$ . This clearly indicates that a better approximation of the connection sensitivity is necessary for good performance in the case of high sparsity regime. Similar trends, although not this extreme, can be observed in the case of GRASP as well. On the other hand, gradual pruning approaches are much more robust in terms of sparsity for example, in the case of $9 9 . { \bar { 9 } } \%$ pruning, while one-shot approaches perform as good as a random classifier (nearly $1 0 \%$ accuracy), both FORCE and Iterative SNIP obtain more than $8 0 \%$ accuracy. While the accuracies obtained at higher sparsities might have degraded too much for some use cases, we argue this is an encouraging result, as no approach before has pruned a network at initialization to such extremes while keeping the network trainable and these results might encourage the community to improve the performance further. Finally, gradual pruning methods consistently improve over other methods even at moderate sparsity levels (refer to Fig 5), this motivates the use of FORCE or Iterative SNIP instead of other methods by default at any sparsity regime. Moreover, the additional cost of using iterative pruning instead of SNIP-MB is negligible compared to the cost of training and is significantly cheaper than GRASP-MB, further discussed in section 5.3.
+
+![](images/ff11ed6c70a4393fea4dc1aba0d965cdfd05ac6875771c946b2f6733a5aea11e.jpg)  
+Figure 3: Test accuracies on CIFAR-100 and Tiny Imagenet for different pruning methods. Each point is the average over 3 runs of prune-train-test. The shaded areas denote the standard deviation of the runs (too small to be visible in some cases).
+
+# 5.2 RESULTS ON LARGER DATASETS
+
+We now present experiments on large datasets. Wang et al. (2020) and Lee et al. (2019) suggest using a batch of size ${ \sim } 1 0$ times the number of classes, which is very large in these experiments. Instead, for memory efficiency, we average the saliencies over several mini-batches. For CIFAR100 and Tiny-ImageNet, we average 10 and 20 batches per iteration respectively, with 128 examples per batch. As we increase the number of batches per iteration, computing the pruning mask becomes more expensive. From Fig 4, we observe that the accuracy converges after just a few iterations. Thus, for the following experiments we used 60 iterations. For a fair comparison, we run SNIP and GRASP with $T \times B$ batches, where $T$ is the number of iterations and $B$ the number of batches per iteration in our method. We find the results, presented in Fig 3, consistent with trends in CIFAR-10.
+
+In the case of Imagenet, we use a batch size of 256 examples and 40 batches per iteration. We use the official implementation of VGG19 with batch norm and Resnet50 from Paszke et al. (2017). As presented in Table 1, gradual pruning methods are consistently better than SNIP, with a larger gap as we increase sparsity. We would like to emphasize that FORCE is able to prune $9 0 \%$ of the weights of VGG while losing less than $3 \%$ of the accuracy, we find this remarkable for a method that prunes before any weight update. Interestingly, GRASP performs better than other methods at $9 5 \%$ sparsity (VGG), moreover, it also slightly surpasses FORCE for Resnet50 at $90 \%$ , however, it under-performs random pruning at $9 5 \%$ . In fact, we find all other methods to perform worse than random pruning for Resnet50. We hypothesize that, for a much more challenging task (Imagenet with 1000 classes), Resnet50 architecture might not be extremely overparametrized. For instance,
+
+Table 1: Test accuracies on Imagenet for different pruning methods and sparsities.   
+
+<table><tr><td>Network</td><td colspan="4">VGG19</td><td colspan="4">Resnet50</td></tr><tr><td>Sparsity percentage</td><td colspan="2">90%</td><td colspan="2">95%</td><td colspan="2">90%</td><td colspan="2">95%</td></tr><tr><td>Accuracy</td><td>Top-1</td><td>Top-5</td><td>Top-1</td><td>Top-5</td><td>Top-1</td><td>Top-5</td><td>Top-1</td><td>Top-5</td></tr><tr><td>(Baseline)</td><td>73.1</td><td>91.3</td><td></td><td></td><td>75.6</td><td>92.8</td><td></td><td></td></tr><tr><td>FORCE (Ours)</td><td>70.2</td><td>89.5</td><td>65.8</td><td>86.8</td><td>64.9</td><td>86.5</td><td>59.0</td><td>82.3</td></tr><tr><td>Iter SNIP (Ours)</td><td>69.8</td><td>89.5</td><td>65.9</td><td>86.9</td><td>63.7</td><td>85.5</td><td>54.7</td><td>78.9</td></tr><tr><td>GRASP Wang et al. (2020)</td><td>69.5</td><td>89.2</td><td>67.6</td><td>87.8</td><td>65.4</td><td>86.7</td><td>46.2</td><td>66.0</td></tr><tr><td>SNIP Lee et al. (2019)</td><td>68.5</td><td>88.8</td><td>63.8</td><td>86.0</td><td>61.5</td><td>83.9</td><td>44.3</td><td>69.6</td></tr><tr><td>Random</td><td>64.2</td><td>86.0</td><td>56.6</td><td>81.0</td><td>64.6</td><td>86.0</td><td>57.2</td><td>80.8</td></tr></table>
+
+![](images/1f32e408cc2d391823461cfa36c40447f4cb419570cbc4b6ef418e23f8b86445.jpg)  
+Figure 4: Left: FORCE saliency (6) obtained with (7) when varying $T$ normalized by the saliency with one-shot SNIP $T = 1$ ). Pruning iteratively brings more gains for higher sparsity levels. Error bars not shown for better visualization. Middle: Test acc pruning with FORCE and Iter SNIP at $9 9 . 5 \%$ sparsity for different $T$ . Both methods are extremely robust to the choice of $T$ . Right: Wall time to compute pruning masks for CIFAR10/Resnet50/TeslaK40m vs acc at $9 9 . 5 \%$ sparsity; $( x \ b )$ means we used $x$ batches to compute the gradients while $\scriptstyle { \dot { x } }$ it) denotes we used $x$ pruning iterations, with one batch per iteration. Numbers in red indicate performance below random pruning.
+
+VGG19 has 143.68M parameters while Resnet50 uses 25.56M (refer to Table 2). On the other hand, the fact that random pruning can yield relatively trainable architectures for these sparsity levels is somewhat surprising and might indicate that there still is room for improvement in this direction. Results seem to indicate that the FORCE saliency is a step in the right direction and we hypothesize further improvements on its optimization might lead to even better performance. In Appendix C.6, we show superior performance of our approach on the Mobilenet-v2 architecture (Sandler et al., 2018) as well, which is much more "slim" than Resnet and VGG 2.
+
+# 5.3 ANALYSIS
+
+Saliency optimization To experimentally validate our approach (7), we conduct an ablation study where we compute the FORCE saliency after pruning (5) while varying the number of iterations $T$ for different sparsity levels. In Fig 4 (left) we present the relative change in saliency as we vary the number of iterations $T$ , note when $T = 1$ we recover one-shot SNIP. As expected, for moderate levels of sparsity, using multiple iterations does not have a significant impact on the saliency. Nevertheless, as we target higher sparsity levels, we can see that the saliency can be better optimized when pruning iteratively. In Appendix C.1 we include results for FORCE where we observe similar trends.
+
+Hyperparameter robustness As shown in Figures 2 and 3, for low sparsity levels, all methods are comparable, but as we move to higher sparsity levels, the gap becomes larger. In Fig 4 (middle) we fix sparsity at $9 9 . 5 \%$ and study the accuracy as we vary the number of iterations $T$ . Each point is averaged over 3 trials. SNIP $T = 1$ ) yields sub-networks unable to train $10 \%$ acc), but as we move to iterative pruning $( T > 1$ ) accuracy increases up to $90 \%$ for FORCE and $89 \%$ for Iter SNIP. Moreover, accuracy is remarkably robust to the choice of $T$ , the best performance for both FORCE and Iter SNIP is with more iterations, however a small number of iterations already brings a huge boost. This suggests these methods might be used by default by a user without worrying too much about hyper-parameter tuning, easily adapting the amount of iterations to their budget.
+
+Pruning cost As shown in Fig 2, SNIP performance quickly degrades beyond $9 5 \%$ sparsity. Wang et al. (2020) suggested GRASP as a more robust alternative, however, it needs to compute a Hessian vector product which is significantly more expensive in terms of memory and time. In Fig 4 (right), we compare the time cost of different methods to obtain the pruning masks along with the corresponding accuracy. We observe that both SNIP and GRASP are fragile when using only one batch (red accuracy indicates performance below random baseline). When using multiple batches their robustness increases, but so does the pruning cost. Moreover, we find that gradual pruning based on the FORCE saliency is much cheaper than GRASP-MB when using equal amount of batches, this is because GRASP involves an expensive Hessian vector product. Thus, FORCE (or Iterative SNIP) would be preferable over GRASP-MB even when they have comparable accuracies.
+
+FORCE vs Iterative SNIP Empirically, we find that FORCE tends to outperform Iter SNIP more often than not, suggesting that allowing weights to recover is indeed beneficial despite having less theoretical guarantees (see gradient approximation in Section 4). Thus, we would make FORCE algorithm our default choice, especially for Resnet architectures. In Appendix C.4 we empirically observe two distinct phases when pruning with FORCE. The first one involves exploration (early phase) when the amount of pruned and recovered weights seem to increase, indicating exploration of masks that are quite different from each other. The second, however, shows rapid decrease in weight recovery, indicating a phase where the algorithm converges to a more constrained topology. As opposed to Iter SNIP, the possibility of the exploration of many possible sub-networks before converging to a final topology might be the reason behind the slightly improved performance of FORCE. But this exploration comes at a price, in Fig 4 (middle and left) we observe how, despite FORCE reaching a higher accuracy when using enough steps, if we are under a highly constrained computational budget and can only afford a few pruning iterations, Iter SNIP is more likely to obtain a better pruning mask. This is indeed expected as FORCE might need more iterations to converge to a good sub-space, while Iter SNIP will be forced to converge by construction. A combination of FORCE and Iter SNIP might lead to an even better approach, we leave this for future work.
+
+Early pruning as an additional baseline Our gradual pruning approaches (SNIP-MB and GRASPMB as well) use multiple batches to obtain a pruned mask, considering that pruning can be regarded as a form of training (Mallya et al., 2018), we create another baseline for the sake of completeness. We train a network for one epoch, a similar number of iterations as used by our approach, and then use magnitude pruning to obtain the final mask, we call this approach early pruning (more details in Appendix C.5). Interestingly, we find that early pruning tends to perform worse than SNIP-MB (and gradual pruning) for Resnet, and shows competitive performance at low sparsity level for VGG but with a sharp drop in the performance as the sparsity level increases. Even though these experiments support the superiority of our approach, we would like to emphasize that they do not conclude that any early pruning strategy would be suboptimal compared to pruning at initialization as an effective approach in this direction might require devising a well thought objective function.
+
+Iterative pruning to maximize the Gradient Norm In Sec 4, we have seen Iterative SNIP can be used to optimize the FORCE saliency. We also tried to use GRASP iteratively, however, after a few iterations the resulting networks were not trainable. Interestingly, if we apply the gradient approximation to GRASP saliency (instead of Taylor), we can come up with a different iterative approximation to maximize the gradient norm after pruning. We empirically observe this method is more robust than GRASP to high sparsity levels. This suggests that 1) Iterative pruning, although beneficial, can not be trivially applied to any method. 2) The gradient approximation is more general than in the context of FORCE/SNIP sensitivity. We present further details and results in Appendix E.
+
+# 6 DISCUSSION
+
+Pruning at initialization has become an active area of research both for its practical and theoretical interests. In this work, we discovered that existing methods mostly perform below random pruning at extreme sparsity regime. We presented FORCE, a new saliency to compute the connection sensitivity after pruning, and two approximations to progressively optimize FORCE in order to prune networks at initialization. We showed that our methods are significantly better than the existing approaches for pruning at extreme sparsity levels, and are at least as good as the existing ones for pruning at moderate sparsity levels. We also provided theoretical insights on why progressive skeletonization is beneficial at initialization, and showed that the cost of iterative methods is reasonable compared to the existing ones. Although pruning iteratively has been ubiquitous in the pruning community, it was not evident that pruning at initialization might benefit from this scheme. Particularly, not every approximation could be used for gradual pruning as we have shown with GRASP. However, the gradient approximation allowed us to gradually prune while maximizing either the gradient norm or FORCE. We consider our results might encourage future work to further investigate the exploration/exploitation trade-off in pruning and find more efficient pruning schedules, not limited to the pruning at initialization.
+
+# ACKNOWLEDGMENTS
+
+This work was supported by the Royal Academy of Engineering under the Research Chair and Senior Research Fellowships scheme, EPSRC/MURI grant EP/N019474/1 and Five AI Limited. Pau de Jorge was fully funded by NAVER LABS Europe. Amartya Sanyal acknowledges support from The Alan Turing Institute under the Turing Doctoral Studentship grant TU/C/000023. Harkirat was supported using a Tencent studentship through the University of Oxford.
+
+# REFERENCES
+
+Guillaume Bellec, David Kappel, Wolfgang Maass, and Robert Legenstein. Deep rewiring: Training very sparse deep networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ BJ_wN01C-.
+
+Miguel Á. Carreira-Perpiñán and Yerlan Idelbayev. “learning-compression” algorithms for neural net pruning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Yves Chauvin. A back-propagation algorithm with optimal use of hidden units. In Advances in neural information processing systems, pp. 519–526, 1989.
+
+Xiaoliang Dai, Hongxu Yin, and Niraj K Jha. Nest: A neural network synthesis tool based on a grow-and-prune paradigm. IEEE Transactions on Computers, 68(10):1487–1497, 2019.
+
+Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ ByeSYa4KPS.
+
+Erich Elsen, Marat Dukhan, Trevor Gale, and Karen Simonyan. Fast sparse convnets. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 14629–14638, 2020.
+
+Utku Evci, Trevor Gale, Jacob Menick, Pablo Samuel Castro, and Erich Elsen. Rigging the lottery: Making all tickets winners. arXiv preprint arXiv:1911.11134, 2019.
+
+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.
+
+Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M. Roy, and Michael Carbin. Stabilizing the lottery ticket hypothesis, 2020.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In Advances in neural information processing systems, pp. 1379–1387, 2016.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pp. 1135–1143, 2015.
+
+Babak Hassibi, David G Stork, and Gregory J Wolff. Optimal brain surgeon and general network pruning. In IEEE international conference on neural networks, pp. 293–299. IEEE, 1993.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015.
+
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images, 2009.
+
+Aditya Kusupati, Vivek Ramanujan, Raghav Somani, Mitchell Wortsman, Prateek Jain, Sham M. Kakade, and Ali Farhadi. Soft threshold weight reparameterization for learnable sparsity. ArXiv, abs/2002.03231, 2020.
+
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.
+
+Namhoon Lee, Thalaiyasingam Ajanthan, and Philip Torr. SNIP: SINGLE-SHOT NETWORK PRUNING BASED ON CONNECTION SENSITIVITY. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ B1VZqjAcYX.
+
+Namhoon Lee, Thalaiyasingam Ajanthan, Stephen Gould, and Philip H. S. Torr. A signal propagation perspective for pruning neural networks at initialization. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HJeTo2VFwH.
+
+Tao Lin, Sebastian U. Stich, Luis Barba, Daniil Dmitriev, and Martin Jaggi. Dynamic model pruning with feedback. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $_ { \cdot } =$ SJem8lSFwB.
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In International Conference on Learning Representations, 2018.
+
+Christos Louizos, Max Welling, and Diederik P. Kingma. Learning sparse neural networks through l0 regularization. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id ${ . } =$ H1Y8hhg0b.
+
+Arun Mallya, Dillon Davis, and Svetlana Lazebnik. Piggyback: Adapting a single network to multiple tasks by learning to mask weights. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 67–82, 2018.
+
+Decebal Constantin Mocanu, Elena Mocanu, Peter Stone, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature communications, 9(1):1–12, 2018.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. In International Conference on Learning Representations, 2017.
+
+Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization, 2019. URL https://openreview.net/forum? id=S1xBioR5KX.
+
+Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In Advances in Neural Information Processing Systems, 1989.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch, 2017.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115 (3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+M. Sandler, A. Howard, M. Zhu, A. Zhmoginov, and L. Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, 2018. doi: 10.1109/CVPR.2018.00474.
+
+Hidenori Tanaka, Daniel Kunin, Daniel L Yamins, and Surya Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 6377–6389. Curran Associates, Inc., 2020. URL https://proceedings.neurips. cc/paper/2020/file/46a4378f835dc8040c8057beb6a2da52-Paper.pdf.
+
+Stijn Verdenius, Maarten Stol, and Patrick Forré. Pruning via iterative ranking of sensitivity statistics. arXiv preprint arXiv:2006.00896, 2020.
+
+Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ SkgsACVKPH.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+# A PRUNING IMPLEMENTATION DETAILS
+
+We present experiments on CIFAR-10/100 (Krizhevsky et al., 2009), which consists of 60k $3 2 \times 3 2$ colour images divided into $1 0 / 1 0 0$ classes, and also on Imagenet challenge ILSVRC-2012 (Russakovsky et al., 2015) and its smaller version Tiny-ImageNet, which respectively consist of $1 . 2  { \mathrm { M } } / 1  { \mathrm { k } }$ and $1 0 0 \dot { \mathrm { k } } / 2 0 0$ images/classes. Networks are initialized using the Kaiming normal initialization (He et al., 2015). For CIFAR datasets, we train Resnet $5 0 ^ { 3 }$ and $\mathrm { V \bar { G } G 1 9 ^ { 4 } }$ architectures during 350 epochs with a batch size of 128. We start with a learning rate of 0.1 and divide it by 10 at 150 and 250 epochs. As optimizer we use SGD with momentum 0.9 and weight decay $5 \times 1 0 ^ { - 4 }$ . We separate $10 \%$ of the training data for validation and report results on the test set. We perform mean and std normalization and augment the data with random crops and horizontal flips. For Tiny-Imagenet, we use the same architectures. We train during 300 epochs and divide the learning rate by 10 at 1/2 and 3/4 of the training. Other hyper-parameters remain the same. For ImageNet training, we adapt the official code5 of Paszke et al. (2017) and we use the default settings. In this case, we use the Resnet50 and VGG19 with batch normalization architectures as implemented in Paszke et al. (2017).
+
+In the case of FORCE and Iter SNIP, we adapt the same public implementation6 of SNIP as Wang et al. (2020). Instead of defining an auxiliary mask to compute the saliencies, we compute the product of the weight times the gradient, which was shown to be equivalent in Lee et al. (2020). As for GRASP, we use their public code.7 After pruning, we implement pruned connections by setting the corresponding weight to 0 and forcing the gradient to be 0. This way, a pruned weight will remain 0 during training.
+
+An important difference between SNIP and GRASP implementations is in the way they select the mini-batch to compute the saliency. SNIP implementation simply loads a batch from the dataloader. In contrast, in GRASP implementation they keep loading batches of data until they obtain exactly 10 examples of each class, discarding redundant samples. In order to compare the methods in equal conditions, we decided to use the way SNIP collects the data since it is simpler to implement and does not require extra memory. This might cause small discrepancies between our results and the ones reported in Wang et al. (2020).
+
+Table 2: Percentage of weights per layer for each network and dataset.   
+
+<table><tr><td>Layer type</td><td>Conv</td><td>Fully connected</td><td>BatchNorm</td><td>Bias</td><td>Prunable</td><td>Total</td></tr><tr><td>CIFAR10</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Resnet50</td><td>99.69</td><td>0.09</td><td>0.11</td><td>0.11</td><td>99.78</td><td>23.52M</td></tr><tr><td>VGG19</td><td>99.92</td><td>0.03</td><td>0.03</td><td>0.03</td><td>99.95</td><td>20.04M</td></tr><tr><td>CIFAR100</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Resnet50</td><td>98.91</td><td>0.86</td><td>0.11</td><td>0.11</td><td>99.78</td><td>23.71M</td></tr><tr><td>VGG19</td><td>99.69</td><td>0.25</td><td>0.03</td><td>0.03</td><td>99.94</td><td>20.08M</td></tr><tr><td>TinyImagenet</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Resnet50</td><td>98.06</td><td>1.71</td><td>0.11</td><td>0.11</td><td>99.78</td><td>23.91M</td></tr><tr><td>VGG19</td><td>99.44</td><td>0.51</td><td>0.03</td><td>0.03</td><td>99.94</td><td>20.13M</td></tr><tr><td>Imagenet</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Resnet50</td><td>91.77</td><td>8.01</td><td>0.10</td><td>0.11</td><td>99.79</td><td>25.56M</td></tr><tr><td>VGG19</td><td>13.93</td><td>86.05</td><td>0.01</td><td>0.01</td><td>99.98</td><td>143.68M</td></tr></table>
+
+A meaningful design choice regarding SNIP and GRASP implementations is that they only prune convolutional and fully connected layers. These layers constitute the vast majority of parameters in most networks, however, as we move to high sparsity regimes, batch norm layers constitute a non-negligible amount. For CIFAR10, batch norm plus biases constitute $0 . 2 \%$ and $0 . 0 5 \%$ of the parameters of Resnet50 and VGG19 networks respectively. For consistency, we have as well restricted pruning to convolutional and fully connected layers and reported percentage sparsity with respect to the prunable parameters, as is also done in Lee et al. (2019) and Wang et al. (2020) to the best of our knowledge. In Table 2 we show the percentage of prunable weights for each network and dataset we use. In future experiments we will explore the performance of pruning at initialization when including batch norm layers and biases as well.
+
+![](images/241864e2afa263a15bc0673ce478298cf938cba1fbf6b2d53f9d6f010cba0fb3.jpg)  
+Figure 5: Test accuracies on CIFAR-10/100 and Tiny Imagenet for different pruning methods. Each point is the average over 3 runs of prune-train-test. The shaded areas denote the standard deviation of the runs (too small to be visible in some cases).
+
+# B ADDITIONAL ACCURACY-SPARSITY PLOTS
+
+In the main text we show the complete range of the accuracy-sparsity curves for the different methods so it is clear why more robust methods are needed. However, it makes it more difficult to appreciate the smaller differences at lower sparsities. In Fig 5 we show the accuracy-sparsity curves where we cut the y axis to show only the higher accuracies.
+
+# C FURTHER ANALYSIS OF PRUNING AT INITIALIZATION
+
+# C.1 SALIENCY VS T
+
+In Fig 4 (left) we have seen that for higher sparsity levels, FORCE obtains a higher saliency when we increase the number of iterations. In Fig 6 we compare the relative saliencies as we increase the number of iterations for FORCE and Iterative SNIP. As can be seen, both have a similar behaviour.
+
+# C.2 PRUNING VS SPARSIFICATION
+
+FORCE algorithm is able to recover pruned weights in later iterations of pruning. In order to do that, we do not consider the intermediate masks as pruning masks but rather as sparsification masks, where connections are set to 0 but not their gradients. In order to understand how does computing the FORCE (5) on a sparsified vs pruned network affect the saliency, we prune several masks with FORCE algorithm at varying sparsity levels. For each mask, we then compute their FORCE saliency either considering the pruned network (gradients of pruned connections will be set to 0 during the backward pass) or the sparsified network (we only set to 0 the connections, but let the gradient signal flow through all the connections). Results are presented in Fig 7. We observe that the two methods to compute the saliency are strongly correlated, thus, we can assume that when we use the FORCE algorithm that maximizes the saliency of sparsified networks we will also maximize the saliency of the corresponding pruned networks.
+
+![](images/d8d14d57b44ea21b137e2aa6b0022b2542d6bdc8db241ba10710b50ab3e5f26f.jpg)  
+Figure 6: FORCE saliency (6) obtained with iterative pruning normalized by the saliency obtained with one-shot SNIP, $T = 1$ . (a) Applying the FORCE algorithm (b) Using Iterative SNIP. Note how both methods have similar behaviour.
+
+![](images/11496fbc93334e2bb240e2f02bc38a3354a6fa2a2a3b9f665371b526e648ea16.jpg)  
+Figure 7: FORCE saliency computed for masks as we vary sparsity. FORCE (sparsification) refers to measuring FORCE when we allow the gradients of zeroed connections to be non-zero, while FORCE (pruning) cuts all backward signal of any removed connection. As can be seen on the plot, they are strongly correlated.
+
+# C.3 NETWORK STRUCTURE AFTER PRUNING
+
+In Fig 8 we visualize the structure of the networks after pruning $9 9 . 9 \%$ of the parameters. We show the fraction of remaining weights and the total number of remaining weights per layer after pruning. As seen in (a) and (d), all analysed methods show a tendency to preserve the initial and final layers and to prune more heavily the deep convolutional layers, this is consistent with results reported in Wang et al. (2020). In (b) and (e), we note that FORCE has a structure that stands out compared to other methods that are more similar. This is reasonable since, it is the only method that allows pruned weights to recover. In the zoomed plots (c) and (f) we would like to point out that FORCE and Iterative SNIP preserve more weights on the deeper layers than GRASP and SNIP for VGG19 while we observe the opposite behaviour for Resnet50.
+
+In Fig 2, we observe that gradual pruning is able to prune the Resnet50 network up to $9 9 . 9 9 \%$ sparsity without falling to random accuracy. In contrast, with VGG19 we observe Iterative SNIP is not able to prune more than $9 9 . 9 \%$ . In Fig 8 we observe that for Resnet50, all methods prune some layers completely. However, in the case of ResNets, even if a convolutional layer is entirely pruned, skip connections still allow the flow of forward and backward signal. On the other hand, architectures without skip connections, such as VGG, require non-empty layers to keep the flow of information. Interestingly, in (c) we observe how FORCE and Iter SNIP have a larger amount of completely pruned layers than GRASP, however, there are a few deep layers with a significantly larger amount of unpruned weights. This seems to indicate that when a high sparsity is required, it is more efficient to have fewer layers with more weights than several extremely sparse layers.
+
+![](images/1c4cc11211a007f7d20534bbc8c663bef04daa2fd759df47a4acb4c4e22aa97b.jpg)  
+Figure 8: Visualization of remaining weights after pruning $9 9 . 9 \%$ of the weights of Resnet-50 and VGG-19 for CIFAR-10. (a) and (d) show the fraction of remaining weights for each prunable layer. (b) and (e) show the actual number of remaining weights and (c) and (f) zoom to the bottom part of the plot. Observe in (c) and (f) that some layers have exactly 0 weights left, so they are removed entirely.
+
+![](images/9d10a7ad4423519576c8803e8b2b80150ca515fa2f7840bb875581ef881139ec.jpg)  
+Figure 9: Normalized amount of globally pruned and recovered weights at each pruning iteration for Resnet50, CIFAR-10 when pruned with (a) Iterative SNIP and (b) FORCE. As expected, the amount of recovered weights for Iterative SNIP is constantly zero, since this is by design. Moreover, the amount of pruned weights decays exponentially as expected from our pruning schedule. On the other hand, we see the amount of recovered weights is non-zero with FORCE, interestingly the amount of pruned/recovered weights does not decay monotonically but has a clear peak, indicating there is an "exploration" and a "convergence" phase during pruning.
+
+# C.4 EVOLUTION OF PRUNING MASKS
+
+As discussed in the main text, FORCE allows weights that have been pruned at earlier iterations to become non-zero again, we argue this might be beneficial compared to Iterative SNIP which will not be able to correct any possible "mistakes" made in earlier iterations. In particular, it seems to give certain advantage to prune VGG to high sparsities without breaking the flow of information (pruning a layer entirely) as can be seen in Fig 2 (b). In order to gain a better intuition of how does the amount of pruned/recovered weights ratio evolve during pruning, in Fig 9 we plot the normalized amount of pruned and recovered weights (globally on the whole network) at each iteration of FORCE and also for Iter SNIP as a sanity check. Note that Iterative SNIP does not recover weights and the amount of weights pruned at each step decays exponentially (this is expected since we derived Iterative SNIP as a constrained optimization of FORCE where each network needs to be a sub-network of the previous iteration. On the other hand, FORCE does recover weights. Moreover, the amount of pruned/recovered weights does not decay monotonically but has a clear peak, indicating there are two phases during pruning: While the amount of pruned weights increases, the algorithm explores masks which are quite far away from each other, although this might be harmful for the gradient approximation (refer to section 4), we argue that during the initial pruning iterations the network is still quite over-parametrized. After reaching a peak, both the pruning and recovery rapidly decay, thus the masks converge to a more constrained subset.
+
+# C.5 COMPARISON WITH EARLY PRUNING
+
+For fair comparison, we provided the same amount of data to SNIP and GRASP as was used by our approach and call this variant SNIP-MB and GRASP-MB. Similarly, under this new baseline which we call early pruning, we train the network on 1 epoch of data of CIFAR-10, that is slightly more examples than our pruning at initialization methods which use $1 2 8 \cdot 3 0 0 = 3 8 4 0 0$ examples (see section 5). After training for 1 epoch we perform magnitude pruning which requires no extra cost (results presented in Fig 10). Although early pruning yields competitive results for VGG at moderate sparsity levels, it soon degrades its performance as we prune more weights. On the other hand, for Resnet architecture it is sub-optimal at all evaluated sparsity levels. Note, this result does not mean that any early pruning strategy would be sub-optimal compared to pruning at initialization, however exploring this further is out of the scope of this work.
+
+![](images/cf6c96d1b7218c79b229924bba57df87b5618c94c32e3d42ec1f381a5093b10e.jpg)  
+Figure 10: Test accuracies on CIFAR-10 for different pruning methods. Each point is the average over 3 runs of prune-train-test. The shaded areas denote the standard deviation of the runs (too small to be visible in some cases). Early pruning is at most on par with gradual pruning at initialization methods and has a strong drop in performance as we go to higher sparsities.
+
+# C.6 MOBILENET EXPERIMENTS
+
+All our experiments were on overparameterized architectures such as Resnet and VGG. To test the wider usability of our methods, in this section we prune the Mobilenet-v2 architecture8 (Sandler et al., 2018) which is much more "slim" than Resnet and VGG (Mobilenet has 2.3M params compared to 20.03M and 23.5M of VGG and Resnet respectively). Results are provided in Fig 11. Similarly to Resnet and VGG architectures, we see that gradual pruning tends to better preserve accuracy at higher sparsity levels than one-shot methods. Moreover, both FORCE and Iter SNIP improve over SNIP at moderate sparsity levels as well. FORCE and Iter SNIP have comparable accuracies except for high sparsity where Iter SNIP surpasses FORCE. We hypothesize for such a slim architecture $\approx 1 0 \times$ fewer parameters than Resnet and VGG) the gradient approximation becomes even more sensitive to the distance between iterative masks and perhaps the exploration of FORCE is harmful in this case. As discussed in the main paper, we believe that further research to understand the exploration/exploitation trade-off when pruning might yield to even more efficient pruning schemes, especially for very high sparsity levels. We train using the same settings as described in Appendix A except for the weight decay which is set to $4 \times 1 0 ^ { - 5 }$ , following the settings of the original Mobilenet paper.
+
+![](images/7110cd910bb63a8ee3800f3086fa3af4bdf82d4f0d7efc169c1efb2d280fa320.jpg)  
+Figure 11: Test accuracies on CIFAR-10 for different pruning methods on Mobilenet architecture. Each point is the average over 3 runs of prune-train-test. The shaded areas denote the standard deviation of the runs (too small to be visible in some cases). When pruning Mobilenet-v2 architecture, which has roughly $1 0 \times$ less parameters than Resnet or VGG, we observe a similar pattern: Gradual pruning tends to be able to preserve accuracy for higher sparsities better than one-shot methods. Moreover, it tends to improve slightly over SNIP at moderate sparsities as well. Although GRASP does not show an acute drop in performance like SNIP, it seems to be sub-optimal with respect to other methods across all sparsities.
+
+# D LOCAL OPTIMAL MASKS
+
+Definition 1 $( ( p , \epsilon )$ -local optimal mask). Consider any two sets9 $\mathbf { c } _ { t } \subseteq \{ 1 , \cdots , m \}$ and $\mathbf { c } _ { t + 1 } \subset \mathbf { c } _ { t }$ For any $\epsilon > 0$ and $0 \leq p \leq | \mathbf { c } _ { t } \rangle \langle \mathbf { c } _ { t + 1 } |$ , $\mathbf { c } _ { t + 1 }$ is a $( p , \epsilon )$ local optimal with respect to $\mathbf { c } _ { t }$ if the following holds
+
+$$
+S ( \theta , \mathbf { c } _ { t + 1 } ) \geq S ( \theta , ( \mathbf { c } _ { t + 1 } \backslash S _ { - } ) \cup S _ { + } ) - \epsilon
+$$
+
+for all $S _ { - } \subset { \mathbf { c } } _ { t + 1 } , | S _ { - } | = p$ and $S _ { + } \subset ( \mathbf { c } _ { t } \setminus ( \mathbf { c } _ { t + 1 } ) , | S _ { + } | = p .$ .
+
+Definition 2 (CRS; Coordinate-Restricted-Smoothness). Given a function $\mathcal { L } : \mathbb { R } ^ { m }  \mathbb { R }$ (which encodes both the network architecture and the dataset), $\mathcal { L }$ is said to be $\lambda _ { c }$ -Coordinated Restricted
+
+Smooth with respect to $\mathbf { c } \subseteq \{ 1 , \cdots , m \}$ if there exists a real number $\lambda _ { c }$ such that
+
+$$
+\left. \mathbf { c } \odot \boldsymbol { \nabla } \mathcal { L } \left( \mathbf { w } \odot \mathbf { c } \right) - \mathbf { c } \odot \boldsymbol { \nabla } \mathcal { L } \left( \mathbf { w } \odot \widehat { \mathbf { c } } \right) \right. _ { \infty } \leq \lambda _ { c } \left. \mathbf { w } \odot \mathbf { c } - \mathbf { w } \odot \widehat { \mathbf { c } } \right. _ { 1 }
+$$
+
+for all $\mathbf { w } \in \mathbb { R } ^ { m }$ and $\widehat { \mathbf { c } } \subset \mathbf { c }$ . When $s = | \mathbf { c } \rangle \widehat { \mathbf { c } } |$ , an application of Holder’s inequality shows
+
+$$
+\lambda _ { c } \left\| \mathbf { w } \odot \mathbf { c } - \mathbf { w } \odot { \widehat { \mathbf { c } } } \right\| _ { 1 } \leq \lambda _ { c } \left\| \mathbf { w } \right\| _ { \infty } \left\| \mathbf { c } - { \widehat { \mathbf { c } } } \right\| _ { 1 } = \lambda _ { c } s \left\| \mathbf { w } \right\| _ { \infty }
+$$
+
+We define $\mathcal { L }$ to be $\Lambda$ -total CRS if there exists a function $\Lambda : \left\{ 0 , 1 \right\} ^ { m } \to \mathbb { R }$ such that for all $\mathbf { c } \in \{ 0 , 1 \} ^ { m }$ $\mathcal { L }$ is $\Lambda \left( \mathbf { c } \right)$ -Coordinate-Restricted-Smooth with respect to $\mathbf { c }$ (for ease of notation we use $\Lambda \left( \mathbf { c } \right) = \lambda _ { \mathbf { c } }$ ).
+
+Theorem 1 (Informal). The mask $\mathbf { c } _ { t + 1 }$ produced from $\mathbf { c } _ { t }$ by FORCE is $\left( p , 2 \lambda p \left\| \theta \right\| _ { \infty } ^ { 2 } \left| \mathbf { c } _ { t } \right| \right)$ -local optimal if the $\mathcal { L }$ is $\Lambda$ -CRS..
+
+Proof. Consider the masks $\mathbf { c } _ { t }$ and $\mathbf { c } _ { t + 1 }$ where the latter is obtained by one step of FORCE on the former. Let $S _ { - }$ and $S _ { + }$ be any set of size $p$ such that $S _ { - } \subset c _ { t + 1 }$ and $S _ { + } \subset ( \mathbf { c } _ { t } \setminus \mathbf { c } _ { t + 1 } )$ . Finally, for ease of notation we define $\zeta \overset { \cdot } { = } ( c _ { t + 1 } \setminus S _ { - } ) \cup S _ { + }$
+
+$$
+\begin{array} { r l } { S \left( \theta , \zeta \right) - S \left( \theta , \mathbf { c } _ { t + 1 } \right) = \displaystyle \sum _ { i \in \zeta } \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \zeta \right) _ { i } \right| - \displaystyle \sum _ { i \in \mathbf { c } _ { t + 1 } } \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \mathbf { c } _ { t + 1 } \right) _ { i } \right| } & { } \\ { = \underbrace { \displaystyle \sum _ { i \in \mathbf { c } _ { t + 1 } } \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \zeta \right) _ { i } \right| - \displaystyle \sum _ { i \in \mathbf { c } _ { t + 1 } } \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \mathbf { c } _ { t + 1 } \right) _ { i } \right| } _ { \mathrm { ~ r _ 1 ~ } } } & { } \\ { + \displaystyle \sum _ { i \in S _ { + } } \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \zeta \right) _ { i } \right| - \displaystyle \sum _ { i \in S _ { - } } \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \zeta \right) _ { i } \right| } & { } \end{array}
+$$
+
+Let us look at the three terms individually. We assume that $\mathcal { L }$ is $\Lambda$ -CRS.
+
+$$
+\begin{array} { r l r l } & { \Gamma _ { 1 } = \displaystyle \sum _ { i \in { \bf c } + 1 } \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \zeta \right) _ { i } \right| - \left| \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot { \bf c } _ { t + 1 } \right) _ { i } \right| } & \\ & { \quad \le \left\| { \bf c } _ { t + 1 } \odot \theta \odot \nabla \mathcal { L } \left( \theta \odot { \bf c } _ { t + 1 } \right) - { \bf c } _ { t + 1 } \odot \theta \odot \nabla \mathcal { L } \left( \theta \odot \zeta \right) \right\| _ { 1 } } & & { \mathrm { B y ~ T r i a n g l e ~ I n e q u a l i t y } } \\ & { \quad \le \left\| { \bf c } _ { t + 1 } \odot \theta \right\| _ { 1 } \left\| { \bf c } _ { t + 1 } \odot \nabla \mathcal { L } \left( \theta \odot { \bf c } _ { t + 1 } \right) - { \bf c } _ { t + 1 } \odot \nabla \mathcal { L } \left( \theta \odot \zeta \right) \right\| _ { \infty } } & & { \mathrm { B y ~ H o l d e r ~ s ~ I n e q u a l i t y } } \\ & { \quad \le 2 \lambda _ { c _ { t + 1 } } \left| c _ { t + 1 } \right| p \left\| \theta \right\| _ { \infty } ^ { 2 } } & & { \quad \cdot \ \cdot \mathcal { L } \mathrm { i s ~ \Lambda - C R S } \enspace ( 1 2 ) } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \Gamma _ { 2 } = \displaystyle \sum _ { i \in S _ { + } } | \theta _ { i } \cdot \nabla \mathcal { L } ( \theta \odot \zeta ) _ { i } | - | \theta _ { i } \cdot \nabla \mathcal { L } ( \theta \odot \mathbf { c } _ { t } ) _ { i } | + | \theta _ { i } \cdot \nabla \mathcal { L } ( \theta \odot \mathbf { c } _ { t } ) _ { i } | } \\ & { \quad \le \displaystyle \sum _ { i \in S _ { + } } | \theta _ { i } \cdot \nabla \mathcal { L } ( \theta \odot \mathbf { c } _ { t } ) _ { i } | + \lambda _ { \mathbf { c } _ { t } } p \| \theta \| _ { \infty } ^ { 2 } ( | \mathbf { c } _ { t } | - | \mathbf { c } _ { t + 1 } | ) \qquad \cdot | \mathbf { c } _ { t }  \zeta | = | \mathbf { c } _ { t } | - | \mathbf { c } _ { t + 1 } | , } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \Gamma _ { 3 } = - \displaystyle \sum _ { i \in S _ { - } } \left. \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \zeta \right) _ { i } \right. + \left. \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \mathbf { c } _ { t } \right) _ { i } \right. - \left. \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \mathbf { c } _ { t } \right) _ { i } \right. } \\ & { \quad \leq - \displaystyle \sum _ { i \in S _ { - } } \left. \theta _ { i } \cdot \nabla \mathcal { L } \left( \theta \odot \mathbf { c } _ { t } \right) _ { i } \right. + \lambda _ { \mathbf { c } _ { t } } p \left. \left. \theta \right. \right. _ { \infty } ^ { 2 } \left( \left. \mathbf { c } _ { t } \right. - \left. \mathbf { c } _ { t + 1 } \right. \right) , } \end{array}
+$$
+
+Adding eqs. (13) and (14), we get
+
+$$
+\begin{array} { r l r } {  { \Gamma _ { 2 } + \Gamma _ { 3 } \leq \sum _ { i \in S _ { + } } | \theta _ { i } \cdot \nabla \mathcal { L } ( \theta \odot \mathbf { c } _ { t } ) _ { i } | - \sum _ { i \in S _ { - } } | \theta _ { i } \cdot \nabla \mathcal { L } ( \theta \odot \mathbf { c } _ { t } ) _ { i } | + 2 \lambda _ { \mathbf { c } _ { t } } p \| \theta \| _ { \infty } ^ { 2 } ( | \mathbf { c } _ { t } | - | \mathbf { c } _ { t + 1 } | ) } } \\ & { } & { \leq 2 \lambda _ { \mathbf { c } _ { t } } p \| \theta \| _ { \infty } ^ { 2 } ( | \mathbf { c } _ { t } | - | \mathbf { c } _ { t + 1 } | ) - \gamma p \qquad \mathrm { ( } } \end{array}
+$$
+
+Substituting eqs. (12) and (15) into (11) we get
+
+$$
+\begin{array} { r l } & { S \left( \theta , \zeta \right) - S \left( \theta , \mathbf { c } _ { t + 1 } \right) \leq 2 \lambda _ { \mathbf { c } _ { t + 1 } } \left. \mathbf { c } _ { t + 1 } \right. p \left. \theta \right. _ { \infty } ^ { 2 } + 2 \lambda _ { \mathbf { c } _ { t } } p \left. \theta \right. _ { \infty } ^ { 2 } \left( \left. \mathbf { c } _ { t } \right. - \left. \mathbf { c } _ { t + 1 } \right. \right) - \gamma p } \\ & { \qquad = 2 \lambda _ { \mathbf { c } _ { t + 1 } } p \left. \theta \right. _ { \infty } ^ { 2 } \left( \left. \mathbf { c } _ { t + 1 } \right. + \left( \left. \mathbf { c } _ { t } \right. - \left. \mathbf { c } _ { t + 1 } \right. \right) \right) - \gamma p } \\ & { \qquad S \left( \theta , \mathbf { c } _ { t + 1 } \right) \geq S \left( \theta , \zeta \right) - 2 \lambda _ { \mathbf { c } _ { t + 1 } } p \left. \theta \right. _ { \infty } ^ { 2 } \left. \mathbf { c } _ { t } \right. + \gamma p } \\ & { \qquad S \left( \theta , \mathbf { c } _ { t + 1 } \right) \geq S \left( \theta , \zeta \right) - 2 \lambda _ { \mathbf { c } _ { t + 1 } } p \left. \theta \right. _ { \infty } ^ { 2 } \left. \mathbf { c } _ { t } \right. } \end{array}
+$$
+
+![](images/d8b98a0c83faf38c3a57f672f7fbede8b57c22e5d23e2a2f670c2e77c8c3694f.jpg)  
+Figure 12: Test accuracies for different datasets and networks when pruned with different methods. Each point is the average over 3 runs of prune-train-test. The shaded areas denote the standard deviation of the runs (sometimes too small to be visible).
+
+# E.1 MAXIMIZING THE GRADIENT NORM USING THE GRADIENT APPROXIMATION
+
+In order to maximize the gradient norm after pruning, the authors in Wang et al. (2020) use the first order Taylor’s approximation. While this seems to be better suited than SNIP for higher levels of sparsity, it assumes that pruning is a small perturbation on the weight matrix. We argue that this approximation will not be valid as we push towards extreme sparsity values. Our gradient approximation (refer to section 4) can also be applied to maximize the gradient norm after pruning. In this case, we have
+
+$$
+G ( \pmb \theta , \pmb c ) : = \Delta \mathcal { L } ( \pmb \theta \odot \pmb c ) - \Delta \mathcal { L } ( \pmb \theta ) \approx \sum _ { \{ i : c _ { i } = 0 \} } - [ \nabla \mathcal { L } ( \pmb \theta ) _ { i } ] ^ { 2 } ,
+$$
+
+where we assume pruned connections have null gradients (this is equivalent to the restriction used for Iterative SNIP) and we assume gradients remain unchanged for unpruned weights (gradient approximation). Combining this approximation with Eq. (7), we obtain a new pruning method we name Iterative GRASP, although it is not the same as applying GRASP iteratively. Unlike FORCE, Iterative GRASP does not recover GRASP when $T = 1$ .
+
+In Fig 12 we compare Iterative GRASP to other pruning methods. We use the same settings as described in section 5. We observe that Iterative GRASP outperforms GRASP in the high sparsity region. Moreover, for VGG19 architecture Iterative GRASP achieves comparable performance to Iterative SNIP. Nevertheless, for Resnet50 we see that Iterative GRASP performance falls below that of FORCE and Iterative SNIP as we prune more weights. FORCE saliency takes into account both the gradient and the magnitude of the weights when computing the saliency, on the other hand, the Gradient Norm only takes gradients into account, therefore it is using less information. We hypothesize this might the reason why Iterative GRASP does not match Iterative SNIP.
+
+![](images/58b86f033b68321529a3d68b84d47bed61f2262e27023b687a6ab029c7cb5868.jpg)  
+E.2 ITERATIVE GRASP (PRUNING CONSISTENCY)   
+Figure 13: (a) - (c) Portion of remaining weights for each layer. Each point is an average of 3 runs and the error bars (hardly visible) denote standard deviation. (b) - (d) Portion of remaining weights for each intermediate mask that is computed during iterative pruning with global portion of remaining weights of 0.01.
+
+As explained in the main text, we tried to apply GRASP iteratively with the Taylor approximation described in Wang et al. (2020). Unfortunately, we found that all resulting masks yield networks unable to train. In light of this result, we performed some analysis of the behaviour of GRASP compared to that of SNIP and, in the following, we provide some insights as to why we can not use GRASP’s approximation iteratively.
+
+In Liu et al. (2018), the authors show that applying a pruning method to the same architecture with different random initializations would yield consistent pruning masks. Specifically, they find that the percentage of pruned weights in each layer had very low variance. We reproduce the same experiment and additionally explore another dimension, the (global) sparsity level. Given an architecture, we prune it at varying levels of sparsity and extract the percentage of remaining weights at each layer. For each level of sparsity, we average the results over 3 trials of initialize-prune. As shown in Fig 2, both SNIP and GRASP have very low variance across initializations, on the other hand, as we vary the global sparsity with GRASP, the percentage of remaining weights for each layer is inconsistent. The layers that are most preserved at high levels of sparsity, such as the initial and last layers, are the most heavily pruned at low sparsity levels.
+
+The authors in Liu et al. (2018), reason that manually designed networks have layers which are more redundant than others. Therefore, pruning methods even this redundancies by pruning layers with different percentages. We extend this reasoning, and hypothesize that pruning algorithms should always have preference for pruning the same (redundant) layers across all levels of sparsity. We denote this as pruning consistency. We observe that when applying iterative pruning to GRASP, the resulting masks tend to prune almost all of the weights at the initial and final layers, producing networks that are unable to converge. When using iterative pruning, we prune a small portion of remaining weights at each step. Thus, we are always in the low sparsity regime, where the GRASP behaviour is reversed. Conversely, when we use SNIP the behaviour changes completely. In this case, the preserved layers are consistent across sparsity levels, and when we use iterative pruning we obtain networks that reach high accuracy values.

parse/train/BJ_UL-k0b/BJ_UL-k0b.md

@@ -0,0 +1,343 @@
+# RECASTING GRADIENT-BASED META-LEARNING AS HIERARCHICAL BAYES
+
+Erin Grant12, Chelsea $\mathbf { F i n n ^ { 1 2 } }$ , Sergey Levine12, Trevor Darrell12, Thomas Griffiths13
+
+1 Berkeley AI Research (BAIR), University of California, Berkeley   
+2 Department of Electrical Engineering & Computer Sciences, University of California, Berkeley   
+3 Department of Psychology, University of California, Berkeley
+
+{eringrant,cbfinn,svlevine,trevor,tom_griffiths}@berkeley.edu
+
+# ABSTRACT
+
+Meta-learning allows an intelligent agent to leverage prior learning episodes as a basis for quickly improving performance on a novel task. Bayesian hierarchical modeling provides a theoretical framework for formalizing meta-learning as inference for a set of parameters that are shared across tasks. Here, we reformulate the model-agnostic meta-learning algorithm (MAML) of Finn et al. (2017) as a method for probabilistic inference in a hierarchical Bayesian model. In contrast to prior methods for meta-learning via hierarchical Bayes, MAML is naturally applicable to complex function approximators through its use of a scalable gradient descent procedure for posterior inference. Furthermore, the identification of MAML as hierarchical Bayes provides a way to understand the algorithm’s operation as a meta-learning procedure, as well as an opportunity to make use of computational strategies for efficient inference. We use this opportunity to propose an improvement to the MAML algorithm that makes use of techniques from approximate inference and curvature estimation.
+
+# 1 INTRODUCTION
+
+A remarkable aspect of human intelligence is the ability to quickly solve a novel problem and to be able to do so even in the face of limited experience in a novel domain. Such fast adaptation is made possible by leveraging prior learning experience in order to improve the efficiency of later learning. This capacity for meta-learning also has the potential to enable an artificially intelligent agent to learn more efficiently in situations with little available data or limited computational resources (Schmidhuber, 1987; Bengio et al., 1991; Naik & Mammone, 1992).
+
+In machine learning, meta-learning is formulated as the extraction of domain-general information that can act as an inductive bias to improve learning efficiency in novel tasks (Caruana, 1998; Thrun & Pratt, 1998). This inductive bias has been implemented in various ways: as learned hyperparameters in a hierarchical Bayesian model that regularize task-specific parameters (Heskes, 1998), as a learned metric space in which to group neighbors (Bottou & Vapnik, 1992), as a trained recurrent neural network that allows encoding and retrieval of episodic information (Santoro et al., 2016), or as an optimization algorithm with learned parameters (Schmidhuber, 1987; Bengio et al., 1992).
+
+The model-agnostic meta-learning (MAML) of Finn et al. (2017) is an instance of a learned optimization procedure that directly optimizes the standard gradient descent rule. The algorithm estimates an initial parameter set to be shared among the task-specific models; the intuition is that gradient descent from the learned initialization provides a favorable inductive bias for fast adaptation. However, this inductive bias has been evaluated only empirically in prior work (Finn et al., 2017).
+
+In this work, we present a novel derivation of and a novel extension to MAML, illustrating that this algorithm can be understood as inference for the parameters of a prior distribution in a hierarchical Bayesian model. The learned prior allows for quick adaptation to unseen tasks on the basis of an implicit predictive density over task-specific parameters. The reinterpretation as hierarchical Bayes gives a principled statistical motivation for MAML as a meta-learning algorithm, and sheds light on the reasons for its favorable performance even among methods with significantly more parameters.
+
+More importantly, by casting gradient-based meta-learning within a Bayesian framework, we are able to improve MAML by taking insights from Bayesian posterior estimation as novel augmentations to the gradient-based meta-learning procedure. We experimentally demonstrate that this enables better performance on a few-shot learning benchmark.
+
+# 2 META-LEARNING FORMULATION
+
+The goal of a meta-learner is to extract task-general knowledge through the experience of solving a number of related tasks. By using this learned prior knowledge, the learner has the potential to quickly adapt to novel tasks even in the face of limited data or limited computation time.
+
+Formally, we consider a dataset $\mathcal { D }$ that defines a distribution over a family of tasks $\tau$ . These tasks share some common structure such that learning to solve a single task has the potential to aid in solving another. Each task $\tau$ defines a distribution over data points $\mathbf { x }$ , which we assume in this work to consist of inputs and either regression targets or classification labels $\mathbf { y }$ in a supervised learning problem (although this assumption can be relaxed to include reinforcement learning problems; e.g., see Finn et al., 2017). The objective of the meta-learner is to be able to minimize a task-specific performance metric associated with any given unseen task from the dataset given even only a small amount of data from the task; i.e., to be capable of fast adaptation to a novel task.
+
+In the following subsections, we discuss two ways of formulating a solution to the meta-learning problem: gradient-based hyperparameter optimization and probabilistic inference in a hierarchical Bayesian model. These approaches were developed orthogonally, but, in Section 3.1, we draw a novel connection between the two.
+
+# 2.1 META-LEARNING AS GRADIENT-BASED HYPERPARAMETER OPTIMIZATION
+
+A parametric meta-learner aims to find some shared parameters $\pmb \theta$ that make it easier to find the right task-specific parameters $\phi$ when faced with a novel task. A variety of meta-learners that employ gradient methods for task-specific fast adaptation have been proposed (e.g., Andrychowicz et al., 2016; Li & Malik, 2017a;b; Wichrowska et al., 2017). MAML (Finn et al., 2017) is distinct in that it provides a gradient-based meta-learning procedure that employs a single additional parameter (the meta-learning rate) and operates on the same parameter space for both meta-learning and fast adaptation. These are necessary features for the equivalence we show in Section 3.1.
+
+To address the meta-learning problem, MAML estimates the parameters $\pmb \theta$ of a set of models so that when one or a few batch gradient descent steps are taken from the initialization at $\pmb \theta$ given a small sample of task data $\mathbf { x } _ { j _ { 1 } } , . . . , \mathbf { x } _ { j _ { N } } \sim p _ { T _ { j } } ( \mathbf { x } )$ each model has good generalization performance on another sample $\mathbf { x } _ { j _ { N + 1 } } , . . . , \mathbf { x } _ { j _ { N + M } } \sim p \bar { \mathcal { T } _ { j } } ( \mathbf { x } )$ from the same task. The MAML objective in a maximum likelihood setting is
+
+$$
+\mathcal { L } ( \pmb { \theta } ) = \frac { 1 } { J } \sum _ { j } \left[ \frac { 1 } { M } \sum _ { m } - \log p \big ( \mathbf { x } _ { j _ { N + m } } \mid \underbrace { \pmb { \theta } - \alpha \nabla _ { \pmb { \theta } } \frac { 1 } { N } \sum _ { n } - \log p \left( \mathbf { x } _ { j _ { n } } \mid \pmb { \theta } \right) } _ { \phi _ { j } } \big ) \right]
+$$
+
+where we use $\phi _ { j }$ to denote the updated parameters after taking a single batch gradient descent step from the initialization at $\pmb { \theta }$ with step size $\alpha$ on the negative log-likelihood associated with the task $\tau _ { j }$ Note that since $\phi _ { j }$ is an iterate of a gradient descent procedure that starts from $\pmb \theta$ , each $\phi _ { j }$ is of the same dimensionality as $\pmb \theta$ . We refer to the inner gradient descent procedure that computes $\mathbf { \bar { \phi } } _ { j }$ as fast adaptation. The computational graph of MAML is given in Figure 1 (left).
+
+# 2.2 META-LEARNING AS HIERARCHICAL BAYESIAN INFERENCE
+
+An alternative way to formulate meta-learning is as a problem of probabilistic inference in the hierarchical model depicted in Figure 1 (right). In particular, in the case of meta-learning, each task-specific parameter $\phi _ { j }$ is distinct from but should influence the estimation of the parameters $\{ \phi _ { j ^ { \prime } } \mid j ^ { \prime } \neq j \}$ from other tasks. We can capture this intuition by introducing a meta-level parameter $\pmb \theta$ on which each task-specific parameter is statistically dependent. With this formulation, the mutual dependence of the task-specific parameters $\phi _ { j }$ is realized only through their individual dependence on the meta-level parameters $\pmb \theta$ . As such, estimating $\pmb \theta$ provides a way to constrain the estimation of each of the $\phi _ { j }$ .
+
+![](images/3e13a7a914b4674e914e750ae9eb6ad6346ae1c1c514ecb4748bf1c73fe61cd7.jpg)  
+Figure 1: (Left) The computational graph of the MAML (Finn et al., 2017) algorithm covered in Section 2.1. Straight arrows denote deterministic computations and crooked arrows denote sampling operations. (Right) The probabilistic graphical model for which MAML provides an inference procedure as described in Section 3.1. In each figure, plates denote repeated computations (left) or factorization (right) across independent and identically distributed samples.
+
+Given some data in a multi-task setting, we may estimate $\pmb \theta$ by integrating out the task-specific parameters to form the marginal likelihood of the data. Formally, grouping all of the data from each of the tasks as $\mathbf { X }$ and again denoting by $\mathbf { x } _ { j _ { 1 } } , \dotsc , \mathbf { x } _ { j _ { N } }$ a sample from task $\tau _ { j }$ , the marginal likelihood of the observed data is given by
+
+$$
+p \left( \mathbf { X } \mid \theta \right) = \prod _ { j } \left( \int p \left( \mathbf { x } _ { j _ { 1 } } , \ldots , \mathbf { x } _ { j _ { N } } \mid \phi _ { j } \right) p \left( \phi _ { j } \mid \theta \right) \mathrm { d } \phi _ { j } \right) .
+$$
+
+Maximizing (2) as a function of $\pmb { \theta }$ gives a point estimate for $\pmb \theta$ , an instance of a method known as empirical Bayes (Bernardo & Smith, 2006; Gelman et al., 2014) due to its use of the data to estimate the parameters of the prior distribution.
+
+Hierarchical Bayesian models have a long history of use in both transfer learning and domain adaptation (e.g., Lawrence & Platt, 2004; Yu et al., 2005; Gao et al., 2008; Daumé III, 2009; Wan et al., 2012). However, the formulation of meta-learning as hierarchical Bayes does not automatically provide an inference procedure, and furthermore, there is no guarantee that inference is tractable for expressive models with many parameters such as deep neural networks.
+
+# 3 LINKING GRADIENT-BASED META-LEARNING & HIERARCHICAL BAYES
+
+In this section, we connect the two independent approaches of Section 2.1 and Section 2.2 by showing that MAML can be understood as empirical Bayes in a hierarchical probabilistic model. Furthermore, we build on this understanding by showing that a choice of update rule for the taskspecific parameters $\phi _ { j }$ (i.e., a choice of inner-loop optimizer) corresponds to a choice of prior over task-specific parameters, $p ( \phi _ { j } \mid \theta )$ .
+
+# 3.1 MODEL-AGNOSTIC META-LEARNING AS EMPIRICAL BAYES
+
+In general, when performing empirical Bayes, the marginalization over task-specific parameters $\phi _ { j }$ in (2) is not tractable to compute exactly. To avoid this issue, we can consider an approximation that makes use of a point estimate $\hat { \phi } _ { j }$ instead of performing the integration over $\phi$ in (2). Using $\hat { \phi } _ { j }$ as an estimator for each $\phi _ { j }$ , we may write the negative logarithm of the marginal likelihood as
+
+$$
+- \log p \left( \mathbf { X } \mid \pmb { \theta } \right) \approx \sum _ { j } \left[ - \log p \left( \mathbf { x } _ { j _ { N + 1 } } , . . . \mathbf { x } _ { j _ { N + M } } \mid \hat { \phi } _ { j } \right) \right] \ .
+$$
+
+Setting $\hat { \phi } _ { j } = \pmb { \theta } + \alpha \nabla _ { \pmb { \theta } } \log p ( \mathbf { x } _ { j _ { 1 } } , \dots , \mathbf { x } _ { j _ { N } } \mid \pmb { \theta } )$ for each $j$ in (3) recovers the unscaled form of the one-step MAML objective in (1). This tells us that the MAML objective is equivalent to a maximization with respect to the meta-level parameters $\pmb { \theta }$ of the marginal likelihood $p ( \mathbf { X } \mid \pmb { \theta } )$ , where a point estimate for each task-specific parameter $\phi _ { j }$ is computed via one or a few steps of gradient descent. By taking only a few steps from the initialization at $\pmb \theta$ , the point estimate $\mathbf { \widehat { \phi } } _ { j } ^ { \star }$ trades off
+
+<table><tr><td colspan="2">Algorithm MAML-HB()</td></tr><tr><td colspan="2">Initialize 0 randomly</td></tr><tr><td>while not converged do</td><td></td></tr><tr><td></td><td>Draw J samples Ti,...,TJ ~ pg(T)</td></tr><tr><td></td><td>Estimate Ex~pt (x)[-logp(x|0)],..,Ex~pT(x)[-logp(x |0)] using ML-.</td></tr><tr><td>Update0 ←0-β ∀θ∑jEx~pTj(x)[-logp(x|θ)]</td><td></td></tr><tr><td colspan="2">end</td></tr></table>
+
+Algorithm 2: Model-agnostic meta-learning as hierarchical Bayesian inference. The choices of the subroutine $\mathrm { M L } - \cdot \cdot$ that we consider are defined in Subroutine 3 and Subroutine 4.
+
+<table><tr><td>Subroutine ML-POINT (0,T) Draw N samples X1,...,XN ~ pτ(x)</td></tr><tr><td>Initialize←0</td></tr><tr><td>for k in 1,...,K do</td></tr><tr><td>Update 𝜙 ←Φ+α∀logp(x1,...,Xn|Φ)</td></tr><tr><td>end</td></tr><tr><td>Draw M samples XN+1,...,XN+M ~ PT(x) return -log p(xN+1,...,Xn+m|𝜙)</td></tr></table>
+
+Subroutine 3: Subroutine for computing a point estimate $\hat { \phi }$ using truncated gradient descent to approximate the marginal negative log likelihood (NLL).
+
+minimizing the fast adaptation objective $- \log p ( \mathbf { x } _ { j _ { 1 } } , \ldots , \mathbf { x } _ { j _ { N } } \mid \pmb { \theta } )$ with staying close in value to the parameter initialization $\pmb \theta$ .
+
+We can formalize this trade-off by considering the linear regression case. Recall that the maximum a posteriori (MAP) estimate of $\phi _ { j }$ corresponds to the global mode of the posterior $p ( \phi _ { j } \mid _ { \mathbf { x } _ { j _ { 1 } } , \mathbf { \bar { \phi } } _ { \bar { \mathbf { \lambda } } \cdot \mathbf { \lambda } \cdot \mathbf { x } _ { j _ { N } } , \mathbf { \bar { \phi } } \mathbf { \phi } \mathbf { \phi } } \mathbf { \alpha } } p ( \mathbf { \alpha } _ { \mathbf { x } _ { j _ { 1 } } } , \mathbf { \beta } _ { \cdot } \mathbf { \alpha } _ { \cdot } \mathbf { \alpha } _ { \cdot } \mathbf { \alpha } _ { \mathbf { x } _ { j _ { N } } } \mid \phi _ { j } \rangle ) p ( \phi _ { j } \mid \mathbf { \bar { \phi } } \mathbf { \phi } \theta ) .$ . In the case of a linear model, early stopping of an iterative gradient descent procedure to estimate $\phi _ { j }$ is exactly equivalent to MAP estimation of $\phi _ { j }$ under the assumption of a prior that depends on the number of descent steps as well as the direction in which each step is taken. In particular, write the input examples as $\mathbf { X }$ and the vector of regression targets as $\mathbf { y }$ , omit the task index from $\phi$ , and consider the gradient descent update
+
+$$
+\begin{array} { l } { \phi _ { ( k ) } = \phi _ { ( k - 1 ) } - \alpha \nabla _ { \phi } \left[ \left\| \mathbf { y } - \mathbf { X } \phi \right\| _ { 2 } ^ { 2 } \right] _ { \phi = \phi _ { ( k - 1 ) } } } \\ { \mathbf { \phi } = \phi _ { ( k - 1 ) } - \alpha \mathbf { X } ^ { \mathrm { T } } \left( \mathbf { X } \phi _ { ( k - 1 ) } - \mathbf { y } \right) } \end{array}
+$$
+
+for iteration index $k$ and learning rate $\alpha \in \mathbb { R } ^ { + }$ . Santos (1996) shows that, starting from $\phi _ { ( 0 ) } = \theta$ , $\phi _ { ( k ) }$ in (4) solves the regularized linear least squares problem
+
+$$
+\operatorname* { m i n } \left( \lVert \mathbf { y } - \mathbf { X } \phi \rVert _ { 2 } ^ { 2 } + \lVert \pmb { \theta } - \phi \rVert _ { \mathbf { Q } } ^ { 2 } \right)
+$$
+
+with $\mathbf { Q }$ -norm defined by $\| \mathbf { z } \| _ { \mathbf { Q } } = \mathbf { z } ^ { \mathrm { T } } \mathbf { Q } ^ { - 1 } \mathbf { z }$ for a symmetric positive definite matrix $\mathbf { Q }$ that depends on the step size $\alpha$ and iteration index $k$ as well as on the covariance structure of $\mathbf { X }$ . We describe the exact form of the dependence in Section 3.2. The minimization in (5) can be expressed as a posterior maximization problem given a conditional Gaussian likelihood over $\mathbf { y }$ and a Gaussian prior over $\phi$ . The posterior takes the form
+
+$$
+p \left( \phi \mid \mathbf { X } , \mathbf { y } , \pmb { \theta } \right) \propto \mathcal { N } ( \mathbf { y } ; \mathbf { X } \phi , \mathbb { I } ) \mathcal { N } ( \phi ; \pmb { \theta } , \mathbf { Q } ) .
+$$
+
+Since $\phi _ { ( k ) }$ in (4) maximizes (6), we may conclude that $k$ iterations of gradient descent in a linear regression model with squared error exactly computes the MAP estimate of $\phi$ , given a Gaussian-noised observation model and a Gaussian prior over $\phi$ with parameters $\mu _ { 0 } = \pmb \theta$ and $\pmb { \Sigma } _ { 0 } = \mathbf { Q }$ . Therefore, in the case of linear regression with squared error, MAML is exactly empirical Bayes using the MAP estimate as the point estimate of $\phi$ .
+
+In the nonlinear case, MAML is again equivalent to an empirical Bayes procedure to maximize the marginal likelihood that uses a point estimate for $\phi$ computed by one or a few steps of gradient descent. However, this point estimate is not necessarily the global mode of a posterior. We can instead understand the point estimate given by truncated gradient descent as the value of the mode of an implicit posterior over $\phi$ resulting from an empirical loss interpreted as a negative log-likelihood, and regularization penalties and the early stopping procedure jointly acting as priors (for similar interpretations, see Sjöberg & Ljung, 1995; Bishop, 1995; Duvenaud et al., 2016).
+
+The exact equivalence between early stopping and a Gaussian prior on the weights in the linear case, as well as the implicit regularization to the parameter initialization the nonlinear case, tells us that every iterate of truncated gradient descent is a mode of an implicit posterior. In particular, we are not required to take the gradient descent procedure of fast adaptation that computes $\hat { \phi }$ to convergence in order to establish a connection between MAML and hierarchical Bayes. MAML can therefore be understood to approximate an expectation of the marginal negative log likelihood (NLL) for each task $\tau _ { j }$ as
+
+$$
+\mathbb { E } _ { \mathbf { x } \sim p _ { T _ { j } } ( \mathbf { x } ) } \left[ - \log p \left( \mathbf { x } \mid \pmb { \theta } \right) \right] \approx \frac { 1 } { M } \sum _ { m } - \log p \left( \mathbf { x } _ { j _ { N + m } } \mid \hat { \phi } _ { j } \right)
+$$
+
+using the point estimate $\hat { \phi } _ { j } = \pmb { \theta } + \alpha \nabla _ { \pmb { \theta } } \log p ( \mathbf { x } _ { j _ { n } } \mid \pmb { \theta } )$ for single-step fast adaptation.
+
+The algorithm for MAML as probabilistic inference is given in Algorithm 2; Subroutine 3 computes each marginal NLL using the point estimate of $\hat { \phi }$ as just described. Formulating MAML in this way, as probabilistic inference in a hierarchical Bayesian model, motivates the interpretation in Section 3.2 of using various meta-optimization algorithms to induce a prior over task-specific parameters.
+
+# 3.2 THE PRIOR OVER TASK-SPECIFIC PARAMETERS
+
+From Section 3.1, we may conclude that early stopping during fast adaptation is equivalent to a specific choice of a prior over task-specific parameters, $p \bar { ( \phi _ { j } \mid \theta ) }$ . We can better understand the role of early stopping in defining the task-specific parameter prior in the case of a quadratic objective. Omit the task index from $\phi$ and $\mathbf { x }$ , and consider a second-order approximation of the fast adaptation objective $\ell ( \phi ) = - \log p ( \mathbf { x } _ { 1 } \ldots , \mathbf { x } _ { N } \mid \phi )$ about a minimum $\phi ^ { * }$ :
+
+$$
+\begin{array} { r } { \ell ( \phi ) \approx \tilde { \ell } ( \phi ) : = \frac 1 2 \| \phi - \phi ^ { * } \| _ { \ H ^ { - 1 } } ^ { 2 } + \ell ( \phi ^ { * } ) } \end{array}
+$$
+
+where the Hessian $\mathbf { H } = \nabla _ { \phi } ^ { 2 } \ell ( \phi ^ { * } )$ is assumed to be positive definite so that $\tilde { \ell }$ is bounded below. Furthermore, consider using a curvature matrix $\boldsymbol { B }$ to precondition the gradient in gradient descent, giving the update
+
+$$
+\phi _ { ( k ) } = \phi _ { ( k - 1 ) } - B \nabla _ { \phi } \tilde { \ell } \big ( \phi _ { ( k - 1 ) } \big ) \mathrm { ~ . ~ }
+$$
+
+If $\boldsymbol { B }$ is diagonal, we can identify (8) as a Newton method with a diagonal approximation to the inverse Hessian; using the inverse Hessian evaluated at the point $\phi _ { ( k - 1 ) }$ recovers Newton’s method itself. On the other hand, meta-learning the matrix $\boldsymbol { B }$ matrix via gradient descent provides a method to incorporate task-general information into the covariance of the fast adaptation prior, $p ( \phi \mid \theta )$ . For instance, the meta-learned matrix $\boldsymbol { B }$ may encode correlations between parameters that dictates how such parameters are updated relative to each other.
+
+Formally, taking $k$ steps of gradient descent from $\phi _ { ( 0 ) } = \theta$ using the update rule in (8) gives a $\phi _ { ( k ) }$ that solves
+
+$$
+\operatorname* { m i n } \left( \lVert \phi - \phi ^ { * } \rVert _ { \mathbf { H } ^ { - 1 } } ^ { 2 } + \lVert \phi _ { ( 0 ) } - \phi \rVert _ { \mathbf { Q } } ^ { 2 } \right) \ .
+$$
+
+The minimization in (9) corresponds to taking a Gaussian prior $p ( \phi \mid \theta )$ with mean $\pmb { \theta }$ and covariance $\mathbf { Q }$ for $\mathbf { Q } = \mathbf { O } \mathbf { A } ^ { - 1 } ( ( \mathbb { I } - \mathbf { B } \mathbf { A } ) ^ { - k } - \mathbb { I } ) \breve { \mathbf { O } } ^ { \mathrm { T } }$ (Santos, 1996) where $\mathbf { B }$ is a diagonal matrix that results from a simultaneous diagonalization of $\mathbf { H }$ and $\boldsymbol { B }$ as $\mathbf { O } ^ { \mathrm { T } } \mathbf { H } \mathbf { O } = \mathrm { d i a g } ( \lambda _ { 1 } , \dots , \lambda _ { n } ) = \Lambda$ and $\mathbf { O } ^ { \mathrm { T } } { \mathcal { B } } ^ { - 1 } \mathbf { O } = \mathrm { d i a g } ( b _ { 1 } , \dots , b _ { n } ) = \mathbf { B }$ with $b _ { i } , \lambda _ { i } \geq 0$ for $i = 1 , \ldots , n$ (Theorem 8.7.1 in Golub $\&$ Van Loan, 1983). If the true objective is indeed quadratic, then, assuming the data is centered, $\mathbf { H }$ is the unscaled covariance matrix of features, $\mathbf { X } ^ { \mathrm { { T } } } \mathbf { X }$ .
+
+# 4 IMPROVING MODEL-AGNOSTIC META-LEARNING
+
+Identifying MAML as a method for probabilistic inference in a hierarchical model allows us to develop novel improvements to the algorithm. In Section 4.1, we consider an approach from Bayesian parameter estimation to improve the MAML algorithm, and in Section 4.2, we discuss how to make this procedure computationally tractable for high-dimensional models.
+
+# 4.1 LAPLACE’S METHOD OF INTEGRATION
+
+We have shown that the MAML algorithm is an empirical Bayes procedure that employs a point estimate for the mid-level, task-specific parameters in a hierarchical Bayesian model. However, the use of this point estimate may lead to an inaccurate point approximation of the integral in (2) if the posterior over the task-specific parameters, $p \big ( \phi _ { j } \mid \mathbf { x } _ { j _ { N + 1 } } , \cdot \cdot \cdot , \mathbf { x } _ { j _ { N + M } } , \pmb { \theta } \big )$ , . . . , xjN+M , θ ), is not sharply peaked at the value of the point estimate. The Laplace approximation (Laplace, 1986; MacKay, 1992b;a) is applicable in this case as it replaces a point estimate of an integral with the volume of a Gaussian centered at a mode of the integrand, thereby forming a local quadratic approximation.
+
+We can make use of this approximation to incorporate uncertainty about the task-specific parameters into the MAML algorithm at fast adaptation time. In particular, suppose that each integrand in (2) has a mode $\boldsymbol { \phi } _ { j } ^ { * }$ at which it is locally well-approximated by a quadratic function. The Laplace approximation uses a second-order Taylor expansion of the negative log posterior in order to approximate each integral in the product in (2) as
+
+$$
+\int p \left( { \bf X } _ { j } \mid \phi _ { j } \right) p \left( \phi _ { j } \mid \theta \right) \mathrm { d } \phi _ { j } \approx p \left( { \bf X } _ { j } \mid \phi _ { j } ^ { * } \right) p \left( \phi _ { j } ^ { * } \mid \theta \right) \operatorname * { d e t } ( { \bf H } _ { j } / 2 \pi ) ^ { - \frac { 1 } { 2 } }
+$$
+
+where $\mathbf { H } _ { j }$ is the Hessian matrix of second derivatives of the negative log posterior.
+
+Classically, the Laplace approximation uses the MAP estimate for $\boldsymbol { \phi } _ { j } ^ { * }$ , although any mode can be used as an expansion site provided the integrand is well enough approximated there by a quadratic. We use the point estimate $\hat { \phi } _ { j }$ uncovered by fast adaptation, in which case the MAML objective in (1) becomes an appropriately scaled version of the approximate marginal likelihood
+
+$$
+- \log p \left( \mathbf { X } \mid \theta \right) \approx \sum _ { j } \left[ - \log p \left( \mathbf { X } _ { j } \mid \hat { \phi } _ { j } \right) - \log p \left( \hat { \phi } _ { j } \mid \theta \right) + \frac { 1 } { 2 } \log \operatorname* { d e t } ( \mathbf { H } _ { j } ) \right] .
+$$
+
+The term $\log p ( \hat { \phi } _ { j } \mid \pmb \theta )$ results from the implicit regularization imposed by early stopping during fast adaptation, as discussed in Section 3.1. The term $\mathbf { \omega } ^ { 1 } / 2 \log \operatorname* { d e t } ( \mathbf { H } _ { j } )$ , on the other hand, results from the Laplace approximation and can be interpreted as a form of regularization that penalizes model complexity.
+
+# 4.2 USING CURVATURE INFORMATION TO IMPROVE MAML
+
+Using (11) as a training criterion for a neural network model is difficult due to the required computation of the determinant of the Hessian of the log posterior $\mathbf { H } _ { j }$ , which itself decomposes into a sum of the Hessian of the log likelihood and the Hessian of the log prior as
+
+$$
+\mathbf { H } _ { j } = \nabla _ { \phi _ { j } } ^ { 2 } \left[ - \log p \left( \mathbf { X } _ { j } \mid \phi _ { j } \right) \right] + \nabla _ { \phi _ { j } } ^ { 2 } \left[ - \log p \left( \phi _ { j } \mid \theta \right) \right] \ .
+$$
+
+In our case of early stopping as regularization, the prior over task-specific parameters $p ( \phi _ { j } \mid \theta )$ is implicit and thus no closed form is available for a general model. Although we may use the quadratic approximation derived in Section 3.2 to obtain an approximate Gaussian prior, this prior is not diagonal and does not, to our knowledge, have a convenient factorization. Therefore, in our experiments, we instead use a simple approximation in which the prior is approximated as a diagonal Gaussian with precision $\tau$ . We keep $\tau$ fixed, although this parameter may be cross-validated for improved performance.
+
+<table><tr><td>Subroutine ML-LAPLACE (0,T) Draw N samples X1,...,XN ~ pτ(x)</td></tr><tr><td>Update 𝜙 ←Φ+αVlogp(x1,...,Xn|Φ) end Draw M samples XN+1,...,XN+M ~ pτ(x) Estimate quadratic curvature H return -log p(xn+1,,XN+M |Φ) + nlog det(H)</td></tr></table>
+
+Subroutine 4: Subroutine for computing a Laplace approximation of the marginal likelihood.
+
+Similarly, the Hessian of the log likelihood is intractable to form exactly for all but the smallest models, and furthermore, is not guaranteed to be positive definite at all points, possibly rendering the Laplace approximation undefined. To combat this, we instead seek a curvature matrix $\hat { \bf H }$ that approximates the quadratic curvature of a neural network objective function. Since it is well-known that the curvature associated with neural network objective functions is highly non-diagonal (e.g., Martens, 2016), a further requirement is that the matrix have off-diagonal terms.
+
+Due to the difficulties listed above, we turn to second order gradient descent methods, which precondition the gradient with an inverse curvature matrix at each iteration of descent. The Fisher information matrix (Fisher, 1925) has been extensively used as an approximation of curvature, giving rise to a method known as natural gradient descent (Amari, 1998). A neural network with an appropriate choice of loss function is a probabilistic model and therefore defines a Fisher information matrix. Furthermore, the Fisher information matrix can be seen to define a convex quadratic approximation to the objective function of a probabilistic neural model (Pascanu & Bengio, 2014; Martens, 2014). Importantly for our use case, the Fisher information matrix is positive definite by definition as well as non-diagonal.
+
+However, the Fisher information matrix is still expensive to work with. Martens & Grosse (2015) developed Kronecker-factored approximate curvature (K-FAC), a scheme for approximating the curvature of the objective function of a neural network with a block-diagonal approximation to the Fisher information matrix. Each block corresponds to a unique layer in the network, and each block is further approximated as a Kronecker product (see Van Loan, 2000) of two much smaller matrices by assuming that the second-order statistics of the input activation and the back-propagated derivatives within a layer are independent. These two approximations ensure that the inverse of the Fisher information matrix can be computed efficiently for the natural gradient.
+
+For the Laplace approximation, we are interested in the determinant of a curvature matrix instead of its inverse. However, we may also make use of the approximations to the Fisher information matrix from K-FAC as well as properties of the Kronecker product. In particular, we use the fact that the determinant of a Kronecker product is the product of the exponentiated determinants of each of the factors, and that the determinant of a block diagonal matrix is the product of the determinants of the blocks (Van Loan, 2000). The determinants for each factor can be computed as efficiently as the inverses required by K-FAC, in $\mathcal { O } ( d ^ { 3 } )$ time for a $d$ -dimensional Kronecker factor.
+
+We make use of the Laplace approximation and K-FAC to replace Subroutine 3, which computes the task-specific marginal NLLs using a point estimate for $\hat { \phi }$ . We call this method the Lightweight Laplace Approximation for Meta-Adaptation (LLAMA), and give a replacement subroutine in Subroutine 4.
+
+# 5 EXPERIMENTAL EVALUATION
+
+The goal of our experiments is to evaluate if we can use our probabilistic interpretation of MAML to generate samples from the distribution over adapted parameters, and futhermore, if our method can be applied to large-scale meta-learning problems such as miniImageNet.
+
+![](images/5bdf18425b1a88e41686bfb5c980d314c5b5c945c7b8c77312f705a230c570c0.jpg)  
+Figure 5: Our method is able to meta-learn a model that can quickly adapt to sinusoids with varying phases and amplitudes, and the interpretation of the method as hierarchical Bayes makes it practical to directly sample models from the posterior. In this figure, we illustrate various samples from the posterior of a model that is meta-trained on different sinusoids, when presented with a few datapoints (in red) from a new, previously unseen sinusoid. Note that the random samples from the posterior predictive describe a distribution of functions that are all sinusoidal and that there is increased uncertainty when the datapoints are less informative (i.e., when the datapoints are sampled only from the lower part of the range input, shown in the bottom-right example).
+
+# 5.1 WARMUP: TOY NONLINEAR MODEL
+
+The connection between MAML and hierarchical Bayes suggests that we should expect MAML to behave like an algorithm that learns the mean of a Gaussian prior on model parameters, and uses the mean of this prior as an initialization during fast adaptation. Using the Laplace approximation to the integration over task-specific parameters as in (10) assumes a task-specific parameter posterior with mean at the adapted parameters $\hat { \phi }$ and covariance equal to the inverse Hessian of the log posterior evaluated at the adapted parameter value. Instead of simply using this density in the Laplace approximation as an additional regularization term as in (11), we may sample parameters $\phi _ { j }$ from this density and use each set of sampled parameters to form a set of predictions for a given task.
+
+To illustrate this relationship between MAML and hierarchical Bayes, we present a meta-dataset of sinusoid tasks in which each task involves regressing to the output of a sinusoid wave in Figure 5. Variation between tasks is obtained by sampling the amplitude uniformly from [0.1, 5.0] and the phase from $[ 0 , \pi ]$ . During training and for each task, 10 input datapoints are sampled uniformly from $[ - 1 0 . 0 , 1 0 . \dot { 0 } ]$ and the loss is the mean squared error between the prediction and the true value.
+
+We observe in Figure 5 that our method allows us to directly sample models from the task-specific parameter distribution after being presented with 10 datapoints from a new, previously unseen sinusoid curve. In particular, the column on the right of Figure 5 demonstrates that the sampled models display an appropriate level of uncertainty when the datapoints are ambiguous (as in the bottom right).
+
+# 5.2 LARGE-SCALE EXPERIMENT: miniIMAGENET
+
+We evaluate LLAMA on the miniImageNet Ravi & Larochelle (2017) 1-shot, 5-way classification task, a standard benchmark in few-shot classification. miniImageNet comprises 64 training classes, 12 validation classes, and 24 test classes. Following the setup of Vinyals et al. (2016), we structure the $N$ -shot, $J$ -way classification task as follows: The model observes $N$ instances of $J$ unseen classes, and is evaluated on its ability to classify $M$ new instances within the $J$ classes.
+
+We use a neural network architecture standard to few-shot classification (e.g., Vinyals et al., 2016; Ravi & Larochelle, 2017), consisting of 4 layers with $3 \times 3$ convolutions and 64 filters, followed by batch normalization (BN) (Ioffe & Szegedy, 2015), a ReLU nonlinearity, and $2 \times 2$ max-pooling. For the scaling variable $\beta$ and centering variable $\gamma$ of BN (see Ioffe & Szegedy, 2015), we ignore the fast adaptation update as well as the Fisher factors for K-FAC. We use Adam (Kingma & Ba, 2014) as the meta-optimizer, and standard batch gradient descent with a fixed learning rate to update the model during fast adaptation. LLAMA requires the prior precision term $\tau$ as well as an additional parameter $\eta \in \bar { \mathbb { R } } ^ { + }$ that weights the regularization term log det $\hat { \bf H }$ contributed by the Laplace approximation. We fix $\tau = 0 . 0 0 1$ and selected $\eta = { { 1 0 } ^ { - 6 } }$ via cross-validation; all other parameters are set to the values reported in Finn et al. (2017).
+
+Table 1: One-shot classification performance on the miniImageNet test set, with comparison methods ordered by one-shot performance. All results are averaged over 600 test episodes, and we report ${ \hat { 9 } } 5 \%$ confidence intervals. ∗Results reported by Ravi & Larochelle (2017). $^ { * * } \mathrm { W e }$ report test accuracy for a comparable architecture .1∗∗∗We report test accuracy for models matching train and test “shot” and “way”.   
+
+<table><tr><td>Model</td><td colspan="2">5-way acc. (%) 1-shot</td></tr><tr><td>Fine-tuning*</td><td>28.86</td><td>士</td><td>0.54</td></tr><tr><td>Nearest Neighbor*</td><td>41.08</td><td>士</td><td>0.70</td></tr><tr><td>Matching Networks FCE (Vinyals et al., 2016)*</td><td>43.56</td><td>士</td><td>0.84</td></tr><tr><td>Meta-LearnerLSTM (Ravi &amp; Larochelle,2017)*</td><td>43.44</td><td>士</td><td>0.77</td></tr><tr><td>SNAIL (Mishra et al., 2018)**</td><td>45.1</td><td>士</td><td></td></tr><tr><td>Prototypical Networks (Snellet al.,2017)***</td><td>46.61</td><td>士</td><td>0.78</td></tr><tr><td>mAP-DLM(Triantafillou et al., 2017)</td><td>49.82</td><td>士</td><td>0.78</td></tr><tr><td>MAML (Finn et al., 2017)</td><td>48.70</td><td>士</td><td>1.84</td></tr><tr><td>LLAMA (Ours)</td><td>49.40</td><td>士</td><td>1.83</td></tr></table>
+
+We find that LLAMA is practical enough to be applied to this larger-scale problem. In particular, our TensorFlow implementation of LLAMA trains for 60,000 iterations on one TITAN $\mathrm { X p }$ GPU in 9 hours, compared to 5 hours to train MAML. As shown in Table 1, LLAMA achieves comparable performance to the state-of-the-art meta-learning method by Triantafillou et al. (2017). While the gap between MAML and LLAMA is small, the improvement from the Laplace approximation suggests that a more accurate approximation to the marginalization over task-specific parameters will lead to further improvements.
+
+# 6 RELATED WORK
+
+Meta-learning and few-shot learning have a long history in hierarchical Bayesian modeling (e.g., Tenenbaum, 1999; Fei-Fei et al., 2003; Lawrence & Platt, 2004; Yu et al., 2005; Gao et al., 2008; Daumé III, 2009; Wan et al., 2012). A related subfield is that of transfer learning, which has used hierarchical Bayes extensively (e.g., Raina et al., 2006). A variety of inference methods have been used in Bayesian models, including exact inference (Lake et al., 2011), sampling methods (Salakhutdinov et al., 2012), and variational methods (Edwards & Storkey, 2017). While some prior works on hierarchical Bayesian models have proposed to handle basic image recognition tasks, the complexity of these tasks does not yet approach the kinds of complex image recognition problems that can be solved by discriminatively trained deep networks, such as the miniImageNet experiment in our evaluation (Mansinghka et al., 2013).
+
+Recently, the Omniglot benchmark Lake et al. (2016) has rekindled interest in the problem of learning from few examples. Modern methods accomplish few-shot learning either through the design of network architectures that ingest the few-shot training samples directly (e.g., Koch, 2015; Vinyals et al., 2016; Snell et al., 2017; Hariharan & Girshick, 2017; Triantafillou et al., 2017), or formulating the problem as one of learning to learn, or meta-learning (e.g., Schmidhuber, 1987; Bengio et al., 1991; Schmidhuber, 1992; Bengio et al., 1992). A variety of inference methods have been used in Bayesian models, including exact inference (Lake et al., 2011), sampling methods (Salakhutdinov et al., 2013), and variational methods (Edwards & Storkey, 2017).
+
+Our work bridges the gap between gradient-based meta-learning methods and hierarchical Bayesian modeling. Our contribution is not to formulate the meta-learning problem as a hierarchical Bayesian model, but instead to formulate a gradient-based meta-learner as hierarchical Bayesian inference, thus providing a way to efficiently perform posterior inference in a model-agnostic manner.
+
+# 7 CONCLUSION
+
+We have shown that model-agnostic meta-learning (MAML) estimates the parameters of a prior in a hierarchical Bayesian model. By casting gradient-based meta-learning within a Bayesian framework, our analysis opens the door to novel improvements inspired by probabilistic machinery.
+
+As a step in this direction, we propose an extension to MAML that employs a Laplace approximation to the posterior distribution over task-specific parameters. This technique provides a more accurate estimate of the integral that, in the original MAML algorithm, is approximated via a point estimate. We show how to estimate the quantity required by the Laplace approximation using Kroneckerfactored approximate curvature (K-FAC), a method recently proposed to approximate the quadratic curvature of a neural network objective for the purpose of a second-order gradient descent technique.
+
+Our contribution illuminates the road to exploring further connections between gradient-based metalearning methods and hierarchical Bayesian modeling. For instance, in this work we assume that the predictive distribution over new data-points is narrow and well-approximated by a point estimate. We may instead employ methods that make use of the variance of the distribution over task-specific parameters in order to model the predictive density over examples from a novel task.
+
+Furthermore, it is known that the Laplace approximation is inaccurate in cases where the integral is highly skewed, or is not unimodal and thus is not amenable to approximation by a single Gaussian mode. This could be solved by using a finite mixture of Gaussians, which can approximate many density functions arbitrarily well (Sorenson & Alspach, 1971; Alspach & Sorenson, 1972). The exploration of additional improvements such as this is an exciting line of future work.
+
+# REFERENCES
+
+Daniel Alspach and Harold Sorenson. Nonlinear Bayesian estimation using Gaussian sum approximations. IEEE Transactions on Automatic Control, 17(4):439–448, 1972.
+
+Shun-Ichi Amari. Natural gradient works efficiently in learning. Neural computation, 10(2):251–276, 1998.
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems (NIPS) 29, pp. 3981–3989, 2016.
+
+Samy Bengio, Yoshua Bengio, Jocelyn Cloutier, and Jan Gecsei. On the optimization of a synaptic learning rule. In Proceedings of the Conference on Optimality in Artificial and Biological Neural Networks, pp. 6–8, 1992.
+
+Yoshua Bengio, Samy Bengio, and Jocelyn Cloutier. Learning a synaptic learning rule. In Proceedings of the International Joint Conference on Neural Networks (IJCNN), volume 2, 1991.
+
+J.M. Bernardo and A.F.M. Smith. Bayesian Theory. Wiley Series in Probability and Statistics. John Wiley & Sons Canada, Limited, 2006.
+
+Christopher M Bishop. Regularization and complexity control in feed-forward networks. In Proceedings of the International Conference on Artificial Neural Networks (ICANN), pp. 141–148, 1995.
+
+Léon Bottou and Vladimir Vapnik. Local learning algorithms. Neural computation, 4(6):888–900, 1992.
+
+Rich Caruana. Multitask learning. In Learning to learn, pp. 95–133. Springer, 1998.
+
+Hal Daumé III. Bayesian multitask learning with latent hierarchies. In Proceedings of the 25th Conference on Uncertainty in Artificial Intelligence (UAI), pp. 135–142, 2009.
+
+David Duvenaud, Dougal Maclaurin, and Ryan Adams. Early stopping as nonparametric variational inference. In Proceedings of the 19th International Conference on Artificial Intelligence and Statistics (AISTATS), pp. 1070–1077, 2016.
+
+Harrison Edwards and Amos Storkey. Towards a neural statistician. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017.
+
+Li Fei-Fei et al. A Bayesian approach to unsupervised one-shot learning of object categories. In Proceedings of the 9th Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1134–1141. IEEE, 2003.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017.
+
+Ronald Aylmer Fisher. Theory of statistical estimation. In Mathematical Proceedings of the Cambridge Philosophical Society, volume 22, pp. 700–725. Cambridge University Press, 1925.
+
+Jing Gao, Wei Fan, Jing Jiang, and Jiawei Han. Knowledge transfer via multiple model local structure mapping. In Proceedings of the 14th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD), pp. 283–291. ACM, 2008.
+
+Andrew Gelman, John B Carlin, Hal S Stern, David B Dunson, Aki Vehtari, and Donald B Rubin. Bayesian data analysis, volume 2. Chapman and Hall, 2014.
+
+Gene H. Golub and Charles F. Van Loan. Matrix computations. The Johns Hopkins University Press, 1983.
+
+Bharath Hariharan and Ross Girshick. Low-shot visual object recognition. In Proceedings of the International Conference on Computer Vision (ICCV), 2017.
+
+Tom Heskes. Solving a huge number of similar tasks: A combination of multi-task learning and a hierarchical Bayesian approach. In Proceedings of the 15th International Conference on Machine Learning (ICML), pp. 233–241, 1998.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning (ICML), pp. 448–456, 2015.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations (ICLR), 2014.
+
+Gregory Koch. Siamese neural networks for one-shot image recognition. Master’s thesis, University of Toronto, 2015.
+
+Brenden M Lake, Ruslan Salakhutdinov, Jason Gross, and Joshua B Tenenbaum. One shot learning of simple visual concepts. In Proceedings of the 33rd Annual Meeting of the Cognitive Science Society (CogSci), 2011.
+
+Brenden M Lake, Tomer D Ullman, Joshua B Tenenbaum, and Samuel J Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, pp. 1–101, 2016.
+
+Pierre Simon Laplace. Memoir on the probability of the causes of events. Statistical Science, 1(3):364–378, 1986.
+
+Neil D Lawrence and John C Platt. Learning to learn with the informative vector machine. In Proceedings of the 21st International Conference on Machine Learning (ICML), pp. 65, 2004.
+
+Ke Li and Jitendra Malik. Learning to optimize. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017a.
+
+Ke Li and Jitendra Malik. Learning to optimize neural nets. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017b.
+
+David MacKay. A practical Bayesian framework for backpropagation networks. Neural computation, 4(3): 448–472, 1992a.
+
+David JC MacKay. The evidence framework applied to classification networks. Neural computation, 4(5): 720–736, 1992b.
+
+Vikash K Mansinghka, Tejas D Kulkarni, Yura N Perov, and Josh Tenenbaum. Approximate bayesian image interpretation using generative probabilistic graphics programs. In Advances in Neural Information Processing Systems, pp. 1520–1528, 2013.
+
+James Martens. New insights and perspectives on the natural gradient method. arXiv preprint arXiv:1412.1193, 2014.
+
+James Martens. Second-order optimization for neural networks. PhD thesis, University of Toronto, 2016.
+
+James Martens and Roger Grosse. Optimizing neural networks with Kronecker-factored approximate curvature. In Proceedings of the 32nd International Conference on Machine Learning (ICML), pp. 2408–2417, 2015.
+
+Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. Meta-learning with temporal convolutions. arXiv preprint arXiv:1707.03141, 2017.
+
+Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A simple neural attentive meta-learner. In Proceedings of the 6th International Conference on Learning Representations (ICLR), 2018.
+
+Tsendsuren Munkhdalai and Hong Yu. Meta networks. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017.
+
+Devang K Naik and RJ Mammone. Meta-neural networks that learn by learning. In Proceedings of the International Joint Conference on Neural Networks (IJCNN), pp. 437–442, 1992.
+
+Razvan Pascanu and Yoshua Bengio. Revisiting natural gradient for deep networks. In Proceedings of the 4th International Conference on Learning Representations (ICLR), 2014.
+
+Rajat Raina, Andrew $\mathrm { ~ Y ~ N ~ g ~ } _ { }$ , and Daphne Koller. Constructing informative priors using transfer learning. In Proceedings of the $2 3 r d$ International Conference on Machine Learning (ICML), pp. 713–720, 2006.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017.
+
+Ruslan Salakhutdinov, Joshua Tenenbaum, and Antonio Torralba. One-shot learning with a hierarchical nonparametric bayesian model. In Proceedings of ICML Workshop on Unsupervised and Transfer Learning, pp. 195–206, 2012.
+
+Ruslan Salakhutdinov, Joshua B Tenenbaum, and Antonio Torralba. Learning with hierarchical-deep models. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(8):1958–1971, 2013.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Meta-learning with memory-augmented neural networks. In Proceedings of the 33rd International Conference on Machine Learning (ICML), pp. 1842–1850, 2016.
+
+Reginaldo J. Santos. Equivalence of regularization and truncated iteration for general ill-posed problems. Linear Algebra and its Applications, 236(15):25–33, 1996.   
+Jürgen Schmidhuber. Evolutionary principles in self-referential learning. PhD thesis, Institut für Informatik, Technische Universität München, 1987.   
+Jürgen Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent networks. Neural Computation, 4(1):131–139, 1992.   
+Jonas Sjöberg and Lennart Ljung. Overtraining, regularization and searching for a minimum, with application to neural networks. International Journal of Control, 62(6):1391–1407, 1995.   
+Jake Snell, Kevin Swersky, and Richard S Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems (NIPS) 30, 2017.   
+Harold W Sorenson and Daniel L Alspach. Recursive Bayesian estimation using Gaussian sums. Automatica, 7 (4):465–479, 1971.   
+Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip H. S. Torr, and Timothy M. Hospedales. Learning to compare: Relation network for few-shot learning. CoRR, abs/1711.06025, 2017.   
+Joshua B Tenenbaum. A Bayesian framework for concept learning. PhD thesis, Massachusetts Institute of Technology, 1999.   
+Sebastian Thrun and Lorien Pratt. Learning to learn. Kluwer Academic Publishers, 1998.   
+Eleni Triantafillou, Richard Zemel, and Raquel Urtasun. Few-shot learning through an information retrieval lens. In Advances in Neural Information Processing Systems (NIPS) 30, 2017.   
+Charles F Van Loan. The ubiquitous Kronecker product. Journal of computational and applied mathematics, 123(1):85–100, 2000.   
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in Neural Information Processing Systems (NIPS) 29, pp. 3630–3638, 2016.   
+Jing Wan, Zhilin Zhang, Jingwen Yan, Taiyong Li, Bhaskar D Rao, Shiaofen Fang, Sungeun Kim, Shannon L Risacher, Andrew J Saykin, and Li Shen. Sparse Bayesian multi-task learning for predicting cognitive outcomes from neuroimaging measures in Alzheimer’s disease. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 940–947. IEEE, 2012.   
+Olga Wichrowska, Niru Maheswaranathan, Matthew W Hoffman, Sergio Gomez Colmenarejo, Misha Denil, Nando de Freitas, and Jascha Sohl-Dickstein. Learned optimizers that scale and generalize. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017.   
+Kai Yu, Volker Tresp, and Anton Schwaighofer. Learning Gaussian processes from multiple tasks. In Proceedings of the 22nd International Conference on Machine Learning (ICML), pp. 1012–1019, 2005.

parse/train/BJ_UL-k0b/BJ_UL-k0b_content_list.json

@@ -0,0 +1,1762 @@
+[
+    {
+        "type": "text",
+        "text": "RECASTING GRADIENT-BASED META-LEARNING AS HIERARCHICAL BAYES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Erin Grant12, Chelsea $\\mathbf { F i n n ^ { 1 2 } }$ , Sergey Levine12, Trevor Darrell12, Thomas Griffiths13 ",
+        "bbox": [
+            186,
+            166,
+            789,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Berkeley AI Research (BAIR), University of California, Berkeley   \n2 Department of Electrical Engineering & Computer Sciences, University of California, Berkeley   \n3 Department of Psychology, University of California, Berkeley ",
+        "bbox": [
+            184,
+            189,
+            820,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{eringrant,cbfinn,svlevine,trevor,tom_griffiths}@berkeley.edu ",
+        "bbox": [
+            189,
+            241,
+            720,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            290,
+            544,
+            305
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Meta-learning allows an intelligent agent to leverage prior learning episodes as a basis for quickly improving performance on a novel task. Bayesian hierarchical modeling provides a theoretical framework for formalizing meta-learning as inference for a set of parameters that are shared across tasks. Here, we reformulate the model-agnostic meta-learning algorithm (MAML) of Finn et al. (2017) as a method for probabilistic inference in a hierarchical Bayesian model. In contrast to prior methods for meta-learning via hierarchical Bayes, MAML is naturally applicable to complex function approximators through its use of a scalable gradient descent procedure for posterior inference. Furthermore, the identification of MAML as hierarchical Bayes provides a way to understand the algorithm’s operation as a meta-learning procedure, as well as an opportunity to make use of computational strategies for efficient inference. We use this opportunity to propose an improvement to the MAML algorithm that makes use of techniques from approximate inference and curvature estimation. ",
+        "bbox": [
+            233,
+            315,
+            766,
+            510
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            336,
+            553
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A remarkable aspect of human intelligence is the ability to quickly solve a novel problem and to be able to do so even in the face of limited experience in a novel domain. Such fast adaptation is made possible by leveraging prior learning experience in order to improve the efficiency of later learning. This capacity for meta-learning also has the potential to enable an artificially intelligent agent to learn more efficiently in situations with little available data or limited computational resources (Schmidhuber, 1987; Bengio et al., 1991; Naik & Mammone, 1992). ",
+        "bbox": [
+            174,
+            568,
+            825,
+            651
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In machine learning, meta-learning is formulated as the extraction of domain-general information that can act as an inductive bias to improve learning efficiency in novel tasks (Caruana, 1998; Thrun & Pratt, 1998). This inductive bias has been implemented in various ways: as learned hyperparameters in a hierarchical Bayesian model that regularize task-specific parameters (Heskes, 1998), as a learned metric space in which to group neighbors (Bottou & Vapnik, 1992), as a trained recurrent neural network that allows encoding and retrieval of episodic information (Santoro et al., 2016), or as an optimization algorithm with learned parameters (Schmidhuber, 1987; Bengio et al., 1992). ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The model-agnostic meta-learning (MAML) of Finn et al. (2017) is an instance of a learned optimization procedure that directly optimizes the standard gradient descent rule. The algorithm estimates an initial parameter set to be shared among the task-specific models; the intuition is that gradient descent from the learned initialization provides a favorable inductive bias for fast adaptation. However, this inductive bias has been evaluated only empirically in prior work (Finn et al., 2017). ",
+        "bbox": [
+            174,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present a novel derivation of and a novel extension to MAML, illustrating that this algorithm can be understood as inference for the parameters of a prior distribution in a hierarchical Bayesian model. The learned prior allows for quick adaptation to unseen tasks on the basis of an implicit predictive density over task-specific parameters. The reinterpretation as hierarchical Bayes gives a principled statistical motivation for MAML as a meta-learning algorithm, and sheds light on the reasons for its favorable performance even among methods with significantly more parameters. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "More importantly, by casting gradient-based meta-learning within a Bayesian framework, we are able to improve MAML by taking insights from Bayesian posterior estimation as novel augmentations to the gradient-based meta-learning procedure. We experimentally demonstrate that this enables better performance on a few-shot learning benchmark. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 META-LEARNING FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            482,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal of a meta-learner is to extract task-general knowledge through the experience of solving a number of related tasks. By using this learned prior knowledge, the learner has the potential to quickly adapt to novel tasks even in the face of limited data or limited computation time. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            253
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Formally, we consider a dataset $\\mathcal { D }$ that defines a distribution over a family of tasks $\\tau$ . These tasks share some common structure such that learning to solve a single task has the potential to aid in solving another. Each task $\\tau$ defines a distribution over data points $\\mathbf { x }$ , which we assume in this work to consist of inputs and either regression targets or classification labels $\\mathbf { y }$ in a supervised learning problem (although this assumption can be relaxed to include reinforcement learning problems; e.g., see Finn et al., 2017). The objective of the meta-learner is to be able to minimize a task-specific performance metric associated with any given unseen task from the dataset given even only a small amount of data from the task; i.e., to be capable of fast adaptation to a novel task. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            372
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the following subsections, we discuss two ways of formulating a solution to the meta-learning problem: gradient-based hyperparameter optimization and probabilistic inference in a hierarchical Bayesian model. These approaches were developed orthogonally, but, in Section 3.1, we draw a novel connection between the two. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 META-LEARNING AS GRADIENT-BASED HYPERPARAMETER OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            735,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A parametric meta-learner aims to find some shared parameters $\\pmb \\theta$ that make it easier to find the right task-specific parameters $\\phi$ when faced with a novel task. A variety of meta-learners that employ gradient methods for task-specific fast adaptation have been proposed (e.g., Andrychowicz et al., 2016; Li & Malik, 2017a;b; Wichrowska et al., 2017). MAML (Finn et al., 2017) is distinct in that it provides a gradient-based meta-learning procedure that employs a single additional parameter (the meta-learning rate) and operates on the same parameter space for both meta-learning and fast adaptation. These are necessary features for the equivalence we show in Section 3.1. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address the meta-learning problem, MAML estimates the parameters $\\pmb \\theta$ of a set of models so that when one or a few batch gradient descent steps are taken from the initialization at $\\pmb \\theta$ given a small sample of task data $\\mathbf { x } _ { j _ { 1 } } , . . . , \\mathbf { x } _ { j _ { N } } \\sim p _ { T _ { j } } ( \\mathbf { x } )$ each model has good generalization performance on another sample $\\mathbf { x } _ { j _ { N + 1 } } , . . . , \\mathbf { x } _ { j _ { N + M } } \\sim p \\bar { \\mathcal { T } _ { j } } ( \\mathbf { x } )$ from the same task. The MAML objective in a maximum likelihood setting is ",
+        "bbox": [
+            176,
+            582,
+            823,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89bba07f240b0f4c4278e8a7f51a46560e6d938d476428be99bfda619a3183e6.jpg",
+        "text": "$$\n\\mathcal { L } ( \\pmb { \\theta } ) = \\frac { 1 } { J } \\sum _ { j } \\left[ \\frac { 1 } { M } \\sum _ { m } - \\log p \\big ( \\mathbf { x } _ { j _ { N + m } } \\mid \\underbrace { \\pmb { \\theta } - \\alpha \\nabla _ { \\pmb { \\theta } } \\frac { 1 } { N } \\sum _ { n } - \\log p \\left( \\mathbf { x } _ { j _ { n } } \\mid \\pmb { \\theta } \\right) } _ { \\phi _ { j } } \\big ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            656,
+            764,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where we use $\\phi _ { j }$ to denote the updated parameters after taking a single batch gradient descent step from the initialization at $\\pmb { \\theta }$ with step size $\\alpha$ on the negative log-likelihood associated with the task $\\tau _ { j }$ Note that since $\\phi _ { j }$ is an iterate of a gradient descent procedure that starts from $\\pmb \\theta$ , each $\\phi _ { j }$ is of the same dimensionality as $\\pmb \\theta$ . We refer to the inner gradient descent procedure that computes $\\mathbf { \\bar { \\phi } } _ { j }$ as fast adaptation. The computational graph of MAML is given in Figure 1 (left). ",
+        "bbox": [
+            174,
+            727,
+            825,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 META-LEARNING AS HIERARCHICAL BAYESIAN INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            632,
+            829
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An alternative way to formulate meta-learning is as a problem of probabilistic inference in the hierarchical model depicted in Figure 1 (right). In particular, in the case of meta-learning, each task-specific parameter $\\phi _ { j }$ is distinct from but should influence the estimation of the parameters $\\{ \\phi _ { j ^ { \\prime } } \\mid j ^ { \\prime } \\neq j \\}$ from other tasks. We can capture this intuition by introducing a meta-level parameter $\\pmb \\theta$ on which each task-specific parameter is statistically dependent. With this formulation, the mutual dependence of the task-specific parameters $\\phi _ { j }$ is realized only through their individual dependence on the meta-level parameters $\\pmb \\theta$ . As such, estimating $\\pmb \\theta$ provides a way to constrain the estimation of each of the $\\phi _ { j }$ . ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e13a7a914b4674e914e750ae9eb6ad6346ae1c1c514ecb4748bf1c73fe61cd7.jpg",
+        "image_caption": [
+            "Figure 1: (Left) The computational graph of the MAML (Finn et al., 2017) algorithm covered in Section 2.1. Straight arrows denote deterministic computations and crooked arrows denote sampling operations. (Right) The probabilistic graphical model for which MAML provides an inference procedure as described in Section 3.1. In each figure, plates denote repeated computations (left) or factorization (right) across independent and identically distributed samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            88,
+            790,
+            226
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            315,
+            825,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given some data in a multi-task setting, we may estimate $\\pmb \\theta$ by integrating out the task-specific parameters to form the marginal likelihood of the data. Formally, grouping all of the data from each of the tasks as $\\mathbf { X }$ and again denoting by $\\mathbf { x } _ { j _ { 1 } } , \\dotsc , \\mathbf { x } _ { j _ { N } }$ a sample from task $\\tau _ { j }$ , the marginal likelihood of the observed data is given by ",
+        "bbox": [
+            173,
+            352,
+            825,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c7c535354a8c6944687ff82d1dffdd0dfb6889c25bb97a19b91f879e0a3202d.jpg",
+        "text": "$$\np \\left( \\mathbf { X } \\mid \\theta \\right) = \\prod _ { j } \\left( \\int p \\left( \\mathbf { x } _ { j _ { 1 } } , \\ldots , \\mathbf { x } _ { j _ { N } } \\mid \\phi _ { j } \\right) p \\left( \\phi _ { j } \\mid \\theta \\right) \\mathrm { d } \\phi _ { j } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            414,
+            714,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Maximizing (2) as a function of $\\pmb { \\theta }$ gives a point estimate for $\\pmb \\theta$ , an instance of a method known as empirical Bayes (Bernardo & Smith, 2006; Gelman et al., 2014) due to its use of the data to estimate the parameters of the prior distribution. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical Bayesian models have a long history of use in both transfer learning and domain adaptation (e.g., Lawrence & Platt, 2004; Yu et al., 2005; Gao et al., 2008; Daumé III, 2009; Wan et al., 2012). However, the formulation of meta-learning as hierarchical Bayes does not automatically provide an inference procedure, and furthermore, there is no guarantee that inference is tractable for expressive models with many parameters such as deep neural networks. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 LINKING GRADIENT-BASED META-LEARNING & HIERARCHICAL BAYES",
+        "text_level": 1,
+        "bbox": [
+            173,
+            599,
+            805,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we connect the two independent approaches of Section 2.1 and Section 2.2 by showing that MAML can be understood as empirical Bayes in a hierarchical probabilistic model. Furthermore, we build on this understanding by showing that a choice of update rule for the taskspecific parameters $\\phi _ { j }$ (i.e., a choice of inner-loop optimizer) corresponds to a choice of prior over task-specific parameters, $p ( \\phi _ { j } \\mid \\theta )$ . ",
+        "bbox": [
+            173,
+            631,
+            826,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MODEL-AGNOSTIC META-LEARNING AS EMPIRICAL BAYES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            717,
+            633,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In general, when performing empirical Bayes, the marginalization over task-specific parameters $\\phi _ { j }$ in (2) is not tractable to compute exactly. To avoid this issue, we can consider an approximation that makes use of a point estimate $\\hat { \\phi } _ { j }$ instead of performing the integration over $\\phi$ in (2). Using $\\hat { \\phi } _ { j }$ as an estimator for each $\\phi _ { j }$ , we may write the negative logarithm of the marginal likelihood as ",
+        "bbox": [
+            173,
+            743,
+            825,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e778ad611b16332db9609a2cf1854d1cd25854875a5dccc6db80bc515da8bbc.jpg",
+        "text": "$$\n- \\log p \\left( \\mathbf { X } \\mid \\pmb { \\theta } \\right) \\approx \\sum _ { j } \\left[ - \\log p \\left( \\mathbf { x } _ { j _ { N + 1 } } , . . . \\mathbf { x } _ { j _ { N + M } } \\mid \\hat { \\phi } _ { j } \\right) \\right] \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            808,
+            705,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Setting $\\hat { \\phi } _ { j } = \\pmb { \\theta } + \\alpha \\nabla _ { \\pmb { \\theta } } \\log p ( \\mathbf { x } _ { j _ { 1 } } , \\dots , \\mathbf { x } _ { j _ { N } } \\mid \\pmb { \\theta } )$ for each $j$ in (3) recovers the unscaled form of the one-step MAML objective in (1). This tells us that the MAML objective is equivalent to a maximization with respect to the meta-level parameters $\\pmb { \\theta }$ of the marginal likelihood $p ( \\mathbf { X } \\mid \\pmb { \\theta } )$ , where a point estimate for each task-specific parameter $\\phi _ { j }$ is computed via one or a few steps of gradient descent. By taking only a few steps from the initialization at $\\pmb \\theta$ , the point estimate $\\mathbf { \\widehat { \\phi } } _ { j } ^ { \\star }$ trades off ",
+        "bbox": [
+            173,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/d18650045c89504331b808b0c511043acc85c496eea5fd5ac84345911d55b97b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm MAML-HB()</td></tr><tr><td colspan=\"2\">Initialize 0 randomly</td></tr><tr><td>while not converged do</td><td></td></tr><tr><td></td><td>Draw J samples Ti,...,TJ ~ pg(T)</td></tr><tr><td></td><td>Estimate Ex~pt (x)[-logp(x|0)],..,Ex~pT(x)[-logp(x |0)] using ML-.</td></tr><tr><td>Update0 ←0-β ∀θ∑jEx~pTj(x)[-logp(x|θ)]</td><td></td></tr><tr><td colspan=\"2\">end</td></tr></table>",
+        "bbox": [
+            174,
+            107,
+            795,
+            233
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: Model-agnostic meta-learning as hierarchical Bayesian inference. The choices of the subroutine $\\mathrm { M L } - \\cdot \\cdot$ that we consider are defined in Subroutine 3 and Subroutine 4. ",
+        "bbox": [
+            169,
+            242,
+            823,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/789b19785d7606a3969e6dfc7fab66df35ec18d55675fcbabad34ceb4b28ed00.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Subroutine ML-POINT (0,T) Draw N samples X1,...,XN ~ pτ(x)</td></tr><tr><td>Initialize←0</td></tr><tr><td>for k in 1,...,K do</td></tr><tr><td>Update 𝜙 ←Φ+α∀logp(x1,...,Xn|Φ)</td></tr><tr><td>end</td></tr><tr><td>Draw M samples XN+1,...,XN+M ~ PT(x) return -log p(xN+1,...,Xn+m|𝜙)</td></tr></table>",
+        "bbox": [
+            174,
+            301,
+            825,
+            436
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Subroutine 3: Subroutine for computing a point estimate $\\hat { \\phi }$ using truncated gradient descent to approximate the marginal negative log likelihood (NLL). ",
+        "bbox": [
+            173,
+            444,
+            823,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "minimizing the fast adaptation objective $- \\log p ( \\mathbf { x } _ { j _ { 1 } } , \\ldots , \\mathbf { x } _ { j _ { N } } \\mid \\pmb { \\theta } )$ with staying close in value to the parameter initialization $\\pmb \\theta$ . ",
+        "bbox": [
+            174,
+            497,
+            823,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can formalize this trade-off by considering the linear regression case. Recall that the maximum a posteriori (MAP) estimate of $\\phi _ { j }$ corresponds to the global mode of the posterior $p ( \\phi _ { j } \\mid _ { \\mathbf { x } _ { j _ { 1 } } , \\mathbf { \\bar { \\phi } } _ { \\bar { \\mathbf { \\lambda } } \\cdot \\mathbf { \\lambda } \\cdot \\mathbf { x } _ { j _ { N } } , \\mathbf { \\bar { \\phi } } \\mathbf { \\phi } \\mathbf { \\phi } } \\mathbf { \\alpha } } p ( \\mathbf { \\alpha } _ { \\mathbf { x } _ { j _ { 1 } } } , \\mathbf { \\beta } _ { \\cdot } \\mathbf { \\alpha } _ { \\cdot } \\mathbf { \\alpha } _ { \\cdot } \\mathbf { \\alpha } _ { \\mathbf { x } _ { j _ { N } } } \\mid \\phi _ { j } \\rangle ) p ( \\phi _ { j } \\mid \\mathbf { \\bar { \\phi } } \\mathbf { \\phi } \\theta ) .$ . In the case of a linear model, early stopping of an iterative gradient descent procedure to estimate $\\phi _ { j }$ is exactly equivalent to MAP estimation of $\\phi _ { j }$ under the assumption of a prior that depends on the number of descent steps as well as the direction in which each step is taken. In particular, write the input examples as $\\mathbf { X }$ and the vector of regression targets as $\\mathbf { y }$ , omit the task index from $\\phi$ , and consider the gradient descent update ",
+        "bbox": [
+            173,
+            532,
+            826,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5acc3f748443e9da9aacb5ffd49d82b86886f2bb22a9c7e87feb585e192d531a.jpg",
+        "text": "$$\n\\begin{array} { l } { \\phi _ { ( k ) } = \\phi _ { ( k - 1 ) } - \\alpha \\nabla _ { \\phi } \\left[ \\left\\| \\mathbf { y } - \\mathbf { X } \\phi \\right\\| _ { 2 } ^ { 2 } \\right] _ { \\phi = \\phi _ { ( k - 1 ) } } } \\\\ { \\mathbf { \\phi } = \\phi _ { ( k - 1 ) } - \\alpha \\mathbf { X } ^ { \\mathrm { T } } \\left( \\mathbf { X } \\phi _ { ( k - 1 ) } - \\mathbf { y } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            637,
+            655,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for iteration index $k$ and learning rate $\\alpha \\in \\mathbb { R } ^ { + }$ . Santos (1996) shows that, starting from $\\phi _ { ( 0 ) } = \\theta$ , $\\phi _ { ( k ) }$ in (4) solves the regularized linear least squares problem ",
+        "bbox": [
+            174,
+            698,
+            828,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e5206274f8f2ae665ecdda6ca9a77cc4ae866b5274e4ab2d453987451ae96f0.jpg",
+        "text": "$$\n\\operatorname* { m i n } \\left( \\lVert \\mathbf { y } - \\mathbf { X } \\phi \\rVert _ { 2 } ^ { 2 } + \\lVert \\pmb { \\theta } - \\phi \\rVert _ { \\mathbf { Q } } ^ { 2 } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            734,
+            611,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with $\\mathbf { Q }$ -norm defined by $\\| \\mathbf { z } \\| _ { \\mathbf { Q } } = \\mathbf { z } ^ { \\mathrm { T } } \\mathbf { Q } ^ { - 1 } \\mathbf { z }$ for a symmetric positive definite matrix $\\mathbf { Q }$ that depends on the step size $\\alpha$ and iteration index $k$ as well as on the covariance structure of $\\mathbf { X }$ . We describe the exact form of the dependence in Section 3.2. The minimization in (5) can be expressed as a posterior maximization problem given a conditional Gaussian likelihood over $\\mathbf { y }$ and a Gaussian prior over $\\phi$ . The posterior takes the form ",
+        "bbox": [
+            173,
+            768,
+            826,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/590879570af22c78eb9e6b909e52c3d66096560344dea8cc7b8ad687a557ffa0.jpg",
+        "text": "$$\np \\left( \\phi \\mid \\mathbf { X } , \\mathbf { y } , \\pmb { \\theta } \\right) \\propto \\mathcal { N } ( \\mathbf { y } ; \\mathbf { X } \\phi , \\mathbb { I } ) \\mathcal { N } ( \\phi ; \\pmb { \\theta } , \\mathbf { Q } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            849,
+            658,
+            868
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since $\\phi _ { ( k ) }$ in (4) maximizes (6), we may conclude that $k$ iterations of gradient descent in a linear regression model with squared error exactly computes the MAP estimate of $\\phi$ , given a Gaussian-noised observation model and a Gaussian prior over $\\phi$ with parameters $\\mu _ { 0 } = \\pmb \\theta$ and $\\pmb { \\Sigma } _ { 0 } = \\mathbf { Q }$ . Therefore, in the case of linear regression with squared error, MAML is exactly empirical Bayes using the MAP estimate as the point estimate of $\\phi$ . ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the nonlinear case, MAML is again equivalent to an empirical Bayes procedure to maximize the marginal likelihood that uses a point estimate for $\\phi$ computed by one or a few steps of gradient descent. However, this point estimate is not necessarily the global mode of a posterior. We can instead understand the point estimate given by truncated gradient descent as the value of the mode of an implicit posterior over $\\phi$ resulting from an empirical loss interpreted as a negative log-likelihood, and regularization penalties and the early stopping procedure jointly acting as priors (for similar interpretations, see Sjöberg & Ljung, 1995; Bishop, 1995; Duvenaud et al., 2016). ",
+        "bbox": [
+            174,
+            138,
+            825,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The exact equivalence between early stopping and a Gaussian prior on the weights in the linear case, as well as the implicit regularization to the parameter initialization the nonlinear case, tells us that every iterate of truncated gradient descent is a mode of an implicit posterior. In particular, we are not required to take the gradient descent procedure of fast adaptation that computes $\\hat { \\phi }$ to convergence in order to establish a connection between MAML and hierarchical Bayes. MAML can therefore be understood to approximate an expectation of the marginal negative log likelihood (NLL) for each task $\\tau _ { j }$ as ",
+        "bbox": [
+            173,
+            242,
+            826,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/628cc52901872f8f1f23c3a9c4a552698e52367081022915e560b26829ab07d1.jpg",
+        "text": "$$\n\\mathbb { E } _ { \\mathbf { x } \\sim p _ { T _ { j } } ( \\mathbf { x } ) } \\left[ - \\log p \\left( \\mathbf { x } \\mid \\pmb { \\theta } \\right) \\right] \\approx \\frac { 1 } { M } \\sum _ { m } - \\log p \\left( \\mathbf { x } _ { j _ { N + m } } \\mid \\hat { \\phi } _ { j } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            347,
+            700,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "using the point estimate $\\hat { \\phi } _ { j } = \\pmb { \\theta } + \\alpha \\nabla _ { \\pmb { \\theta } } \\log p ( \\mathbf { x } _ { j _ { n } } \\mid \\pmb { \\theta } )$ for single-step fast adaptation. ",
+        "bbox": [
+            171,
+            391,
+            743,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The algorithm for MAML as probabilistic inference is given in Algorithm 2; Subroutine 3 computes each marginal NLL using the point estimate of $\\hat { \\phi }$ as just described. Formulating MAML in this way, as probabilistic inference in a hierarchical Bayesian model, motivates the interpretation in Section 3.2 of using various meta-optimization algorithms to induce a prior over task-specific parameters. ",
+        "bbox": [
+            173,
+            412,
+            826,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 THE PRIOR OVER TASK-SPECIFIC PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            547,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "From Section 3.1, we may conclude that early stopping during fast adaptation is equivalent to a specific choice of a prior over task-specific parameters, $p \\bar { ( \\phi _ { j } \\mid \\theta ) }$ . We can better understand the role of early stopping in defining the task-specific parameter prior in the case of a quadratic objective. Omit the task index from $\\phi$ and $\\mathbf { x }$ , and consider a second-order approximation of the fast adaptation objective $\\ell ( \\phi ) = - \\log p ( \\mathbf { x } _ { 1 } \\ldots , \\mathbf { x } _ { N } \\mid \\phi )$ about a minimum $\\phi ^ { * }$ : ",
+        "bbox": [
+            173,
+            512,
+            825,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0e206b6a6ced3dcefec32758a3e2763927117579dedf15bab2fd80f25e0b03d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\ell ( \\phi ) \\approx \\tilde { \\ell } ( \\phi ) : = \\frac 1 2 \\| \\phi - \\phi ^ { * } \\| _ { \\ H ^ { - 1 } } ^ { 2 } + \\ell ( \\phi ^ { * } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            606,
+            637,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the Hessian $\\mathbf { H } = \\nabla _ { \\phi } ^ { 2 } \\ell ( \\phi ^ { * } )$ is assumed to be positive definite so that $\\tilde { \\ell }$ is bounded below. Furthermore, consider using a curvature matrix $\\boldsymbol { B }$ to precondition the gradient in gradient descent, giving the update ",
+        "bbox": [
+            173,
+            640,
+            826,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2209ee46a19f8ff621a71ce78b58ad56bebd01f330304017432941b8840fa35.jpg",
+        "text": "$$\n\\phi _ { ( k ) } = \\phi _ { ( k - 1 ) } - B \\nabla _ { \\phi } \\tilde { \\ell } \\big ( \\phi _ { ( k - 1 ) } \\big ) \\mathrm { ~ . ~ }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            709,
+            619,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If $\\boldsymbol { B }$ is diagonal, we can identify (8) as a Newton method with a diagonal approximation to the inverse Hessian; using the inverse Hessian evaluated at the point $\\phi _ { ( k - 1 ) }$ recovers Newton’s method itself. On the other hand, meta-learning the matrix $\\boldsymbol { B }$ matrix via gradient descent provides a method to incorporate task-general information into the covariance of the fast adaptation prior, $p ( \\phi \\mid \\theta )$ . For instance, the meta-learned matrix $\\boldsymbol { B }$ may encode correlations between parameters that dictates how such parameters are updated relative to each other. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formally, taking $k$ steps of gradient descent from $\\phi _ { ( 0 ) } = \\theta$ using the update rule in (8) gives a $\\phi _ { ( k ) }$ that solves ",
+        "bbox": [
+            173,
+            832,
+            823,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9e5dc44a81e8bd04c4681695634728bb2c95772ff79ff3b776108d5e056dd0e.jpg",
+        "text": "$$\n\\operatorname* { m i n } \\left( \\lVert \\phi - \\phi ^ { * } \\rVert _ { \\mathbf { H } ^ { - 1 } } ^ { 2 } + \\lVert \\phi _ { ( 0 ) } - \\phi \\rVert _ { \\mathbf { Q } } ^ { 2 } \\right) \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            863,
+            633,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The minimization in (9) corresponds to taking a Gaussian prior $p ( \\phi \\mid \\theta )$ with mean $\\pmb { \\theta }$ and covariance $\\mathbf { Q }$ for $\\mathbf { Q } = \\mathbf { O } \\mathbf { A } ^ { - 1 } ( ( \\mathbb { I } - \\mathbf { B } \\mathbf { A } ) ^ { - k } - \\mathbb { I } ) \\breve { \\mathbf { O } } ^ { \\mathrm { T } }$ (Santos, 1996) where $\\mathbf { B }$ is a diagonal matrix that results from a simultaneous diagonalization of $\\mathbf { H }$ and $\\boldsymbol { B }$ as $\\mathbf { O } ^ { \\mathrm { T } } \\mathbf { H } \\mathbf { O } = \\mathrm { d i a g } ( \\lambda _ { 1 } , \\dots , \\lambda _ { n } ) = \\Lambda$ and $\\mathbf { O } ^ { \\mathrm { T } } { \\mathcal { B } } ^ { - 1 } \\mathbf { O } = \\mathrm { d i a g } ( b _ { 1 } , \\dots , b _ { n } ) = \\mathbf { B }$ with $b _ { i } , \\lambda _ { i } \\geq 0$ for $i = 1 , \\ldots , n$ (Theorem 8.7.1 in Golub $\\&$ Van Loan, 1983). If the true objective is indeed quadratic, then, assuming the data is centered, $\\mathbf { H }$ is the unscaled covariance matrix of features, $\\mathbf { X } ^ { \\mathrm { { T } } } \\mathbf { X }$ . ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            101,
+            825,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 IMPROVING MODEL-AGNOSTIC META-LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            620,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Identifying MAML as a method for probabilistic inference in a hierarchical model allows us to develop novel improvements to the algorithm. In Section 4.1, we consider an approach from Bayesian parameter estimation to improve the MAML algorithm, and in Section 4.2, we discuss how to make this procedure computationally tractable for high-dimensional models. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 LAPLACE’S METHOD OF INTEGRATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            284,
+            485,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We have shown that the MAML algorithm is an empirical Bayes procedure that employs a point estimate for the mid-level, task-specific parameters in a hierarchical Bayesian model. However, the use of this point estimate may lead to an inaccurate point approximation of the integral in (2) if the posterior over the task-specific parameters, $p \\big ( \\phi _ { j } \\mid \\mathbf { x } _ { j _ { N + 1 } } , \\cdot \\cdot \\cdot , \\mathbf { x } _ { j _ { N + M } } , \\pmb { \\theta } \\big )$ , . . . , xjN+M , θ ), is not sharply peaked at the value of the point estimate. The Laplace approximation (Laplace, 1986; MacKay, 1992b;a) is applicable in this case as it replaces a point estimate of an integral with the volume of a Gaussian centered at a mode of the integrand, thereby forming a local quadratic approximation. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            409
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We can make use of this approximation to incorporate uncertainty about the task-specific parameters into the MAML algorithm at fast adaptation time. In particular, suppose that each integrand in (2) has a mode $\\boldsymbol { \\phi } _ { j } ^ { * }$ at which it is locally well-approximated by a quadratic function. The Laplace approximation uses a second-order Taylor expansion of the negative log posterior in order to approximate each integral in the product in (2) as ",
+        "bbox": [
+            173,
+            414,
+            825,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/648a5fe855fb59d827eeb9bf480fe93a5aaf790a3ef9c396eafeb2a974b510f8.jpg",
+        "text": "$$\n\\int p \\left( { \\bf X } _ { j } \\mid \\phi _ { j } \\right) p \\left( \\phi _ { j } \\mid \\theta \\right) \\mathrm { d } \\phi _ { j } \\approx p \\left( { \\bf X } _ { j } \\mid \\phi _ { j } ^ { * } \\right) p \\left( \\phi _ { j } ^ { * } \\mid \\theta \\right) \\operatorname * { d e t } ( { \\bf H } _ { j } / 2 \\pi ) ^ { - \\frac { 1 } { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            489,
+            750,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { H } _ { j }$ is the Hessian matrix of second derivatives of the negative log posterior. ",
+        "bbox": [
+            171,
+            526,
+            714,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Classically, the Laplace approximation uses the MAP estimate for $\\boldsymbol { \\phi } _ { j } ^ { * }$ , although any mode can be used as an expansion site provided the integrand is well enough approximated there by a quadratic. We use the point estimate $\\hat { \\phi } _ { j }$ uncovered by fast adaptation, in which case the MAML objective in (1) becomes an appropriately scaled version of the approximate marginal likelihood ",
+        "bbox": [
+            173,
+            547,
+            825,
+            604
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c619b3c6c6265f44ef27ce854d2093675e8576f1b7f4ce2d8aaa70dc74e71624.jpg",
+        "text": "$$\n- \\log p \\left( \\mathbf { X } \\mid \\theta \\right) \\approx \\sum _ { j } \\left[ - \\log p \\left( \\mathbf { X } _ { j } \\mid \\hat { \\phi } _ { j } \\right) - \\log p \\left( \\hat { \\phi } _ { j } \\mid \\theta \\right) + \\frac { 1 } { 2 } \\log \\operatorname* { d e t } ( \\mathbf { H } _ { j } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            207,
+            611,
+            761,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The term $\\log p ( \\hat { \\phi } _ { j } \\mid \\pmb \\theta )$ results from the implicit regularization imposed by early stopping during fast adaptation, as discussed in Section 3.1. The term $\\mathbf { \\omega } ^ { 1 } / 2 \\log \\operatorname* { d e t } ( \\mathbf { H } _ { j } )$ , on the other hand, results from the Laplace approximation and can be interpreted as a form of regularization that penalizes model complexity. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 USING CURVATURE INFORMATION TO IMPROVE MAML ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            726,
+            602,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using (11) as a training criterion for a neural network model is difficult due to the required computation of the determinant of the Hessian of the log posterior $\\mathbf { H } _ { j }$ , which itself decomposes into a sum of the Hessian of the log likelihood and the Hessian of the log prior as ",
+        "bbox": [
+            174,
+            751,
+            825,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a87b231617bfb482de63da8459b93b2b3e69a4abd8dd9c95e8900f2e69c38a04.jpg",
+        "text": "$$\n\\mathbf { H } _ { j } = \\nabla _ { \\phi _ { j } } ^ { 2 } \\left[ - \\log p \\left( \\mathbf { X } _ { j } \\mid \\phi _ { j } \\right) \\right] + \\nabla _ { \\phi _ { j } } ^ { 2 } \\left[ - \\log p \\left( \\phi _ { j } \\mid \\theta \\right) \\right] \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            799,
+            704,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our case of early stopping as regularization, the prior over task-specific parameters $p ( \\phi _ { j } \\mid \\theta )$ is implicit and thus no closed form is available for a general model. Although we may use the quadratic approximation derived in Section 3.2 to obtain an approximate Gaussian prior, this prior is not diagonal and does not, to our knowledge, have a convenient factorization. Therefore, in our experiments, we instead use a simple approximation in which the prior is approximated as a diagonal Gaussian with precision $\\tau$ . We keep $\\tau$ fixed, although this parameter may be cross-validated for improved performance. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3fba0f5acb7a67d2330df937ecbde14031bc2f9d63995377d52960a111bfdb44.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Subroutine ML-LAPLACE (0,T) Draw N samples X1,...,XN ~ pτ(x)</td></tr><tr><td>Update 𝜙 ←Φ+αVlogp(x1,...,Xn|Φ) end Draw M samples XN+1,...,XN+M ~ pτ(x) Estimate quadratic curvature H return -log p(xn+1,,XN+M |Φ) + nlog det(H)</td></tr></table>",
+        "bbox": [
+            174,
+            107,
+            591,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Subroutine 4: Subroutine for computing a Laplace approximation of the marginal likelihood. ",
+        "bbox": [
+            215,
+            273,
+            779,
+            287
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Similarly, the Hessian of the log likelihood is intractable to form exactly for all but the smallest models, and furthermore, is not guaranteed to be positive definite at all points, possibly rendering the Laplace approximation undefined. To combat this, we instead seek a curvature matrix $\\hat { \\bf H }$ that approximates the quadratic curvature of a neural network objective function. Since it is well-known that the curvature associated with neural network objective functions is highly non-diagonal (e.g., Martens, 2016), a further requirement is that the matrix have off-diagonal terms. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            402
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Due to the difficulties listed above, we turn to second order gradient descent methods, which precondition the gradient with an inverse curvature matrix at each iteration of descent. The Fisher information matrix (Fisher, 1925) has been extensively used as an approximation of curvature, giving rise to a method known as natural gradient descent (Amari, 1998). A neural network with an appropriate choice of loss function is a probabilistic model and therefore defines a Fisher information matrix. Furthermore, the Fisher information matrix can be seen to define a convex quadratic approximation to the objective function of a probabilistic neural model (Pascanu & Bengio, 2014; Martens, 2014). Importantly for our use case, the Fisher information matrix is positive definite by definition as well as non-diagonal. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "However, the Fisher information matrix is still expensive to work with. Martens & Grosse (2015) developed Kronecker-factored approximate curvature (K-FAC), a scheme for approximating the curvature of the objective function of a neural network with a block-diagonal approximation to the Fisher information matrix. Each block corresponds to a unique layer in the network, and each block is further approximated as a Kronecker product (see Van Loan, 2000) of two much smaller matrices by assuming that the second-order statistics of the input activation and the back-propagated derivatives within a layer are independent. These two approximations ensure that the inverse of the Fisher information matrix can be computed efficiently for the natural gradient. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the Laplace approximation, we are interested in the determinant of a curvature matrix instead of its inverse. However, we may also make use of the approximations to the Fisher information matrix from K-FAC as well as properties of the Kronecker product. In particular, we use the fact that the determinant of a Kronecker product is the product of the exponentiated determinants of each of the factors, and that the determinant of a block diagonal matrix is the product of the determinants of the blocks (Van Loan, 2000). The determinants for each factor can be computed as efficiently as the inverses required by K-FAC, in $\\mathcal { O } ( d ^ { 3 } )$ time for a $d$ -dimensional Kronecker factor. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            758
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We make use of the Laplace approximation and K-FAC to replace Subroutine 3, which computes the task-specific marginal NLLs using a point estimate for $\\hat { \\phi }$ . We call this method the Lightweight Laplace Approximation for Meta-Adaptation (LLAMA), and give a replacement subroutine in Subroutine 4. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            820
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            847,
+            450,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The goal of our experiments is to evaluate if we can use our probabilistic interpretation of MAML to generate samples from the distribution over adapted parameters, and futhermore, if our method can be applied to large-scale meta-learning problems such as miniImageNet. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5bdf18425b1a88e41686bfb5c980d314c5b5c945c7b8c77312f705a230c570c0.jpg",
+        "image_caption": [
+            "Figure 5: Our method is able to meta-learn a model that can quickly adapt to sinusoids with varying phases and amplitudes, and the interpretation of the method as hierarchical Bayes makes it practical to directly sample models from the posterior. In this figure, we illustrate various samples from the posterior of a model that is meta-trained on different sinusoids, when presented with a few datapoints (in red) from a new, previously unseen sinusoid. Note that the random samples from the posterior predictive describe a distribution of functions that are all sinusoidal and that there is increased uncertainty when the datapoints are less informative (i.e., when the datapoints are sampled only from the lower part of the range input, shown in the bottom-right example). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            103,
+            794,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 WARMUP: TOY NONLINEAR MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            467,
+            435
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The connection between MAML and hierarchical Bayes suggests that we should expect MAML to behave like an algorithm that learns the mean of a Gaussian prior on model parameters, and uses the mean of this prior as an initialization during fast adaptation. Using the Laplace approximation to the integration over task-specific parameters as in (10) assumes a task-specific parameter posterior with mean at the adapted parameters $\\hat { \\phi }$ and covariance equal to the inverse Hessian of the log posterior evaluated at the adapted parameter value. Instead of simply using this density in the Laplace approximation as an additional regularization term as in (11), we may sample parameters $\\phi _ { j }$ from this density and use each set of sampled parameters to form a set of predictions for a given task. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To illustrate this relationship between MAML and hierarchical Bayes, we present a meta-dataset of sinusoid tasks in which each task involves regressing to the output of a sinusoid wave in Figure 5. Variation between tasks is obtained by sampling the amplitude uniformly from [0.1, 5.0] and the phase from $[ 0 , \\pi ]$ . During training and for each task, 10 input datapoints are sampled uniformly from $[ - 1 0 . 0 , 1 0 . \\dot { 0 } ]$ and the loss is the mean squared error between the prediction and the true value. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observe in Figure 5 that our method allows us to directly sample models from the task-specific parameter distribution after being presented with 10 datapoints from a new, previously unseen sinusoid curve. In particular, the column on the right of Figure 5 demonstrates that the sampled models display an appropriate level of uncertainty when the datapoints are ambiguous (as in the bottom right). ",
+        "bbox": [
+            174,
+            643,
+            825,
+            714
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 LARGE-SCALE EXPERIMENT: miniIMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            531,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate LLAMA on the miniImageNet Ravi & Larochelle (2017) 1-shot, 5-way classification task, a standard benchmark in few-shot classification. miniImageNet comprises 64 training classes, 12 validation classes, and 24 test classes. Following the setup of Vinyals et al. (2016), we structure the $N$ -shot, $J$ -way classification task as follows: The model observes $N$ instances of $J$ unseen classes, and is evaluated on its ability to classify $M$ new instances within the $J$ classes. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use a neural network architecture standard to few-shot classification (e.g., Vinyals et al., 2016; Ravi & Larochelle, 2017), consisting of 4 layers with $3 \\times 3$ convolutions and 64 filters, followed by batch normalization (BN) (Ioffe & Szegedy, 2015), a ReLU nonlinearity, and $2 \\times 2$ max-pooling. For the scaling variable $\\beta$ and centering variable $\\gamma$ of BN (see Ioffe & Szegedy, 2015), we ignore the fast adaptation update as well as the Fisher factors for K-FAC. We use Adam (Kingma & Ba, 2014) as the meta-optimizer, and standard batch gradient descent with a fixed learning rate to update the model during fast adaptation. LLAMA requires the prior precision term $\\tau$ as well as an additional parameter $\\eta \\in \\bar { \\mathbb { R } } ^ { + }$ that weights the regularization term log det $\\hat { \\bf H }$ contributed by the Laplace approximation. We fix $\\tau = 0 . 0 0 1$ and selected $\\eta = { { 1 0 } ^ { - 6 } }$ via cross-validation; all other parameters are set to the values reported in Finn et al. (2017). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/629d27d3414eab00f80480073af0e804e5a620251cc0684d60afbbb4bda08a4d.jpg",
+        "table_caption": [
+            "Table 1: One-shot classification performance on the miniImageNet test set, with comparison methods ordered by one-shot performance. All results are averaged over 600 test episodes, and we report ${ \\hat { 9 } } 5 \\%$ confidence intervals. ∗Results reported by Ravi & Larochelle (2017). $^ { * * } \\mathrm { W e }$ report test accuracy for a comparable architecture .1∗∗∗We report test accuracy for models matching train and test “shot” and “way”. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"2\">5-way acc. (%) 1-shot</td></tr><tr><td>Fine-tuning*</td><td>28.86</td><td>士</td><td>0.54</td></tr><tr><td>Nearest Neighbor*</td><td>41.08</td><td>士</td><td>0.70</td></tr><tr><td>Matching Networks FCE (Vinyals et al., 2016)*</td><td>43.56</td><td>士</td><td>0.84</td></tr><tr><td>Meta-LearnerLSTM (Ravi &amp; Larochelle,2017)*</td><td>43.44</td><td>士</td><td>0.77</td></tr><tr><td>SNAIL (Mishra et al., 2018)**</td><td>45.1</td><td>士</td><td></td></tr><tr><td>Prototypical Networks (Snellet al.,2017)***</td><td>46.61</td><td>士</td><td>0.78</td></tr><tr><td>mAP-DLM(Triantafillou et al., 2017)</td><td>49.82</td><td>士</td><td>0.78</td></tr><tr><td>MAML (Finn et al., 2017)</td><td>48.70</td><td>士</td><td>1.84</td></tr><tr><td>LLAMA (Ours)</td><td>49.40</td><td>士</td><td>1.83</td></tr></table>",
+        "bbox": [
+            269,
+            101,
+            727,
+            265
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            342,
+            825,
+            398
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We find that LLAMA is practical enough to be applied to this larger-scale problem. In particular, our TensorFlow implementation of LLAMA trains for 60,000 iterations on one TITAN $\\mathrm { X p }$ GPU in 9 hours, compared to 5 hours to train MAML. As shown in Table 1, LLAMA achieves comparable performance to the state-of-the-art meta-learning method by Triantafillou et al. (2017). While the gap between MAML and LLAMA is small, the improvement from the Laplace approximation suggests that a more accurate approximation to the marginalization over task-specific parameters will lead to further improvements. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            502
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            344,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Meta-learning and few-shot learning have a long history in hierarchical Bayesian modeling (e.g., Tenenbaum, 1999; Fei-Fei et al., 2003; Lawrence & Platt, 2004; Yu et al., 2005; Gao et al., 2008; Daumé III, 2009; Wan et al., 2012). A related subfield is that of transfer learning, which has used hierarchical Bayes extensively (e.g., Raina et al., 2006). A variety of inference methods have been used in Bayesian models, including exact inference (Lake et al., 2011), sampling methods (Salakhutdinov et al., 2012), and variational methods (Edwards & Storkey, 2017). While some prior works on hierarchical Bayesian models have proposed to handle basic image recognition tasks, the complexity of these tasks does not yet approach the kinds of complex image recognition problems that can be solved by discriminatively trained deep networks, such as the miniImageNet experiment in our evaluation (Mansinghka et al., 2013). ",
+        "bbox": [
+            174,
+            560,
+            825,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Recently, the Omniglot benchmark Lake et al. (2016) has rekindled interest in the problem of learning from few examples. Modern methods accomplish few-shot learning either through the design of network architectures that ingest the few-shot training samples directly (e.g., Koch, 2015; Vinyals et al., 2016; Snell et al., 2017; Hariharan & Girshick, 2017; Triantafillou et al., 2017), or formulating the problem as one of learning to learn, or meta-learning (e.g., Schmidhuber, 1987; Bengio et al., 1991; Schmidhuber, 1992; Bengio et al., 1992). A variety of inference methods have been used in Bayesian models, including exact inference (Lake et al., 2011), sampling methods (Salakhutdinov et al., 2013), and variational methods (Edwards & Storkey, 2017). ",
+        "bbox": [
+            174,
+            707,
+            825,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our work bridges the gap between gradient-based meta-learning methods and hierarchical Bayesian modeling. Our contribution is not to formulate the meta-learning problem as a hierarchical Bayesian model, but instead to formulate a gradient-based meta-learner as hierarchical Bayesian inference, thus providing a way to efficiently perform posterior inference in a model-agnostic manner. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            853
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            151,
+            318,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have shown that model-agnostic meta-learning (MAML) estimates the parameters of a prior in a hierarchical Bayesian model. By casting gradient-based meta-learning within a Bayesian framework, our analysis opens the door to novel improvements inspired by probabilistic machinery. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As a step in this direction, we propose an extension to MAML that employs a Laplace approximation to the posterior distribution over task-specific parameters. This technique provides a more accurate estimate of the integral that, in the original MAML algorithm, is approximated via a point estimate. We show how to estimate the quantity required by the Laplace approximation using Kroneckerfactored approximate curvature (K-FAC), a method recently proposed to approximate the quadratic curvature of a neural network objective for the purpose of a second-order gradient descent technique. ",
+        "bbox": [
+            174,
+            232,
+            825,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our contribution illuminates the road to exploring further connections between gradient-based metalearning methods and hierarchical Bayesian modeling. For instance, in this work we assume that the predictive distribution over new data-points is narrow and well-approximated by a point estimate. We may instead employ methods that make use of the variance of the distribution over task-specific parameters in order to model the predictive density over examples from a novel task. ",
+        "bbox": [
+            174,
+            323,
+            825,
+            393
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, it is known that the Laplace approximation is inaccurate in cases where the integral is highly skewed, or is not unimodal and thus is not amenable to approximation by a single Gaussian mode. This could be solved by using a finite mixture of Gaussians, which can approximate many density functions arbitrarily well (Sorenson & Alspach, 1971; Alspach & Sorenson, 1972). The exploration of additional improvements such as this is an exciting line of future work. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            469
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Alspach and Harold Sorenson. Nonlinear Bayesian estimation using Gaussian sum approximations. IEEE Transactions on Automatic Control, 17(4):439–448, 1972. ",
+        "bbox": [
+            176,
+            125,
+            820,
+            151
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shun-Ichi Amari. Natural gradient works efficiently in learning. Neural computation, 10(2):251–276, 1998. ",
+        "bbox": [
+            173,
+            160,
+            810,
+            175
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems (NIPS) 29, pp. 3981–3989, 2016. ",
+        "bbox": [
+            174,
+            184,
+            820,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Yoshua Bengio, Jocelyn Cloutier, and Jan Gecsei. On the optimization of a synaptic learning rule. In Proceedings of the Conference on Optimality in Artificial and Biological Neural Networks, pp. 6–8, 1992. ",
+        "bbox": [
+            174,
+            233,
+            823,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Samy Bengio, and Jocelyn Cloutier. Learning a synaptic learning rule. In Proceedings of the International Joint Conference on Neural Networks (IJCNN), volume 2, 1991. ",
+        "bbox": [
+            174,
+            268,
+            823,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J.M. Bernardo and A.F.M. Smith. Bayesian Theory. Wiley Series in Probability and Statistics. John Wiley & Sons Canada, Limited, 2006. ",
+        "bbox": [
+            174,
+            305,
+            823,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher M Bishop. Regularization and complexity control in feed-forward networks. In Proceedings of the International Conference on Artificial Neural Networks (ICANN), pp. 141–148, 1995. ",
+        "bbox": [
+            173,
+            342,
+            823,
+            369
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Léon Bottou and Vladimir Vapnik. Local learning algorithms. Neural computation, 4(6):888–900, 1992. ",
+        "bbox": [
+            174,
+            377,
+            792,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana. Multitask learning. In Learning to learn, pp. 95–133. Springer, 1998. ",
+        "bbox": [
+            174,
+            401,
+            674,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hal Daumé III. Bayesian multitask learning with latent hierarchies. In Proceedings of the 25th Conference on Uncertainty in Artificial Intelligence (UAI), pp. 135–142, 2009. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Duvenaud, Dougal Maclaurin, and Ryan Adams. Early stopping as nonparametric variational inference. In Proceedings of the 19th International Conference on Artificial Intelligence and Statistics (AISTATS), pp. 1070–1077, 2016. ",
+        "bbox": [
+            173,
+            460,
+            826,
+            501
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Harrison Edwards and Amos Storkey. Towards a neural statistician. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            537
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Li Fei-Fei et al. A Bayesian approach to unsupervised one-shot learning of object categories. In Proceedings of the 9th Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1134–1141. IEEE, 2003. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            173,
+            582,
+            823,
+            609
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronald Aylmer Fisher. Theory of statistical estimation. In Mathematical Proceedings of the Cambridge Philosophical Society, volume 22, pp. 700–725. Cambridge University Press, 1925. ",
+        "bbox": [
+            173,
+            618,
+            823,
+            646
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jing Gao, Wei Fan, Jing Jiang, and Jiawei Han. Knowledge transfer via multiple model local structure mapping. In Proceedings of the 14th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD), pp. 283–291. ACM, 2008. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Gelman, John B Carlin, Hal S Stern, David B Dunson, Aki Vehtari, and Donald B Rubin. Bayesian data analysis, volume 2. Chapman and Hall, 2014. ",
+        "bbox": [
+            171,
+            703,
+            823,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gene H. Golub and Charles F. Van Loan. Matrix computations. The Johns Hopkins University Press, 1983. ",
+        "bbox": [
+            174,
+            739,
+            808,
+            755
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bharath Hariharan and Ross Girshick. Low-shot visual object recognition. In Proceedings of the International Conference on Computer Vision (ICCV), 2017. ",
+        "bbox": [
+            173,
+            763,
+            825,
+            790
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Heskes. Solving a huge number of similar tasks: A combination of multi-task learning and a hierarchical Bayesian approach. In Proceedings of the 15th International Conference on Machine Learning (ICML), pp. 233–241, 1998. ",
+        "bbox": [
+            173,
+            800,
+            826,
+            838
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning (ICML), pp. 448–456, 2015. ",
+        "bbox": [
+            171,
+            848,
+            823,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations (ICLR), 2014. ",
+        "bbox": [
+            171,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregory Koch. Siamese neural networks for one-shot image recognition. Master’s thesis, University of Toronto, 2015. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Ruslan Salakhutdinov, Jason Gross, and Joshua B Tenenbaum. One shot learning of simple visual concepts. In Proceedings of the 33rd Annual Meeting of the Cognitive Science Society (CogSci), 2011. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            166
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Tomer D Ullman, Joshua B Tenenbaum, and Samuel J Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, pp. 1–101, 2016. ",
+        "bbox": [
+            176,
+            174,
+            823,
+            200
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pierre Simon Laplace. Memoir on the probability of the causes of events. Statistical Science, 1(3):364–378, 1986. ",
+        "bbox": [
+            176,
+            208,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Neil D Lawrence and John C Platt. Learning to learn with the informative vector machine. In Proceedings of the 21st International Conference on Machine Learning (ICML), pp. 65, 2004. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            271
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ke Li and Jitendra Malik. Learning to optimize. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017a. ",
+        "bbox": [
+            174,
+            279,
+            823,
+            306
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ke Li and Jitendra Malik. Learning to optimize neural nets. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017b. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            340
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David MacKay. A practical Bayesian framework for backpropagation networks. Neural computation, 4(3): 448–472, 1992a. ",
+        "bbox": [
+            173,
+            348,
+            823,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David JC MacKay. The evidence framework applied to classification networks. Neural computation, 4(5): 720–736, 1992b. ",
+        "bbox": [
+            173,
+            382,
+            823,
+            410
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vikash K Mansinghka, Tejas D Kulkarni, Yura N Perov, and Josh Tenenbaum. Approximate bayesian image interpretation using generative probabilistic graphics programs. In Advances in Neural Information Processing Systems, pp. 1520–1528, 2013. ",
+        "bbox": [
+            173,
+            417,
+            823,
+            458
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "James Martens. New insights and perspectives on the natural gradient method. arXiv preprint arXiv:1412.1193, 2014. ",
+        "bbox": [
+            171,
+            465,
+            825,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "James Martens. Second-order optimization for neural networks. PhD thesis, University of Toronto, 2016. ",
+        "bbox": [
+            173,
+            500,
+            795,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Roger Grosse. Optimizing neural networks with Kronecker-factored approximate curvature. In Proceedings of the 32nd International Conference on Machine Learning (ICML), pp. 2408–2417, 2015. ",
+        "bbox": [
+            173,
+            522,
+            823,
+            550
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. Meta-learning with temporal convolutions. arXiv preprint arXiv:1707.03141, 2017. ",
+        "bbox": [
+            171,
+            558,
+            823,
+            585
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A simple neural attentive meta-learner. In Proceedings of the 6th International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            592,
+            823,
+            621
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsendsuren Munkhdalai and Hong Yu. Meta networks. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            173,
+            627,
+            823,
+            655
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Devang K Naik and RJ Mammone. Meta-neural networks that learn by learning. In Proceedings of the International Joint Conference on Neural Networks (IJCNN), pp. 437–442, 1992. ",
+        "bbox": [
+            174,
+            662,
+            823,
+            690
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu and Yoshua Bengio. Revisiting natural gradient for deep networks. In Proceedings of the 4th International Conference on Learning Representations (ICLR), 2014. ",
+        "bbox": [
+            173,
+            696,
+            821,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rajat Raina, Andrew $\\mathrm { ~ Y ~ N ~ g ~ } _ { }$ , and Daphne Koller. Constructing informative priors using transfer learning. In Proceedings of the $2 3 r d$ International Conference on Machine Learning (ICML), pp. 713–720, 2006. ",
+        "bbox": [
+            174,
+            732,
+            823,
+            760
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruslan Salakhutdinov, Joshua Tenenbaum, and Antonio Torralba. One-shot learning with a hierarchical nonparametric bayesian model. In Proceedings of ICML Workshop on Unsupervised and Transfer Learning, pp. 195–206, 2012. ",
+        "bbox": [
+            173,
+            801,
+            823,
+            842
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruslan Salakhutdinov, Joshua B Tenenbaum, and Antonio Torralba. Learning with hierarchical-deep models. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(8):1958–1971, 2013. ",
+        "bbox": [
+            171,
+            849,
+            823,
+            877
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Meta-learning with memory-augmented neural networks. In Proceedings of the 33rd International Conference on Machine Learning (ICML), pp. 1842–1850, 2016. ",
+        "bbox": [
+            176,
+            885,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Reginaldo J. Santos. Equivalence of regularization and truncated iteration for general ill-posed problems. Linear Algebra and its Applications, 236(15):25–33, 1996.   \nJürgen Schmidhuber. Evolutionary principles in self-referential learning. PhD thesis, Institut für Informatik, Technische Universität München, 1987.   \nJürgen Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent networks. Neural Computation, 4(1):131–139, 1992.   \nJonas Sjöberg and Lennart Ljung. Overtraining, regularization and searching for a minimum, with application to neural networks. International Journal of Control, 62(6):1391–1407, 1995.   \nJake Snell, Kevin Swersky, and Richard S Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems (NIPS) 30, 2017.   \nHarold W Sorenson and Daniel L Alspach. Recursive Bayesian estimation using Gaussian sums. Automatica, 7 (4):465–479, 1971.   \nFlood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip H. S. Torr, and Timothy M. Hospedales. Learning to compare: Relation network for few-shot learning. CoRR, abs/1711.06025, 2017.   \nJoshua B Tenenbaum. A Bayesian framework for concept learning. PhD thesis, Massachusetts Institute of Technology, 1999.   \nSebastian Thrun and Lorien Pratt. Learning to learn. Kluwer Academic Publishers, 1998.   \nEleni Triantafillou, Richard Zemel, and Raquel Urtasun. Few-shot learning through an information retrieval lens. In Advances in Neural Information Processing Systems (NIPS) 30, 2017.   \nCharles F Van Loan. The ubiquitous Kronecker product. Journal of computational and applied mathematics, 123(1):85–100, 2000.   \nOriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in Neural Information Processing Systems (NIPS) 29, pp. 3630–3638, 2016.   \nJing Wan, Zhilin Zhang, Jingwen Yan, Taiyong Li, Bhaskar D Rao, Shiaofen Fang, Sungeun Kim, Shannon L Risacher, Andrew J Saykin, and Li Shen. Sparse Bayesian multi-task learning for predicting cognitive outcomes from neuroimaging measures in Alzheimer’s disease. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 940–947. IEEE, 2012.   \nOlga Wichrowska, Niru Maheswaranathan, Matthew W Hoffman, Sergio Gomez Colmenarejo, Misha Denil, Nando de Freitas, and Jascha Sohl-Dickstein. Learned optimizers that scale and generalize. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017.   \nKai Yu, Volker Tresp, and Anton Schwaighofer. Learning Gaussian processes from multiple tasks. In Proceedings of the 22nd International Conference on Machine Learning (ICML), pp. 1012–1019, 2005. ",
+        "bbox": [
+            171,
+            94,
+            828,
+            660
+        ],
+        "page_idx": 12
+    }
+]

parse/train/BJxh2j0qYm/BJxh2j0qYm.md

@@ -0,0 +1,283 @@
+# Dynamic Channel Pruning: Feature Boosting and Suppression
+
+Xitong Gao $\bot$ ∗, Yiren Zhao $^ 2$ ∗, Lukasz Dudziak $^ 3$ , Robert Mullins4, Cheng-zhong $\mathbf { X u } ^ { \mathrm { 5 } }$
+
+1 Shenzhen Institutes of Advanced Technology, Shenzhen, China   
+2,3,4 University of Cambridge, Cambridge, UK   
+5 University of Macau, Macau, China   
+1 xt.gao@siat.ac.cn, 2 yaz21@cam.ac.uk
+
+# Abstract
+
+Making deep convolutional neural networks more accurate typically comes at the cost of increased computational and memory resources. In this paper, we reduce this cost by exploiting the fact that the importance of features computed by convolutional layers is highly input-dependent, and propose feature boosting and suppression (FBS), a new method to predictively amplify salient convolutional channels and skip unimportant ones at run-time. FBS introduces small auxiliary connections to existing convolutional layers. In contrast to channel pruning methods which permanently remove channels, it preserves the full network structures and accelerates convolution by dynamically skipping unimportant input and output channels. FBS-augmented networks are trained with conventional stochastic gradient descent, making it readily available for many state-of-the-art CNNs. We compare FBS to a range of existing channel pruning and dynamic execution schemes and demonstrate large improvements on ImageNet classification. Experiments show that FBS can respectively provide $5 \times$ and $2 \times$ savings in compute on VGG-16 and ResNet-18, both with less than $0 . 6 \%$ top-5 accuracy loss.
+
+# 1 Introduction
+
+State-of-the-art vision and image-based tasks such as image classification (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015; He et al., 2016), object detection (Ren et al., 2017; Huang et al., 2017) and segmentation (Long et al., 2015) are all built upon deep convolutional neural networks (CNNs). While CNN architectures have evolved to become more efficient, the general trend has been to use larger models with greater memory utilization, bandwidth and compute requirements to achieve higher accuracy. The formidable amount of computational resources used by CNNs present a great challenge in the deployment of CNNs in both cost-sensitive cloud services and low-powered edge computing applications.
+
+One common approach to reduce the memory, bandwidth and compute costs is to prune over-parameterized CNNs. If performed in a coarse-grain manner this approach is known as channel pruning (Ye et al., 2018; He et al., 2017; Liu et al., 2017; Wen et al., 2016). Channel pruning evaluates channel saliency measures and removes all input and output connections from unimportant channels— generating a smaller dense model. A saliency-based pruning method, however, has threefold disadvantages. Firstly, by removing channels, the capabilities of CNNs are permanently lost, and the resulting CNN may never regain its accuracy for difficult inputs for which the removed channels were responsible. Secondly, despite the fact that channel pruning may drastically shrink model size, without careful design, computational resources cannot be effectively reduced in a CNN without a detrimental impact on its accuracy. Finally, the saliency of a neuron is not static, which can be illustrated by the feature visualization in Figure 1. Here, a CNN is shown a set of input images, certain channel neurons in a convolutional output may get highly excited, whereas another set of images elicit little response from the same channels. This is in line with our understanding of CNNs that neurons in a convolutional layer specialize in recognizing distinct features, and the relative importance of a neuron depends heavily on the inputs.
+
+The above shortcomings prompt the question: why should we prune by static importance, if the importance is highly input-dependent? Surely, a more promising alternative is to prune dynamically depending on the current input. A dynamic channel pruning strategy allows the network to learn to prioritize certain convolutional channels and ignore irrelevant ones. Instead of simply reducing model size at the cost of accuracy with pruning, we can accelerate convolution by selectively computing only a subset of channels predicted to be important at run-time, while considering the sparse input from the preceding convolution layer. In effect, the amount of cached activations and the number of read, write and arithmetic operations used by a well-designed dynamic model can be almost identical to an equivalently sparse statically pruned one. In addition to saving computational resources, a dynamic model preserves all neurons of the full model, which minimizes the impact on task accuracy.
+
+In this paper, we propose feature boosting and suppression (FBS) to dynamically amplify and suppress output channels computed by the convolutional layer. Intuitively, we can imagine that the flow of information of each output channel can be amplified or restricted under the control of a “valve”. This allows salient information to flow freely while we stop all information from unimportant channels and skip their computation. Unlike pruning statically, the valves use features from the previous layer to predict the saliency of output channels. With conventional stochastic gradient descent (SGD) methods, the predictor can learn to adapt itself by observing the input and output features of the convolution operation.
+
+FBS introduces tiny auxiliary connections to existing convolutional layers. The minimal overhead added to the existing model is thus negligible when compared to the potential speed up provided by the dynamic sparsity. Existing dynamic computation strategies in CNNs (Lin et al., 2017; Odena et al., 2017; Bolukbasi et al., 2017) produce on/off pruning decisions or execution path selections. Training them thus often resorts to reinforcement learning, which in practice is often computationally expensive. Even though FBS similarly use non-differentiable functions, contrary to these methods, the unified losses are still wellminimized with conventional SGD.
+
+We apply FBS to a custom CIFAR-10 (Krizhevsky et al., 2014) classifier and popular CNN models such as VGG-16 (Simonyan & Zisserman, 2015) and ResNet-18 (He et al., 2016) trained on the ImageNet dataset (Deng et al., 2009). Empirical results show that under the same speed-ups, FBS can produce models with validation accuracies surpassing all other channel pruning and dynamic conditional execution methods examined in the paper.
+
+![](images/ec163895e99a91029cb698a9a91ed95b476b1369b23dfb25f76e0587a202b687.jpg)  
+Figure 1: When images from the ImageNet validation dataset are shown to a pre-trained ResNet-18 (He et al., 2016), the outputs from certain channel neurons may vary drastically. The top rows in (a) and (b) are found respectively to greatly excite neurons in channels 114 and 181 of layer block 3b/conv2, whereas the bottom images elicit little activation from the same channel neurons. The number below each image indicate the maximum values observed in the channel before adding the shortcut and activation. Finally, (c) shows the distribution of maximum activations observed in the first 20 channels.
+
+# 2 Related Work
+
+# 2.1 Structured Sparsity
+
+Since LeCun et al. (1990) introduced optimal brain damage, the idea of creating more compact and efficient CNNs by removing connections or neurons has received significant attention. Early literature on pruning deep CNNs zero out individual weight parameters (Hassibi et al., 1994; Guo et al., 2016). This results in highly irregular sparse connections, which were notoriously difficult for GPUs to exploit. This has prompted custom accelerator solutions that exploit sparse weights (Parashar et al., 2017; Han et al., 2016). Although supporting both sparse and dense convolutions efficiently normally involves some compromises in terms of efficiency or performance.
+
+Alternatively, recent work has thus increasingly focused on introducing structured sparsity (Wen et al., 2016; Ye et al., 2018; Alvarez & Salzmann, 2016; Zhou et al., 2016), which can be exploited by GPUs and allows custom accelerators to focus solely on efficient dense operations. Wen et al. (2016) added group Lasso on channel weights to the model’s training loss function. This has the effect of reducing the magnitude of channel weights to diminish during training, and remove connections from zeroed-out channels. To facilitate this process, Alvarez & Salzmann (2016) additionally used proximal gradient descent, while Li et al. (2017) and He et al. (2018a) proposed to prune channels by thresholds, i.e. they set unimportant channels to zero, and fine-tune the resulting CNN. The objective to induce sparsity in groups of weights may present difficulties for gradient-based methods, given the large number of weights that need to be optimized. A common approach to overcome this is to solve (He et al., 2017) or learn (Liu et al., 2017; Ye et al., 2018) channel saliencies to drive the sparsification of CNNs. He et al. (2017) solved an optimization problem which limits the number of active convolutional channels while minimizing the reconstruction error on the convolutional output. Liu et al. (2017) used Lasso regularization on channel saliencies to induce sparsity and prune channels with a global threshold. Ye et al. (2018) learned to sparsify CNNs with an iterative shrinkage/thresholding algorithm applied to the scaling factors in batch normalization. There are methods (Luo et al., 2017; Zhuang et al., 2018) that use greedy algorithms for channel selection. Huang et al. (2018) and He et al. (2018b) adopted reinforcement learning to train agents to produce channel pruning decisions. PerforatedCNNs, proposed by Figurnov et al. (2016), use predefined masks that are model-agnostic to skip the output pixels in convolutional layers.
+
+# 2.2 Dynamic Execution
+
+In a pruned model produced by structured sparsity methods, the capabilities of the pruned neurons and connections are permanently lost. Therefore, many propose to use dynamic networks as an alternative to structured sparsity. During inference, a dynamic network can use the input data to choose parts of the network to evaluate.
+
+Convolutional layers are usually spatially sparse, i.e. their activation outputs may contain only small patches of salient regions. A number of recent publications exploit this for acceleration. Dong et al. (2017) introduced low-cost collaborative layers which induce spatial sparsity in cheap convolutions, so that the main expensive ones can use the same sparsity information. Figurnov et al. (2017) proposed spatially adaptive computation time for residual networks (He et al., 2016), which learns the number of residual blocks required to compute a certain spatial location. Almahairi et al. (2016) presented dynamic capacity networks, which use the gradient of a coarse output’s entropy to select salient locations in the input image for refinement. Ren et al. (2018) assumed the availability of $a$ priori spatial sparsity in the input image, and accelerated the convolutional layer by computing non-sparse regions.
+
+There are dynamic networks that make binary decisions or multiple choices for the inference paths taken. BlockDrop, proposed by Wu et al. (2018), trains a policy network to skip blocks in residual networks. Liu & Deng (2018) proposed conditional branches in deep neural networks (DNNs), and used Q-learning to train the branching policies. Odena et al. (2017) designed a DNN with layers containing multiple modules, and decided which module to use with a recurrent neural network (RNN). Lin et al. (2017) learned an RNN to adaptively prune channels in convolutional layers. The on/off decisions commonly used in these networks cannot be represented by differentiable functions, hence the gradients are not well-defined. Consequently, the dynamic networks above train their policy functions by reinforcement learning. There exist, however, methods that workaround such limitations. Shazeer et al. (2017) introduced sparsely-gated mixture-of-experts and used a noisy ranking on the backpropagate-able gating networks to select the expensive experts to evaluate. Bolukbasi et al. (2017) trained differentiable policy functions to implement early exits in a DNN. Hua et al. (2018) learned binary policies that decide whether partial or all input channels are used for convolution, but approximate the gradients of the non-differentiable policy functions with continuous ones.
+
+# 3 Feature Boosting and Suppression
+
+We start with a high-level illustration (Figure 2) of how FBS accelerates a convolutional layer with batch normalization (BN). The auxiliary components (in red) predict the importance of each output channel based on the input features, and amplify the output features accordingly. Moreover, certain output channels are predicted to be entirely suppressed (or zero-valued as represented by $\varTheta$ ), such output sparsity information can advise the convolution operation to skip the computation of these channels, as indicated by the dashed arrow. It is notable that the expensive convolution can be doubly accelerated by skipping the inactive channels from both the input features and the predicted output channel saliencies. The rest of this section provides detailed explanation of the components in Figure 2.
+
+![](images/00841c99e6441664d8e5cf5e76ee9ffd57468d400db2d18166279b67b9b3218e.jpg)  
+Figure 2: A high level view of a convolutional layer with FBS. By way of illustration, we use the $l ^ { \mathrm { t h } }$ layer with 8-channel input and output features, where channels are colored to indicate different saliencies, and the white blocks $( \boxed { \mathcal { Q } } )$ represent all-zero channels.
+
+# 3.1 Preliminaries
+
+For simplicity, we consider a deep sequential batch-normalized (Ioffe & Szegedy, 2015) CNN with $L$ convolutional layers, i.e ${ \bf \therefore } \ { \bf x } _ { L } = F ( { \bf x } _ { 0 } ) = f _ { L } \left( \cdot \cdot \cdot f _ { 2 } ( f _ { 1 } ( { \bf x } _ { 0 } ) \right) \cdot \cdot \cdot { \bf \cdot } ) $ , where the $l ^ { \mathrm { t h } }$ layer $f _ { l } : \mathbb { R } ^ { C _ { l - 1 } \times H _ { l - 1 } \times W _ { l - 1 } } \to \mathbb { R } ^ { C _ { l } \times H _ { l } \times W _ { l } }$ computes the features $\mathbf { x } _ { l } \in \mathbb { R } ^ { C _ { l } \times H _ { l } \times W _ { l } }$ , which comprise of $C _ { l }$ channels of features with height $H _ { l }$ and width $W _ { l }$ . The $l ^ { \mathrm { t h } }$ layer is thus defined as:
+
+$$
+f _ { l } \left( \mathbf { x } _ { l - 1 } \right) = ( \gamma _ { l } \cdot \mathsf { n o r m } \left( \mathsf { c o n v } _ { l } \left( \mathbf { x } _ { l - 1 } , \pmb { \theta } _ { l } \right) \right) + \beta _ { l } ) _ { + } .
+$$
+
+Here, additions $( + )$ and multiplications $( \cdot )$ are element-wise, $( \mathbf { z } ) _ { + } = \operatorname* { m a x } \left( \mathbf { z } , 0 \right)$ denotes the ReLU activation, $\gamma _ { l } , \beta _ { l } \in \mathbb { R } ^ { C _ { l } }$ are trainable parameters, norm $\mathbf { \rho } ( \mathbf { z } )$ normalizes each channel of features $\mathbf { z }$ across the population of $\mathbf { z }$ , with $\mu _ { \mathbf { z } } , \pmb { \sigma } _ { \mathbf { z } } ^ { 2 } \in \mathbb { R } ^ { C _ { l } }$ respectively containing the population mean and variance of each channel, and a small $\epsilon$ prevents division by zero:
+
+$$
+\mathsf { n o r m } \left( \mathbf { z } \right) = \frac { \mathbf { z } - \mu _ { \mathbf { z } } } { \sqrt { \pmb { \sigma } _ { \mathbf { z } } ^ { 2 } + \epsilon } } .
+$$
+
+Additionally, convl $\left( \mathbf { x } _ { l - 1 } , \pmb { \theta } _ { l } \right)$ computes the convolution of input features using the weight tensor $\pmb { \theta } _ { l } \in \mathbb { R } ^ { C ^ { l } \times C ^ { l - 1 } \times k ^ { 2 } }$ , where $k$ −is the kernel size. Specifically, FBS concerns the
+
+optimization of convl $\left( \mathbf { x } _ { l - 1 } , \pmb { \theta } _ { l } \right)$ functions, as a CNN spends the majority of its inference time in them, using $k ^ { 2 } C _ { l - 1 } C _ { l } H _ { l } W _ { l }$ multiply-accumulate operations (MACs) for the $l ^ { \mathrm { t h } }$ layer.
+
+# 3.2 Designing a Dynamic Layer
+
+Consider the following generalization of a layer with dynamic execution:
+
+$$
+\hat { f } \left( \mathbf { x } , \cdots \right) = f \left( \mathbf { x } , \pmb { \theta } , \cdots \right) \cdot \pi \left( \mathbf { x } , \pmb { \phi } , \cdots \right) ,
+$$
+
+where $f$ and $\pi$ respectively use weight parameters $\pmb { \theta }$ and $\phi$ and may have additional inputs, and compute tensors of the same output shape, denoted by $\mathbf { F }$ and $\mathbf { G }$ . Intuitively, the expensive $\mathbf { F } ^ { [ \mathbf { i } ] }$ can always be skipped for any index i whenever the cost-effective $\mathbf { G } ^ { [ \mathbf { i } ] }$ evaluates to $\mathbf { 0 }$ . Here, the superscript [i] is used to index the $\mathbf { i } ^ { \mathrm { t h } }$ slice of the tensor. For example, if we have features $\mathbf { F } \in \mathbb { R } ^ { C \times H \times W }$ containing $C$ channels of $H$ -by- $W$ features, $\mathbf { F } ^ { \left\lfloor c \right\rfloor } \in \mathbb { R } ^ { H \times W }$ retrieves the $c ^ { \mathrm { t h } }$ feature image. We can further sparsify and accelerate the layer by adding, for instance, a Lasso on $\pi$ to the total loss, where $\mathbb { E } _ { \mathbf { x } } \left[ \mathbf { z } \right]$ is the expectation of $\mathbf { z }$ over $\mathbf { x }$ :
+
+$$
+\mathcal { R } \left( \mathbf { x } \right) = \mathbb { E } _ { \mathbf { x } } \left[ \left. \pi \left( \mathbf { x } , \phi , \cdot \cdot \cdot \right) \right. _ { 1 } \right] ,
+$$
+
+Despite the simplicity of this formulation, it is however very tricky to design $\hat { f }$ properly. Under the right conditions, we can arbitrarily minimize the Lasso while maintaining the same output from the layer by scaling parameters. For example, in low-cost collaborative layers (Dong et al., 2017), $f$ and $\pi$ are simply convolutions (with or without ReLU activation) that respectively have weights $\pmb { \theta }$ and $\phi$ . Since $f$ and $\pi$ are homogeneous functions, one can always halve $\phi$ and double $\pmb { \theta }$ to decrease (4) while the network output remains the same. In other words, the optimal network must have $\| \phi \| _ { \infty }  0$ , which is infeasible in finiteprecision arithmetic. For the above reasons, Dong et al. (2017) observed that the additional loss in (4) always degrades the CNN’s task performance. Ye et al. (2018) pointed out that gradient-based training algorithms are highly inefficient in exploring such reparameterization patterns, and channel pruning methods may experience similar difficulties. Shazeer et al. (2017) avoided this limitation by finishing $\pi$ with a softmax normalization, but (4) can no longer be used as the softmax renders the $\ell ^ { 1 }$ -norm, which now evaluates to 1, useless. In addition, similar to sigmoid, softmax (without the cross entropy) is easily saturated, and thus may equally suffer from vanishing gradients. Many instead design $\pi$ to produce on/off decisions and train them with reinforcement learning as discussed in Section 2.
+
+# 3.3 Feature Boosting and Suppression with Channel Saliencies
+
+Instead of imposing sparsity on features or convolutional weight parameters (e.g. Wen et al. (2016); Alvarez & Salzmann (2016); Li et al. (2017); He et al. (2018a)), recent channel pruning methods (Liu et al., 2017; Ye et al., 2018) induce sparsity on the BN scaling factors $\gamma _ { l }$ . Inspired by them, FBS similarly generates a channel-wise importance measure. Yet contrary to them, instead of using the constant BN scaling factors $\gamma _ { l }$ , we predict channel importance and dynamically amplify or suppress channels with a parametric function $\pi ( \mathbf { x } _ { l - 1 } )$ dependent on the output from the previous layer $\mathbf x l - 1$ . Here, we propose to replace the layer definition $f _ { l } \left( \mathbf { x } _ { l - 1 } \right)$ for each of $l \in [ 1 , L ]$ with $\hat { f } _ { l } \left( \mathbf { x } _ { l - 1 } \right)$ which employs dynamic channel pruning:
+
+$$
+\hat { f } _ { l } \left( \mathbf { x } _ { l - 1 } \right) = \left( \pi _ { l } \left( \mathbf { x } _ { l - 1 } \right) \cdot \left( \mathsf { n o r m } \left( \mathsf { c o n v } _ { l } \left( \mathbf { x } _ { l - 1 } , \pmb { \theta } _ { l } \right) \right) + \beta _ { l } \right) \right) _ { + } ,
+$$
+
+where a low-overhead policy $\pi _ { l } \left( \mathbf { x } _ { l - 1 } \right)$ evaluates the pruning decisions for the computationally demanding conv $\left( \mathbf { x } _ { l - 1 } , \pmb { \theta } _ { l } \right)$ :
+
+$$
+\pi _ { l } \left( \mathbf { x } _ { l - 1 } \right) = \mathsf { w t a } _ { \lceil d C _ { l } \rceil } \left( g _ { l } \left( \mathbf { x } _ { l - 1 } \right) \right) .
+$$
+
+Here, ${ \mathsf { w t a } } _ { k } ( { \mathbf { z } } )$ is a $k$ -winners-take-all function, i.e. it returns a tensor identical to $\mathbf { z }$ , except that we zero out entries in $\mathbf { z }$ that are smaller than the $k$ largest entries in absolute magnitude. In other words, $\mathsf { w t a } _ { \lceil d C _ { l } \rceil } \bigl ( g _ { l } \bigl ( \mathbf { x } _ { l - 1 } \bigr ) \bigr )$ provides a pruning strategy that computes only $\lceil d C _ { l } \rceil$ most salient channels predicted by $g _ { l } ( \mathbf { x } _ { l - 1 } )$ , and suppresses the remaining channels with zeros. In Section 3.4, we provide a detailed explanation of how we design a cheap $g _ { l } ( \mathbf { x } _ { l - 1 } )$ that learns to predict channel saliencies.
+
+It is notable that our strategy prunes $C _ { l } - \lceil d C _ { l } \rceil$ least salient output channels from $l ^ { \mathrm { t h } }$ layer, where the density $d \in ] 0 , 1 ]$ can be varied to sweep the trade-off relationship between performance and accuracy. Moreover, pruned channels contain all-zero values. This allows the subsequent $( l + 1 ) ^ { \mathrm { t h } }$ layer to trivially make use of input-side sparsity, since all-zero features can be safely skipped even for zero-padded layers. Because all convolutions can exploit both input- and output-side sparsity, the speed-up gained from pruning is quadratic with respect to the pruning ratio. For instance, dynamically pruning half of the channels in all layers gives rise to a dynamic CNN that uses approximately $\frac { 1 } { 4 }$ of the original MACs.
+
+Theoretically, FBS does not introduce the reparameterization discussed in Section 3.2. By batch normalizing the convolution output, the convolution kernel $\theta _ { l }$ is invariant to scaling. Computationally, it is more efficient to train. Many alternative methods use nondifferentiable $\pi$ functions that produce on/off decisions. In general, DNNs with these policy functions are incompatible with SGD, and resort to reinforcement learning for training. In contrast, (6) allows end-to-end training, as wta is a piecewise differentiable and continuous function like ReLU. Srivastava et al. (2015) suggested that in general, a network is easier and faster to train for complex tasks and less prone to catastrophic forgetting, if it uses functions such as wta that promote local competition between many subnetworks.
+
+# 3.4 Learning to Predict Channel Saliencies
+
+This section explains the design of the channel saliency predictor $g _ { l } ( \mathbf { x } _ { l - 1 } )$ . To avoid significant computational cost in $g _ { l }$ , we subsample $\mathbf x _ { l - 1 }$ by reducing the spatial dimensions of each channel to a scalar using the following function $\mathsf { s s } : \mathbb { R } ^ { C \times H \times W } \to \mathbb { R } ^ { C }$ :
+
+$$
+\mathfrak { s s } \left( \mathbf { x } _ { l - 1 } \right) = \frac { 1 } { H W } \left[ \mathfrak { s } \left( \mathbf { x } _ { l - 1 } ^ { [ 1 ] } \right) \ \mathfrak { s } \left( \mathbf { x } _ { l - 1 } ^ { [ 2 ] } \right) \ \cdot \ \cdot \ \mathfrak { s } \left( \mathbf { x } _ { l - 1 } ^ { [ C ] } \right) \right] ,
+$$
+
+where $\mathsf { s } \left( \mathbf { x } _ { l - 1 } ^ { [ c ] } \right)$ reduces the $c ^ { \mathrm { t h } }$ channel of $\mathbf { z }$ to a scalar using, for instance, the $\ell ^ { 1 }$ -norm $\| \mathbf { x } _ { l - 1 } ^ { [ c ] } \| _ { 1 }$ , $\ell ^ { 2 }$ -norm, $\ell ^ { \infty }$ -norm, or the variance of $\mathbf { x } _ { l - 1 } ^ { [ c ] }$ . The results in Section 4 use the $\ell ^ { 1 }$ - −  − norm by default, which is equivalent to global average pooling for the ReLU activated $\mathbf x l - 1$ . We then design $g _ { l } ( \mathbf { x } _ { l - 1 } )$ − to predict channel saliencies with a fully connected layer following −the subsampled activations $\mathsf { s s } \left( \mathbf { x } _ { l - 1 } \right)$ , where $\phi _ { l } \in \mathbb { R } ^ { C ^ { l } \times C ^ { l - 1 } }$ is the weight tensor of the layer:
+
+$$
+g _ { l } \left( \mathbf { x } _ { l - 1 } \right) = \left( \mathsf { s s } \left( \mathbf { x } _ { l - 1 } \right) \phi _ { l } + \pmb { \rho } _ { l } \right) _ { + } .
+$$
+
+We generally initialize $\rho _ { l }$ with $1$ and apply He et al. (2015)’s initialization to $\phi _ { l }$ . Similar to how Liu et al. (2017) and Ye et al. (2018) induced sparsity in the BN scaling factors, we regularize all layers with the Lasso on $g _ { l } ( \mathbf { x } _ { l - 1 } )$ : $\begin{array} { r l } {  { \lambda \sum _ { l = 1 } ^ { L } \mathbb { E } _ { \mathbf { x } } [  g _ { l } ( \mathbf { x } _ { l - 1 } )  _ { 1 } ] } \quad } & { { } } \end{array}$ in the total loss, where $\lambda = 1 0 ^ { - 8 }$ in our experiments.
+
+# 4 Experiments
+
+We ran extensive experiments on CIFAR-10 (Krizhevsky et al., 2014) and the ImageNet ILSVRC2012 (Deng et al., 2009), two popular image classification datasets. We use MCifarNet (Zhao et al., 2018), a custom 8-layer CNN for CIFAR-10 (see Appendix A for its structure), using only 1.3 M parameters with 91.37% and 99.67% top-1 and top-5 accuracies respectively. M-CifarNet is much smaller than a VGG-16 on CIFAR-10 (Liu et al., 2017), which uses $2 0 \mathrm { M }$ parameters and only $2 . 2 9 \%$ more accurate. Because of its compactness, our CNN is more challenging to accelerate. By faithfully reimplementing Network Slimming (NS) (Liu et al., 2017), we closely compare FBS with NS under various speedup constraints. For ILSVRC2012, we augment two popular CNN variants, ResNet-18 (He et al., 2016) and VGG-16 (Simonyan & Zisserman, 2015), and provide detailed accuracy/MACs trade-off comparison against recent structured pruning and dynamic execution methods.
+
+Our method begins by first replacing all convolutional layer computations with (5), and initializing the new convolutional kernels with previous parameters. Initially, we do not suppress any channel computations by using density $d = 1$ in (6) and fine-tune the resulting network. For fair comparison against NS, we then follow Liu et al. (2017) by iteratively decrementing the overall density $d$ of the network by 10% in each step, and thus gradually using fewer channels to sweep the accuracy/performance trade-off. The difference is that NS prunes channels by ranking globally, while FBS prunes around $1 - d$ of each layer.
+
+# 4.1 CIFAR-10
+
+![](images/bf0b69083c0580f998d0a893355ef98d28a82ea3f6269d64ac066bec0980aa44.jpg)  
+Figure 3: Experimental results on M-CifarNet. We compare in (a) the accuracy/MACs trade-off between FBS, NS and FBS $^ +$ NS. The baseline is emphasized by the circle $\bigcirc$ . The heat map in (b) reveals the individual probability of skipping a channel for each channel ( $x$ -axis), when an image of a category ( $y$ -axis) is shown to the network with $d = 1$ .
+
+By respectively applying NS and FBS to our CIFAR-10 classifier and incrementally increasing sparsity, we produce the trade-off relationships between number of operations (measured in MACs) and the classification accuracy as shown in Figure 3a. FBS clearly surpasses NS in its ability to retain the task accuracy under an increasingly stringent computational budget. Besides comparing FBS against NS, we are interested in combining both methods, which demonstrates the effectiveness of FBS if the model is already less redundant, i.e. it cannot be pruned further using NS without degrading the accuracy by more than $1 \%$ . The composite method (NS+FBS) is shown to successfully regain most of the lost accuracy due to NS, producing a trade-off curve closely matching FBS. It is notable that under the same $9 0 . 5 0 \%$ accuracy constraints, FBS, NS+FBS, and NS respectively achieve $3 . 9 3 \times$ , $3 . 2 2 \times$ , and $1 . 1 9 \times$ speed-up ratios. Conversely for a $2 \times$ speed-up target, they respectively produce models with accuracies not lower than $9 1 . 5 5 \%$ , $9 0 . 9 0 \%$ and $8 7 . 5 4 \%$ .
+
+Figure 3b demonstrates that our FBS can effectively learn to amplify and suppress channels when dealing with different input images. The 8 heat maps respectively represent the channel skipping probabilities of the 8 convolutional layers. The brightness of the pixel at location $( x , y )$ denotes the probability of skipping the $x ^ { \mathrm { t h } }$ channel when looking at an image of the $y ^ { \mathrm { t h } }$ category. The heat maps verify our belief that the auxiliary network learned to predict which channels specialize to which features, as channels may have drastically distinct probabilites of being used for images of different categories. The model here is a M-CifarNet using FBS with $d = 0 . 5$ , which has a top-1 accuracy of $9 0 . 5 9 \%$ (top-5 $9 9 . 6 5 \%$ ). Moreover, channels in the heat maps are sorted so the channels that are on average least frequently evaluated are placed on the left, and channels shaded in stripes are never evaluated. The network in Figure 3b is not only approximately $4 \times$ faster than the original, by removing the unused channels, we also reduce the number of weights by 2.37 $\times$ . This reveals that FBS naturally subsumes channel pruning strategies such as NS, as we can simply prune away channels that are skipped regardless of the input. It is notable that even though we specified a universal density $d$ , FBS learned to adjust its dynamicity across all layers, and prune different ratios of channels from the convolutional layers.
+
+# 4.2 ImageNet ILSVRC2012 Classification
+
+By applying FBS and NS respectively to ResNet-18, we saw that the ILSVRC2012 validation accuracy of FBS consistently outperforms NS under different speed-up constraints (see Appendix B for the implementation details and trade-off curves). For instance, at $d = 0 . 7$ , it utilizes only 1.12 G MACs (1.62 $\times$ fewer) to achieve a top-1 error rate of $3 1 . 5 4 \%$ , while NS requires 1.51 G MACs (1.21 $\times$ fewer) for a similar error rate of $3 1 . 7 0 \%$ . When compared across recent dynamic execution methods examined in Table 1, FBS demonstrates simultaneously the highest possible speed-up and the lowest error rates. It is notable that the baseline accuracies for FBS refer to a network that has been augmented with the auxiliary layers featuring FBS but suppress no channels, i.e. $d = 1$ . We found that this method brings immediate accuracy improvements, an increase of $1 . 7 3 \%$ in top-1 and $0 . 4 6 \%$ in top-5 accuracies, to the baseline network, which is in line with our observation on M-CifarNet.
+
+In Table 2, we compare different structured pruning and dynamic execution methods to FBS for VGG-16 (see Appendix B for the setup). At a speed-up of 3.01 $\times$ , FBS shows a minimal increase of $0 . 4 4 \%$ and $0 . 0 4 \%$ in top-1 and top-5 errors respectively. At $5 . 2 3 \times$ speed-up, it only degrades the top-1 error by $1 . 0 8 \%$ and the top-5 by $0 . 5 9 \%$ .
+
+Not only does FBS use much fewer MACs, it also demonstrates significant reductions in bandwidth and memory requirements. In Table 3, we observe a large reduction in the number of memory accesses in single image inference as we simply do not access suppressed weights and activations. Because these memory operations are often costly DRAM accesses, minimizing them leads to power-savings. Table 3 further reveals that in diverse application scenarios such as low-end and cloud environments, the peak memory usages by the optimized models are much smaller than the originals, which in general improves cache utilization.
+
+Table 1: Comparisons of error rates of the baseline and accelerated ResNet-18 models.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Dynamic</td><td colspan="2">Baseline</td><td colspan="2">Accelerated</td><td rowspan="2">MAC saving</td></tr><tr><td>Top-1</td><td>Top-5</td><td>Top-1</td><td>Top-5</td></tr><tr><td>Soft Filter Pruning (He et al., 2018a)</td><td></td><td>29.72</td><td>10.37</td><td>32.90</td><td>12.22</td><td>1.72×</td></tr><tr><td>Network Slimming (Liu et al. (20l7),our implementation)</td><td></td><td>31.02</td><td>11.32</td><td>32.79</td><td>12.61</td><td>1.39×</td></tr><tr><td>Discrimination-aware Channel Pruning (Zhuang et al., 2018)</td><td></td><td>30.36</td><td>11.02</td><td>32.65</td><td>12.40</td><td>1.89×</td></tr><tr><td>Low-cost Collaborative Layers (Dong et al., 2017)</td><td></td><td>30.02</td><td>10.76</td><td>33.67</td><td>13.06</td><td>1.53×</td></tr><tr><td>Channel Gating Neural Networks (Hua et al., 2018)</td><td>广</td><td>30.98</td><td>11.16</td><td>32.60</td><td>12.19</td><td>1.61×</td></tr><tr><td>Feature Boosting and Suppression (FBS)</td><td>√</td><td>29.29</td><td>10.32</td><td>31.83</td><td>11.78</td><td>1.98×</td></tr></table>
+
+Table 2: Comparisons of top-5 error rate increases for VGG-16 on ILSVRC2012 validation set under 3 $\times$ , 4 $\times$ and $5 \times$ speed-up constraints. The baseline has a $1 0 . 1 \%$ top-5 error rate. Results from He et al. (2017) only show numbers with one digit after the decimal point.   
+
+<table><tr><td>Method</td><td>Dynamic</td><td>△ top-5 errors 3× 4×</td><td></td><td>(%) 5×</td></tr><tr><td>Filter Pruning (Li et al. (20l7),reproduced by He et al. (2017))</td><td rowspan="10"></td><td></td><td>8.6</td><td>14.6</td></tr><tr><td>Perforated CNNs (Figurnov et al., 2016)</td><td>3.7</td><td>5.5</td><td></td></tr><tr><td>Network Slimming (Liu et al. (20i7),our implementation)</td><td>1.37</td><td>3.26</td><td>5.18</td></tr><tr><td>Runtime Neural Pruning (Lin et al., 2017)</td><td>2.32</td><td>3.23</td><td>3.58</td></tr><tr><td>Channel Pruning (He et al., 2017)</td><td>0.0</td><td>1.0</td><td>1.7</td></tr><tr><td>AutoML for Model Compression (He et al., 2018b)</td><td></td><td></td><td>1.4</td></tr><tr><td>ThiNet-Conv (Luo et al., 2017)</td><td>0.37</td><td></td><td></td></tr><tr><td>Feature Boosting and Suppression (FBS)</td><td></td><td>0.04 0.52</td><td>0.59</td></tr></table>
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Total Memory Accesses</td><td colspan="2">PeakMemory Usage</td></tr><tr><td>Weights</td><td>Activations</td><td>Edge (1 image)</td><td>Cloud (128 images)</td></tr><tr><td>VGG-16</td><td>56.2MB</td><td>86.5MB</td><td>24.6MB</td><td>3.09GB</td></tr><tr><td>VGG-16 3×</td><td>23.9 MB (2.35x)</td><td>40.8MB (2.12×)</td><td>9.97MB (2.47×)</td><td>1.24 GB (2.47×)</td></tr><tr><td>ResNet-18</td><td>44.6MB</td><td>17.8MB</td><td>9.19MB</td><td>0.47 GB</td></tr><tr><td>ResNet-18 2×</td><td>20.5MB (2.18×)</td><td>12.3 MB (1.45×)</td><td>4.68MB (1.96x)</td><td>0.31GB (1.49×)</td></tr></table>
+
+Table 3: Comparisons of the memory accesses and peak memory usage of the ILSVRC2012 classifiers with FBS respectively under $3 \times$ and $2 \times$ inference speed-ups. The Weights and Activations columns respectively show the total amount of weight and activation accesses required by all convolutions for a single image inference. The Peak Memory Usage columns show the peak memory usages with different batch sizes.
+
+# 5 Conclusion
+
+In summary, we proposed feature boosting and suppression that helps CNNs to achieve significant reductions in the compute required while maintaining high accuracies. FBS fully preserves the capabilities of CNNs and predictively boosts important channels to help the accelerated models retain high accuracies. We demonstrated that FBS achieves around 2 $\times$ and $5 \times$ savings in computation respectively on ResNet-18 and VGG-16 within $0 . 6 \%$ loss of top-5 accuracy. Under the same performance constraints, the accuracy gained by FBS surpasses all recent structured pruning and dynamic execution methods examined in this paper. In addition, it can serve as an off-the-shelf technique for accelerating many popular CNN networks and the fine-tuning process is unified in the traditional SGD which requires no algorithmic changes in training. Finally, the implementation of FBS and the optimized networks are fully open source and released to the public1.
+
+# Acknowledgements
+
+This work is supported in part by the National Key R&D Program of China (No.   
+2018YFB1004804), the National Natural Science Foundation of China (No. 61806192).   
+We thank EPSRC for providing Yiren Zhao his doctoral scholarship.
+
+# References
+
+Amjad Almahairi, Nicolas Ballas, Tim Cooijmans, Yin Zheng, Hugo Larochelle, and Aaron Courville. Dynamic capacity networks. In Proceedings of the 33rd International Conference on International Conference on Machine Learning (ICML), pp. 2549–2558, 2016.
+
+Jose M Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 2270–2278. 2016.
+
+Tolga Bolukbasi, Joseph Wang, Ofer Dekel, and Venkatesh Saligrama. Adaptive neural networks for efficient inference. In Proceedings of the 34th International Conference on Machine Learning (ICML), pp. 527–536, 2017.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A large-scale hierarchical image database. In IEEE Conference on Computer Vision and Pattern Recognition, 2009.
+
+Xuanyi Dong, Junshi Huang, Yi Yang, and Shuicheng Yan. More is less: A more complicated network with less inference complexity. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Michael Figurnov, Maxwell D. Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially adaptive computation time for residual networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Mikhail Figurnov, Aizhan Ibraimova, Dmitry P Vetrov, and Pushmeet Kohli. PerforatedCNNs: Acceleration through elimination of redundant convolutions. In Advances in Neural Information Processing Systems (NIPS), pp. 947–955, 2016.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient DNNs. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A Horowitz, and William J Dally. Eie: efficient inference engine on compressed deep neural network. In Computer Architecture (ISCA), 2016 ACM/IEEE 43rd Annual International Symposium on, pp. 243–254. IEEE, 2016.
+
+Babak Hassibi, David G. Stork, and Gregory Wolff. Optimal brain surgeon: Extensions and performance comparisons. In J. D. Cowan, G. Tesauro, and J. Alspector (eds.), Advances in Neural Information Processing Systems (NIPS), pp. 263–270. 1994.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV ’15, pp. 1026– 1034, Washington, DC, USA, 2015. IEEE Computer Society. ISBN 978-1-4673-8391-2. doi: 10.1109/ICCV.2015.123.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. In International Joint Conference on Artificial Intelligence (IJCAI), pp. 2234–2240, 2018a.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. IEEE International Conference on Computer Vision (ICCV), pp. 1398–1406, 2017.
+
+Yihui He, Ji Lin, Zhijian Liu, Hanrui Wang, Li-Jia Li, and Song Han. AMC: AutoML for model compression and acceleration on mobile devices. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 784–800, 2018b.
+
+Weizhe Hua, Christopher De Sa, Zhiru Zhang, and G. Edward Suh. Channel gating neural networks. CoRR, abs/1805.12549, 2018. URL http://arxiv.org/abs/1805.12549.
+
+J. Huang, V. Rathod, C. Sun, M. Zhu, A. Korattikara, A. Fathi, I. Fischer, Z. Wojna, Y. Song, S. Guadarrama, and K. Murphy. Speed/accuracy trade-offs for modern convolutional object detectors. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3296–3297, July 2017.
+
+Qiangui Huang, Kevin Zhou, Suya You, and Ulrich Neumann. Learning to prune filters in convolutional neural networks. In IEEE Winter Conference on Computer Vision. 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning (ICML), pp. 448–456, 2015.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NIPS). 2012.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The CIFAR-10 and CIFAR-100 datasets. http://www.cs.toronto.edu/ kriz/cifar.html, 2014.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In Advances in Neural Information Processing Systems (NIPS), pp. 598–605. 1990.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. 2017.
+
+Ji Lin, Yongming Rao, Jiwen Lu, and Jie Zhou. Runtime neural pruning. In Advances in Neural Information Processing Systems (NIPS), pp. 2181–2191. 2017.
+
+Lanlan Liu and Jia Deng. Dynamic deep neural networks: Optimizing accuracy-efficiency trade-offs by selective execution. 2018.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In International Conference on Computer Vision (ICCV), 2017.
+
+J. Long, E. Shelhamer, and T. Darrell. Fully convolutional networks for semantic segmentation. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3431–3440, June 2015.
+
+Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. ThiNet: A filter level pruning method for deep neural network compression. In ICCV, pp. 5058–5066, 2017.
+
+Augustus Odena, Dieterich Lawson, and Christopher Olah. Changing model behavior at test-time using reinforcement learning. 2017.
+
+Angshuman Parashar, Minsoo Rhu, Anurag Mukkara, Antonio Puglielli, Rangharajan Venkatesan, Brucek Khailany, Joel Emer, Stephen W Keckler, and William J Dally. Scnn: An accelerator for compressed-sparse convolutional neural networks. In ACM SIGARCH Computer Architecture News, volume 45, pp. 27–40. ACM, 2017.
+
+Mengye Ren, Andrei Pokrovsky, Bin Yang, and Raquel Urtasun. SBNet: Sparse blocks network for fast inference. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+S. Ren, K. He, R. Girshick, and J. Sun. Faster R-CNN: Towards real-time object detection with region proposal networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 39(6):1137–1149, June 2017.
+
+Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-ofexperts layer. 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR), 2015.
+
+Rupesh Kumar Srivastava, Jonathan Masci, Faustino J. Gomez, and J¨urgen Schmidhuber. Understanding locally competitive networks. In International Conference on Learning Representations (ICLR), 2015.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems (NIPS), pp. 2074–2082. 2016.
+
+Zuxuan Wu, Tushar Nagarajan, Abhishek Kumar, Steven Rennie, Larry S. Davis, Kristen Grauman, and Rogerio Feris. BlockDrop: Dynamic inference paths in residual networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Jianbo Ye, Xin Lu, Zhe L. Lin, and James Z. Wang. Rethinking the smaller-norm-lessinformative assumption in channel pruning of convolution layers. In International Conference on Learning Representations (ICLR), 2018.
+
+Yiren Zhao, Xitong Gao, Robert Mullins, and Chengzhong Xu. Mayo: A framework for autogenerating hardware friendly deep neural networks. In Proceedings of 2nd International Workshop on Embedded and Mobile Deep Learning, EMDL ’18. ACM, 2018. doi: 10.1145/ 3212725.3212726. URL http://doi.acm.org/10.1145/3212725.3212726.
+
+Hao Zhou, Jose M. Alvarez, and Fatih Porikli. Less is more: Towards compact cnns. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling (eds.), Computer Vision – ECCV 2016, pp. 662–677, Cham, 2016. Springer International Publishing. ISBN 978-3-319- 46493-0.
+
+Zhuangwei Zhuang, Mingkui Tan, Bohan Zhuang, Jing Liu, Yong Guo, Qingyao Wu, Junzhou Huang, and Jinhui Zhu. Discrimination-aware channel pruning for deep neural networks. In Advances in Neural Information Processing Systems (NIPS). 2018.
+
+# A Details of M-CifarNet on CIFAR-10
+
+For the CIFAR-10 classification task, we use M-CifarNet, a custom designed CNN, with less than 1.30 M parameters and takes 174 M MACs to perform inference for a 32-by-32 RGB image. The architecture is illustrated in Table 4, where all convolutional layers use $3 \times 3$ kernels, the Shape column shows the shapes of each layer’s features, and pool7 is a global average pooling layer.
+
+We trained M-CifarNet (see Appendix A) with a 0.01 learning rate and a 256 batch size. We reduced the learning rate by a factor of $1 0 \times$ for every 100 epochs. To compare FBS against NS fairly, every model with a new target MACs budget were consecutively initialized with the previous model, and trained for a maximum of 300 epochs, which is enough for all models to converge to the best obtainable accuracies. For NS, we follow Liu et al. (2017) and start training with an $\ell ^ { 1 }$ -norm sparsity regularization weighted by $1 0 ^ { - 5 }$ on the BN scaling factors. We then prune at 150 epochs and fine-tune the resulting network without the sparsity regularization.
+
+We additionally employed image augmentation procedures from Krizhevsky et al. (2012) to preprocess each training example. Each CIFAR-10 example was randomly horizontal flipped and slightly perturbed in the brightness, saturation and hue.
+
+Table 4 additionally provides further comparisons of layer-wise compute costs between FBS, NS, and the composition of the two methods (NS $^ +$ FBS). It is notable that the FBS column has two different output channel counts, where the former is the number of computed channels for each inference, and the latter is the number of channels remaining in the layer after removing the unused channels.
+
+Table 4: The network structure of M-CifarNet for CIFAR-10 classification. In addition, we provide a detailed per-layer MACs comparison between FBS, NS, and the composition of them (NS+FBS). We minimize the models generated by the three methods while maintaining a classification accuracy of at least $9 0 . 5 \%$ .   
+
+<table><tr><td>Layer</td><td>Shape</td><td colspan="4">Number of MACs (Output Channels) Original NS FBS</td></tr><tr><td>convo</td><td>30 × 30</td><td></td><td></td><td>893k</td><td>NS+FBS</td></tr><tr><td>conv1</td><td>30 × 30</td><td>1.5 M (64)</td><td>1.3M (52) 27.0M (64)</td><td>(32/62) 8.4M (32/42)</td><td>860k (32) 10.2M (39)</td></tr><tr><td>conv2</td><td>15 ×15</td><td>33.2M (64)</td><td></td><td>4.2M</td><td>5.9M</td></tr><tr><td></td><td>15×15</td><td>16.6M (128)</td><td>15.9 M (123)</td><td>(64/67) 8.3M</td><td>（74 11.6 M</td></tr><tr><td>conv3</td><td>15 ×15</td><td>33.2M (128)</td><td>31.9M (128)</td><td>(64/79)</td><td>（77）</td></tr><tr><td>conv4 conv5</td><td>8×8</td><td>33.2M (128) 14.1M</td><td>33.1M (128) 13.4M (182)</td><td>8.3M (64/83)</td><td>12.1M (77)</td></tr><tr><td>conv6</td><td>8×8</td><td>(192) (192)</td><td>11.6 M (111)</td><td>3.6 M (96/128)</td><td>4.9M (110) 4.3M (67)</td></tr><tr><td>conv7</td><td>8×8</td><td>21.2M 21.2M</td><td>12.3 M</td><td>5.4M (96/152)</td><td></td></tr><tr><td>pool7</td><td></td><td>(192)</td><td>(192)</td><td>5.4 M (96/96)</td><td>4.5M (116)</td></tr><tr><td>fc</td><td>1×1 1×1</td><td>1.9k (10)</td><td>1.9k (10)</td><td>960 (10)</td><td>1.1k (10)</td></tr><tr><td></td><td></td><td>174.3M</td><td>146.5M</td><td></td><td></td></tr><tr><td>Total Saving</td><td></td><td>1</td><td>1.19×</td><td>44.3M 3.93×</td><td>54.2M 3.21×</td></tr></table>
+
+Figure 4 shows how the skipping probabilites heat maps of the convolutional layer conv4 evolve as we fine-tune FBS-augmented M-CifarNet. The network was trained for 12 epochs, and we saved the model at every epoch. The heat maps are generated with the saved models in sequence, where we apply the same reordering to all heat map channels with the sorted result from the first epoch. It can be observed that as we train the network, the channel skipping probabilites become more pronounced.
+
+![](images/0ac2dbb3a50aafe67f3efd4e38811dfbcd9c7c0d1019acfb820610f3f0cc6d8a.jpg)  
+Figure 4: The training history of a convolutional layer conv4 in M-CifarNet. The history is visualized by the 12 skipping probabilites heat maps, where the heights denote the 10 categories in CIFAR-10, and channels in conv4 occupy the width.
+
+# B Details of the ILSVRC2012 classifiers
+
+ILSVRC2012 classifiers, i.e. ResNet-18 and VGG-16, were trained with a procedure similar to Appendix A. The difference was that they were trained for a maximum of 35 epochs, the learning rate was decayed for every 20 epochs, and NS models were all pruned at 15 epochs. For image preprocessing, we additionally cropped and stretched/squeezed images randomly following Krizhevsky et al. (2012).
+
+Since VGG-16 is computationally intensive with over 15 G MACs, We first applied NS on VGG-16 to reduce the computational and memory requirements, and ease the training of the FBS-augmented variant. We assigned a $1 \%$ budget in top-5 accuracy degradation and compressed the network using NS, which gave us a smaller VGG-16 with $2 0 \%$ of all channels pruned. The resulting network is a lot less redundant, which almost halves the compute requirements, with only 7.90 G MACs remaining. We then apply FBS to the well-compressed network.
+
+Residual networks (He et al., 2016), such as ResNet-18, adopt sequential structure of residual blocks: $\mathbf { x } _ { b } = K \left( \mathbf { x } _ { b - 1 } \right) + F \left( \mathbf { x } _ { b - 1 } \right)$ , where $\mathbf { x } _ { b }$ is the output of the $b ^ { \mathrm { t h } }$ block, $K$ is either an identity function or a downsampling convolution, and $F ^ { \prime }$ consists of a sequence of convolutions. For residual networks, we directly apply FBS to all convolutional layers, with a difference in the way we handle the feature summation. Because the $\left( b + 1 \right) ^ { \mathrm { t h } }$ block receives as input the sum of the two features with sparse channels $K \left( \mathbf { x } _ { b - 1 } \right)$ and $F \left( \mathbf { x } _ { b - 1 } \right)$ , a certain channel of this sum is treated as sparse when the same channels in both features are simultaneously sparse.
+
+Figure 5 compares the accuracy/performance trade-off curves between FBS and NS for ResNet-18.
+
+![](images/03cc25e4465c9126a92eedc919885878b989aaaa077f60070dd89df8fb2e157e.jpg)  
+Figure 5: The accuracy/performance trade-off comparison between NS and FBS for ResNet18 on the ImageNet ILSVRC2012 validation set.

parse/train/S1fQSiCcYm/S1fQSiCcYm.md

@@ -0,0 +1,308 @@
+# UNDERSTANDING AND IMPROVING INTERPOLATION IN AUTOENCODERS VIA AN ADVERSARIAL REGULARIZER
+
+David Berthelot∗ Google Brain dberth@google.com
+
+Colin Raffel∗   
+Google Brain   
+craffel@gmail.com   
+Aurko Roy   
+Google Brain   
+aurkor@google.com   
+Ian Goodfellow   
+Google Brain   
+goodfellow@google.com
+
+# ABSTRACT
+
+Autoencoders provide a powerful framework for learning compressed representations by encoding all of the information needed to reconstruct a data point in a latent code. In some cases, autoencoders can “interpolate”: By decoding the convex combination of the latent codes for two datapoints, the autoencoder can produce an output which semantically mixes characteristics from the datapoints. In this paper, we propose a regularization procedure which encourages interpolated outputs to appear more realistic by fooling a critic network which has been trained to recover the mixing coefficient from interpolated data. We then develop a simple benchmark task where we can quantitatively measure the extent to which various autoencoders can interpolate and show that our regularizer dramatically improves interpolation in this setting. We also demonstrate empirically that our regularizer produces latent codes which are more effective on downstream tasks, suggesting a possible link between interpolation abilities and learning useful representations.
+
+# 1 INTRODUCTION
+
+One goal of unsupervised learning is to uncover the underlying structure of a dataset without using explicit labels. A common architecture used for this purpose is the autoencoder, which learns to map datapoints to a latent code from which the data can be recovered with minimal information loss. Typically, the latent code is lower dimensional than the data, which indicates that autoencoders can perform some form of dimensionality reduction. For certain architectures, the latent codes have been shown to disentangle important factors of variation in the dataset which makes such models useful for representation learning (Chen et al., 2016a; Higgins et al., 2017). In the past, they were also used for pre-training other networks by being trained on unlabeled data and then being stacked to initialize a deep network (Bengio et al., 2007; Vincent et al., 2010). More recently, it was shown that imposing a prior on the latent space allows autoencoders to be used for probabilistic or generative modeling (Kingma & Welling, 2014; Rezende et al., 2014; Makhzani et al., 2015).
+
+In some cases, autoencoders have shown the ability to interpolate. Specifically, by mixing codes in latent space and decoding the result, the autoencoder can produce a semantically meaningful combination of the corresponding datapoints. Interpolation has been frequently reported as a qualitative experimental result in studies about autoencoders (Dumoulin et al., 2016; Bowman et al., 2015; Roberts et al., 2018; Mescheder et al., 2017; Mathieu et al., 2016; Ha & Eck, 2018) and latent-variable generative models in general (Dinh et al., 2016; Radford et al., 2015; van den Oord et al., 2016). The ability to interpolate can be useful in its own right e.g. for creative applications (Carter & Nielsen, 2017). However, it also indicates that the autoencoder can “extrapolate” beyond the training data and has learned a latent space with a particular structure. Specifically, if interpolating between two points in latent space produces a smooth semantic warping in data space, this suggests that nearby points in latent space are semantically similar. A visualization of this idea is shown in fig. 1, where a smooth interpolation between a “2” and a “9” suggests that the 2 is surrounded by semantically similar points, i.e. other 2s. This property may suggest that an autoencoder which interpolates well could also provide a good learned representation for downstream tasks because similar points are clustered. If the interpolation is not smooth, there may be “discontinuities” in latent space which could result in the representation being less useful as a learned feature. This connection between interpolation and a “flat” data manifold has been explored in the context of unsupervised representation learning (Bengio et al., 2013b) and regularization (Verma et al., 2018).
+
+![](images/5630761622d92221bde976e9ee4da80f4d47ac78ed0050620eafd2c13a506e28.jpg)  
+Figure 1: Successful interpolation suggests that semantically similar points may be clustered together in latent space.
+
+![](images/611fdc6f66b401e9eaa12590a538cddbffa0dc1156d6e0afd94a714f10b7e1a2.jpg)  
+Figure 2: Adversarially Constrained Autoencoder Interpolation (ACAI). A critic network is fed interpolants and reconstructions and tries to predict the interpolation coefficient $\alpha$ corresponding to its input (with $\alpha = 0$ for reconstructions). The autoencoder is trained to fool the critic into outputting $\alpha = 0$ for interpolants.
+
+Given the widespread use of interpolation as a qualitative measure of autoencoder performance, we believe additional investigation into the connection between interpolation and representation learning is warranted. Our goal in this paper is threefold: First, we introduce a regularization strategy with the specific goal of encouraging improved interpolations in autoencoders (section 2); second, we develop a synthetic benchmark where the slippery concept of a “semantically meaningful interpolation” is quantitatively measurable (section 3.1) and evaluate common autoencoders on this task (section 3.2); and third, we confirm the intuition that good interpolation can result in a useful representation by showing that the improved interpolation ability produced by our regularizer elicits improved representation learning performance on downstream tasks (section 4). We also make our codebase available1 which provides a unified implementation of many common autoencoders including our proposed regularizer.
+
+# 2 AN ADVERSARIAL REGULARIZER FOR IMPROVING INTERPOLATIONS
+
+Autoencoders, also called auto-associators (Bourlard & Kamp, 1988), consist of the following structure: First, an input $x \in \mathbb { R } ^ { d _ { x } }$ is passed through an “encoder” $z = f _ { \boldsymbol { \theta } } ( x )$ parametrized by $\theta$ to obtain a latent code $z \in \mathbb { R } ^ { d _ { z } }$ . The latent code is then passed through a “decoder” $\hat { x } = g _ { \phi } ( z )$ parametrized by $\phi$ to produce an approximate reconstruction $\hat { \boldsymbol { x } } \in \mathbb { R } ^ { d _ { x } }$ of the input $x$ . We consider the case where $f _ { \theta }$ and $g _ { \phi }$ are implemented as multi-layer neural networks. The encoder and decoder are trained simultaneously (i.e. with respect to $\theta$ and $\phi$ ) to minimize some notion of distance between the input $x$ and the output $\hat { x }$ , for example the squared $L _ { 2 }$ distance $\| x - { \hat { x } } \| ^ { 2 }$ .
+
+Interpolating using an autoencoder describes the process of using the decoder $g _ { \phi }$ to decode a mixture of two latent codes. Typically, the latent codes are combined via a convex combination, so that interpolation amounts to computing $\hat { x } _ { \alpha } = g _ { \phi } ( \alpha z _ { 1 } + ( 1 - \alpha ) z _ { 2 } )$ for some $\alpha \in [ 0 , 1 ]$ where $z _ { 1 } = f _ { \theta } ( x _ { 1 } )$ and $z _ { 2 } = f _ { \theta } ( x _ { 2 } )$ are the latent codes corresponding to data points $x _ { 1 }$ and $x _ { 2 }$ . We also experimented with spherical interpolation which has been used in settings where the latent codes are expected to have spherical structure (Huszar, 2017; White, 2016; Roberts et al., 2018), but found it made no ´ discernible difference in practice for any autoencoder we studied. Ideally, adjusting $\alpha$ from 0 to 1 will produce a sequence of realistic datapoints where each subsequent $\hat { x } _ { \alpha }$ is progressively less semantically similar to $x _ { 1 }$ and more semantically similar to $x _ { 2 }$ . The notion of “semantic similarity” is problem-dependent and ill-defined; we discuss this further in section 3.
+
+2.1 ADVERSARIALLY CONSTRAINED AUTOENCODER INTERPOLATION (ACAI)
+
+As mentioned above, a high-quality interpolation should have two characteristics: First, that intermediate points along the interpolation are indistinguishable from real data; and second, that the intermediate points provide a semantically smooth morphing between the endpoints. The latter characteristic is hard to enforce because it requires defining a notion of semantic similarity for a given dataset, which is often hard to explicitly codify. So instead, we propose a regularizer which encourages interpolated datapoints to appear realistic, or more specifically, to appear indistinguishable from reconstructions of real datapoints. We find empirically that this constraint results in realistic and smooth interpolations in practice (section 3.1) in addition to providing improved performance on downstream tasks (section 4).
+
+To enforce this constraint we introduce a critic network (Goodfellow et al., 2014) which is fed interpolations of existing datapoints (i.e. $\hat { x } _ { \alpha }$ as defined above). Its goal is to predict $\alpha$ from $\hat { x } _ { \alpha }$ , i.e. to predict the mixing coefficient used to generate its input. When training the model, for each pair of training data points we randomly sample a value of $\alpha$ to produce $\hat { x } _ { \alpha }$ . In order to resolve the ambiguity between predicting $\alpha$ and $1 - \alpha$ , we constrain $\alpha$ to the range $[ 0 , 0 . 5 ]$ when feeding $\hat { x } _ { \alpha }$ to the critic. In contrast, the autoencoder is trained to fool the critic to think that $\alpha$ is always zero. This is achieved by adding an additional term to the autoencoder’s loss to optimize its parameters to fool the critic. In a loose sense, the critic can be seen as approximating an “adversarial divergence” (Liu et al., 2017; Arora et al., 2017) between reconstructions and interpolants which the autoencoder tries to minimize.
+
+Formally, let $d _ { \omega } ( x )$ be the critic network, which for a given input produces a scalar value. The critic is trained to minimize
+
+$$
+\mathcal { L } _ { d } = \| d _ { \omega } ( \hat { x } _ { \alpha } ) - \alpha \| ^ { 2 } + \| d _ { \omega } ( \gamma x + ( 1 - \gamma ) \hat { x } ) \| ^ { 2 }
+$$
+
+where, as above, $\hat { x } _ { \alpha } = g _ { \phi } ( \alpha f _ { \theta } ( x _ { 1 } ) + ( 1 - \alpha ) f _ { \theta } ( x _ { 2 } ) )$ , $\hat { x } = g _ { \phi } ( f _ { \theta } ( x ) )$ for some $x$ (not necessarily $x _ { 1 }$ or $x _ { 2 }$ ), and $\gamma$ is a scalar hyperparameter. The first term trains the critic to recover $\alpha$ from $\hat { x } _ { \alpha }$ . The second term serves as a regularizer with two functions: First, it enforces that the critic consistently outputs 0 for non-interpolated inputs; and second, by interpolating between $x$ and $\hat { x }$ (the autoencoder’s reconstruction of $x$ ) in data space it ensures the critic is exposed to realistic data even when the autoencoder’s reconstructions are poor. We found the second term was not crucial for our approach, but helped stabilize the convergence of the autoencoder and allowed us to use consistent hyperparameters and architectures across all datasets and experiments. The autoencoder’s loss function is modified by adding a regularization term:
+
+$$
+\mathcal { L } _ { f , g } = \Vert x - g _ { \phi } ( f _ { \theta } ( x ) ) \Vert ^ { 2 } + \lambda \Vert d _ { \omega } ( \hat { x } _ { \alpha } ) \Vert ^ { 2 }
+$$
+
+where $\lambda$ is a scalar hyperparameter which controls the weight of the regularization term. Note that the regularization term is effectively trying to make the critic output 0 regardless of the value of $\alpha$ , thereby “fooling” the critic into thinking that an interpolated input is non-interpolated (i.e., having $\alpha = 0$ ). The parameters $\theta$ and $\phi$ are optimized with respect to $\mathcal { L } _ { f , g }$ (which gives the autoencoder access to the critic’s gradients) and $\omega$ is optimized with respect to $\mathcal { L } _ { d }$ . We refer to the use of this regularizer as Adversarially Constrained Autoencoder Interpolation (ACAI). A diagram of the ACAI is shown in fig. 2. Assuming an effective critic, the autoencoder successfully “wins” this adversarial game by producing interpolated points which are indistinguishable from reconstructed data. We find in practice that encouraging this behavior also produces semantically smooth interpolations and improved representation learning performance, which we demonstrate in the following sections. Our loss function is similar to the one used in the Least Squares Generative Adversarial Network (Mao et al., 2017) in the sense that they both measure the distance between a critic’s output and a scalar using a squared L2 loss. However, they are substantially different in that ours is used as a regularizer for autoencoders rather than for generative modeling and our critic attempts to regress the interpolation coefficient $\alpha$ instead of a fixed scalar hyperparameter.
+
+Note that the only thing ACAI encourages is that interpolated points appear realistic. The critic only ever sees a single reconstruction or interpolant at a time; it is never fed real datapoints or latent vectors. It therefore will only be able to successfully recover $\alpha$ if the quality of the autoencoder’s output degrades consistently across an interpolation as a function of $\alpha$ (as seen, for example, in fig. 3a where interpolated points become successively blurrier and darker). ACAI’s primary purpose is to discourage this behavior. In doing so, it may implicitly modify the structure of the latent space learned by the autoencoder, but ACAI itself does not directly impose a specific structure. Our goal in introducing ACAI is to test whether simply encouraging better interpolation behavior produces a better representation for downstream tasks. Further, in contrast with the standard Generative Adversarial Network (GAN) setup (Goodfellow et al., 2014), ACAI does not distinguish between “real” and “fake” data; rather, it simply attempts to regress the interpolation coefficient $\alpha$ . Furthermore, GANs are a generative modeling technique, not a representation learning technique; in this paper, we focus on autoencoders and their ability to learn useful representations.
+
+# 3 AUTOENCODERS, AND HOW THEY INTERPOLATE
+
+How can we measure whether an autoencoder interpolates effectively and whether our proposed regularization strategy achieves its stated goal? As mentioned in section 2, defining interpolation relies on the notion of “semantic similarity” which is a vague and problem-dependent concept. For example, a definition of interpolation along the lines of $^ { \mathrm { \infty } } \alpha z _ { 1 } \mathrm { ~ + ~ } ( 1 - \mathrm { \bar { \alpha } } ) z _ { 2 }$ should map to $\alpha x _ { 1 } \bar { + } ( 1 - \alpha ) { x _ { 2 } } ^ { \bar { \gamma } }$ is overly simplistic because interpolating in “data space” often does not result in realistic datapoints – in images, this corresponds to simply fading between the pixel values of the two images. Instead, we might hope that our autoencoder smoothly morphs between salient characteristics of $x _ { 1 }$ and $x _ { 2 }$ , even when they are dissimilar. Put another way, we might hope that decoded points along the interpolation smoothly traverse the underlying manifold of the data instead of simply interpolating in data space. However, we rarely have access to the underlying data manifold. To make this problem more concrete, we introduce a simple benchmark task where the data manifold is simple and known a priori which makes it possible to quantify interpolation quality. We then evaluate the ability of various common autoencoders to interpolate on our benchmark. Finally, we test ACAI on our benchmark and show that it exhibits dramatically improved performance and qualitatively superior interpolations.
+
+# 3.1 AUTOENCODING LINES
+
+Given that the concept of interpolation is difficult to pin down, our goal is to define a task where a “correct” interpolation between two datapoints is unambiguous and well-defined. This will allow us to quantitatively evaluate the extent to which different autoencoders can successfully interpolate. Towards this goal, we propose the task of autoencoding $3 2 \times 3 2$ grayscale images of lines. We consider 16-pixel-long lines beginning from the center of the image and extending outward at an angle $\Lambda \in [ 0 , 2 \pi ]$ (or put another way, lines are radii of the circle circumscribed within the image borders). An example of 16 such images is shown in fig. 4a (appendix A.1). In this task, the data manifold can be defined entirely by a single variable: $\Lambda$ . We can therefore define a valid interpolation from $x _ { 1 }$ to $x _ { 2 }$ as one which smoothly and linearly adjusts $\Lambda$ from the angle of the line in $x _ { 1 }$ to the angle in $x _ { 2 }$ . We further require that the interpolation traverses the shortest path possible along the data manifold. We provide some concrete examples of good and bad interpolations, shown and described in appendix A.1.
+
+On any dataset, our desiderata for a successful interpolation are that intermediate points look realistic and provide a semantically meaningful morphing between its endpoints. On this synthetic lines dataset, we can formalize these notions as specific evaluation metrics, which we describe in detail in appendix A.2. To summarize, we propose two metrics: Mean Distance and Smoothness. Mean Distance measures the average distance between interpolated points and “real” datapoints. Smoothness measures whether the angles of the interpolated lines follow a linear trajectory between the angle of the start and endpoint. Both of these metrics are simple to define due to our construction of a dataset where we exactly know the data distribution and manifold; we provide a full definition and justification in appendix A.2. A perfect alignment would achieve 0 for both scores; larger values indicate a failure to generate realistic interpolated points or produce a smooth interpolation respectively. By choosing a synthetic benchmark where we can explicitly measure the quality of an interpolation, we can confidently evaluate different autoencoders on their interpolation abilities.
+
+To evaluate an autoencoder on the synthetic lines task, we randomly sample line images during training and compute our evaluation metrics on a separate randomly-sampled test set of images. Note that we never train any autoencoder explicitly to produce an optimal interpolation; “good” interpolation is an emergent property which occurs only when the architecture, loss function, training procedure, etc. produce a suitable latent space.
+
+Table 1: Scores achieved by different autoencoders on the synthetic line benchmark (lower is better).   
+
+<table><tr><td>Metric</td><td>Baseline</td><td>Denoising</td><td>VAE</td><td>AAE</td><td>VQ-VAE</td><td>ACAI</td></tr><tr><td>Mean Distance ( （×10-3)</td><td>6.88±0.21</td><td>4.21±0.32</td><td>1.21±0.17</td><td>3.26±0.19</td><td>5.41±0.49</td><td>0.24±0.01</td></tr><tr><td>Smoothness</td><td>0.44±0.04</td><td>0.66±0.02</td><td>0.49±0.13</td><td>0.14±0.02</td><td>0.77±0.02</td><td>0.10±0.01</td></tr></table>
+
+![](images/ec36ffc7cb437f33fb80e7cef44a912d2b91f3875e4be808b7576abc3083aa00.jpg)  
+Figure 3: Interpolations on the synthetic lines benchmark produced by (a) baseline auto-encoder, (b) denoising autoencoder, (c) Variational Autoencoder, (d) Adversarial Autoencoder, (e) Vector Quantized Variational Autoencoder, (f) Adversarially Constrained Autoencoder Interpolation (our model). While we only show one example here, the behavior of each autoencoder was generally similar for all interpolations. A more comprehensive measure of interpolation behavior is given in table 1.
+
+# 3.2 AUTOENCODERS
+
+In this section, we describe various common autoencoder structures and objectives and try them on the lines task. Our goal is to quantitatively evaluate the extent to which standard autoencoders exhibit useful interpolation behavior. Our results, which we describe below, are summarized in table 1.
+
+Base Model Perhaps the most basic autoencoder structure is one which simply maps input datapoints through a “bottleneck” layer whose dimensionality is smaller than the input. In this setup, $f _ { \theta }$ and $g _ { \phi }$ are both neural networks which respectively map the input to a deterministic latent code $z$ and then back to a reconstructed input. Typically, $f _ { \theta }$ and $g _ { \phi }$ are trained simultaneously with respect to $\| x - { \hat { x } } \| ^ { 2 }$ . We will use this framework as a baseline for experimentation for all of the autoencoder variants discussed below. In particular, for our base model and all of the other autoencoders we will use the model architecture and training procedure described in appendix B. As a short summary, our encoder consists of a stack of convolutional and average pooling layers, whereas the decoder consists of convolutional and nearest-neighbor upsampling layers. For experiments on the synthetic “lines” task, we use a latent dimensionality of 64. Note that, because the data manifold is effectively onedimensional, we might expect autoencoders to be able to model this dataset using a one-dimensional latent code; however, using a larger latent code reflects the realistic scenario where the latent space is larger than necessary. After training our baseline autoencoder, we achieved a Mean Distance score which was the worst (highest) of all of the autoencoders we studied, though the Smoothness was on par with various other approaches. In general, we observed some reasonable interpolations when using the baseline model, but found that the intermediate points on the interpolation were typically not realistic as seen in the example interpolation in fig. 3a.
+
+Denoising Autoencoder An early modification to the standard autoencoder setup was proposed by Vincent et al. (2010), where instead of feeding $x$ into the autoencoder, a corrupted version $\tilde { x } \sim q ( \tilde { x } | x )$ is sampled from the conditional probability distribution $q ( \tilde { x } | x )$ and is fed into the autoencoder instead. The autoencoder’s goal remains to produce $\hat { x }$ which minimizes $\| x - { \hat { x } } \| ^ { 2 }$ . One justification of this approach is that the corrupted inputs should fall outside of the true data manifold, so the autoencoder must learn to map points from outside of the data manifold back onto it. This provides an implicit way of defining and learning the data manifold via the coordinate system induced by the latent space.
+
+While various corruption procedures $q ( \tilde { x } | x )$ have been used such as masking and salt-and-pepper noise, in this paper we consider the simple case of additive isotropic Gaussian noise where $\tilde { x } \sim$ ${ \mathcal { N } } ( x , \sigma ^ { 2 } I )$ and $\sigma$ is a hyperparameter. After tuning $\sigma$ , we found simply setting $\sigma = 1 . 0$ to work best. Interestingly, we found the denoising autoencoder often produced “data-space” interpolation (as seen in fig. 3b) when interpolating in latent space. This resulted in comparatively poor Mean Distance and Smoothness scores.
+
+Variational Autoencoder The Variational Autoencoder (VAE) (Kingma & Welling, 2014; Rezende et al., 2014) introduces the constraint that the latent code $z$ is a random variable distributed according to a prior distribution $p ( z )$ . The encoder $f _ { \theta }$ can then be considered an approximation to the posterior $p ( z | x )$ . Then, the decoder $g _ { \phi }$ is taken to parametrize the likelihood $p ( x \bar { | } \bar { z } )$ ; in all of our experiments, we consider $x$ to be Bernoulli distributed. The latent distribution constraint is enforced by an additional loss term which measures the KL divergence between approximate posterior and prior. VAEs then use log-likelihood for the reconstruction loss (cross-entropy in the case of Bernoulli-distributed data), which results in the following combined loss function: $- \mathbb { E } [ \log g _ { \phi } ( z ) ] + \mathrm { K L } ( f _ { \theta } ( x ) | | p ( z ) )$ where the expectation is taken with respect to $z \sim f _ { \theta } ( x )$ and $\mathrm { K L } ( \cdot | | \cdot )$ is the KL divergence. Minimizing this loss function can be considered maximizing a lower bound (the “ELBO”) on the likelihood of the training set, producing a likelihood-based generative model which allows novel data points to be sampled by first sampling $z \sim p ( z )$ and then computing $g _ { \phi } ( z )$ . A common choice is to let $q ( z | x )$ be a diagonalcovariance Gaussian, in which case backpropagation through sampling from $q ( z | x )$ is feasible via the “reparametrization trick” which replaces $\bar { z } \sim \mathcal { N } ( \mu , \bar { \sigma I } )$ with $\epsilon \sim \mathcal { N } ( 0 , I ) , z = \mu + \sigma \odot \epsilon$ where $\bar { \mu } , \sigma \in \mathbb { R } ^ { d _ { z } }$ are the predicted mean and standard deviation produced by $f _ { \theta }$ . Various modified objectives (Higgins et al., 2017; Zhao et al., 2017), improved prior distributions (Kingma et al., 2016; Tomczak & Welling, 2016; 2017) and improved model architectures (Sønderby et al., 2016; Chen et al., 2016b; Gulrajani et al., 2016) have been proposed to better the VAE’s performance on downstream tasks, but in this paper we solely consider the “vanilla” VAE objective and prior described above applied to our baseline autoencoder structure.
+
+When trained on the lines benchmark, we found the VAE was able to effectively model the data distribution (see samples, fig. 5 in appendix C) and accurately reconstruct inputs. In interpolations produced by the VAE, intermediate points tend to look realistic, but the angle of the lines do not follow a smooth or short path (fig. 3c). This resulted in a very good Mean Distance score but a very poor Smoothness score. Contrary to expectations, this suggests that desirable interpolation behavior may not follow from an effective generative model of the data distribution.
+
+Adversarial Autoencoder The Adversarial Autoencoder (AAE) (Makhzani et al., 2015) proposes an alternative way of enforcing structure on the latent code. Instead of minimizing a KL divergence between the distribution of latent codes and a prior distribution, a critic network is trained in tandem with the autoencoder to predict whether a latent code comes from $f _ { \theta }$ or from the prior $p ( z )$ . The autoencoder is simultaneously trained to reconstruct inputs (via a standard reconstruction loss) and to “fool” the critic. The autoencoder is allowed to backpropagate gradients through the critic’s loss function, but the autoencoder and critic parameters are optimized separately. This effectively computes an “adversarial divergence” between the latent code distribution and the chosen prior. This framework was later generalized and referred to as the “Wasserstein Autoencoder” (Tolstikhin et al., 2017) One advantage of this approach is that it allows for an arbitrary prior (as opposed to those which have a tractable KL divergence). The disadvantages are that the AAE no longer has a probabilistic interpretation and involves optimizing a minimax game, which can cause instabilities.
+
+Using the AAE requires choosing a prior, a critic structure, and a training scheme for the critic. For simplicity, we also used a spherical Gaussian prior for the AAE. We experimented with various architectures for the critic, and found the best performance with a critic which consisted of two dense layers, each with 100 units and a leaky ReLU nonlinearity. We found it satisfactory to simply use the same optimizer and learning rate for the critic as was used for the autoencoder. On our lines benchmark, the AAE typically produced smooth interpolations, but exhibited degraded quality in the middle of interpolations (fig. 3d). This behavior produced the best Smoothness score among existing autoencoders, but a relatively poor Mean Distance score.
+
+Vector Quantized Variational Autoencoder (VQ-VAE) The Vector Quantized Variational Autoencoder (VQ-VAE) was introduced by (van den Oord et al., 2017) as a way to train discrete-latent autoencoders using a learned codebook. In the VQ-VAE, the encoder $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ produces a continuous hidden representation $z \in \mathbb { R } _ { z } ^ { d }$ which is then mapped to $z _ { q }$ , its nearest neighbor in a “codebook” $\{ e _ { j } \in \mathbb { R } ^ { d _ { z } } , j \in 1 , \ldots , K \}$ . $z _ { q }$ is then passed to the decoder for reconstruction. The encoder is trained to minimize the reconstruction loss using the straight-through gradient estimator (Bengio et al., 2013a), together with a commitment loss term $\beta \parallel z - \operatorname { s g } ( z _ { q } ) \parallel$ (where $\beta$ is a scalar hyperparameter) which encourages encoder outputs to move closer to their nearest codebook entry. Here sg denotes the stop gradient operator, i.e. $\ \operatorname { s g } ( x ) = x$ in the forward pass, and $\operatorname { s g } ( x ) = 0$ in the backward pass. The codebook entries $e _ { j }$ are updated as an exponential moving average (EMA) of the continuous latents $z$ that map to them at each training iteration. The VQ-VAE training procedure using this EMA update rule can be seen as performing the $K$ -means or the hard Expectation Maximization (EM) algorithm on the latent codes (Roy et al., 2018).
+
+We perform interpolation in the VQ-VAE by interpolating continuous latents, mapping them to their nearest codebook entries, and decoding the result. Assuming sufficiently large codebook, a semantically “smooth” interpolation may be possible. On the lines task, we found that this procedure produced poor interpolations. Ultimately, many entries of the codebook were mapped to unrealistic datapoints, and the interpolations resembled those of the baseline autoencoder.
+
+Adversarially Constrained Autoencoder Interpolation Finally, we turn to evaluating our proposed adversarial regularizer for improving interpolations. For simplicity, on the lines benchmark we found it sufficient to use a critic architecture which was equivalent to the encoder (as described in appendix B). To produce a single scalar value from its output, we computed the mean of its final layer activations. For the hyperparameters $\lambda$ and $\gamma$ we found values of 0.5 and 0.2 to achieve good results, though the performance was not very sensitive to their values. We use these values for the coefficients for all of our experiments. Finally, we trained the critic using the same optimizer and hyperparameters as the autoencoder.
+
+We found dramatically improved performance on the lines benchmark when using ACAI – it achieved the best Mean Distance and Smoothness score among the autoencoders we considered. When inspecting the resulting interpolations, we found it occasionally chose a longer path than necessary but typically produced “perfect” interpolation behavior as seen in fig. 3f. This provides quantitative evidence ACAI is successful at encouraging realistic and smooth interpolations.
+
+# 3.3 INTERPOLATIONS ON REAL DATA
+
+We have so far only discussed results on our synthetic lines benchmark. We also provide example reconstructions and interpolations produced by each autoencoder for MNIST (LeCun, 1998), SVHN (Netzer et al., 2011), and CelebA (Liu et al., 2015) in appendix D. For each dataset, we trained autoencoders with latent dimensionalities of 32 and 256. Since we do not know the underlying data manifold for these datasets, no metrics are available to evaluate performance and we can only make qualitative judgments as to the reconstruction and interpolation quality. We find that most autoencoders produce “blurrier” images with $d _ { z } = 3 2$ but generally give smooth interpolations regardless of the latent dimensionality. The exception to this observation was the VQ-VAE which seems generally to work better with $d _ { z } = 3 2$ and occasionally even diverged for $d _ { z } = 2 5 6$ (see e.g. fig. 9e). This may be due to the nearest-neighbor discretization (and gradient estimator) failing in high dimensions. Across datasets, we found the VAE and denoising autoencoder typically produced more blurry interpolations. AAE and ACAI generally produced realistic interpolations, even between dissimilar datapoints (for example, in fig. 7 bottom). The baseline model often effectively interpolated in data space.
+
+# 4 IMPROVED REPRESENTATION LEARNING
+
+We have so far solely focused on measuring the interpolation abilities of different autoencoders. Now, we turn to the question of whether improved interpolation is associated with improved performance on downstream tasks. Specifically, we will evaluate whether using our proposed regularizer results in latent space representations which provide better performance in supervised learning and clustering. Put another way, we seek to test whether improving interpolation results in a latent representation which has disentangled important factors of variation (such as class identity) in the dataset. To answer this question, we ran classification and clustering experiments using the learned latent spaces of different autoencoders on the MNIST (LeCun, 1998), SVHN (Netzer et al., 2011), and CIFAR-10 (Krizhevsky, 2009) datasets.
+
+Table 2: Single-layer classifier accuracy achieved by different autoencoders.   
+
+<table><tr><td>Dataset</td><td>dz</td><td>Baseline</td><td>Denoising</td><td>VAE</td><td>AAE</td><td>VQ-VAE</td><td>ACAI</td></tr><tr><td rowspan="2">MNIST</td><td>32</td><td>94.90±0.14</td><td>96.00±0.27</td><td>96.56±0.31</td><td>70.74±3.27</td><td>97.50±0.18</td><td>98.25±0.11</td></tr><tr><td>256</td><td>93.94±0.13</td><td>98.51±0.04</td><td>98.74±0.14</td><td>90.03±0.54</td><td>97.25±1.42</td><td>99.00±0.08</td></tr><tr><td rowspan="2">SVHN</td><td>32</td><td>26.21±0.42</td><td>25.15±0.78</td><td>29.58±3.22</td><td>23.43±0.79</td><td>24.53±1.33</td><td>34.47±1.14</td></tr><tr><td>256</td><td>22.74±0.05</td><td>77.89±0.35</td><td>66.30±1.06</td><td>22.81±0.24</td><td>44.94±20.42</td><td>85.14±0.20</td></tr><tr><td rowspan="2">CIFAR-10</td><td>256</td><td>47.92±0.20</td><td>53.78±0.36</td><td>47.49±0.22</td><td>40.65±1.45</td><td>42.80±0.44</td><td>52.77±0.45</td></tr><tr><td>1024</td><td>51.62±0.25</td><td>60.65±0.14</td><td>51.39±0.46</td><td>42.86±0.88</td><td>16.22±12.44</td><td>63.99±0.47</td></tr></table>
+
+Table 3: Clustering accuracy for using K-Means on the latent space of different autoencoders (left) and previously reported methods (right). On the right, “Data” refers to performing K-Means directly on the data and DEC, RIM, and IMSAT are the methods proposed in (Xie et al., 2016; Krause et al., 2010; Hu et al., 2017) respectively. Results marked \* are excerpted from (Hu et al., 2017) and \*\* are from (Xie et al., 2016).   
+
+<table><tr><td>Dataset</td><td>dz</td><td>Baseline</td><td>Denoising</td><td>VAE</td><td>AAE</td><td>VQ-VAE</td><td>ACAI</td><td>Data</td><td>DEC</td><td>RIM</td><td>IMSAT</td></tr><tr><td>MNIST</td><td>32 256</td><td>77.56 53.70</td><td>82.59 70.89</td><td>75.74 83.44</td><td>79.19 81.00</td><td>82.39 96.80</td><td>94.38 96.17</td><td>53.2*</td><td>84.3**</td><td>58.5*</td><td>98.4*</td></tr><tr><td>SVHN</td><td>32 256</td><td>19.38 15.62</td><td>17.91 31.49</td><td>16.83 11.36</td><td>17.35 13.59</td><td>15.19 18.84</td><td>20.86 24.98</td><td>17.9*</td><td>11.9*</td><td>26.8*</td><td>57.3*</td></tr></table>
+
+Single-Layer Classifier A common method for evaluating the quality of a learned representation (such as the latent space of an autoencoder) is to use it as a feature representation for a simple, one-layer classifier (i.e. logistic regression) trained on a supervised learning task (Coates et al., 2011). The justification for this evaluation procedure is that a learned representation which has effectively disentangled class identity will allow the classifier to obtain reasonable performance despite its simplicity. To test different autoencoders in this setting, we trained a separate single-layer classifier in tandem with the autoencoder using the latent representation as input. We did not optimize autoencoder parameters with respect to the classifier’s loss, which ensures that we are measuring unsupervised representation learning performance. We repeated this procedure for latent dimensionalities of 32 and 256 (MNIST and SVHN) and 256 and 1024 (CIFAR-10).
+
+Our results are shown in table 2. In all settings, using ACAI instead of the baseline autoencoder upon which it is based produced significant gains – most notably, on SVHN with a latent dimensionality of 256, the baseline achieved an accuracy of only $2 2 . 7 4 \%$ whereas ACAI achieved $8 5 . 1 4 \%$ . In general, we found the denoising autoencoder, VAE, and ACAI obtained significantly higher performance compared to the remaining models. On MNIST and SVHN, ACAI achieved the best accuracy by a significant margin; on CIFAR-10, the performance of ACAI and the denoising autoencoder was similar. By way of comparison, we found a single-layer classifier applied directly to (flattened) image pixels achieved an accuracy of $9 2 . 3 1 \%$ , $2 3 . 4 8 \%$ , and $3 9 . 7 0 \%$ on MNIST, SVHN, and CIFAR-10 respectively, so classifying using the representation learned by ACAI provides a huge benefit.
+
+Clustering If an autoencoder groups points with common salient characteristics close together in latent space without observing any labels, it arguably has uncovered some important structure in the data in an unsupervised fashion. A more difficult test of an autoencoder is therefore clustering its latent space, i.e. separating the latent codes for a dataset into distinct groups without using any labels. To test the clusterability of the latent spaces learned by different autoencoders, we simply apply K-Means clustering (MacQueen, 1967) to the latent codes for a given dataset. Since K-Means uses Euclidean distance, it is sensitive to each dimension’s relative variance. We therefore used PCA whitening on the latent space learned by each autoencoder to normalize the variance of its dimensions prior to clustering. K-Means can exhibit highly variable results depending on how it is initialized, so for each autoencoder we ran K-Means 1,000 times from different random initializations and chose the clustering with the best objective value on the training set. For evaluation, we adopt the methodology of Xie et al. (2016); Hu et al. (2017): Given that the dataset in question has labels (which are not used for training the model, the clustering algorithm, or choice of random initialization), we can cluster the data into $C$ distinct groups where $C$ is the number of classes in the dataset. We then compute the “clustering accuracy”, which is simply the accuracy corresponding to the optimal one-to-one mapping of cluster IDs and classes (Xie et al., 2016).
+
+Our results are shown in table 3. On both MNIST and SVHN, ACAI achieved the best or second-best performance for both $d _ { z } = 3 2$ and $d _ { z } = 2 5 6$ . We do not report results on CIFAR-10 because all of the autoencoders we studied achieved a near-random clustering accuracy. Previous efforts to evaluate clustering performance on CIFAR-10 use learned feature representations from a convolutional network trained on ImageNet (Hu et al., 2017) which we believe only indirectly measures unsupervised learning capabilities.
+
+# 5 CONCLUSION
+
+In this paper, we have provided an in-depth perspective on interpolation in autoencoders. We proposed Adversarially Constrained Autoencoder Interpolation (ACAI), which uses a critic to encourage interpolated datapoints to be more realistic. To make interpolation a quantifiable concept, we proposed a synthetic benchmark and showed that ACAI substantially outperformed common autoencoder models. This task also yielded unexpected insights, such as that a VAE which has effectively learned the data distribution might not interpolate. We also studied the effect of improved interpolation on downstream tasks, and showed that ACAI led to improved performance for feature learning and unsupervised clustering. These findings confirm our intuition that improving the interpolation abilities of a baseline autoencoder can also produce a better learned representation for downstream tasks. However, we emphasize that we do not claim that good interpolation always implies a good representation – for example, the AAE produced smooth and realistic interpolations but fared poorly in our representations learning experiments and the denoising autoencoder had low-quality interpolations but provided a useful representation.
+
+In future work, we are interested in investigating whether our regularizer improves the performance of autoencoders other than the standard “vanilla” autoencoder we applied it to. In this paper, we primarily focused on image datasets due to the ease of visualizing interpolations, but we are also interested in applying these ideas to non-image datasets.
+
+# REFERENCES
+
+Sanjeev Arora, Rong Ge, Yingyu Liang, Tengyu Ma, and Yi Zhang. Generalization and equilibrium in generative adversarial nets (gans). In International Conference on Machine Learning, 2017.
+
+Yoshua Bengio, Pascal Lamblin, Dan Popovici, and Hugo Larochelle. Greedy layer-wise training of deep networks. In Advances in neural information processing systems, 2007.
+
+Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients through ´ stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013a.
+
+Yoshua Bengio, Gregoire Mesnil, Yann Dauphin, and Salah Rifai. Better mixing via deep representa- ´ tions. In International Conference on Machine Learning, 2013b.
+
+Herve Bourlard and Yves Kamp. Auto-association by multilayer perceptrons and singular value ´ decomposition. Biological cybernetics, 59(4-5), 1988.
+
+Samuel R. Bowman, Luke Vilnis, Oriol Vinyals, Andrew M. Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015.
+
+Shan Carter and Michael Nielsen. Using artificial intelligence to augment human intelligence. Distill, 2017. https://distill.pub/2017/aia.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. InfoGAN: Interpretable representation learning by information maximizing generative adversarial nets. In Advances in neural information processing systems, pp. 2172–2180, 2016a.
+
+Xi Chen, Diederik P. Kingma, Tim Salimans, Yan Duan, Prafulla Dhariwal, John Schulman, Ilya Sutskever, and Pieter Abbeel. Variational lossy autoencoder. arXiv preprint arXiv:1611.02731, 2016b.
+
+Adam Coates, Andrew $\mathrm { N g }$ , and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, 2011.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, 2014.
+
+Ishaan Gulrajani, Kundan Kumar, Faruk Ahmed, Adrien Ali Taiga, Francesco Visin, David Vazquez, and Aaron Courville. PixelVAE: A latent variable model for natural images. arXiv preprint arXiv:1611.05013, 2016.
+
+David Ha and Douglas Eck. A neural representation of sketch drawings. In Sixth International Conference on Learning Representations, 2018.
+
+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 Fifth International Conference on Learning Representations, 2017.
+
+Weihua Hu, Takeru Miyato, Seiya Tokui, Eiichi Matsumoto, and Masashi Sugiyama. Learning discrete representations via information maximizing self augmented training. arXiv preprint arXiv:1702.08720, 2017.
+
+Ferenc Huszar. Gaussian distributions are soap bubbles. ´ inFERENCe, 2017.
+
+Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. In Third International Conference on Learning Representations, 2014.
+
+Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improved variational inference with inverse autoregressive flow. In Advances in Neural Information Processing Systems, 2016.
+
+Andreas Krause, Pietro Perona, and Ryan G. Gomes. Discriminative clustering by regularized information maximization. In Advances in neural information processing systems, 2010.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
+
+Yann LeCun. The mnist database of handwritten digits. 1998.
+
+Shuang Liu, Olivier Bousquet, and Kamalika Chaudhuri. Approximation and convergence properties of generative adversarial learning. In Advances in Neural Information Processing Systems, 2017.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), 2015.
+
+Andrew L. Maas, Awni Y. Hannun, and Andrew Y. Ng. Rectifier nonlinearities improve neural network acoustic models. In International Conference on Machine Learning, 2013.
+
+James MacQueen. Some methods for classification and analysis of multivariate observations. In Proceedings of 5th Berkeley Symposium on Mathematical Statistics and Probability, 1967.
+
+Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In IEEE International Conference on Computer Vision, 2017.
+
+Michael F. Mathieu, Junbo Jake Zhao, Aditya Ramesh, Pablo Sprechmann, and Yann LeCun. Disentangling factors of variation in deep representation using adversarial training. In Advances in Neural Information Processing Systems, 2016.
+
+Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv preprint arXiv:1701.04722, 2017.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, 2011.
+
+Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016. URL http://distill.pub/2016/deconv-checkerboard.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In International Conference on Machine Learning, 2014.
+
+Adam Roberts, Jesse Engel, Colin Raffel, Curtis Hawthorne, and Douglas Eck. A hierarchical latent vector model for learning long-term structure in music. arXiv preprint arXiv:1803.05428, 2018.
+
+Aurko Roy, Ashish Vaswani, Arvind Neelakantan, and Niki Parmar. Theory and experiments on vector quantized autoencoders. arXiv preprint arXiv:1805.11063, 2018.
+
+Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. Ladder variational autoencoders. In Advances in Neural Information Processing Systems, 2016.
+
+Ilya Tolstikhin, Olivier Bousquet, Sylvain Gelly, and Bernhard Schoelkopf. Wasserstein auto-encoders. In Fifth International Conference on Learning Representations, 2017.
+
+Jakub M. Tomczak and Max Welling. Improving variational auto-encoders using householder flow. arXiv preprint arXiv:1611.09630, 2016.
+
+Jakub M. Tomczak and Max Welling. Vae with a vampprior. arXiv preprint arXiv:1705.07120, 2017.
+
+Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems, 2016.
+
+Aaron van den Oord, Oriol Vinyals, et al. Neural discrete representation learning. In Advances in Neural Information Processing Systems, pp. 6309–6318, 2017.
+
+Vikas Verma, Alex Lamb, Christopher Beckham, Aaron Courville, Ioannis Mitliagkis, and Yoshua Bengio. Manifold mixup: Encouraging meaningful on-manifold interpolation as a regularizer. arXiv preprint arXiv:1806.05236, 2018.
+
+Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of Machine Learning Research, 11, 2010.
+
+Tom White. Sampling generative networks: Notes on a few effective techniques. arXiv preprint arXiv:1609.04468, 2016.
+
+Junyuan Xie, Ross Girshick, and Ali Farhadi. Unsupervised deep embedding for clustering analysis. In International conference on machine learning, pp. 478–487, 2016.
+
+Shengjia Zhao, Jiaming Song, and Stefano Ermon. InfoVAE: Information maximizing variational autoencoders. arXiv preprint arXiv:1706.02262, 2017.
+
+![](images/8ad93aefd87dcaa05eb84f1109f9c8f406de2bea636705b07a2b75aadbe8716f.jpg)  
+Figure 4: Examples of data and interpolations from our synthetic lines dataset. (a) 16 random samples from the dataset. (b) A perfect interpolation from $\Lambda = { ^ { 1 1 \pi } } / { _ { 1 4 } }$ to 0. (c) Interpolating in data space rather than “semantic” or latent space. Clearly, interpolating in this way produces points not on the data manifold. (d) An interpolation which abruptly changes from one image to the other, rather than smoothly changing. (e) A smooth interpolation which takes a longer path from the start to end point than necessary. (f) An interpolation which takes the correct path but where intermediate points are not realistic.
+
+# A LINE BENCHMARK
+
+# A.1 EXAMPLE INTERPOLATIONS
+
+Some example data and interpolations for our synthetic lines benchmark are shown in fig. 4. Full discussion of this benchmark is available in section 3.1.
+
+# A.2 EVALUATION METRICS
+
+We define our Mean Distance and Smoothness metrics as follows: Let $x _ { 1 }$ and $x _ { 2 }$ be two input images we are interpolating between and
+
+$$
+\hat { x } _ { n } = g _ { \phi } \left( \frac { n - 1 } { N - 1 } z _ { 1 } + \left( 1 - \frac { n - 1 } { N - 1 } \right) z _ { 2 } \right)
+$$
+
+be the decoded point corresponding to mixing $x _ { 1 }$ and $x _ { 2 }$ ’s latent codes using coefficient $\alpha = { \mathfrak { n } } - 1 / { \mathfrak { N } } - 1$ The images $\hat { x } _ { n } , n \in \{ 1 , \ldots , N \}$ then comprise a length- $N$ interpolation between $x _ { 1 }$ and $x _ { 2 }$ . To produce our evaluation metrics, we first find the closest true datapoint (according to cosine distance) for each of the $N$ intermediate images along the interpolation. Finding the closest image among all possible line images is infeasible; instead we first generate a size- $D$ collection of line images $\mathcal { D }$ with corresponding angles $\Lambda _ { q } , q \in \{ 1 , \ldots , D \}$ spaced evenly between 0 and $2 \pi$ . Then, we match each image in the interpolation to a real datapoint by finding
+
+$$
+\begin{array} { c } { { C _ { n , q } = 1 - \frac { { \hat { x } _ { n } } { \mathcal { D } _ { q } } } { \| \hat { x } _ { n } \| \| { \mathcal { D } _ { q } } \| } } } \\ { { q _ { n } ^ { \star } = \arg \underset { q } { \operatorname* { m i n } } C _ { n , q } } } \end{array}
+$$
+
+for $n \in \{ 1 , \ldots , N \}$ , where $C _ { n , q }$ is the cosine distance between ${ \hat { x } } _ { n }$ and the $q$ th entry of $\mathcal { D }$ . To capture the notion of “intermediate points look realistic”, we compute
+
+$$
+\operatorname { M e a n } \operatorname { D i s t a n c e } ( \left\{ { \hat { x } } _ { 1 } , { \hat { x } } _ { 2 } , \ldots , { \hat { x } } _ { N } \right\} ) = { \frac { 1 } { N } } \sum _ { n = 1 } ^ { N } C _ { n , q _ { n } ^ { \star } }
+$$
+
+We now define a perfectly smooth interpolation to be one which consists of lines with angles which linearly move from the angle of $\mathcal { D } _ { q _ { 1 } ^ { \star } }$ to that of $\mathcal { D } _ { \boldsymbol { q } _ { N } ^ { \star } }$ . Note that if, for example, the interpolated lines go from $\Lambda _ { q _ { 1 } ^ { \star } } = \pi / 1 0$ to $\Lambda _ { q _ { N } ^ { \star } } = { } ^ { 1 9 \pi } / 1 0$ then the angles corresponding to the shortest path will have a discontinuity from 0 to $2 \pi$ . To avoid this, we first “unwrap” the angles $\{ \Lambda _ { q _ { 1 } ^ { \star } } , \ldots , \Lambda _ { q _ { N } ^ { \star } } \}$ by removing discontinuities larger than $\pi$ by adding multiples of $\pm 2 \pi$ when the absolute difference between $\Lambda _ { q _ { n - 1 } ^ { \star } }$ and $\Lambda _ { { q } _ { n } ^ { \star } }$ is greater than $\pi$ to produce the angle sequence $\{ \tilde { \Lambda } _ { q _ { 1 } ^ { \star } } , \ldots , \tilde { \Lambda } _ { q _ { N } ^ { \star } } \}$ .2 Then, we define a measure of smoothness as
+
+$$
+\mathrm { S m o o t h n e s s } \big ( \big \{ \hat { x } _ { 1 } , \hat { x } _ { 2 } , . . . , \hat { x } _ { N } \big \} \big ) = \frac { 1 } { \vert \tilde { \Lambda } _ { q _ { 1 } ^ { * } } - \tilde { \Lambda } _ { q _ { N } ^ { * } } \vert } \operatorname* { m a x } _ { n \in \{ 1 , . . . , N - 1 \} } \Big ( \tilde { \Lambda } _ { q _ { n + 1 } ^ { * } } - \tilde { \Lambda } _ { q _ { n } ^ { * } } \Big ) - \frac { 1 } { N - 1 }
+$$
+
+In other words, we measure the how much larger the largest change in (normalized) angle is compared to the minimum possible value $\left( { } ^ { 1 } / ( N { - } 1 ) \right)$ .
+
+By way of example, figs. 4b, 4d and 4e would all achieve Mean Distance scores near zero and figs. 4c and 4f would achieve larger Mean Distance scores. Figures 4b and 4f would achieve Smoothness scores near zero, figs. 4c and 4d have poor Smoothness, and fig. $_ { 4 \mathrm { e } }$ is in between.
+
+# B BASE MODEL ARCHITECTURE AND TRAINING PROCEDURE
+
+All of the autoencoder models we studied in this paper used the following architecture and training procedure: The encoder consists of blocks of two consecutive $3 \times 3$ convolutional layers followed by $2 \times 2$ average pooling. All convolutions (in the encoder and decoder) are zero-padded so that the input and output height and width are equal. The number of channels is doubled before each average pooling layer. Two more $3 \times 3$ convolutions are then performed, the last one without activation and the final output is used as the latent representation. All convolutional layers except for the final use a leaky ReLU nonlinearity (Maas et al., 2013). For experiments on the synthetic “lines” task, the convolution-average pool blocks are repeated 4 times until we reach a latent dimensionality of 64. For subsequent experiments on real datasets (section 4), we repeat the blocks 3 times, resulting in a latent dimensionality of 256.
+
+The decoder consists of blocks of two consecutive $3 \times 3$ convolutional layers with leaky ReLU nonlinearities followed by $2 \times 2$ nearest neighbor upsampling (Odena et al., 2016). The number of channels is halved after each upsampling layer. These blocks are repeated until we reach the target resolution $3 2 \times 3 2$ in all experiments). Two more $3 \times 3$ convolutions are then performed, the last one without activation and with a number of channels equal to the number of desired colors.
+
+All parameters are initialized as zero-mean Gaussian random variables with a standard deviation of $1 / \sqrt { \tan \_ { - } \mathrm { i n } ( 1 + 0 . 2 ^ { 2 } ) }$ set in accordance with the leaky ReLU slope of 0.2. Models are trained on $2 ^ { 2 4 }$ samples in batches of size 64. Parameters are optimized with Adam (Kingma & Welling, 2014) with a learning rate of 0.0001 and default values for $\beta _ { 1 } , \beta _ { 2 }$ , and $\epsilon$ .
+
+# C VAE SAMPLES ON THE LINE BENCHMARK
+
+In fig. 5, we show some samples from our VAE trained on the synthetic line benchmark. The VAE generally produces realistic samples and seems to cover the data distribution well, despite the fact that it does not produce high-quality interpolations (fig. 3c).
+
+# D INTERPOLATION EXAMPLES ON REAL DATA
+
+In this section, we provide a series of figures (figs. 6 to 11) showing interpolation behavior for the different autoencoders we studied. Further discussion of these results is available in section 3.3
+
+![](images/011b1d5ca5a163871496158859d0e142b9e53ddb0eae4efef60407763041d635.jpg)  
+Figure 5: Samples from a VAE trained on the lines dataset described in section 3.1.
+
+![](images/db363f651bed0df99d894ff8748b176860a5645e01396365f1bbaccac330a733.jpg)  
+Figure 6: Example interpolations on MNIST with a latent dimensionality of 32 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders.
+
+![](images/2efdc3a2b3e2b708fcdafcc88768f0d53ebfd36bbc3051aecfbd180d1f170ce1.jpg)  
+Figure 7: Example interpolations on MNIST with a latent dimensionality of 256 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders.
+
+![](images/47de7ca907daaf8fc9e0bdbadba83520b961226907f1b5076ae26acedb1b1e9c.jpg)  
+Figure 8: Example interpolations on SVHN with a latent dimensionality of 32 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders.
+
+![](images/d6ad7a3f626f887a67a272b156817696c598021ea8e689ebd4cd30406740f6d4.jpg)  
+Figure 9: Example interpolations on SVHN with a latent dimensionality of 256 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders.
+
+![](images/4c48de8b1f74145157c8b8b7cfe6d11bfa33d99734117c359409d43734b2424d.jpg)  
+Figure 10: Example interpolations on CelebA with a latent dimensionality of 32 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders.
+
+![](images/63948b88054bf695f2323771a5e64557140ff80440ce0329caa06dd514cc8482.jpg)  
+Figure 11: Example interpolations on CelebA with a latent dimensionality of 256 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders.

parse/train/S1fQSiCcYm/S1fQSiCcYm_content_list.json

@@ -0,0 +1,1674 @@
+[
+    {
+        "type": "text",
+        "text": "UNDERSTANDING AND IMPROVING INTERPOLATION IN AUTOENCODERS VIA AN ADVERSARIAL REGULARIZER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot∗ Google Brain dberth@google.com ",
+        "bbox": [
+            184,
+            170,
+            352,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel∗   \nGoogle Brain   \ncraffel@gmail.com   \nAurko Roy   \nGoogle Brain   \naurkor@google.com   \nIan Goodfellow   \nGoogle Brain   \ngoodfellow@google.com ",
+        "bbox": [
+            413,
+            170,
+            584,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            643,
+            170,
+            813,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            183,
+            233,
+            392,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            311,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Autoencoders provide a powerful framework for learning compressed representations by encoding all of the information needed to reconstruct a data point in a latent code. In some cases, autoencoders can “interpolate”: By decoding the convex combination of the latent codes for two datapoints, the autoencoder can produce an output which semantically mixes characteristics from the datapoints. In this paper, we propose a regularization procedure which encourages interpolated outputs to appear more realistic by fooling a critic network which has been trained to recover the mixing coefficient from interpolated data. We then develop a simple benchmark task where we can quantitatively measure the extent to which various autoencoders can interpolate and show that our regularizer dramatically improves interpolation in this setting. We also demonstrate empirically that our regularizer produces latent codes which are more effective on downstream tasks, suggesting a possible link between interpolation abilities and learning useful representations. ",
+        "bbox": [
+            233,
+            344,
+            766,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            336,
+            569
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One goal of unsupervised learning is to uncover the underlying structure of a dataset without using explicit labels. A common architecture used for this purpose is the autoencoder, which learns to map datapoints to a latent code from which the data can be recovered with minimal information loss. Typically, the latent code is lower dimensional than the data, which indicates that autoencoders can perform some form of dimensionality reduction. For certain architectures, the latent codes have been shown to disentangle important factors of variation in the dataset which makes such models useful for representation learning (Chen et al., 2016a; Higgins et al., 2017). In the past, they were also used for pre-training other networks by being trained on unlabeled data and then being stacked to initialize a deep network (Bengio et al., 2007; Vincent et al., 2010). More recently, it was shown that imposing a prior on the latent space allows autoencoders to be used for probabilistic or generative modeling (Kingma & Welling, 2014; Rezende et al., 2014; Makhzani et al., 2015). ",
+        "bbox": [
+            174,
+            587,
+            825,
+            738
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In some cases, autoencoders have shown the ability to interpolate. Specifically, by mixing codes in latent space and decoding the result, the autoencoder can produce a semantically meaningful combination of the corresponding datapoints. Interpolation has been frequently reported as a qualitative experimental result in studies about autoencoders (Dumoulin et al., 2016; Bowman et al., 2015; Roberts et al., 2018; Mescheder et al., 2017; Mathieu et al., 2016; Ha & Eck, 2018) and latent-variable generative models in general (Dinh et al., 2016; Radford et al., 2015; van den Oord et al., 2016). The ability to interpolate can be useful in its own right e.g. for creative applications (Carter & Nielsen, 2017). However, it also indicates that the autoencoder can “extrapolate” beyond the training data and has learned a latent space with a particular structure. Specifically, if interpolating between two points in latent space produces a smooth semantic warping in data space, this suggests that nearby points in latent space are semantically similar. A visualization of this idea is shown in fig. 1, where a smooth interpolation between a “2” and a “9” suggests that the 2 is surrounded by semantically similar points, i.e. other 2s. This property may suggest that an autoencoder which interpolates well could also provide a good learned representation for downstream tasks because similar points are clustered. If the interpolation is not smooth, there may be “discontinuities” in latent space which could result in the representation being less useful as a learned feature. This connection between interpolation and a “flat” data manifold has been explored in the context of unsupervised representation learning (Bengio et al., 2013b) and regularization (Verma et al., 2018). ",
+        "bbox": [
+            174,
+            746,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/5630761622d92221bde976e9ee4da80f4d47ac78ed0050620eafd2c13a506e28.jpg",
+        "image_caption": [
+            "Figure 1: Successful interpolation suggests that semantically similar points may be clustered together in latent space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            336,
+            196
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/611fdc6f66b401e9eaa12590a538cddbffa0dc1156d6e0afd94a714f10b7e1a2.jpg",
+        "image_caption": [
+            "Figure 2: Adversarially Constrained Autoencoder Interpolation (ACAI). A critic network is fed interpolants and reconstructions and tries to predict the interpolation coefficient $\\alpha$ corresponding to its input (with $\\alpha = 0$ for reconstructions). The autoencoder is trained to fool the critic into outputting $\\alpha = 0$ for interpolants. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            351,
+            103,
+            818,
+            189
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            319,
+            825,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given the widespread use of interpolation as a qualitative measure of autoencoder performance, we believe additional investigation into the connection between interpolation and representation learning is warranted. Our goal in this paper is threefold: First, we introduce a regularization strategy with the specific goal of encouraging improved interpolations in autoencoders (section 2); second, we develop a synthetic benchmark where the slippery concept of a “semantically meaningful interpolation” is quantitatively measurable (section 3.1) and evaluate common autoencoders on this task (section 3.2); and third, we confirm the intuition that good interpolation can result in a useful representation by showing that the improved interpolation ability produced by our regularizer elicits improved representation learning performance on downstream tasks (section 4). We also make our codebase available1 which provides a unified implementation of many common autoencoders including our proposed regularizer. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            577
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 AN ADVERSARIAL REGULARIZER FOR IMPROVING INTERPOLATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            627,
+            777,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Autoencoders, also called auto-associators (Bourlard & Kamp, 1988), consist of the following structure: First, an input $x \\in \\mathbb { R } ^ { d _ { x } }$ is passed through an “encoder” $z = f _ { \\boldsymbol { \\theta } } ( x )$ parametrized by $\\theta$ to obtain a latent code $z \\in \\mathbb { R } ^ { d _ { z } }$ . The latent code is then passed through a “decoder” $\\hat { x } = g _ { \\phi } ( z )$ parametrized by $\\phi$ to produce an approximate reconstruction $\\hat { \\boldsymbol { x } } \\in \\mathbb { R } ^ { d _ { x } }$ of the input $x$ . We consider the case where $f _ { \\theta }$ and $g _ { \\phi }$ are implemented as multi-layer neural networks. The encoder and decoder are trained simultaneously (i.e. with respect to $\\theta$ and $\\phi$ ) to minimize some notion of distance between the input $x$ and the output $\\hat { x }$ , for example the squared $L _ { 2 }$ distance $\\| x - { \\hat { x } } \\| ^ { 2 }$ . ",
+        "bbox": [
+            174,
+            678,
+            825,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Interpolating using an autoencoder describes the process of using the decoder $g _ { \\phi }$ to decode a mixture of two latent codes. Typically, the latent codes are combined via a convex combination, so that interpolation amounts to computing $\\hat { x } _ { \\alpha } = g _ { \\phi } ( \\alpha z _ { 1 } + ( 1 - \\alpha ) z _ { 2 } )$ for some $\\alpha \\in [ 0 , 1 ]$ where $z _ { 1 } = f _ { \\theta } ( x _ { 1 } )$ and $z _ { 2 } = f _ { \\theta } ( x _ { 2 } )$ are the latent codes corresponding to data points $x _ { 1 }$ and $x _ { 2 }$ . We also experimented with spherical interpolation which has been used in settings where the latent codes are expected to have spherical structure (Huszar, 2017; White, 2016; Roberts et al., 2018), but found it made no ´ discernible difference in practice for any autoencoder we studied. Ideally, adjusting $\\alpha$ from 0 to 1 will produce a sequence of realistic datapoints where each subsequent $\\hat { x } _ { \\alpha }$ is progressively less semantically similar to $x _ { 1 }$ and more semantically similar to $x _ { 2 }$ . The notion of “semantic similarity” is problem-dependent and ill-defined; we discuss this further in section 3. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ADVERSARIALLY CONSTRAINED AUTOENCODER INTERPOLATION (ACAI)",
+        "bbox": [
+            176,
+            103,
+            730,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, a high-quality interpolation should have two characteristics: First, that intermediate points along the interpolation are indistinguishable from real data; and second, that the intermediate points provide a semantically smooth morphing between the endpoints. The latter characteristic is hard to enforce because it requires defining a notion of semantic similarity for a given dataset, which is often hard to explicitly codify. So instead, we propose a regularizer which encourages interpolated datapoints to appear realistic, or more specifically, to appear indistinguishable from reconstructions of real datapoints. We find empirically that this constraint results in realistic and smooth interpolations in practice (section 3.1) in addition to providing improved performance on downstream tasks (section 4). ",
+        "bbox": [
+            174,
+            128,
+            825,
+            255
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To enforce this constraint we introduce a critic network (Goodfellow et al., 2014) which is fed interpolations of existing datapoints (i.e. $\\hat { x } _ { \\alpha }$ as defined above). Its goal is to predict $\\alpha$ from $\\hat { x } _ { \\alpha }$ , i.e. to predict the mixing coefficient used to generate its input. When training the model, for each pair of training data points we randomly sample a value of $\\alpha$ to produce $\\hat { x } _ { \\alpha }$ . In order to resolve the ambiguity between predicting $\\alpha$ and $1 - \\alpha$ , we constrain $\\alpha$ to the range $[ 0 , 0 . 5 ]$ when feeding $\\hat { x } _ { \\alpha }$ to the critic. In contrast, the autoencoder is trained to fool the critic to think that $\\alpha$ is always zero. This is achieved by adding an additional term to the autoencoder’s loss to optimize its parameters to fool the critic. In a loose sense, the critic can be seen as approximating an “adversarial divergence” (Liu et al., 2017; Arora et al., 2017) between reconstructions and interpolants which the autoencoder tries to minimize. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            387
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, let $d _ { \\omega } ( x )$ be the critic network, which for a given input produces a scalar value. The critic is trained to minimize ",
+        "bbox": [
+            174,
+            393,
+            823,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d194f9f93a1aa48e2682e8b301065a90f91c6977cf54be04ac8bfbad0bf69e3d.jpg",
+        "text": "$$\n\\mathcal { L } _ { d } = \\| d _ { \\omega } ( \\hat { x } _ { \\alpha } ) - \\alpha \\| ^ { 2 } + \\| d _ { \\omega } ( \\gamma x + ( 1 - \\gamma ) \\hat { x } ) \\| ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            426,
+            658,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where, as above, $\\hat { x } _ { \\alpha } = g _ { \\phi } ( \\alpha f _ { \\theta } ( x _ { 1 } ) + ( 1 - \\alpha ) f _ { \\theta } ( x _ { 2 } ) )$ , $\\hat { x } = g _ { \\phi } ( f _ { \\theta } ( x ) )$ for some $x$ (not necessarily $x _ { 1 }$ or $x _ { 2 }$ ), and $\\gamma$ is a scalar hyperparameter. The first term trains the critic to recover $\\alpha$ from $\\hat { x } _ { \\alpha }$ . The second term serves as a regularizer with two functions: First, it enforces that the critic consistently outputs 0 for non-interpolated inputs; and second, by interpolating between $x$ and $\\hat { x }$ (the autoencoder’s reconstruction of $x$ ) in data space it ensures the critic is exposed to realistic data even when the autoencoder’s reconstructions are poor. We found the second term was not crucial for our approach, but helped stabilize the convergence of the autoencoder and allowed us to use consistent hyperparameters and architectures across all datasets and experiments. The autoencoder’s loss function is modified by adding a regularization term: ",
+        "bbox": [
+            173,
+            448,
+            825,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf67f9b63c1611c043daf133c296cd22981851839fc04df636da3ec08b8e3bc3.jpg",
+        "text": "$$\n\\mathcal { L } _ { f , g } = \\Vert x - g _ { \\phi } ( f _ { \\theta } ( x ) ) \\Vert ^ { 2 } + \\lambda \\Vert d _ { \\omega } ( \\hat { x } _ { \\alpha } ) \\Vert ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            578,
+            637,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a scalar hyperparameter which controls the weight of the regularization term. Note that the regularization term is effectively trying to make the critic output 0 regardless of the value of $\\alpha$ , thereby “fooling” the critic into thinking that an interpolated input is non-interpolated (i.e., having $\\alpha = 0$ ). The parameters $\\theta$ and $\\phi$ are optimized with respect to $\\mathcal { L } _ { f , g }$ (which gives the autoencoder access to the critic’s gradients) and $\\omega$ is optimized with respect to $\\mathcal { L } _ { d }$ . We refer to the use of this regularizer as Adversarially Constrained Autoencoder Interpolation (ACAI). A diagram of the ACAI is shown in fig. 2. Assuming an effective critic, the autoencoder successfully “wins” this adversarial game by producing interpolated points which are indistinguishable from reconstructed data. We find in practice that encouraging this behavior also produces semantically smooth interpolations and improved representation learning performance, which we demonstrate in the following sections. Our loss function is similar to the one used in the Least Squares Generative Adversarial Network (Mao et al., 2017) in the sense that they both measure the distance between a critic’s output and a scalar using a squared L2 loss. However, they are substantially different in that ours is used as a regularizer for autoencoders rather than for generative modeling and our critic attempts to regress the interpolation coefficient $\\alpha$ instead of a fixed scalar hyperparameter. ",
+        "bbox": [
+            173,
+            602,
+            825,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that the only thing ACAI encourages is that interpolated points appear realistic. The critic only ever sees a single reconstruction or interpolant at a time; it is never fed real datapoints or latent vectors. It therefore will only be able to successfully recover $\\alpha$ if the quality of the autoencoder’s output degrades consistently across an interpolation as a function of $\\alpha$ (as seen, for example, in fig. 3a where interpolated points become successively blurrier and darker). ACAI’s primary purpose is to discourage this behavior. In doing so, it may implicitly modify the structure of the latent space learned by the autoencoder, but ACAI itself does not directly impose a specific structure. Our goal in introducing ACAI is to test whether simply encouraging better interpolation behavior produces a better representation for downstream tasks. Further, in contrast with the standard Generative Adversarial Network (GAN) setup (Goodfellow et al., 2014), ACAI does not distinguish between “real” and “fake” data; rather, it simply attempts to regress the interpolation coefficient $\\alpha$ . Furthermore, GANs are a generative modeling technique, not a representation learning technique; in this paper, we focus on autoencoders and their ability to learn useful representations. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 AUTOENCODERS, AND HOW THEY INTERPOLATE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            227,
+            614,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "How can we measure whether an autoencoder interpolates effectively and whether our proposed regularization strategy achieves its stated goal? As mentioned in section 2, defining interpolation relies on the notion of “semantic similarity” which is a vague and problem-dependent concept. For example, a definition of interpolation along the lines of $^ { \\mathrm { \\infty } } \\alpha z _ { 1 } \\mathrm { ~ + ~ } ( 1 - \\mathrm { \\bar { \\alpha } } ) z _ { 2 }$ should map to $\\alpha x _ { 1 } \\bar { + } ( 1 - \\alpha ) { x _ { 2 } } ^ { \\bar { \\gamma } }$ is overly simplistic because interpolating in “data space” often does not result in realistic datapoints – in images, this corresponds to simply fading between the pixel values of the two images. Instead, we might hope that our autoencoder smoothly morphs between salient characteristics of $x _ { 1 }$ and $x _ { 2 }$ , even when they are dissimilar. Put another way, we might hope that decoded points along the interpolation smoothly traverse the underlying manifold of the data instead of simply interpolating in data space. However, we rarely have access to the underlying data manifold. To make this problem more concrete, we introduce a simple benchmark task where the data manifold is simple and known a priori which makes it possible to quantify interpolation quality. We then evaluate the ability of various common autoencoders to interpolate on our benchmark. Finally, we test ACAI on our benchmark and show that it exhibits dramatically improved performance and qualitatively superior interpolations. ",
+        "bbox": [
+            174,
+            262,
+            826,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 AUTOENCODING LINES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            377,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given that the concept of interpolation is difficult to pin down, our goal is to define a task where a “correct” interpolation between two datapoints is unambiguous and well-defined. This will allow us to quantitatively evaluate the extent to which different autoencoders can successfully interpolate. Towards this goal, we propose the task of autoencoding $3 2 \\times 3 2$ grayscale images of lines. We consider 16-pixel-long lines beginning from the center of the image and extending outward at an angle $\\Lambda \\in [ 0 , 2 \\pi ]$ (or put another way, lines are radii of the circle circumscribed within the image borders). An example of 16 such images is shown in fig. 4a (appendix A.1). In this task, the data manifold can be defined entirely by a single variable: $\\Lambda$ . We can therefore define a valid interpolation from $x _ { 1 }$ to $x _ { 2 }$ as one which smoothly and linearly adjusts $\\Lambda$ from the angle of the line in $x _ { 1 }$ to the angle in $x _ { 2 }$ . We further require that the interpolation traverses the shortest path possible along the data manifold. We provide some concrete examples of good and bad interpolations, shown and described in appendix A.1. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On any dataset, our desiderata for a successful interpolation are that intermediate points look realistic and provide a semantically meaningful morphing between its endpoints. On this synthetic lines dataset, we can formalize these notions as specific evaluation metrics, which we describe in detail in appendix A.2. To summarize, we propose two metrics: Mean Distance and Smoothness. Mean Distance measures the average distance between interpolated points and “real” datapoints. Smoothness measures whether the angles of the interpolated lines follow a linear trajectory between the angle of the start and endpoint. Both of these metrics are simple to define due to our construction of a dataset where we exactly know the data distribution and manifold; we provide a full definition and justification in appendix A.2. A perfect alignment would achieve 0 for both scores; larger values indicate a failure to generate realistic interpolated points or produce a smooth interpolation respectively. By choosing a synthetic benchmark where we can explicitly measure the quality of an interpolation, we can confidently evaluate different autoencoders on their interpolation abilities. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            847
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To evaluate an autoencoder on the synthetic lines task, we randomly sample line images during training and compute our evaluation metrics on a separate randomly-sampled test set of images. Note that we never train any autoencoder explicitly to produce an optimal interpolation; “good” interpolation is an emergent property which occurs only when the architecture, loss function, training procedure, etc. produce a suitable latent space. ",
+        "bbox": [
+            176,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/bdc8e4063a0c49e702849a7968772c01b8edb8d7f9b21bebc1464568d482d666.jpg",
+        "table_caption": [
+            "Table 1: Scores achieved by different autoencoders on the synthetic line benchmark (lower is better). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Metric</td><td>Baseline</td><td>Denoising</td><td>VAE</td><td>AAE</td><td>VQ-VAE</td><td>ACAI</td></tr><tr><td>Mean Distance ( （×10-3)</td><td>6.88±0.21</td><td>4.21±0.32</td><td>1.21±0.17</td><td>3.26±0.19</td><td>5.41±0.49</td><td>0.24±0.01</td></tr><tr><td>Smoothness</td><td>0.44±0.04</td><td>0.66±0.02</td><td>0.49±0.13</td><td>0.14±0.02</td><td>0.77±0.02</td><td>0.10±0.01</td></tr></table>",
+        "bbox": [
+            215,
+            127,
+            782,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec36ffc7cb437f33fb80e7cef44a912d2b91f3875e4be808b7576abc3083aa00.jpg",
+        "image_caption": [
+            "Figure 3: Interpolations on the synthetic lines benchmark produced by (a) baseline auto-encoder, (b) denoising autoencoder, (c) Variational Autoencoder, (d) Adversarial Autoencoder, (e) Vector Quantized Variational Autoencoder, (f) Adversarially Constrained Autoencoder Interpolation (our model). While we only show one example here, the behavior of each autoencoder was generally similar for all interpolations. A more comprehensive measure of interpolation behavior is given in table 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            193,
+            787,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 AUTOENCODERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            331,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe various common autoencoder structures and objectives and try them on the lines task. Our goal is to quantitatively evaluate the extent to which standard autoencoders exhibit useful interpolation behavior. Our results, which we describe below, are summarized in table 1. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Base Model Perhaps the most basic autoencoder structure is one which simply maps input datapoints through a “bottleneck” layer whose dimensionality is smaller than the input. In this setup, $f _ { \\theta }$ and $g _ { \\phi }$ are both neural networks which respectively map the input to a deterministic latent code $z$ and then back to a reconstructed input. Typically, $f _ { \\theta }$ and $g _ { \\phi }$ are trained simultaneously with respect to $\\| x - { \\hat { x } } \\| ^ { 2 }$ . We will use this framework as a baseline for experimentation for all of the autoencoder variants discussed below. In particular, for our base model and all of the other autoencoders we will use the model architecture and training procedure described in appendix B. As a short summary, our encoder consists of a stack of convolutional and average pooling layers, whereas the decoder consists of convolutional and nearest-neighbor upsampling layers. For experiments on the synthetic “lines” task, we use a latent dimensionality of 64. Note that, because the data manifold is effectively onedimensional, we might expect autoencoders to be able to model this dataset using a one-dimensional latent code; however, using a larger latent code reflects the realistic scenario where the latent space is larger than necessary. After training our baseline autoencoder, we achieved a Mean Distance score which was the worst (highest) of all of the autoencoders we studied, though the Smoothness was on par with various other approaches. In general, we observed some reasonable interpolations when using the baseline model, but found that the intermediate points on the interpolation were typically not realistic as seen in the example interpolation in fig. 3a. ",
+        "bbox": [
+            174,
+            570,
+            826,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Denoising Autoencoder An early modification to the standard autoencoder setup was proposed by Vincent et al. (2010), where instead of feeding $x$ into the autoencoder, a corrupted version $\\tilde { x } \\sim q ( \\tilde { x } | x )$ is sampled from the conditional probability distribution $q ( \\tilde { x } | x )$ and is fed into the autoencoder instead. The autoencoder’s goal remains to produce $\\hat { x }$ which minimizes $\\| x - { \\hat { x } } \\| ^ { 2 }$ . One justification of this approach is that the corrupted inputs should fall outside of the true data manifold, so the autoencoder must learn to map points from outside of the data manifold back onto it. This provides an implicit way of defining and learning the data manifold via the coordinate system induced by the latent space. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While various corruption procedures $q ( \\tilde { x } | x )$ have been used such as masking and salt-and-pepper noise, in this paper we consider the simple case of additive isotropic Gaussian noise where $\\tilde { x } \\sim$ ${ \\mathcal { N } } ( x , \\sigma ^ { 2 } I )$ and $\\sigma$ is a hyperparameter. After tuning $\\sigma$ , we found simply setting $\\sigma = 1 . 0$ to work best. Interestingly, we found the denoising autoencoder often produced “data-space” interpolation (as seen in fig. 3b) when interpolating in latent space. This resulted in comparatively poor Mean Distance and Smoothness scores. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Variational Autoencoder The Variational Autoencoder (VAE) (Kingma & Welling, 2014; Rezende et al., 2014) introduces the constraint that the latent code $z$ is a random variable distributed according to a prior distribution $p ( z )$ . The encoder $f _ { \\theta }$ can then be considered an approximation to the posterior $p ( z | x )$ . Then, the decoder $g _ { \\phi }$ is taken to parametrize the likelihood $p ( x \\bar { | } \\bar { z } )$ ; in all of our experiments, we consider $x$ to be Bernoulli distributed. The latent distribution constraint is enforced by an additional loss term which measures the KL divergence between approximate posterior and prior. VAEs then use log-likelihood for the reconstruction loss (cross-entropy in the case of Bernoulli-distributed data), which results in the following combined loss function: $- \\mathbb { E } [ \\log g _ { \\phi } ( z ) ] + \\mathrm { K L } ( f _ { \\theta } ( x ) | | p ( z ) )$ where the expectation is taken with respect to $z \\sim f _ { \\theta } ( x )$ and $\\mathrm { K L } ( \\cdot | | \\cdot )$ is the KL divergence. Minimizing this loss function can be considered maximizing a lower bound (the “ELBO”) on the likelihood of the training set, producing a likelihood-based generative model which allows novel data points to be sampled by first sampling $z \\sim p ( z )$ and then computing $g _ { \\phi } ( z )$ . A common choice is to let $q ( z | x )$ be a diagonalcovariance Gaussian, in which case backpropagation through sampling from $q ( z | x )$ is feasible via the “reparametrization trick” which replaces $\\bar { z } \\sim \\mathcal { N } ( \\mu , \\bar { \\sigma I } )$ with $\\epsilon \\sim \\mathcal { N } ( 0 , I ) , z = \\mu + \\sigma \\odot \\epsilon$ where $\\bar { \\mu } , \\sigma \\in \\mathbb { R } ^ { d _ { z } }$ are the predicted mean and standard deviation produced by $f _ { \\theta }$ . Various modified objectives (Higgins et al., 2017; Zhao et al., 2017), improved prior distributions (Kingma et al., 2016; Tomczak & Welling, 2016; 2017) and improved model architectures (Sønderby et al., 2016; Chen et al., 2016b; Gulrajani et al., 2016) have been proposed to better the VAE’s performance on downstream tasks, but in this paper we solely consider the “vanilla” VAE objective and prior described above applied to our baseline autoencoder structure. ",
+        "bbox": [
+            173,
+            205,
+            826,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When trained on the lines benchmark, we found the VAE was able to effectively model the data distribution (see samples, fig. 5 in appendix C) and accurately reconstruct inputs. In interpolations produced by the VAE, intermediate points tend to look realistic, but the angle of the lines do not follow a smooth or short path (fig. 3c). This resulted in a very good Mean Distance score but a very poor Smoothness score. Contrary to expectations, this suggests that desirable interpolation behavior may not follow from an effective generative model of the data distribution. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            573
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Autoencoder The Adversarial Autoencoder (AAE) (Makhzani et al., 2015) proposes an alternative way of enforcing structure on the latent code. Instead of minimizing a KL divergence between the distribution of latent codes and a prior distribution, a critic network is trained in tandem with the autoencoder to predict whether a latent code comes from $f _ { \\theta }$ or from the prior $p ( z )$ . The autoencoder is simultaneously trained to reconstruct inputs (via a standard reconstruction loss) and to “fool” the critic. The autoencoder is allowed to backpropagate gradients through the critic’s loss function, but the autoencoder and critic parameters are optimized separately. This effectively computes an “adversarial divergence” between the latent code distribution and the chosen prior. This framework was later generalized and referred to as the “Wasserstein Autoencoder” (Tolstikhin et al., 2017) One advantage of this approach is that it allows for an arbitrary prior (as opposed to those which have a tractable KL divergence). The disadvantages are that the AAE no longer has a probabilistic interpretation and involves optimizing a minimax game, which can cause instabilities. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using the AAE requires choosing a prior, a critic structure, and a training scheme for the critic. For simplicity, we also used a spherical Gaussian prior for the AAE. We experimented with various architectures for the critic, and found the best performance with a critic which consisted of two dense layers, each with 100 units and a leaky ReLU nonlinearity. We found it satisfactory to simply use the same optimizer and learning rate for the critic as was used for the autoencoder. On our lines benchmark, the AAE typically produced smooth interpolations, but exhibited degraded quality in the middle of interpolations (fig. 3d). This behavior produced the best Smoothness score among existing autoencoders, but a relatively poor Mean Distance score. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Vector Quantized Variational Autoencoder (VQ-VAE) The Vector Quantized Variational Autoencoder (VQ-VAE) was introduced by (van den Oord et al., 2017) as a way to train discrete-latent autoencoders using a learned codebook. In the VQ-VAE, the encoder $f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ produces a continuous hidden representation $z \\in \\mathbb { R } _ { z } ^ { d }$ which is then mapped to $z _ { q }$ , its nearest neighbor in a “codebook” $\\{ e _ { j } \\in \\mathbb { R } ^ { d _ { z } } , j \\in 1 , \\ldots , K \\}$ . $z _ { q }$ is then passed to the decoder for reconstruction. The encoder is trained to minimize the reconstruction loss using the straight-through gradient estimator (Bengio et al., 2013a), together with a commitment loss term $\\beta \\parallel z - \\operatorname { s g } ( z _ { q } ) \\parallel$ (where $\\beta$ is a scalar hyperparameter) which encourages encoder outputs to move closer to their nearest codebook entry. Here sg denotes the stop gradient operator, i.e. $\\ \\operatorname { s g } ( x ) = x$ in the forward pass, and $\\operatorname { s g } ( x ) = 0$ in the backward pass. The codebook entries $e _ { j }$ are updated as an exponential moving average (EMA) of the continuous latents $z$ that map to them at each training iteration. The VQ-VAE training procedure using this EMA update rule can be seen as performing the $K$ -means or the hard Expectation Maximization (EM) algorithm on the latent codes (Roy et al., 2018). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            826,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We perform interpolation in the VQ-VAE by interpolating continuous latents, mapping them to their nearest codebook entries, and decoding the result. Assuming sufficiently large codebook, a semantically “smooth” interpolation may be possible. On the lines task, we found that this procedure produced poor interpolations. Ultimately, many entries of the codebook were mapped to unrealistic datapoints, and the interpolations resembled those of the baseline autoencoder. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            334
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Adversarially Constrained Autoencoder Interpolation Finally, we turn to evaluating our proposed adversarial regularizer for improving interpolations. For simplicity, on the lines benchmark we found it sufficient to use a critic architecture which was equivalent to the encoder (as described in appendix B). To produce a single scalar value from its output, we computed the mean of its final layer activations. For the hyperparameters $\\lambda$ and $\\gamma$ we found values of 0.5 and 0.2 to achieve good results, though the performance was not very sensitive to their values. We use these values for the coefficients for all of our experiments. Finally, we trained the critic using the same optimizer and hyperparameters as the autoencoder. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We found dramatically improved performance on the lines benchmark when using ACAI – it achieved the best Mean Distance and Smoothness score among the autoencoders we considered. When inspecting the resulting interpolations, we found it occasionally chose a longer path than necessary but typically produced “perfect” interpolation behavior as seen in fig. 3f. This provides quantitative evidence ACAI is successful at encouraging realistic and smooth interpolations. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 INTERPOLATIONS ON REAL DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            555,
+            446,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have so far only discussed results on our synthetic lines benchmark. We also provide example reconstructions and interpolations produced by each autoencoder for MNIST (LeCun, 1998), SVHN (Netzer et al., 2011), and CelebA (Liu et al., 2015) in appendix D. For each dataset, we trained autoencoders with latent dimensionalities of 32 and 256. Since we do not know the underlying data manifold for these datasets, no metrics are available to evaluate performance and we can only make qualitative judgments as to the reconstruction and interpolation quality. We find that most autoencoders produce “blurrier” images with $d _ { z } = 3 2$ but generally give smooth interpolations regardless of the latent dimensionality. The exception to this observation was the VQ-VAE which seems generally to work better with $d _ { z } = 3 2$ and occasionally even diverged for $d _ { z } = 2 5 6$ (see e.g. fig. 9e). This may be due to the nearest-neighbor discretization (and gradient estimator) failing in high dimensions. Across datasets, we found the VAE and denoising autoencoder typically produced more blurry interpolations. AAE and ACAI generally produced realistic interpolations, even between dissimilar datapoints (for example, in fig. 7 bottom). The baseline model often effectively interpolated in data space. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            775
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 IMPROVED REPRESENTATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            545,
+            811
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have so far solely focused on measuring the interpolation abilities of different autoencoders. Now, we turn to the question of whether improved interpolation is associated with improved performance on downstream tasks. Specifically, we will evaluate whether using our proposed regularizer results in latent space representations which provide better performance in supervised learning and clustering. Put another way, we seek to test whether improving interpolation results in a latent representation which has disentangled important factors of variation (such as class identity) in the dataset. To answer this question, we ran classification and clustering experiments using the learned latent spaces of different autoencoders on the MNIST (LeCun, 1998), SVHN (Netzer et al., 2011), and CIFAR-10 (Krizhevsky, 2009) datasets. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d7216d2ef5d21375777407e6bb0e9004a5973d3c6464607364cdeb4858c01492.jpg",
+        "table_caption": [
+            "Table 2: Single-layer classifier accuracy achieved by different autoencoders. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>dz</td><td>Baseline</td><td>Denoising</td><td>VAE</td><td>AAE</td><td>VQ-VAE</td><td>ACAI</td></tr><tr><td rowspan=\"2\">MNIST</td><td>32</td><td>94.90±0.14</td><td>96.00±0.27</td><td>96.56±0.31</td><td>70.74±3.27</td><td>97.50±0.18</td><td>98.25±0.11</td></tr><tr><td>256</td><td>93.94±0.13</td><td>98.51±0.04</td><td>98.74±0.14</td><td>90.03±0.54</td><td>97.25±1.42</td><td>99.00±0.08</td></tr><tr><td rowspan=\"2\">SVHN</td><td>32</td><td>26.21±0.42</td><td>25.15±0.78</td><td>29.58±3.22</td><td>23.43±0.79</td><td>24.53±1.33</td><td>34.47±1.14</td></tr><tr><td>256</td><td>22.74±0.05</td><td>77.89±0.35</td><td>66.30±1.06</td><td>22.81±0.24</td><td>44.94±20.42</td><td>85.14±0.20</td></tr><tr><td rowspan=\"2\">CIFAR-10</td><td>256</td><td>47.92±0.20</td><td>53.78±0.36</td><td>47.49±0.22</td><td>40.65±1.45</td><td>42.80±0.44</td><td>52.77±0.45</td></tr><tr><td>1024</td><td>51.62±0.25</td><td>60.65±0.14</td><td>51.39±0.46</td><td>42.86±0.88</td><td>16.22±12.44</td><td>63.99±0.47</td></tr></table>",
+        "bbox": [
+            212,
+            127,
+            785,
+            227
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ac3839685db6f883848dad00b6eb56f5b3c9c15e968b3606e4bdb09161093f08.jpg",
+        "table_caption": [
+            "Table 3: Clustering accuracy for using K-Means on the latent space of different autoencoders (left) and previously reported methods (right). On the right, “Data” refers to performing K-Means directly on the data and DEC, RIM, and IMSAT are the methods proposed in (Xie et al., 2016; Krause et al., 2010; Hu et al., 2017) respectively. Results marked \\* are excerpted from (Hu et al., 2017) and \\*\\* are from (Xie et al., 2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>dz</td><td>Baseline</td><td>Denoising</td><td>VAE</td><td>AAE</td><td>VQ-VAE</td><td>ACAI</td><td>Data</td><td>DEC</td><td>RIM</td><td>IMSAT</td></tr><tr><td>MNIST</td><td>32 256</td><td>77.56 53.70</td><td>82.59 70.89</td><td>75.74 83.44</td><td>79.19 81.00</td><td>82.39 96.80</td><td>94.38 96.17</td><td>53.2*</td><td>84.3**</td><td>58.5*</td><td>98.4*</td></tr><tr><td>SVHN</td><td>32 256</td><td>19.38 15.62</td><td>17.91 31.49</td><td>16.83 11.36</td><td>17.35 13.59</td><td>15.19 18.84</td><td>20.86 24.98</td><td>17.9*</td><td>11.9*</td><td>26.8*</td><td>57.3*</td></tr></table>",
+        "bbox": [
+            225,
+            323,
+            774,
+            396
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            422,
+            826,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Single-Layer Classifier A common method for evaluating the quality of a learned representation (such as the latent space of an autoencoder) is to use it as a feature representation for a simple, one-layer classifier (i.e. logistic regression) trained on a supervised learning task (Coates et al., 2011). The justification for this evaluation procedure is that a learned representation which has effectively disentangled class identity will allow the classifier to obtain reasonable performance despite its simplicity. To test different autoencoders in this setting, we trained a separate single-layer classifier in tandem with the autoencoder using the latent representation as input. We did not optimize autoencoder parameters with respect to the classifier’s loss, which ensures that we are measuring unsupervised representation learning performance. We repeated this procedure for latent dimensionalities of 32 and 256 (MNIST and SVHN) and 256 and 1024 (CIFAR-10). ",
+        "bbox": [
+            173,
+            468,
+            825,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our results are shown in table 2. In all settings, using ACAI instead of the baseline autoencoder upon which it is based produced significant gains – most notably, on SVHN with a latent dimensionality of 256, the baseline achieved an accuracy of only $2 2 . 7 4 \\%$ whereas ACAI achieved $8 5 . 1 4 \\%$ . In general, we found the denoising autoencoder, VAE, and ACAI obtained significantly higher performance compared to the remaining models. On MNIST and SVHN, ACAI achieved the best accuracy by a significant margin; on CIFAR-10, the performance of ACAI and the denoising autoencoder was similar. By way of comparison, we found a single-layer classifier applied directly to (flattened) image pixels achieved an accuracy of $9 2 . 3 1 \\%$ , $2 3 . 4 8 \\%$ , and $3 9 . 7 0 \\%$ on MNIST, SVHN, and CIFAR-10 respectively, so classifying using the representation learned by ACAI provides a huge benefit. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            741
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Clustering If an autoencoder groups points with common salient characteristics close together in latent space without observing any labels, it arguably has uncovered some important structure in the data in an unsupervised fashion. A more difficult test of an autoencoder is therefore clustering its latent space, i.e. separating the latent codes for a dataset into distinct groups without using any labels. To test the clusterability of the latent spaces learned by different autoencoders, we simply apply K-Means clustering (MacQueen, 1967) to the latent codes for a given dataset. Since K-Means uses Euclidean distance, it is sensitive to each dimension’s relative variance. We therefore used PCA whitening on the latent space learned by each autoencoder to normalize the variance of its dimensions prior to clustering. K-Means can exhibit highly variable results depending on how it is initialized, so for each autoencoder we ran K-Means 1,000 times from different random initializations and chose the clustering with the best objective value on the training set. For evaluation, we adopt the methodology of Xie et al. (2016); Hu et al. (2017): Given that the dataset in question has labels (which are not used for training the model, the clustering algorithm, or choice of random initialization), we can cluster the data into $C$ distinct groups where $C$ is the number of classes in the dataset. We then compute the “clustering accuracy”, which is simply the accuracy corresponding to the optimal one-to-one mapping of cluster IDs and classes (Xie et al., 2016). ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our results are shown in table 3. On both MNIST and SVHN, ACAI achieved the best or second-best performance for both $d _ { z } = 3 2$ and $d _ { z } = 2 5 6$ . We do not report results on CIFAR-10 because all of the autoencoders we studied achieved a near-random clustering accuracy. Previous efforts to evaluate clustering performance on CIFAR-10 use learned feature representations from a convolutional network trained on ImageNet (Hu et al., 2017) which we believe only indirectly measures unsupervised learning capabilities. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            272,
+            318,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have provided an in-depth perspective on interpolation in autoencoders. We proposed Adversarially Constrained Autoencoder Interpolation (ACAI), which uses a critic to encourage interpolated datapoints to be more realistic. To make interpolation a quantifiable concept, we proposed a synthetic benchmark and showed that ACAI substantially outperformed common autoencoder models. This task also yielded unexpected insights, such as that a VAE which has effectively learned the data distribution might not interpolate. We also studied the effect of improved interpolation on downstream tasks, and showed that ACAI led to improved performance for feature learning and unsupervised clustering. These findings confirm our intuition that improving the interpolation abilities of a baseline autoencoder can also produce a better learned representation for downstream tasks. However, we emphasize that we do not claim that good interpolation always implies a good representation – for example, the AAE produced smooth and realistic interpolations but fared poorly in our representations learning experiments and the denoising autoencoder had low-quality interpolations but provided a useful representation. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In future work, we are interested in investigating whether our regularizer improves the performance of autoencoders other than the standard “vanilla” autoencoder we applied it to. In this paper, we primarily focused on image datasets due to the ease of visualizing interpolations, but we are also interested in applying these ideas to non-image datasets. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            285,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Rong Ge, Yingyu Liang, Tengyu Ma, and Yi Zhang. Generalization and equilibrium in generative adversarial nets (gans). In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            174,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Pascal Lamblin, Dan Popovici, and Hugo Larochelle. Greedy layer-wise training of deep networks. In Advances in neural information processing systems, 2007. ",
+        "bbox": [
+            173,
+            636,
+            821,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients through ´ stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013a. ",
+        "bbox": [
+            173,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Gregoire Mesnil, Yann Dauphin, and Salah Rifai. Better mixing via deep representa- ´ tions. In International Conference on Machine Learning, 2013b. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Herve Bourlard and Yves Kamp. Auto-association by multilayer perceptrons and singular value ´ decomposition. Biological cybernetics, 59(4-5), 1988. ",
+        "bbox": [
+            174,
+            758,
+            823,
+            787
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samuel R. Bowman, Luke Vilnis, Oriol Vinyals, Andrew M. Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            828
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shan Carter and Michael Nielsen. Using artificial intelligence to augment human intelligence. Distill, 2017. https://distill.pub/2017/aia. ",
+        "bbox": [
+            171,
+            840,
+            825,
+            869
+        ],
+        "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 Advances in neural information processing systems, pp. 2172–2180, 2016a. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Diederik P. Kingma, Tim Salimans, Yan Duan, Prafulla Dhariwal, John Schulman, Ilya Sutskever, and Pieter Abbeel. Variational lossy autoencoder. arXiv preprint arXiv:1611.02731, 2016b. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Coates, Andrew $\\mathrm { N g }$ , and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, 2011. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016. ",
+        "bbox": [
+            171,
+            205,
+            825,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016. ",
+        "bbox": [
+            169,
+            242,
+            825,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, 2014. ",
+        "bbox": [
+            174,
+            280,
+            826,
+            323
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Kundan Kumar, Faruk Ahmed, Adrien Ali Taiga, Francesco Visin, David Vazquez, and Aaron Courville. PixelVAE: A latent variable model for natural images. arXiv preprint arXiv:1611.05013, 2016. ",
+        "bbox": [
+            174,
+            330,
+            826,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Ha and Douglas Eck. A neural representation of sketch drawings. In Sixth International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            382,
+            821,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 Fifth International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            419,
+            826,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Weihua Hu, Takeru Miyato, Seiya Tokui, Eiichi Matsumoto, and Masashi Sugiyama. Learning discrete representations via information maximizing self augmented training. arXiv preprint arXiv:1702.08720, 2017. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ferenc Huszar. Gaussian distributions are soap bubbles. ´ inFERENCe, 2017. ",
+        "bbox": [
+            173,
+            535,
+            674,
+            551
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. In Third International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improved variational inference with inverse autoregressive flow. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            173,
+            595,
+            826,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Krause, Pietro Perona, and Ryan G. Gomes. Discriminative clustering by regularized information maximization. In Advances in neural information processing systems, 2010. ",
+        "bbox": [
+            173,
+            647,
+            823,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009. ",
+        "bbox": [
+            173,
+            684,
+            826,
+            713
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun. The mnist database of handwritten digits. 1998. ",
+        "bbox": [
+            173,
+            722,
+            581,
+            738
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuang Liu, Olivier Bousquet, and Kamalika Chaudhuri. Approximation and convergence properties of generative adversarial learning. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            173,
+            746,
+            826,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), 2015. ",
+        "bbox": [
+            173,
+            782,
+            823,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew L. Maas, Awni Y. Hannun, and Andrew Y. Ng. Rectifier nonlinearities improve neural network acoustic models. In International Conference on Machine Learning, 2013. ",
+        "bbox": [
+            173,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James MacQueen. Some methods for classification and analysis of multivariate observations. In Proceedings of 5th Berkeley Symposium on Mathematical Statistics and Probability, 1967. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In IEEE International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael F. Mathieu, Junbo Jake Zhao, Aditya Ramesh, Pablo Sprechmann, and Yann LeCun. Disentangling factors of variation in deep representation using adversarial training. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            176,
+            154,
+            823,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv preprint arXiv:1701.04722, 2017. ",
+        "bbox": [
+            176,
+            204,
+            823,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, 2011. ",
+        "bbox": [
+            176,
+            253,
+            823,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016. URL http://distill.pub/2016/deconv-checkerboard. ",
+        "bbox": [
+            173,
+            304,
+            825,
+            334
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In International Conference on Machine Learning, 2014. ",
+        "bbox": [
+            176,
+            377,
+            823,
+            420
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Roberts, Jesse Engel, Colin Raffel, Curtis Hawthorne, and Douglas Eck. A hierarchical latent vector model for learning long-term structure in music. arXiv preprint arXiv:1803.05428, 2018. ",
+        "bbox": [
+            171,
+            428,
+            823,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aurko Roy, Ashish Vaswani, Arvind Neelakantan, and Niki Parmar. Theory and experiments on vector quantized autoencoders. arXiv preprint arXiv:1805.11063, 2018. ",
+        "bbox": [
+            171,
+            464,
+            823,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. Ladder variational autoencoders. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            174,
+            501,
+            823,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Tolstikhin, Olivier Bousquet, Sylvain Gelly, and Bernhard Schoelkopf. Wasserstein auto-encoders. In Fifth International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakub M. Tomczak and Max Welling. Improving variational auto-encoders using householder flow. arXiv preprint arXiv:1611.09630, 2016. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            604
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakub M. Tomczak and Max Welling. Vae with a vampprior. arXiv preprint arXiv:1705.07120, 2017. ",
+        "bbox": [
+            171,
+            611,
+            823,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            174,
+            633,
+            826,
+            676
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Oriol Vinyals, et al. Neural discrete representation learning. In Advances in Neural Information Processing Systems, pp. 6309–6318, 2017. ",
+        "bbox": [
+            173,
+            684,
+            823,
+            714
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vikas Verma, Alex Lamb, Christopher Beckham, Aaron Courville, Ioannis Mitliagkis, and Yoshua Bengio. Manifold mixup: Encouraging meaningful on-manifold interpolation as a regularizer. arXiv preprint arXiv:1806.05236, 2018. ",
+        "bbox": [
+            174,
+            720,
+            826,
+            763
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of Machine Learning Research, 11, 2010. ",
+        "bbox": [
+            173,
+            771,
+            826,
+            814
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom White. Sampling generative networks: Notes on a few effective techniques. arXiv preprint arXiv:1609.04468, 2016. ",
+        "bbox": [
+            173,
+            821,
+            825,
+            851
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junyuan Xie, Ross Girshick, and Ali Farhadi. Unsupervised deep embedding for clustering analysis. In International conference on machine learning, pp. 478–487, 2016. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shengjia Zhao, Jiaming Song, and Stefano Ermon. InfoVAE: Information maximizing variational autoencoders. arXiv preprint arXiv:1706.02262, 2017. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ad93aefd87dcaa05eb84f1109f9c8f406de2bea636705b07a2b75aadbe8716f.jpg",
+        "image_caption": [
+            "Figure 4: Examples of data and interpolations from our synthetic lines dataset. (a) 16 random samples from the dataset. (b) A perfect interpolation from $\\Lambda = { ^ { 1 1 \\pi } } / { _ { 1 4 } }$ to 0. (c) Interpolating in data space rather than “semantic” or latent space. Clearly, interpolating in this way produces points not on the data manifold. (d) An interpolation which abruptly changes from one image to the other, rather than smoothly changing. (e) A smooth interpolation which takes a longer path from the start to end point than necessary. (f) An interpolation which takes the correct path but where intermediate points are not realistic. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            102,
+            789,
+            281
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A LINE BENCHMARK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            416,
+            369,
+            433
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 EXAMPLE INTERPOLATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            448,
+            413,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Some example data and interpolations for our synthetic lines benchmark are shown in fig. 4. Full discussion of this benchmark is available in section 3.1. ",
+        "bbox": [
+            176,
+            474,
+            825,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 EVALUATION METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            520,
+            379,
+            535
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We define our Mean Distance and Smoothness metrics as follows: Let $x _ { 1 }$ and $x _ { 2 }$ be two input images we are interpolating between and ",
+        "bbox": [
+            174,
+            546,
+            825,
+            575
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08da12b3802455e39aaf08c39672dc7f7b9465e67bb8bee66c0b4f85e9c1fc2d.jpg",
+        "text": "$$\n\\hat { x } _ { n } = g _ { \\phi } \\left( \\frac { n - 1 } { N - 1 } z _ { 1 } + \\left( 1 - \\frac { n - 1 } { N - 1 } \\right) z _ { 2 } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            582,
+            642,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "be the decoded point corresponding to mixing $x _ { 1 }$ and $x _ { 2 }$ ’s latent codes using coefficient $\\alpha = { \\mathfrak { n } } - 1 / { \\mathfrak { N } } - 1$ The images $\\hat { x } _ { n } , n \\in \\{ 1 , \\ldots , N \\}$ then comprise a length- $N$ interpolation between $x _ { 1 }$ and $x _ { 2 }$ . To produce our evaluation metrics, we first find the closest true datapoint (according to cosine distance) for each of the $N$ intermediate images along the interpolation. Finding the closest image among all possible line images is infeasible; instead we first generate a size- $D$ collection of line images $\\mathcal { D }$ with corresponding angles $\\Lambda _ { q } , q \\in \\{ 1 , \\ldots , D \\}$ spaced evenly between 0 and $2 \\pi$ . Then, we match each image in the interpolation to a real datapoint by finding ",
+        "bbox": [
+            173,
+            623,
+            825,
+            722
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7d0406e62bd4f89c8088f77d1b88b9e13edc3c2e6198879efb381dbd3511dd9.jpg",
+        "text": "$$\n\\begin{array} { c } { { C _ { n , q } = 1 - \\frac { { \\hat { x } _ { n } } { \\mathcal { D } _ { q } } } { \\| \\hat { x } _ { n } \\| \\| { \\mathcal { D } _ { q } } \\| } } } \\\\ { { q _ { n } ^ { \\star } = \\arg \\underset { q } { \\operatorname* { m i n } } C _ { n , q } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            728,
+            578,
+            789
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "for $n \\in \\{ 1 , \\ldots , N \\}$ , where $C _ { n , q }$ is the cosine distance between ${ \\hat { x } } _ { n }$ and the $q$ th entry of $\\mathcal { D }$ . To capture the notion of “intermediate points look realistic”, we compute ",
+        "bbox": [
+            173,
+            795,
+            825,
+            824
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e084ebf67a669b56f292e25e23d186dd55ec23d91de2dc5549c04bdb67c0d21.jpg",
+        "text": "$$\n\\operatorname { M e a n } \\operatorname { D i s t a n c e } ( \\left\\{ { \\hat { x } } _ { 1 } , { \\hat { x } } _ { 2 } , \\ldots , { \\hat { x } } _ { N } \\right\\} ) = { \\frac { 1 } { N } } \\sum _ { n = 1 } ^ { N } C _ { n , q _ { n } ^ { \\star } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            830,
+            671,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We now define a perfectly smooth interpolation to be one which consists of lines with angles which linearly move from the angle of $\\mathcal { D } _ { q _ { 1 } ^ { \\star } }$ to that of $\\mathcal { D } _ { \\boldsymbol { q } _ { N } ^ { \\star } }$ . Note that if, for example, the interpolated lines go from $\\Lambda _ { q _ { 1 } ^ { \\star } } = \\pi / 1 0$ to $\\Lambda _ { q _ { N } ^ { \\star } } = { } ^ { 1 9 \\pi } / 1 0$ then the angles corresponding to the shortest path will have a discontinuity from 0 to $2 \\pi$ . To avoid this, we first “unwrap” the angles $\\{ \\Lambda _ { q _ { 1 } ^ { \\star } } , \\ldots , \\Lambda _ { q _ { N } ^ { \\star } } \\}$ by removing discontinuities larger than $\\pi$ by adding multiples of $\\pm 2 \\pi$ when the absolute difference between $\\Lambda _ { q _ { n - 1 } ^ { \\star } }$ and $\\Lambda _ { { q } _ { n } ^ { \\star } }$ is greater than $\\pi$ to produce the angle sequence $\\{ \\tilde { \\Lambda } _ { q _ { 1 } ^ { \\star } } , \\ldots , \\tilde { \\Lambda } _ { q _ { N } ^ { \\star } } \\}$ .2 Then, we define a measure of smoothness as ",
+        "bbox": [
+            174,
+            880,
+            825,
+            926
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            102,
+            825,
+            162
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/339978803cbcd13a27dd3a1a8e401df11fb8afe083365588d5635e83c85ef98a.jpg",
+        "text": "$$\n\\mathrm { S m o o t h n e s s } \\big ( \\big \\{ \\hat { x } _ { 1 } , \\hat { x } _ { 2 } , . . . , \\hat { x } _ { N } \\big \\} \\big ) = \\frac { 1 } { \\vert \\tilde { \\Lambda } _ { q _ { 1 } ^ { * } } - \\tilde { \\Lambda } _ { q _ { N } ^ { * } } \\vert } \\operatorname* { m a x } _ { n \\in \\{ 1 , . . . , N - 1 \\} } \\Big ( \\tilde { \\Lambda } _ { q _ { n + 1 } ^ { * } } - \\tilde { \\Lambda } _ { q _ { n } ^ { * } } \\Big ) - \\frac { 1 } { N - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            166,
+            782,
+            204
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In other words, we measure the how much larger the largest change in (normalized) angle is compared to the minimum possible value $\\left( { } ^ { 1 } / ( N { - } 1 ) \\right)$ . ",
+        "bbox": [
+            176,
+            209,
+            823,
+            238
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "By way of example, figs. 4b, 4d and 4e would all achieve Mean Distance scores near zero and figs. 4c and 4f would achieve larger Mean Distance scores. Figures 4b and 4f would achieve Smoothness scores near zero, figs. 4c and 4d have poor Smoothness, and fig. $_ { 4 \\mathrm { e } }$ is in between. ",
+        "bbox": [
+            174,
+            244,
+            825,
+            286
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B BASE MODEL ARCHITECTURE AND TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            702,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "All of the autoencoder models we studied in this paper used the following architecture and training procedure: The encoder consists of blocks of two consecutive $3 \\times 3$ convolutional layers followed by $2 \\times 2$ average pooling. All convolutions (in the encoder and decoder) are zero-padded so that the input and output height and width are equal. The number of channels is doubled before each average pooling layer. Two more $3 \\times 3$ convolutions are then performed, the last one without activation and the final output is used as the latent representation. All convolutional layers except for the final use a leaky ReLU nonlinearity (Maas et al., 2013). For experiments on the synthetic “lines” task, the convolution-average pool blocks are repeated 4 times until we reach a latent dimensionality of 64. For subsequent experiments on real datasets (section 4), we repeat the blocks 3 times, resulting in a latent dimensionality of 256. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            478
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The decoder consists of blocks of two consecutive $3 \\times 3$ convolutional layers with leaky ReLU nonlinearities followed by $2 \\times 2$ nearest neighbor upsampling (Odena et al., 2016). The number of channels is halved after each upsampling layer. These blocks are repeated until we reach the target resolution $3 2 \\times 3 2$ in all experiments). Two more $3 \\times 3$ convolutions are then performed, the last one without activation and with a number of channels equal to the number of desired colors. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "All parameters are initialized as zero-mean Gaussian random variables with a standard deviation of $1 / \\sqrt { \\tan \\_ { - } \\mathrm { i n } ( 1 + 0 . 2 ^ { 2 } ) }$ set in accordance with the leaky ReLU slope of 0.2. Models are trained on $2 ^ { 2 4 }$ samples in batches of size 64. Parameters are optimized with Adam (Kingma & Welling, 2014) with a learning rate of 0.0001 and default values for $\\beta _ { 1 } , \\beta _ { 2 }$ , and $\\epsilon$ . ",
+        "bbox": [
+            174,
+            560,
+            825,
+            617
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C VAE SAMPLES ON THE LINE BENCHMARK",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            565,
+            654
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In fig. 5, we show some samples from our VAE trained on the synthetic line benchmark. The VAE generally produces realistic samples and seems to cover the data distribution well, despite the fact that it does not produce high-quality interpolations (fig. 3c). ",
+        "bbox": [
+            174,
+            669,
+            825,
+            712
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D INTERPOLATION EXAMPLES ON REAL DATA ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            731,
+            576,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide a series of figures (figs. 6 to 11) showing interpolation behavior for the different autoencoders we studied. Further discussion of these results is available in section 3.3 ",
+        "bbox": [
+            173,
+            762,
+            825,
+            791
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/011b1d5ca5a163871496158859d0e142b9e53ddb0eae4efef60407763041d635.jpg",
+        "image_caption": [
+            "Figure 5: Samples from a VAE trained on the lines dataset described in section 3.1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            247,
+            823,
+            748
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/db363f651bed0df99d894ff8748b176860a5645e01396365f1bbaccac330a733.jpg",
+        "image_caption": [
+            "Figure 6: Example interpolations on MNIST with a latent dimensionality of 32 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            161,
+            774,
+            823
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/2efdc3a2b3e2b708fcdafcc88768f0d53ebfd36bbc3051aecfbd180d1f170ce1.jpg",
+        "image_caption": [
+            "Figure 7: Example interpolations on MNIST with a latent dimensionality of 256 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            160,
+            774,
+            821
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/47de7ca907daaf8fc9e0bdbadba83520b961226907f1b5076ae26acedb1b1e9c.jpg",
+        "image_caption": [
+            "Figure 8: Example interpolations on SVHN with a latent dimensionality of 32 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            166,
+            774,
+            819
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6ad7a3f626f887a67a272b156817696c598021ea8e689ebd4cd30406740f6d4.jpg",
+        "image_caption": [
+            "Figure 9: Example interpolations on SVHN with a latent dimensionality of 256 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            166,
+            774,
+            820
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c48de8b1f74145157c8b8b7cfe6d11bfa33d99734117c359409d43734b2424d.jpg",
+        "image_caption": [
+            "Figure 10: Example interpolations on CelebA with a latent dimensionality of 32 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            167,
+            776,
+            820
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/63948b88054bf695f2323771a5e64557140ff80440ce0329caa06dd514cc8482.jpg",
+        "image_caption": [
+            "Figure 11: Example interpolations on CelebA with a latent dimensionality of 256 for (a) Baseline, (b) Denoising, (c) VAE, (d) AAE, (e) VQ-VAE, (f) ACAI autoencoders. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            166,
+            776,
+            820
+        ],
+        "page_idx": 19
+    }
+]

parse/train/e68IYJNOYau/e68IYJNOYau.md

@@ -0,0 +1,419 @@
+# POINT CLOUD INSTANCE SEGMENTATION USING PROBABILISTIC EMBEDDINGS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In this paper we propose a new framework for point cloud instance segmentation. Our framework has two steps: an embedding step and a clustering step. In the embedding step, our main contribution is to propose a probabilistic embedding space for point cloud embedding. Specifically, each point is represented as a tri-variate normal distribution. In the clustering step, we propose a novel loss function, which benefits both the semantic segmentation and the clustering. Our experimental results show important improvements to the SOTA, i.e., $3 . 1 \%$ increased average per-category mAP on the PartNet dataset.
+
+# 1 INTRODUCTION
+
+In this paper we tackle the problem of instance segmentation of point clouds. In instance segmentation we would like to assign two labels to each point in a point cloud. The first label is the class label (e.g., leg, back, seat, ... for a chair data set) and the second label is the instance ID (a unique number, e.g., to distinguish the different legs of a chair). While instance segmentation had many recent successes in the image domain (He et al. (2017); Liu et al. (2018); Fathi et al. (2017); Novotny et al. (2018); De Brabandere et al. (2017); Neven et al. (2019)), we believe that the problem of instance segmentation for point clouds is not sufficiently explored.
+
+We build our work on the idea of embedding-based instance segmentation, that is very popular in the image and volume domain (Fathi et al. (2017); Novotny et al. (2018); De Brabandere et al. (2017); Neven et al. (2019); Lahoud et al. (2019)) and has also been successfully applied in the point clouds domain (Wang et al. (2018; 2019b)). In this approach typically two steps are employed. In the first step, each point (or pixel) is embedded in a feature space such that points belonging to the same instance should be close and points belonging to different instances should be further apart from each other. In the second step points are grouped using a clustering algorithm, such as mean-shift or greedy clustering. We remark that the current state of the art methods (Neven et al. (2019); Wang et al. (2018)) follow this approach.
+
+One important design choice in embedding-based methods is the dimensionality of the feature space. Some methods propose to use a high dimensional feature space (De Brabandere et al. (2017); Kong & Fowlkes (2018)), while others use a low dimensional features space that has the same dimensionality as the input data (Novotny et al. (2018); Kendall et al. (2018); Neven et al. (2019)), e.g., 2D for images, and 3D for point clouds. Methods with a low dimensional embedding space not only have lower computational complexity, but they also lead to better interpretability, e.g., embeddings are encoded as offset vectors towards instance centers.
+
+Therefore, the main goal of our work is to extend the expressiveness of the embedding space in a way that leads to improved segmentation performance. Our proposed solution is to employ probabilistic embeddings, such that each point in the embedding space is encoded by a distribution. While assessing uncertainty is a popular tool in recent computer vision research (Kendall & Gal (2017); Khan et al. (2019); Liu et al. (2019); Dorta et al. (2018)) and we introduce this idea to the task of instance segmentation. Incorporating uncertainty leads to an important improvement in segmentation performance. For example, on the PartNet (Mo et al. (2019)) fine-grained instance segmentation dataset we can improve the SOTA by $3 . 1 \%$ average per-category mAP.
+
+In the remainder of the paper, we will give more details on the probabilistic embedding algorithm (Sec. 3), explain the embedding step (Sec. 3.1) and the clustering step (Sec. 3.4) in more detail.
+
+![](images/b0ccf815269fb3c636a18d8d80e69d24682e56f469ddded46e527000542043c6.jpg)  
+Figure 1: Our method takes a point cloud as input, encodes the points as random variables, and outputs semantic class labels and instance labels.
+
+![](images/f7a5344ff8128579bc2584f1a98c8eccfa2aaac82850a899ca405cb6b743c5a2.jpg)  
+Figure 2: Examples of (dis)similarity measures
+
+Contribution. Our main contributions are as follows
+
+1. We propose to use probabilistic embeddings for instance segmentation and present a complete framework in the context of point cloud instance segmentation based on probabilistic embeddings.   
+2. We develop a new loss function for the clustering step that is especially suited for highgranularity data sets.   
+3. We show that the proposed probabilistic embeddings can be incorporated into existing embedding-based methods.
+
+# 2 RELATED WORK
+
+# 2.1 2D IMAGE INSTANCE SEGMENTATION
+
+The dominant approaches for image instance segmentation are proposal-based methods (He et al. (2017); Liu et al. (2018)), which are built upon object detection methods (Girshick (2015); Ren et al. (2015)). Typically, they have higher quality, but a slower computation time compared to proposal free methods. The mainstream proposal free approaches are based on metric learning. The basic idea is to learn an embedding space, in which pixels belonging to the same object instance are close to each other and distant to pixels belonging to other object instances (Fathi et al. (2017); De Brabandere et al. (2017)). All above works are based on high-dimensional embedding, while more recent works (Liang et al. (2017); Kendall et al. (2018); Novotny et al. (2018); Neven et al. (2019)) show that 2D spatial embedding is sufficient to achieve the same or even higher performance.
+
+# 2.2 3D POINT CLOUD INSTANCE SEGMENTATION
+
+SGPN (Wang et al. (2018)) uses PointNet+ $^ +$ (Qi et al. (2017)) as backbone network and designs a double-hinge loss function to learn a pairwise similarity matrix of points. GSPN (Yi et al. (2019)) produces object proposals with high objectness for point cloud instance segmentation. ASIS (Wang et al. (2019b)) is a module capable of making semantic segmentation and instance segmentation take advantage of each other. Mo et al. (2019) release a large scale point cloud dataset for part instance segmentation and benchmark their method and SGPN on this dataset.
+
+# 2.3 UNCERTAINTY IN COMPUTER VISION
+
+Kendall & Gal (2017) present a unified framework combining model uncertainty with data uncertainty and can estimate uncertainty in classification and regression tasks. We introduce uncertainty estimation to the literature of instance embedding, by modeling points as random variables. Our method is related to recent works in deep generative networks (Kingma & Welling (2013); Rezende et al. (2014)). They use a stochastic encoder to encode a data sample as a set of random variables, while focusing on solving the problem of backpropagation through random variables in deep neural networks. We deal with this problem by using a probabilistic product kernel (Jebara et al. (2004)).
+
+# 3 METHOD
+
+A training sample is a labeled 3D point cloud. It consists of point coordinates $\left\{ { \bf x } _ { i } \right\} _ { i = 1 } ^ { N }$ , class labels $\{ y _ { i } \} _ { i = 1 } ^ { N }$ and instance IDs $\left\{ z _ { i } \right\} _ { i = 1 } ^ { N }$ . We want to train a neural network to infer per point class labels and per point instance IDs at the same time.
+
+# 3.1 PROBABILISTIC SPATIAL EMBEDDING
+
+A common approach in the literature of instance segmentation is to learn a function to embed pixels/points into a space where pair-wise similarity can be measured. Usually, this function is a deep neural network $f$ which transforms an unordered point set $\{ { \mathbf { x } } _ { i } \} _ { i = 1 } ^ { N }$ to embeddings $\left\{ { \bf e } _ { i } \right\} _ { i = 1 } ^ { N }$ . Instead of deterministic embeddings used in previous work, here we consider a probabilistic embedding, by modeling $\mathbf { e } _ { i }$ as a random variable, $\mathbf { e } _ { i } \sim p _ { i } ( \mathbf { e } )$ , where $p _ { i }$ is a probability density function. In Section 3.3 we will need to calculate the sum of random variables. In the ideal case, the distribution of a single random variable and the sum of multiple random variables has the same type of distribution that can be described with a few parameters. Thus we propose to model the embedding with a (symmetric) stable distribution. This leaves us two options, Gaussian and Cauchy. For the Cauchy distribution, it is challenging to get a closed-form expression in our calculation in Section 3.2. Therefore, we choose to work with the tri-variate Gaussian distribution1 $p _ { i } ( \mathbf { e } ) = \mathcal { N } ( \mathbf { e } ; \mu _ { i } , \pmb { \Sigma } _ { i } )$ with mean vector $\pmb { \mu _ { i } } \in \mathbb { R } ^ { 3 }$ and covariance matrix $\pmb { \Sigma } _ { i } \in \mathbb { R } ^ { 3 \times 3 }$ . For simplicity, let $\Sigma _ { i }$ be a diagonal matrix, $\Sigma _ { i } = \mathrm { d i a g } ( \sigma _ { i } ^ { ( 1 ) 2 } , \sigma _ { i } ^ { ( 2 ) 2 } , \sigma _ { i } ^ { ( 3 ) 2 } )$ , where $\sigma _ { i } ^ { ( d ) 2 }$ is the square of $\sigma _ { i } ^ { ( \bar { d } ) }$ and $d = 1 , 2 , 3$ .
+
+The network $f ( \cdot )$ takes as input a (unordered) point set $\left\{ { \bf x } _ { i } \right\} _ { i = 1 } ^ { N }$ , and outputs $\{ \mu _ { i } , \pmb { \sigma } _ { i } , \mathbf { p } _ { i } \} _ { i = 1 } ^ { N }$ $f ( \{ \mathbf { x } _ { i } \} _ { i = 1 } ^ { N } ) = \{ \mu _ { i } , \pmb { \sigma } _ { i } , \mathbf { p } _ { i } \} _ { i = 1 } ^ { N }$ , where $\pmb { \sigma } _ { i } = \left[ \sigma _ { i } ^ { ( 1 ) } , \sigma _ { i } ^ { ( 2 ) } , \sigma _ { i } ^ { ( 3 ) } \right] ^ { \mathsf { T } } \in \mathbb { R } ^ { 3 }$ and $\mathbf { p } _ { i }$ is a probability vector which can be used to infer class label of $\mathbf { x } _ { i }$ and will be explained in Sec. 3.4.
+
+# 3.2 SIMILARITY MEASURE
+
+In deterministic embeddings, the (dis)similarity between points is usually measured by Euclidean distance $\| \mathbf { e } _ { i } - \mathbf { e } _ { j } \|$ , or cosine similarity $\frac { \mathbf { e } _ { i } ^ { \mathsf { T } } \mathbf { e } _ { j } ^ { \mathsf { - } } } { \| \mathbf { e } _ { i } \| \| \mathbf { e } _ { j } \| }$ (See Figure 2). Since now we are using probabilistic embeddings, a similarity kernel for random variables needs to be selected. Here we describe the Bhattacharyya kernel (Jebara et al. (2004)).
+
+Definition. Let $\mathcal { P }$ be the set of distributions over $\Omega$ . The Bhattacharyya kernel on $\mathcal { P }$ is the function $\mathcal { K } : \mathcal { P } \times \mathcal { P } \mapsto \mathbb { R }$ such that, for all $p , q \in \mathcal { P }$ ,
+
+$$
+\begin{array} { r } { \mathcal { K } ( p , q ) = \displaystyle \int _ { \Omega } \sqrt { p ( \mathbf { x } ) } \sqrt { q ( \mathbf { x } ) } \mathrm { d } \mathbf { x } . } \end{array}
+$$
+
+We choose this kernel as our similarity measure for two reasons, 1) the Bhattacharyya kernel is symmetric, i.e. $\begin{array} { r } { K ( p , q ) = K ( q , p ) ; 2 } \end{array}$ ) the Bhattacharyya kernel has values between 0 (no similarity) and 1 (maximal similarity). And $\ K ( p , q ) = 1$ if and only if $p = q$ .
+
+Then the similarity $\kappa ( \cdot , \cdot )$ between random variables can be represented by the Bhattacharyya kernel of their probability density functions,
+
+$$
+\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } ) = \int \sqrt { \mathcal { N } ( \mathbf { e } ; \mu _ { i } , \Sigma _ { i } ) } \sqrt { \mathcal { N } ( \mathbf { e } ; \mu _ { j } , \Sigma _ { j } ) } \mathrm { d } \mathbf { e } = \beta _ { i , j } \exp \left( - \left\| \mu _ { i } - \mu _ { j } \right\| _ { \Sigma _ { i , j } ^ { - 1 } } ^ { 2 } \right) 2 ,
+$$
+
+![](images/c5dcbf3f20cc5b32cfdf95c04be5d2ea894b875d6be1c2d16258f4e8b65a6f1a.jpg)  
+Figure 3: Contour plot. Left: 1-D uncertainty similarity $\beta _ { i , j } = \left( \left( \sigma _ { i } / \sigma _ { j } + \sigma _ { j } / \sigma _ { i } \right) / 2 \right) ^ { - 1 / 2 }$ . The highest value 1 is achieved when $\sigma _ { i } = \sigma _ { j }$ . The value goes to 0 when one of the uncertainties is small and the other is large. Right (4 figures): the similarity for different values of $\Delta \mu$ (from left to right, $\Delta \mu = 1 , 5 , 1 0 , 2 5 )$ in the case of 1-D probabilistic embedding. The similarity becomes $\beta _ { i , j } \exp { \left( - \frac { 1 } { 2 } \frac { \Delta \mu } { \alpha _ { i , j } } \right) }$ , where $\Delta \mu = \left( \mu _ { i } - \mu _ { j } \right) ^ { 2 }$ , $\alpha _ { i , j } = 4 \left( \sigma _ { i } ^ { 2 } + \sigma _ { j } ^ { 2 } \right)$ .
+
+where
+
+$$
+\begin{array} { c } { \displaystyle \alpha _ { i , j } ^ { ( d ) } = 4 ( \sigma _ { i } ^ { ( d ) 2 } + \sigma _ { j } ^ { ( d ) 2 } ) , \quad \displaystyle \beta _ { i , j } = \left( \prod _ { d = 1 } ^ { 3 } \frac { 1 } { 2 } \left( \frac { \sigma _ { i } ^ { ( d ) } } { \sigma _ { j } ^ { ( d ) } } + \frac { \sigma _ { j } ^ { ( d ) } } { \sigma _ { i } ^ { ( d ) } } \right) \right) ^ { - \frac { 1 } { 2 } } , } \\ { \displaystyle \Sigma _ { i , j } = \mathrm { d i a g } ( \alpha _ { i , j } ^ { ( 1 ) } , \alpha _ { i , j } ^ { ( 2 ) } , \alpha _ { i , j } ^ { ( 3 ) } ) , } \\ { \displaystyle \| \mu _ { i } - \mu _ { j } \| _ { \Sigma _ { i , j } ^ { - 1 } } ^ { 2 } = ( \mu _ { i } - \mu _ { j } ) ^ { \mathsf T } \Sigma _ { i , j } ^ { - 1 } ( \mu _ { i } - \mu _ { j } ) = \sum _ { d = 1 } ^ { 3 } \frac { \mu _ { i } ^ { ( d ) } - \mu _ { j } ^ { ( d ) } } { \alpha _ { i , j } ^ { ( d ) } } . } \end{array}
+$$
+
+• If the uncertainties $\sigma _ { i }$ and $\pmb { \sigma } _ { j }$ have a large difference, $\beta _ { i , j }$ will be small, so will be $\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } )$ . See Fig. 3.
+
+• If the centers $\pmb { \mu _ { i } }$ and $\mu _ { j }$ have a large difference, the exponential term will be small, so will be $\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } )$ . See Fig. 3.
+
+• The scale term $\beta _ { i , j } = 1$ if and only if the uncertainties $\sigma _ { i }$ and $\pmb { \sigma } _ { j }$ are element-wise equal. In this case, $\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } )$ becomes an anisotropic Gaussian kernel,
+
+$$
+\kappa _ { R B F } ( \pmb { \mu } _ { i } , \pmb { \mu } _ { j } ) = \exp \left( - \left\| \pmb { \mu } _ { i } - \pmb { \mu } _ { j } \right\| _ { \pmb { \Sigma } _ { i , j } ^ { - 1 } } ^ { 2 } \right) .
+$$
+
+• The exponential term equals 1 if and only if the centers $\pmb { \mu _ { i } }$ and $\pmb { \mu } _ { j }$ are element-wise equal. In this case, $\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } )$ becomes $\beta _ { i , j }$ , i.e., the similarity between uncertainties. This property allows two points that have the same embedding centers to have a low similarity, as long as $\beta _ { i , j }$ is small.
+
+Compared to deterministic embedding, $\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } ) = \exp \left( - \left\| \mathbf { e } _ { i } - \mathbf { e } _ { j } \right\| ^ { 2 } \right) ^ { 3 }$ , our similarity measure consists not merely of the similarity of spatial distances, but also the similarity of uncertainties.
+
+In the following, we discuss multiple choices of embedding distributions that we will evaluate in Sec 4.2.
+
+Homoscedasticity vs. Heteroscedasticity. The embeddings $\{ { \mathbf { e } } _ { i } \} _ { i = 1 } ^ { N }$ are homoscedastic if they have the same variance instead of point-depende $\pmb { \Sigma }$ . In this  variances a point cloud . And the sim $\mathbf { X }$ we learn to predicrity kernel becomes $\pmb { \Sigma }$ $\left\{ \pmb { \Sigma } _ { i } \right\} _ { i = 1 } ^ { N }$ $\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } ) \ =$ $\exp \left( - \left. \pmb { \mu } _ { i } - \pmb { \mu } _ { j } \right. _ { \pmb { \Sigma } _ { i , j } ^ { - 1 } } ^ { 2 } \right)$ , which is also the form of the RBF kernel in Eq. 2.
+
+Isotropy vs. Anisotropy. The variance $\Sigma _ { i }$ is isotropic if its diagonal elements (variances of dimensions) are the same. Then we can write $\Sigma _ { i } = \sigma _ { i } ^ { 2 } \mathbf { I }$ , where $\mathbf { I }$ is a $3 \times 3$ identity matrix. The similarity can be written as $\begin{array} { r } { \kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } ) = \beta _ { i , j } \exp \left( - \frac { \vert \vert \mu _ { i } - \mu _ { j } \vert \vert ^ { 2 } } { \alpha _ { i , j } } \right) } \end{array}$ , where $\beta _ { i , j } = \left( \left( \sigma _ { i } / \sigma _ { j } + \sigma _ { j } / \sigma _ { i } \right) / 2 \right) ^ { - \frac { 3 } { 2 } }$ and $\alpha _ { i , j } = 4 ( \sigma _ { i } ^ { 2 } + \sigma _ { j } ^ { 2 } )$ .
+
+# 3.3 INSTANCE GROUPING
+
+Let $\{ i : z _ { i } = k \}$ be the index set of points having instance $\textrm { I D } k$ . We take an average of these embeddings to get the embedding $\mathbf { c } _ { k }$ of instance $k$ , $\begin{array} { r } { \mathbf { c } _ { k } = \frac { 1 } { | \{ i : z _ { i } = k \} | } \sum _ { \{ i : z _ { i } = k \} } \mathbf { e } _ { i } } \end{array}$ . Since the sum of Gaussian random variables is still a Gaussian random variable, we can derive the following:
+
+$$
+p ( \mathbf { c } _ { k } ) = { \mathcal { N } } ( \mathbf { c } _ { k } ; { \hat { \mu } } _ { k } , { \hat { \Sigma } } _ { k } ) , \quad { \hat { \mu } } _ { k } = { \frac { 1 } { | \left\{ i : z _ { i } = k \right\} | } } \sum _ { \left\{ i : z _ { i } = k \right\} } \mu _ { i } , \quad { \hat { \Sigma } } _ { k } = { \frac { 1 } { | \left\{ i : z _ { i } = k \right\} | } } \sum _ { \left\{ i : z _ { i } = k \right\} } \Sigma _ { i } .
+$$
+
+Now we can measure the similarity between a point and an instance by using $\kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } )$ .
+
+If $z _ { i } = k$ , we want $\kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } )$ to be close to 1, otherwise 0. We can optimize a binary cross entropy loss function,
+
+$$
+\mathcal { L } _ { I n s C E } = \frac { 1 } { N K } \sum _ { k = 0 } ^ { K - 1 } \sum _ { i = 1 } ^ { N } \left\{ \begin{array} { l l } { - \ln \kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } ) , } & { \mathrm { i f ~ } z _ { i } = k , } \\ { - \ln ( 1 - \kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } ) ) , } & { \mathrm { o t h e r w i s e } . } \end{array} \right.
+$$
+
+However, in practice, this suffers from a serious foreground-background imbalance problem. To remedy this drawback we propose to use the combined log-Dice loss function (Wong et al. (2018)) instead:
+
+$$
+\mathcal { L } _ { I n s } = \mathcal { L } _ { I n s C E } - \ln \frac { 2 \sum _ { k = 0 } ^ { K - 1 } \sum _ { i = 1 } ^ { N } \kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } ) \mathbb { 1 } _ { z _ { i } = k } } { \sum _ { k = 0 } ^ { K - 1 } \sum _ { i = 1 } ^ { N } \left( \kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } ) + \mathbb { 1 } _ { z _ { i } = k } \right) } ,
+$$
+
+where $\mathbb { 1 } _ { z _ { i } = k }$ is an indicator function which equals 1 when $z _ { i } = k$ , 0 otherwise.
+
+Entropy Regularization. As we can see in Figure 3, when $\boldsymbol { \sigma } _ { i } ^ { ( l ) }$ and $\sigma _ { j } ^ { ( l ) }$ goes to infinity while keeping σ(li $\sigma _ { i } ^ { ( l ) } = \sigma _ { j } ^ { ( l ) }$ , $\beta _ { i , j } = 1$ and the similarity equals to 1 no matter what the value $\mu _ { i } - \mu _ { j }$ is. Formally speaking,
+
+$$
+\operatorname* { l i m } _ { \substack { \sigma _ { i } ^ { ( l ) }  \infty , \sigma _ { j } ^ { ( l ) }  \infty , \sigma _ { i } ^ { ( l ) } = \sigma _ { j } ^ { ( l ) } , l = 1 , 2 , 3 } }  \kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { j } ) = 1 .
+$$
+
+Consequently, the similarity degenerates to constant 1 for every pair of embeddings. To address this issue, we propose an entropy regularizer,
+
+$$
+\mathcal { L } _ { R e g } = \sum _ { i = 1 } ^ { N } \mathbb { H } ( \mathbf { e } _ { i } ) = \sum _ { i = 1 } ^ { N } \left[ \frac { 3 } { 2 } \ln ( 2 \pi e ) + \frac { 1 } { 2 } \ln \left( \sigma _ { i } ^ { ( 1 ) } \sigma _ { i } ^ { ( 2 ) } \sigma _ { i } ^ { ( 3 ) } \right) ^ { 2 } \right] ,
+$$
+
+where $\mathbb { H } ( \mathbf { e } _ { i } )$ is the entropy of multivariate Gaussian variable $\mathbf { e } _ { i }$ . This regularizer is not only able to prevent the similarity degeneration by minimizing the variances along all dimensions, but can also penalize large uncertainties, thus increasing the confidence of the network output as in Grandvalet & Bengio (2005) and Wang et al. (2019a).
+
+# 3.4 SEMANTIC CLASSIFICATION
+
+Neven et al. (2019) introduces a way to use score maps to find cluster centers. Our main novelty is the new loss function, so our description focuses on this part. We still describe the greedy clustering steps from Neven et al. (2019) for completeness. In Section 4.2, we compare our new center-aware loss Eq 10 to the previously used minimum squared error (MSE) loss by Neven et al. (2019).
+
+After defining the similarity measure, we can easily find out all points similar to an instance center. However, during the inference phase, we don’t have the information of ground-truth instance IDs, thus, it is impossible to use Eq. 3 to get instance centers. Therefore, along with distribution parameters $\{ \mu _ { i } \} _ { i = 1 } ^ { N }$ and $\{ \pmb { \sigma } _ { i } \} _ { i = 1 } ^ { N }$ , we also predict a score map $\{ { \bf p } _ { i } \} _ { i = 1 } ^ { N }$ , where $\mathbf { p } _ { i } \in \mathbb { R } ^ { L }$ and its $l$ -th entry p(l) indicates the probability of $\mathbf { x } _ { i }$ being an instance center with class label $l$ . Consider $\tilde { \mathbf { Q } } \in \mathbb { R } ^ { N \times K }$ ,
+
+$$
+\begin{array} { r } { \tilde { \mathbf { Q } } [ i , k ] = \kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } ) \mathbb { 1 } _ { z _ { i } = k } = \left\{ { \begin{array} { l l } { \kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } ) } & { z _ { i } = k , } \\ { 0 } & { \mathrm { o t h e r w i s e } , } \end{array} } \right. } \end{array}
+$$
+
+where each entry $\tilde { \bf Q } [ i , k ]$ can be interpreted as the probability of $\mathbf { x } _ { i }$ being the center of instance $k$ . Upon this we calculate $\mathbf { Q } \in \mathbb { R } ^ { N \times \dot { L } }$ , where $\mathbf { Q } [ i , l ]$ gives the probability of $\mathbf { x } _ { i }$ being an instance center with class label $l$ ,
+
+$$
+\mathbf { Q } [ i , l ] = \operatorname* { m a x } _ { \{ k : y ( k ) = l \} } \tilde { \mathbf { Q } } [ i , k ] ,
+$$
+
+where $y ( k )$ is the class label of instance $k$ , due to the fact that $\{ { \bf x } _ { i } : z _ { i } = k \}$ must have the same class label. (See an illustration in Appendix Figure 7.)
+
+We design a new loss function,
+
+$$
+\mathcal { L } _ { S c o r e } = \frac { 1 } { N L } \sum _ { i = 1 } ^ { N } \sum _ { l = 1 } ^ { L } - \mathbf { Q } [ i , l ] \log \mathbf { P } [ i , l ] .
+$$
+
+Here $\mathbf { Q }$ is fixed as a target when training. See appendix for a detailed explanation of the loss function.
+
+The inference process is done with a greedy approach (Neven et al. (2019)). From foreground score maps $\{ \mathbf { P } [ : , 1 ] , \mathbf { \bar { P } } [ : , 2 ] , \ldots , \mathbf { P } [ : , L ] \}$ , we sample a point $\mathbf { x } _ { i _ { 0 } }$ with highest score $\mathbf { P } [ i _ { 0 } , l _ { 0 } ]$ , where $i _ { 0 }$ is the point index and $l _ { 0 }$ is its class label,
+
+$$
+\operatorname * { a r g m a x } _ { l _ { 0 } , l _ { 0 } \in \{ 1 , 2 , . . . , L \} } { \bf P } [ : , l _ { 0 } ] ( i _ { 0 } , l _ { 0 } ) = \operatorname * { a r g m a x } _ { i \in \{ 1 , 2 , . . . , N \} , l \in \{ 1 , 2 , . . . , L \} } { \bf P } [ i , l ] .
+$$
+
+The point $\mathbf { x } _ { i _ { 0 } }$ is an anchor and we want to find all similar points. Specifically we find all points $\mathbf { x } _ { i }$ with $\kappa ( \mathbf { e } _ { i } , \mathbf { e } _ { i _ { 0 } } ) \geq \tau$ . As a result, the instance $\mathrm { I D }$ of $\mathbf { x } _ { i }$ is 0. After that, all points satisfying the inequality are all masked out. Similarly, we sample $\mathbf { x } _ { i _ { 1 } }$ and mask out points with instance ID 1, sample $\mathbf { x } _ { i _ { 2 } }$ and mask out points with instance $\mathrm { I D 2 }$ , and so on. We stop this loop if there is no point left. We use the validation set to fit hyperparameter $\tau$ , which is 0.35 in our experiments.
+
+# 4 RESULTS
+
+We describe the implementation details in the appendix. PartNet (Mo et al. (2019)) provides coarse-, middle- and fine-grained part instance-level annotations for 3D point clouds from ShapeNet (Chang et al. (2015)). It contains 24 object categories, but the number of training samples varies greatly from 92 to 5707 for different categories. In contrast to indoor scene point cloud datasets (e.g., ScanNet by Dai et al. (2017)), instances (object parts) of PartNet require more context to be classified and are connected. Many visually alike parts have different semantic labels, e.g., ping-pong table’s legs and pool table’s legs in the category of table. Also, instance masks should have no overlaps. All these make it a very challenging dataset for instance segmentation. While our main experiments are on PartNet, we provide results on ScanNet in the appendix.
+
+# 4.1 QUANTITATIVE AND QUALITATIVE RESULTS
+
+We report per-category mean Average Precision (mAP) scores for the PartNet dataset in Table 1.   
+The IoU threshold is 0.5. We compare our probabilistic embedding algorithm to GSPN (Yi et al.   
+(2019)), PartNet (Mo et al. (2019)) and SGPN (Wang et al. (2018)). The results are averaged over three levels of granularity (fine(3), middle(2), and coarse(1)). It should be noted that GSPN (Yi et al.   
+(2019)) only reports fine-grained results of 4 categories.
+
+On the complete dataset, our method outperforms the best competitor PartNet by $3 . 1 \%$ average per-category mAP. We can observe that our method has a slightly bigger advantage in fine-grained instance segmentation compared to coarse-grained instance segmentation ( $3 . 2 \%$ vs. $2 . 5 \%$ ). We can also observe consistent improvements in categories with little as well as many training samples. While we beat SOTA in all categories with many training samples (Chair, Table, StorageFurniture, and Lamp), PartNet has better results in some of the categories with fewer training samples.
+
+We also show visualization examples in Figure 8. Compared to PartNet (Mo et al. (2019)), our method shows great improvement especially when there are many instances in a point cloud.
+
+# 4.2 ABLATION STUDY AND ANALYSIS
+
+We conduct the ablation study on all categories of PartNet (Mo et al. (2019)), but we only list detailed values for the four largest categories in Table 2.
+
+Effect of probabilistic embedding. We compare four different versions of probabilistic embedding. The Gaussian distribution used in the model can either be isotropic or anisotropic, homoscedastic or heteroscedastic. Thus we have isotropic homoscedastic, anisotropic homoscedastic, isotropic heteroscedastic, and anisotropic heteroscedastic.
+
+Table 1: Instance segmentation results on PartNet (part-category $\mathbf { m A P \% }$ , IoU threshold 0.5, fine(3), middle(2), and coarse(1)-grained).   
+
+<table><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>3     Bog Gaet Coe  o 00     Jaeee         aiue duer donder L.ITITe  p3品M3 s30A</td></tr><tr><td></td><td rowspan=1 colspan=1>SPSS</td><td rowspan=1 colspan=2>１２3[55.7|29.729.5</td><td rowspan=1 colspan=1>38.8 29.8 61.956.972.420.372.289.349.057.8 63.2 68.720.0 63.232.710.050.682.250.671.732.949.2 56.846.6115.41  125.4- 58.1-25.4                121.7-49.4-22.1-30.5 18.9111.8 45.1-19.4 18.2 38.3 78.8 15.4 35.9 37.8-    38.3 14.4-32.7- 18.2 - 21.5 14.6 24.9 36.5</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>46.8</td><td rowspan=1 colspan=1>Avg46.8|38819.053.556939.119.356.284.129.946950.568.720.050.822.910044.282.230.371.728.327.640.941.6</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td></tr><tr><td></td><td rowspan=1 colspan=1>SSSD</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-                                                        =                                    --             26.8                                    18.3                    26.7 21.9</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>|Avg|-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1  =  -  -  -  -  1  -  -  -  -  -  =   =  -   =   -  -  -  -  -  -  -  1</td></tr><tr><td></td><td rowspan=1 colspan=1>Pree</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>37.436.6</td><td rowspan=1 colspan=1>62.664.748463.659.774.442.876.393.352.957769.670.943.958437.2100050.06050080.945.254.271749.823.0      35.5，62.839.7=               -26.9·47.8  35.235.031.0115.0 48.6129.0 32.3 53.3 80.1 17.2 39.4 44.7      45.8 18.7 ·34.8：26.5127.5 23.9 33.7 52.0</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>Avg|54.4</td><td rowspan=1 colspan=1>Avg54.464.728.856.159.746.3376 64.186.736.648.657.2 70.943.952.127.6100044.286.037.280.935.936.452.750.9</td></tr><tr><td rowspan=2 colspan=2>s.Ino</td><td rowspan=1 colspan=1>s.Ino</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>40.439.8</td></tr><tr><td rowspan=1 colspan=2>Avg57.5</td><td rowspan=1 colspan=1>Avg57.564.6362 569 7.050.135.6 6.788.741.3 54.9 64.4 71.8 48.660.529.51000462 90.9 39.688.641.232.453.448.</td></tr></table>
+
+![](images/9aae9c1ad1dec43cab2d498fdaed4865cd7b8934af5bf3b533bd2c2c4268646f.jpg)  
+Figure 4: Top row: ground-truth. Middle row: PartNet. Bottom row: Probabilistic Embedding. We show true positives (IoU threshold 0.5) with the same color as ground truth. False detections are shown in transparent red.
+
+The isotropic homoscedastic probabilistic embedding, learns to predict a single scalar representing the uncertainty of a point cloud. We do not see improvements over its determinisitc counterpart, but there is a large gap between them in large categories which have much more part instances and classes than others.
+
+Similar cases happen in anisotropic homoscedastic and isotropic homoscedastic embedding. The former learns a 3D uncertainty vector for a single point cloud, while the latter learns point-dependent uncertainty scalars. They all show significant improvements over determinisitc embedding on finegrained categories.
+
+Finally, our full model uses anisotropic heteroscedastic probabilistic embedding, which outputs not only point-dependent but also axis-dependent uncertainties. See Figure 5 for an illustration of learned uncertainties. The points at boundary regions have significantly larger uncertainties compared to others. In summary, the full model achieves the best results among all variations.
+
+Table 2: Ablation study. Center, ExtDim, Prob refer to our proposed center-aware loss for the clustering step, the 6D deterministic embedding, and our proposed probabilistic embedding. Aniso and Hetero refer to the choice of Gaussian: anisotropic and heteroscedastic. AllAvg means taking all levels of granularity and categories into consideration. Large means fine-grained level of four largest categories. Others means fine-grained level of all the other categories. Here we also list the results on four largest categories of fine-grained level. The top two results are marked bold.   
+
+<table><tr><td>Ablation</td><td>Model</td><td>ceeer</td><td>aig </td><td>1STUo</td><td>aH</td><td>BAAIA</td><td>△</td><td>e</td><td>△</td><td>sPett</td><td>△</td><td>Gart</td><td>△</td><td>due</td><td>△</td><td>2</td><td>△</td><td>Jqee</td><td>△</td></tr><tr><td>Loss</td><td></td><td></td><td></td><td>&lt;</td><td></td><td>|54.3</td><td>-0.7</td><td>16.2</td><td>-7.3</td><td>43.1</td><td>3.1</td><td>19.0</td><td>-8.4</td><td>8.8</td><td>-9.6</td><td>29.7</td><td>6.2</td><td>7.1</td><td>-17.4</td></tr><tr><td rowspan="2">Deterministic</td><td rowspan="2">Reference</td><td>M</td><td></td><td></td><td></td><td>55.0</td><td>0.0</td><td>23.4</td><td>0.0</td><td>40.0</td><td>0.0</td><td>27.4</td><td>0.0</td><td>18.5</td><td>0.0</td><td>23.5</td><td>0.0</td><td>24.4</td><td>0.0</td></tr><tr><td></td><td>√</td><td></td><td></td><td>56.2</td><td>1.2</td><td>27.2</td><td>3.7</td><td>41.2</td><td>1.2</td><td>32.8</td><td>5.4</td><td>20.2</td><td>1.7</td><td>29.8</td><td>6.4</td><td>25.8</td><td>1.4</td></tr><tr><td rowspan="4">Probabilistic</td><td></td><td></td><td></td><td></td><td></td><td>54.7</td><td>-0.3</td><td>26.4</td><td>3.0</td><td>39.9</td><td>-0.1</td><td>33.7</td><td>6.3</td><td>17.8</td><td>-0.7</td><td>30.0</td><td>6.5</td><td>24.3</td><td>-0.2</td></tr><tr><td></td><td>区</td><td></td><td></td><td>√</td><td>53.1</td><td>-1.9</td><td>27.4</td><td>3.9</td><td>38.1</td><td>-1.8</td><td>33.6</td><td>6.2</td><td>20.0</td><td>1.5</td><td>30.9</td><td>7.5</td><td>25.0</td><td>0.6</td></tr><tr><td></td><td></td><td>√</td><td>√</td><td></td><td></td><td>55.60.6</td><td>27.3</td><td>3.9</td><td>41.0</td><td>1.1</td><td>33.9</td><td>6.5</td><td>19.5</td><td>1.0</td><td>31.1</td><td>7.6</td><td>24.8</td><td>0.3</td></tr><tr><td>Full</td><td>公</td><td>√</td><td>√</td><td>√</td><td>57.5</td><td>2.5</td><td>28.7</td><td>5.2</td><td>43.0</td><td>3.0</td><td>34.7</td><td>7.3</td><td>20.3</td><td>1.8</td><td>34.2</td><td>10.7</td><td>25.5</td><td>1.1</td></tr></table>
+
+![](images/061579210f0d0b85ff94609c453a44632715c2777bb1eb4bd9023d829df5d84f.jpg)  
+Figure 5: Learned Uncertainties. Top left: uncertainties are represented as ellipsoids, where directional scaling shows the value of uncertainties along 3 axes. The other 3 subfigures: uncertainties along 3 axes. We represent large values with red colors and smaller values with blue colors.
+
+![](images/445c93162d986452a5aab014b737b0b5d64453b744ea7cf75f797abed41d9b72.jpg)  
+Figure 6: Comparison of embeddings. Top row: Deterministic embedding. Bottom row: Probabilistic embedding. Left to right: we show a gradual shape transformation between the original point cloud and the embedded point cloud.
+
+Effect of spatial embedding. Since our full model outputs a 3D center vector and 3D uncertainty vector, in a way, we can regard it as a 6D embedding method (with a totally different similarity kernel). One may wonder: how does it compare with the performance of 6D deterministic embedding? The results in Table 2 show, increasing the dimension of deterministic embedding from 3 to 6 shows some improvement, but less than using probabilistic embedding. Thus the performance of our method, cannot be achieved by simply increasing the dimension of deterministic embedding, which also shows the superiority of the probabilistic embedding. We illustrate the differences between deterministic and probabilistic embedding in 3D in Figure 6. We can observe, that probabilistic embedding introduces much stronger deformations of the geometry.
+
+Effect of center-aware loss. We examine the effect of the center-aware loss in the clustering step. We use the same setup as in our full model except changing the center-aware loss to MSE loss (Neven et al. (2019)). In Table 2, we can see that our proposed loss function is especially stable on large fine-grained datasets $5 . 2 \%$ vs $- 7 . 3 \%$ ).
+
+# 5 CONCLUSION
+
+We build on embedding-based instance segmentation to present a framework of probabilistic embedding and a new loss function for the clustering step. We evaluate our framework on a large scale point cloud dataset, PartNet, and achieve state-of-the-art performance. Moreover, the qualitative results show the new framework is robust to point clouds with many instances. Additionally, it is able to estimate uncertainties while increasing the accuracy of instance segmentation. In future work, we hope that the probabilistic embedding can be further applied to other kinds of data representation, e.g., 2D images, 3D volumes, and meshes.
+
+# REFERENCES
+
+Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015. 6
+
+Christopher Choy, JunYoung Gwak, and Silvio Savarese. 4d spatio-temporal convnets: Minkowski convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3075–3084, 2019. 15
+
+Angela Dai, Angel X Chang, Manolis Savva, Maciej Halber, Thomas Funkhouser, and Matthias Nießner. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5828–5839, 2017. 6, 13
+
+Bert De Brabandere, Davy Neven, and Luc Van Gool. Semantic instance segmentation with a discriminative loss function. arXiv preprint arXiv:1708.02551, 2017. 1, 2
+
+Garoe Dorta, Sara Vicente, Lourdes Agapito, Neill D. F. Campbell, and Ivor Simpson. Structured uncertainty prediction networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. 1
+
+Francis Engelmann, Martin Bokeloh, Alireza Fathi, Bastian Leibe, and Matthias Nießner. 3dmpa: Multi-proposal aggregation for 3d semantic instance segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9031–9040, 2020. 15
+
+Alireza Fathi, Zbigniew Wojna, Vivek Rathod, Peng Wang, Hyun Oh Song, Sergio Guadarrama, and Kevin P Murphy. Semantic instance segmentation via deep metric learning. arXiv preprint arXiv:1703.10277, 2017. 1, 2
+
+Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019. 13
+
+Ross Girshick. Fast r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 1440–1448, 2015. 2
+
+Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Advances in neural information processing systems, pp. 529–536, 2005. 5
+
+Lei Han, Tian Zheng, Lan Xu, and Lu Fang. Occuseg: Occupancy-aware 3d instance segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2940–2949, 2020. 15
+
+Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ Proceedings of the IEEE international conference on computer vision, pp. 2961–2969, 2017. 1, 2
+
+Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, and Mu Li. Bag of tricks for image classification with convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 558–567, 2019. 12
+
+Tony Jebara, Risi Kondor, and Andrew Howard. Probability product kernels. Journal of Machine Learning Research, 5(Jul):819–844, 2004. 2, 3
+
+Li Jiang, Hengshuang Zhao, Shaoshuai Shi, Shu Liu, Chi-Wing Fu, and Jiaya Jia. Pointgroup: Dualset point grouping for 3d instance segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4867–4876, 2020. 15
+
+Alex Kendall and Yarin Gal. What uncertainties do we need in bayesian deep learning for computer vision? In Advances in neural information processing systems, pp. 5574–5584, 2017. 1, 2
+
+Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7482–7491, 2018. 1, 2, 3
+
+Salman Khan, Munawar Hayat, Syed Waqas Zamir, Jianbing Shen, and Ling Shao. Striking the right balance with uncertainty. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. 1
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 13
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. 2
+
+Shu Kong and Charless C Fowlkes. Recurrent pixel embedding for instance grouping. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9018–9028, 2018. 1
+
+Jean Lahoud, Bernard Ghanem, Marc Pollefeys, and Martin R Oswald. 3d instance segmentation via multi-task metric learning. arXiv preprint arXiv:1906.08650, 2019. 1, 15
+
+Xiaodan Liang, Liang Lin, Yunchao Wei, Xiaohui Shen, Jianchao Yang, and Shuicheng Yan. Proposal-free network for instance-level object segmentation. IEEE transactions on pattern analysis and machine intelligence, 40(12):2978–2991, 2017. 2, 3
+
+Chao Liu, Jinwei Gu, Kihwan Kim, Srinivasa G. Narasimhan, and Jan Kautz. Neural rgb(r)d sensing: Depth and uncertainty from a video camera. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. 1
+
+Shu Liu, Lu Qi, Haifang Qin, Jianping Shi, and Jiaya Jia. Path aggregation network for instance segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8759–8768, 2018. 1, 2
+
+Kaichun Mo, Shilin Zhu, Angel X Chang, Li Yi, Subarna Tripathi, Leonidas J Guibas, and Hao Su. Partnet: A large-scale benchmark for fine-grained and hierarchical part-level 3d object understanding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 909–918, 2019. 1, 2, 6, 12
+
+Davy Neven, Bert De Brabandere, Marc Proesmans, and Luc Van Gool. Instance segmentation by jointly optimizing spatial embeddings and clustering bandwidth. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8837–8845, 2019. 1, 2, 3, 5, 6, 8, 15
+
+David Novotny, Samuel Albanie, Diane Larlus, and Andrea Vedaldi. Semi-convolutional operators for instance segmentation. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 86–102, 2018. 1, 2, 3
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, highperformance deep learning library. In Advances in Neural Information Processing Systems, pp. 8024–8035, 2019. 13
+
+Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In Advances in neural information processing systems, pp. 5099–5108, 2017. 2, 12
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems, pp. 91–99, 2015. 2
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014. 2
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016. 12
+
+Dequan Wang, Evan Shelhamer, Bruno Olshausen, and Trevor Darrell. Dynamic scale inference by entropy minimization. arXiv preprint arXiv:1908.03182, 2019a. 5
+
+Weiyue Wang, Ronald Yu, Qiangui Huang, and Ulrich Neumann. Sgpn: Similarity group proposal network for 3d point cloud instance segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2569–2578, 2018. 1, 2, 6
+
+Xinlong Wang, Shu Liu, Xiaoyong Shen, Chunhua Shen, and Jiaya Jia. Associatively segmenting instances and semantics in point clouds. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4096–4105, 2019b. 1, 2
+
+Ken CL Wong, Mehdi Moradi, Hui Tang, and Tanveer Syeda-Mahmood. 3d segmentation with exponential logarithmic loss for highly unbalanced object sizes. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pp. 612–619. Springer, 2018. 5
+
+Li Yi, Wang Zhao, He Wang, Minhyuk Sung, and Leonidas J Guibas. Gspn: Generative shape proposal network for 3d instance segmentation in point cloud. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3947–3956, 2019. 2, 6
+
+# A APPENDIX
+
+# A.1 CENTER-AWARE LOSS EXPLANATION
+
+We want $\mathbf { P } \in \mathbb { R } ^ { N \times L }$ , the matrix form of $\{ { \bf p } _ { i } \} _ { i = 1 } ^ { N }$ , to satisfy two conditions:
+
+1. $\mathbf { P } [ i , : ]$ is a probability vector and can be used to infer class label $y _ { i }$ of point $\mathbf { x } _ { i }$ , i.e., $y _ { i } =$ arg $\mathrm { m a x } _ { l = 1 } ^ { L } \mathbf { P } [ i , l ]$ .   
+2. For foreground class labels $l \in \{ 1 , 2 , \ldots , L \} , \mathbf { P } [ : , l ]$ is a score map of being an instance center with class label $l$ .
+
+The first condition is easy to satisfy with the cross entropy loss. Assuming $\mathbf { P } [ i , : ]$ is the output of a softmax function, we can minimize,
+
+$$
+\mathcal { L } _ { C l s C E } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left( \frac { 1 } { L } \sum _ { l = 1 } ^ { L } - \mathbb { 1 } _ { y _ { i } = l } \log \mathbf { P } [ i , l ] \right) ,
+$$
+
+where $\mathbb { 1 } _ { y _ { i } = l }$ is an indicator function which equals 1 when $y _ { i } = l , 0$ otherwise.
+
+For the second condition, we take into account $\kappa ( \mathbf { e } _ { i } , \mathbf { c } _ { k } )$ , which is the similarity between $\mathbf { x } _ { i }$ and an instance $k$ .
+
+We want both $\mathbf { P } [ : , l ]$ and $\mathbf { Q } [ : , l ]$ to achieve local maxima at the same points for all $l \in \{ 1 , 2 , \ldots , L \}$ . When we are doing inference, these local maxima are chosen as instance centers. Therefore, the first condition can be weakened, and only points which are close to instance centers should be classified correctly.
+
+We can view $\mathcal { L } _ { S c o r e }$ in two ways,
+
+1. First, we switch the order of summation in Eq. 10,
+
+$$
+\mathcal { L } _ { S c o r e } = \frac { 1 } { L } \sum _ { l = 1 } ^ { L } \left( \frac { 1 } { N } \sum _ { i = 1 } ^ { N } - \mathbf { Q } [ i , l ] \log \mathbf { P } [ i , l ] \right) .
+$$
+
+The value of this quantity $- \mathbf { Q } [ i , l ] \log \mathbf { P } [ i , l ]$ is high when weight term $\mathbf { Q } [ i , l ]$ is high, and if we minimize it, we are forcing $- \log \mathbf { P } [ i , l ]$ to be small. Consequently, $\mathbf { P } [ i , l ]$ would be large. This guarantees local maxima of $\mathbf { Q } [ : , l ]$ are also local maxima of $\mathbf { P } [ : , l ]$ . And minimizing this loss term is equivalent to minimize the KL-divergence between (unnor$\mathbf { Q } [ : , l ]$ and (unnormalized probability) $\begin{array} { r l } { \mathbf { P } [ : , l ] , \mathbb { K L } ( \mathbf { Q } [ : , l ] | \mathbf { P } [ : , l ] ) } & { { } = } \end{array}$ $\begin{array} { r } { \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathbf { Q } [ i , l ] \log \frac { \mathbf { Q } [ i , l ] } { \mathbf { P } [ i , l ] } } \end{array}$
+
+Table 3: Activations for different output branches   
+
+<table><tr><td></td><td>Output</td><td>Activation</td></tr><tr><td>Centers</td><td>Oi∈R</td><td>μ = Xi +tanhOi</td></tr><tr><td>Uncert</td><td>ER</td><td>Oi = expoi</td></tr><tr><td>Scores</td><td>PiER</td><td>Pi = softmax(Pi)</td></tr></table>
+
+2. Second, we look at the inner summation of Eq. 10,
+
+$$
+\mathcal { L } _ { S c o r e } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left( \frac { 1 } { L } \sum _ { l = 1 } ^ { L } - \mathbf { Q } [ i , l ] \log \mathbf { P } [ i , l ] \right) .
+$$
+
+The inner summation inside the round bracket is the cross entropy between $\mathbf { Q } [ i , : ]$ and $\mathbf { P } [ i , : ]$ . And it is equivalent to replacing the one-hot vector in Equation 12 with $\mathbf { Q } [ i , : ]$ . Also, it is the form of label smoothing, a commonly used training trick in image classification (Szegedy et al. (2016); He et al. (2019)). The closer $\mathbf { Q } [ i , : ]$ is to a one-hot vector, the more confidence we give to the classification loss of point $\mathbf { x } _ { i }$ . By definition of $\mathbf { Q } [ i , l ]$ , it can be easily seen that the resulting classifier only classifies near-centers points correctly. Thus we call our new loss function the center-aware loss.
+
+# A.2 IMPLEMENTATION
+
+For a fair comparison to our main competitor PartNet (Mo et al. (2019)) we keep as much of their structure as possible (Note that PartNet is the name of a dataset as well as an instance segmentation method). We also use PointNet $^ { + + }$ (Qi et al. (2017)) as the feature extraction backbone, with the same parameters as by Mo et al. (2019). We use 3 output heads for centers, uncertainties, and scores as in $\mathsf { \bar { f } } ( \{ \mathbf { x } _ { i } \} _ { i = 1 } ^ { N } ) = \mathsf { \bar { \{ } }  \mu _ { i } , \pmb { \sigma } _ { i } , \mathbf { p } _ { i } \} _ { i = 1 } ^ { N }$ . The output dimensions are 3, 3 and the number of semantic classes, uncertainties and scores, respectively. We list the activation functions for output heads in Table 3.
+
+Following the notation of PointNet+ $^ +$ Qi et al. (2017), we give the architecture of the feature network:
+
+$$
+\begin{array} { r l } & { S A ( 5 1 2 , 0 . 2 , [ 6 4 , 6 4 , 1 2 8 ] ) , } \\ & { S A ( 1 2 8 , 0 . 4 , [ 1 2 8 , 1 2 8 , 2 5 6 ] ) , } \\ & { S A ( [ 2 5 6 , 5 1 2 , 1 0 2 4 ] ) , } \\ & { F P ( 2 5 6 , 2 5 6 ) , } \\ & { F P ( 2 5 6 , 1 2 8 ) , } \\ & { F P ( 1 2 8 , 1 2 8 ) . } \end{array}
+$$
+
+The output head network is:
+
+F ullyConnected(128, 256),   
+BatchNorm(256),   
+ReLU (),   
+F ullyConnected(256, 128),   
+BatchNorm(128),   
+ReLU (),   
+F ullyConnected(128, 128),   
+BatchNorm(128),   
+ReLU (),   
+F ullyConnected(128, C),
+
+![](images/5baeeb435abae2f1dd6a5beaea5aa831f9f1138ce902c7095c7ed3866bba6c81.jpg)  
+Figure 7: Top row: similarity maps for each part instance $\tilde { \mathbf { Q } } [ : , k ]$ . Bottom row: probability map $\mathbf { Q } [ : , l ]$ . The arrows show that information of instances of the same class is aggregated in Eq. 9. Red means high similarity, while blue means low.
+
+Table 4: Instance segmentation results on PartNet. The metric is mAP $( \% )$ with IoU threshold 0.25.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>Bnoget  o 0     aenee          doider i  383品M3s </td></tr><tr><td rowspan=1 colspan=1>d</td><td rowspan=1 colspan=1>１２3</td><td rowspan=1 colspan=1>70.2|46.745.6</td><td rowspan=1 colspan=1>89.482.3 65.263.178.148.079.197.164.9 64.677.373.958.959.242.510.0 50.092.950.096.357.759.382.752.6144.5       43.0171.3-49.3     =             32.2 1 51.2  45.2146.7 36.5-29.0 52.6-35.3 39.6 59.9 89.3 27.1 56.9 55.0     -49.0 22.6 1 56.9135.6，36.3 28.6 44.8 57.0</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg|</td><td rowspan=1 colspan=1>62.8|</td><td rowspan=1 colspan=1>389.4 51.9 58.9 63.152.143.8 70.193.247.160.8 66.2 73.958.954.132.4100052.792.943.696.346.941.5 63.8 54.8</td></tr><tr><td rowspan=1 colspan=1>s.no</td><td rowspan=1 colspan=1>1123</td><td rowspan=1 colspan=1>72.751.451.6</td><td rowspan=1 colspan=1>82.8 79.6 65.672.082.8 49.183.8 98.375.574.3 83.279.5 59.97.8 45.2 1.050.595.4 51.696.9 60.944.682.9 51.1，55.41  147.1-78.0-48.1                   39.3154.448.853.737.7-44.4 57.2，43.2 45.7 64.8 90.7 34.6 59.3 67.2       53.0 26.0 1 60.0-51.5- 44.4 31.7 50.0 53.9</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg|</td><td rowspan=1 colspan=1>66.5</td><td rowspan=1 colspan=1>66.582.8 59.8 61.472.057.747.475.694.552.7 66.8 75.279.559.9 65.936.8100055.095.4 506 96.953.038.0 66.5 52.5</td></tr></table>
+
+where $C$ is 3, 3 and the number of classes for centers, uncertainties and scores, respectively.
+
+We implemented our method using PyTorch Paszke et al. (2019) and the geometric deep learning library PyTorch Geometric Fey & Lenssen (2019). The final objective function is
+
+$$
+\mathcal { L } = \mathcal { L } _ { I n s } + \mathcal { L } _ { S c o r e } + 0 . 0 0 1 \cdot \mathcal { L } _ { R e g }
+$$
+
+We use random jittering, translation (between $- 0 . 0 1$ and 0.01) and rotation (between $- 1 5 ^ { \circ }$ and $1 5 ^ { \circ }$ for each axis) as data augmentation, and use the Adam Kingma & Ba (2014) optimizer. We use a batch-size of 16 and an initial learning rate of 0.001 for 500 epochs with a decay factor of 0.5 at epoch 50 and epoch 150.
+
+# A.3 ADDITIONAL RESULTS ON PARTNET
+
+Results of different IoU thresholds We report detailed results of IoU threshold at $2 5 \%$ and $7 5 \%$ in Table 4 and Table 5. The metric is mean Average Precision (mAP).
+
+Qualitive results We present more qualitive results in Figure 8 which shows the instanceawareness of our method. We also demonstrate the 3D models in the attached video.
+
+# A.4 ADDITIONAL RESULTS ON SCANNET
+
+ScanNet (Dai et al. (2017)) is a dataset containing 3D reconstructions of indoor scenes. Different from objects in PartNet, instances are more separated, e.g., chairs and tables usually are not connected, while in PartNet, parts are closely connected together and have more intertwined correspondence. Also PartNet provides detailed and high-granularity semantic and instance information, i.e. the number of instances and classes are often larger than ones of ScanNet. This makes PartNet a more suitable dataset for instance segmentation. However, we still validate our method on ScanNet to show the potential of probabilistic embedding. As baseline method we chose a network based on performance and availability of code. Since the best methods, such as OccuSeg, do not release code for ScanNet, we decided to build our own baseline using MinkowskiNet (Choy et al. (2019)) as feature backbone. MinkowskiNet is a sparse tensor network that achieved great results on indoor semantic scene segmentation. In order to adapt the network to instance segmentation, we re-implement the learnable margin method proposed by Neven et al. (2019). The learnable margin method does well on common image instance segmentation datasets and is well-balanced both in speed and accuracy. This combination of two recent papers gives a strong baseline, but not stateof-the-art results in the metrics. We compare to this baseline, also using MinkowskiNet as feature backbone to make the results directly comparable.
+
+Table 5: Instance segmentation results on PartNet. The metric is mAP $( \% )$ with IoU threshold 0.75.   
+
+<table><tr><td></td><td></td><td>Avg</td><td>3</td><td>o o0</td><td>eenee duer doider L.ITe 0 阿 S 品 M</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td>22.0 1</td><td>4.2</td><td>47.439.714.6 60.641.458.328.858.384.735.649.148.2 66.310.748.729.698.047.876.150.035.129.943.242.240.5</td></tr><tr><td>ee</td><td>123</td><td>23.5</td><td>-</td><td>21.4 1 = 3.937.9 、</td><td>37.2 1 22.4 19.6 1 32.1 1 16.7 1 22.8 22.0 - 16.6 17.6 29.8 63.2 8.1 27.6 25.8 31.0 13.6 23.9 12.1 18.2 16.4 19.7 34.5</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>- - - 1 -</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>Avg|38.939.77.649.241.432.123.241.773.922038437.066.310.739.820.998.3467.126.335.123.627.23037.5</td></tr><tr><td></td><td>1</td><td>23.8</td><td></td><td>7.1 1 22.8</td><td>50.040.313.3 60.2 60.259.328.261.990.639.159.6542 69.37.465.728.598.047.977.150.542.830.134.840.741.1 -22.0- 35.5- 20.6- 26.121.4 1 -</td></tr><tr><td>，</td><td></td><td>23 |25.7</td><td>- 7.3 38.8</td><td>37.4- 21.3 20.5 17.2 30.0 66.8 10.8 28.2 33.2</td><td>31.5 14.1 21.0 17.4 19.4 38.0</td></tr><tr><td>s.no</td><td></td><td></td><td></td><td>-</td><td>， 25.6 ， 17.1 -</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>Avg|41.740.39.249.5 60.234.2.743.178.723.743.9 43.769.37.448.621.5 98.36477.129.4 42.8 25.724.50039.6</td></tr></table>
+
+![](images/ddf38a2b7c8ca8218109b83409407d1b63c79a627cad3c1e1be3de09a03af765.jpg)  
+Figure 8: Top row: ground-truth (background points are shown in transparent red). Second and third row: PartNet and Ours (only true positives are shown, and false detections are shown in transparent red). Fourth and fifth row: PartNet and Ours (all detected instances, unclassified points are shown in transparent red). PartNet can group instance points together but fails to give the correct class labels in some cases (e.g., in the first and the third subfigures from left to right, points of table legs are grouped together (fourth row) but they are not true positives (second row). Besides, in the sixth subfigure from left to right, PartNet fails to distinguish different instances of lamp covers (second and fourth row). While our method performs especially better in these cases.
+
+Table 6: Results on ScanNet. We list the results on both validation and hidden test sets of ScanNet. Note that due to the unique submission policy of ScanNet, we are unable to provide the results of learnable margin on the test set. On validation set, we improve mAP by $4 . 9 \%$ .   
+
+<table><tr><td></td><td colspan="3">validation</td><td colspan="3">test</td></tr><tr><td></td><td>mAP</td><td>AP50</td><td>AP25</td><td>mAP</td><td>AP50</td><td>AP25</td></tr><tr><td>MTML (Lahoud et al. (2019))</td><td>20.3</td><td>40.2</td><td>55.4</td><td>28.2</td><td>54.9</td><td>73.1</td></tr><tr><td>3D-MPA (Engelmann et al. (2020))</td><td>35.3</td><td>59.1</td><td>72.4</td><td>35.5</td><td>61.1</td><td>73.7</td></tr><tr><td>PointGroup (Jiang et al. (2020))</td><td>34.8</td><td>56.9</td><td>71.3</td><td>40.7</td><td>63.6</td><td>77.8</td></tr><tr><td>OccuSeg (Han et al. (2020))</td><td>44.2</td><td>60.7</td><td>71.9</td><td>44.3</td><td>63.4</td><td>73.9</td></tr><tr><td>Learnable margin + MinkowskiNet</td><td>28.1</td><td>50.1</td><td>70.1</td><td>-</td><td>1</td><td>-</td></tr><tr><td>Proposed + MinkowskiNet</td><td>33.0</td><td>57.1</td><td>73.8</td><td>32.8</td><td>56.0</td><td>75.2</td></tr></table>
+
+We report the average precision (AP) in Table 6 and compare our method with other leading results on ScanNet. Although we do not have the overall state-of-the-art results, the improvement over the baseline Neven et al. (2019) verifies the impact of probabilistic embedding and demonstrates that our method can be integrated with any embedding-based method and any backbone network. We can improve the validation mAP by $4 . { \dot { 9 } } \%$ .
+
+# A.5 DIFFERENCES TO LEARNABLE MARGIN
+
+Neven et al. (2019) proposed to use a learnable margin for image instance segmentation, which is similar in formulation to our proposed probabilistic embedding. Although we differ in several aspects:
+
+1. The intuition behind learnable margin comes from the hinge loss: give different hinge margin to objects of different sizes. However, our intuition comes from modeling neural network’s output as random variables to estimate uncertainty.   
+2. The parameters have a different meaning in our method compared to Neven et al. (2019). In learnable margin, $\sigma$ is an instance-specific bandwidth (or margin) per cluster. In our work $\sigma$ are uncertainties per point.   
+3. The bandwidth $\sigma$ is influenced by the size of instances (large instances have large $\sigma$ ). In contrast, our uncertainty $\sigma$ encodes per-point uncertainty close to the boundary of instances (see Fig. 5).   
+4. Neven et al. (2019) add a loss term to enforce the bandwidths from the same instance to be close. By contrast, we don’t have this kind of restriction. Also, uncertaintes from the same instance can be different as along as they have similar spatial embeddings.

parse/train/e68IYJNOYau/e68IYJNOYau_content_list.json

@@ -0,0 +1,2048 @@
+[
+    {
+        "type": "text",
+        "text": "POINT CLOUD INSTANCE SEGMENTATION USING PROBABILISTIC EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose a new framework for point cloud instance segmentation. Our framework has two steps: an embedding step and a clustering step. In the embedding step, our main contribution is to propose a probabilistic embedding space for point cloud embedding. Specifically, each point is represented as a tri-variate normal distribution. In the clustering step, we propose a novel loss function, which benefits both the semantic segmentation and the clustering. Our experimental results show important improvements to the SOTA, i.e., $3 . 1 \\%$ increased average per-category mAP on the PartNet dataset. ",
+        "bbox": [
+            232,
+            267,
+            764,
+            377
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            405,
+            336,
+            420
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we tackle the problem of instance segmentation of point clouds. In instance segmentation we would like to assign two labels to each point in a point cloud. The first label is the class label (e.g., leg, back, seat, ... for a chair data set) and the second label is the instance ID (a unique number, e.g., to distinguish the different legs of a chair). While instance segmentation had many recent successes in the image domain (He et al. (2017); Liu et al. (2018); Fathi et al. (2017); Novotny et al. (2018); De Brabandere et al. (2017); Neven et al. (2019)), we believe that the problem of instance segmentation for point clouds is not sufficiently explored. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We build our work on the idea of embedding-based instance segmentation, that is very popular in the image and volume domain (Fathi et al. (2017); Novotny et al. (2018); De Brabandere et al. (2017); Neven et al. (2019); Lahoud et al. (2019)) and has also been successfully applied in the point clouds domain (Wang et al. (2018; 2019b)). In this approach typically two steps are employed. In the first step, each point (or pixel) is embedded in a feature space such that points belonging to the same instance should be close and points belonging to different instances should be further apart from each other. In the second step points are grouped using a clustering algorithm, such as mean-shift or greedy clustering. We remark that the current state of the art methods (Neven et al. (2019); Wang et al. (2018)) follow this approach. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One important design choice in embedding-based methods is the dimensionality of the feature space. Some methods propose to use a high dimensional feature space (De Brabandere et al. (2017); Kong & Fowlkes (2018)), while others use a low dimensional features space that has the same dimensionality as the input data (Novotny et al. (2018); Kendall et al. (2018); Neven et al. (2019)), e.g., 2D for images, and 3D for point clouds. Methods with a low dimensional embedding space not only have lower computational complexity, but they also lead to better interpretability, e.g., embeddings are encoded as offset vectors towards instance centers. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the main goal of our work is to extend the expressiveness of the embedding space in a way that leads to improved segmentation performance. Our proposed solution is to employ probabilistic embeddings, such that each point in the embedding space is encoded by a distribution. While assessing uncertainty is a popular tool in recent computer vision research (Kendall & Gal (2017); Khan et al. (2019); Liu et al. (2019); Dorta et al. (2018)) and we introduce this idea to the task of instance segmentation. Incorporating uncertainty leads to an important improvement in segmentation performance. For example, on the PartNet (Mo et al. (2019)) fine-grained instance segmentation dataset we can improve the SOTA by $3 . 1 \\%$ average per-category mAP. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the remainder of the paper, we will give more details on the probabilistic embedding algorithm (Sec. 3), explain the embedding step (Sec. 3.1) and the clustering step (Sec. 3.4) in more detail. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0ccf815269fb3c636a18d8d80e69d24682e56f469ddded46e527000542043c6.jpg",
+        "image_caption": [
+            "Figure 1: Our method takes a point cloud as input, encodes the points as random variables, and outputs semantic class labels and instance labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            108,
+            473,
+            213
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7a5344ff8128579bc2584f1a98c8eccfa2aaac82850a899ca405cb6b743c5a2.jpg",
+        "image_caption": [
+            "Figure 2: Examples of (dis)similarity measures "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            526,
+            122,
+            818,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contribution. Our main contributions are as follows ",
+        "bbox": [
+            174,
+            299,
+            532,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose to use probabilistic embeddings for instance segmentation and present a complete framework in the context of point cloud instance segmentation based on probabilistic embeddings.   \n2. We develop a new loss function for the clustering step that is especially suited for highgranularity data sets.   \n3. We show that the proposed probabilistic embeddings can be incorporated into existing embedding-based methods. ",
+        "bbox": [
+            212,
+            325,
+            825,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            462,
+            341,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 2D IMAGE INSTANCE SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            472,
+            510
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The dominant approaches for image instance segmentation are proposal-based methods (He et al. (2017); Liu et al. (2018)), which are built upon object detection methods (Girshick (2015); Ren et al. (2015)). Typically, they have higher quality, but a slower computation time compared to proposal free methods. The mainstream proposal free approaches are based on metric learning. The basic idea is to learn an embedding space, in which pixels belonging to the same object instance are close to each other and distant to pixels belonging to other object instances (Fathi et al. (2017); De Brabandere et al. (2017)). All above works are based on high-dimensional embedding, while more recent works (Liang et al. (2017); Kendall et al. (2018); Novotny et al. (2018); Neven et al. (2019)) show that 2D spatial embedding is sufficient to achieve the same or even higher performance. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 3D POINT CLOUD INSTANCE SEGMENTATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            524,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SGPN (Wang et al. (2018)) uses PointNet+ $^ +$ (Qi et al. (2017)) as backbone network and designs a double-hinge loss function to learn a pairwise similarity matrix of points. GSPN (Yi et al. (2019)) produces object proposals with high objectness for point cloud instance segmentation. ASIS (Wang et al. (2019b)) is a module capable of making semantic segmentation and instance segmentation take advantage of each other. Mo et al. (2019) release a large scale point cloud dataset for part instance segmentation and benchmark their method and SGPN on this dataset. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.3 UNCERTAINTY IN COMPUTER VISION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            799,
+            470,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Kendall & Gal (2017) present a unified framework combining model uncertainty with data uncertainty and can estimate uncertainty in classification and regression tasks. We introduce uncertainty estimation to the literature of instance embedding, by modeling points as random variables. Our method is related to recent works in deep generative networks (Kingma & Welling (2013); Rezende et al. (2014)). They use a stochastic encoder to encode a data sample as a set of random variables, while focusing on solving the problem of backpropagation through random variables in deep neural networks. We deal with this problem by using a probabilistic product kernel (Jebara et al. (2004)). ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            282,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A training sample is a labeled 3D point cloud. It consists of point coordinates $\\left\\{ { \\bf x } _ { i } \\right\\} _ { i = 1 } ^ { N }$ , class labels $\\{ y _ { i } \\} _ { i = 1 } ^ { N }$ and instance IDs $\\left\\{ z _ { i } \\right\\} _ { i = 1 } ^ { N }$ . We want to train a neural network to infer per point class labels and per point instance IDs at the same time. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            186
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBABILISTIC SPATIAL EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            214,
+            473,
+            228
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A common approach in the literature of instance segmentation is to learn a function to embed pixels/points into a space where pair-wise similarity can be measured. Usually, this function is a deep neural network $f$ which transforms an unordered point set $\\{ { \\mathbf { x } } _ { i } \\} _ { i = 1 } ^ { N }$ to embeddings $\\left\\{ { \\bf e } _ { i } \\right\\} _ { i = 1 } ^ { N }$ . Instead of deterministic embeddings used in previous work, here we consider a probabilistic embedding, by modeling $\\mathbf { e } _ { i }$ as a random variable, $\\mathbf { e } _ { i } \\sim p _ { i } ( \\mathbf { e } )$ , where $p _ { i }$ is a probability density function. In Section 3.3 we will need to calculate the sum of random variables. In the ideal case, the distribution of a single random variable and the sum of multiple random variables has the same type of distribution that can be described with a few parameters. Thus we propose to model the embedding with a (symmetric) stable distribution. This leaves us two options, Gaussian and Cauchy. For the Cauchy distribution, it is challenging to get a closed-form expression in our calculation in Section 3.2. Therefore, we choose to work with the tri-variate Gaussian distribution1 $p _ { i } ( \\mathbf { e } ) = \\mathcal { N } ( \\mathbf { e } ; \\mu _ { i } , \\pmb { \\Sigma } _ { i } )$ with mean vector $\\pmb { \\mu _ { i } } \\in \\mathbb { R } ^ { 3 }$ and covariance matrix $\\pmb { \\Sigma } _ { i } \\in \\mathbb { R } ^ { 3 \\times 3 }$ . For simplicity, let $\\Sigma _ { i }$ be a diagonal matrix, $\\Sigma _ { i } = \\mathrm { d i a g } ( \\sigma _ { i } ^ { ( 1 ) 2 } , \\sigma _ { i } ^ { ( 2 ) 2 } , \\sigma _ { i } ^ { ( 3 ) 2 } )$ , where $\\sigma _ { i } ^ { ( d ) 2 }$ is the square of $\\sigma _ { i } ^ { ( \\bar { d } ) }$ and $d = 1 , 2 , 3$ . ",
+        "bbox": [
+            173,
+            244,
+            826,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The network $f ( \\cdot )$ takes as input a (unordered) point set $\\left\\{ { \\bf x } _ { i } \\right\\} _ { i = 1 } ^ { N }$ , and outputs $\\{ \\mu _ { i } , \\pmb { \\sigma } _ { i } , \\mathbf { p } _ { i } \\} _ { i = 1 } ^ { N }$ $f ( \\{ \\mathbf { x } _ { i } \\} _ { i = 1 } ^ { N } ) = \\{ \\mu _ { i } , \\pmb { \\sigma } _ { i } , \\mathbf { p } _ { i } \\} _ { i = 1 } ^ { N }$ , where $\\pmb { \\sigma } _ { i } = \\left[ \\sigma _ { i } ^ { ( 1 ) } , \\sigma _ { i } ^ { ( 2 ) } , \\sigma _ { i } ^ { ( 3 ) } \\right] ^ { \\mathsf { T } } \\in \\mathbb { R } ^ { 3 }$ and $\\mathbf { p } _ { i }$ is a probability vector which can be used to infer class label of $\\mathbf { x } _ { i }$ and will be explained in Sec. 3.4. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 SIMILARITY MEASURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            522,
+            372,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In deterministic embeddings, the (dis)similarity between points is usually measured by Euclidean distance $\\| \\mathbf { e } _ { i } - \\mathbf { e } _ { j } \\|$ , or cosine similarity $\\frac { \\mathbf { e } _ { i } ^ { \\mathsf { T } } \\mathbf { e } _ { j } ^ { \\mathsf { - } } } { \\| \\mathbf { e } _ { i } \\| \\| \\mathbf { e } _ { j } \\| }$ (See Figure 2). Since now we are using probabilistic embeddings, a similarity kernel for random variables needs to be selected. Here we describe the Bhattacharyya kernel (Jebara et al. (2004)). ",
+        "bbox": [
+            173,
+            553,
+            825,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition. Let $\\mathcal { P }$ be the set of distributions over $\\Omega$ . The Bhattacharyya kernel on $\\mathcal { P }$ is the function $\\mathcal { K } : \\mathcal { P } \\times \\mathcal { P } \\mapsto \\mathbb { R }$ such that, for all $p , q \\in \\mathcal { P }$ , ",
+        "bbox": [
+            173,
+            625,
+            823,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b8c5212e4bd9bac4ee06dbce3d5361598ed697799d47cfa131c9d6a08fb8e07.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { K } ( p , q ) = \\displaystyle \\int _ { \\Omega } \\sqrt { p ( \\mathbf { x } ) } \\sqrt { q ( \\mathbf { x } ) } \\mathrm { d } \\mathbf { x } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            670,
+            606,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We choose this kernel as our similarity measure for two reasons, 1) the Bhattacharyya kernel is symmetric, i.e. $\\begin{array} { r } { K ( p , q ) = K ( q , p ) ; 2 } \\end{array}$ ) the Bhattacharyya kernel has values between 0 (no similarity) and 1 (maximal similarity). And $\\ K ( p , q ) = 1$ if and only if $p = q$ . ",
+        "bbox": [
+            174,
+            727,
+            826,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Then the similarity $\\kappa ( \\cdot , \\cdot )$ between random variables can be represented by the Bhattacharyya kernel of their probability density functions, ",
+        "bbox": [
+            169,
+            776,
+            823,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0bb7e975d535d6fc49b704bb715c82e60383d0eb94bba550b633dea29a1a7940.jpg",
+        "text": "$$\n\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } ) = \\int \\sqrt { \\mathcal { N } ( \\mathbf { e } ; \\mu _ { i } , \\Sigma _ { i } ) } \\sqrt { \\mathcal { N } ( \\mathbf { e } ; \\mu _ { j } , \\Sigma _ { j } ) } \\mathrm { d } \\mathbf { e } = \\beta _ { i , j } \\exp \\left( - \\left\\| \\mu _ { i } - \\mu _ { j } \\right\\| _ { \\Sigma _ { i , j } ^ { - 1 } } ^ { 2 } \\right) 2 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            821,
+            776,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5dcbf3f20cc5b32cfdf95c04be5d2ea894b875d6be1c2d16258f4e8b65a6f1a.jpg",
+        "image_caption": [
+            "Figure 3: Contour plot. Left: 1-D uncertainty similarity $\\beta _ { i , j } = \\left( \\left( \\sigma _ { i } / \\sigma _ { j } + \\sigma _ { j } / \\sigma _ { i } \\right) / 2 \\right) ^ { - 1 / 2 }$ . The highest value 1 is achieved when $\\sigma _ { i } = \\sigma _ { j }$ . The value goes to 0 when one of the uncertainties is small and the other is large. Right (4 figures): the similarity for different values of $\\Delta \\mu$ (from left to right, $\\Delta \\mu = 1 , 5 , 1 0 , 2 5 )$ in the case of 1-D probabilistic embedding. The similarity becomes $\\beta _ { i , j } \\exp { \\left( - \\frac { 1 } { 2 } \\frac { \\Delta \\mu } { \\alpha _ { i , j } } \\right) }$ , where $\\Delta \\mu = \\left( \\mu _ { i } - \\mu _ { j } \\right) ^ { 2 }$ , $\\alpha _ { i , j } = 4 \\left( \\sigma _ { i } ^ { 2 } + \\sigma _ { j } ^ { 2 } \\right)$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            102,
+            805,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            174,
+            314,
+            217,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f65e47771533713a0e98cf8903fae041eccade91e50f3d712a3ecfffc5c60d36.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle \\alpha _ { i , j } ^ { ( d ) } = 4 ( \\sigma _ { i } ^ { ( d ) 2 } + \\sigma _ { j } ^ { ( d ) 2 } ) , \\quad \\displaystyle \\beta _ { i , j } = \\left( \\prod _ { d = 1 } ^ { 3 } \\frac { 1 } { 2 } \\left( \\frac { \\sigma _ { i } ^ { ( d ) } } { \\sigma _ { j } ^ { ( d ) } } + \\frac { \\sigma _ { j } ^ { ( d ) } } { \\sigma _ { i } ^ { ( d ) } } \\right) \\right) ^ { - \\frac { 1 } { 2 } } , } \\\\ { \\displaystyle \\Sigma _ { i , j } = \\mathrm { d i a g } ( \\alpha _ { i , j } ^ { ( 1 ) } , \\alpha _ { i , j } ^ { ( 2 ) } , \\alpha _ { i , j } ^ { ( 3 ) } ) , } \\\\ { \\displaystyle \\| \\mu _ { i } - \\mu _ { j } \\| _ { \\Sigma _ { i , j } ^ { - 1 } } ^ { 2 } = ( \\mu _ { i } - \\mu _ { j } ) ^ { \\mathsf T } \\Sigma _ { i , j } ^ { - 1 } ( \\mu _ { i } - \\mu _ { j } ) = \\sum _ { d = 1 } ^ { 3 } \\frac { \\mu _ { i } ^ { ( d ) } - \\mu _ { j } ^ { ( d ) } } { \\alpha _ { i , j } ^ { ( d ) } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            328,
+            751,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• If the uncertainties $\\sigma _ { i }$ and $\\pmb { \\sigma } _ { j }$ have a large difference, $\\beta _ { i , j }$ will be small, so will be $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } )$ . See Fig. 3. ",
+        "bbox": [
+            210,
+            454,
+            823,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• If the centers $\\pmb { \\mu _ { i } }$ and $\\mu _ { j }$ have a large difference, the exponential term will be small, so will be $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } )$ . See Fig. 3. ",
+        "bbox": [
+            215,
+            487,
+            825,
+            516
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• The scale term $\\beta _ { i , j } = 1$ if and only if the uncertainties $\\sigma _ { i }$ and $\\pmb { \\sigma } _ { j }$ are element-wise equal. In this case, $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } )$ becomes an anisotropic Gaussian kernel, ",
+        "bbox": [
+            212,
+            518,
+            820,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/977d7bafb66f46494c7cf6056528c738cf765e6ba4a156920c5d3a7cde441ce3.jpg",
+        "text": "$$\n\\kappa _ { R B F } ( \\pmb { \\mu } _ { i } , \\pmb { \\mu } _ { j } ) = \\exp \\left( - \\left\\| \\pmb { \\mu } _ { i } - \\pmb { \\mu } _ { j } \\right\\| _ { \\pmb { \\Sigma } _ { i , j } ^ { - 1 } } ^ { 2 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            550,
+            673,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• The exponential term equals 1 if and only if the centers $\\pmb { \\mu _ { i } }$ and $\\pmb { \\mu } _ { j }$ are element-wise equal. In this case, $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } )$ becomes $\\beta _ { i , j }$ , i.e., the similarity between uncertainties. This property allows two points that have the same embedding centers to have a low similarity, as long as $\\beta _ { i , j }$ is small. ",
+        "bbox": [
+            215,
+            580,
+            825,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compared to deterministic embedding, $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } ) = \\exp \\left( - \\left\\| \\mathbf { e } _ { i } - \\mathbf { e } _ { j } \\right\\| ^ { 2 } \\right) ^ { 3 }$ , our similarity measure consists not merely of the similarity of spatial distances, but also the similarity of uncertainties. ",
+        "bbox": [
+            178,
+            648,
+            826,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following, we discuss multiple choices of embedding distributions that we will evaluate in Sec 4.2. ",
+        "bbox": [
+            176,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Homoscedasticity vs. Heteroscedasticity. The embeddings $\\{ { \\mathbf { e } } _ { i } \\} _ { i = 1 } ^ { N }$ are homoscedastic if they have the same variance instead of point-depende $\\pmb { \\Sigma }$ . In this  variances a point cloud . And the sim $\\mathbf { X }$ we learn to predicrity kernel becomes $\\pmb { \\Sigma }$ $\\left\\{ \\pmb { \\Sigma } _ { i } \\right\\} _ { i = 1 } ^ { N }$ $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } ) \\ =$ $\\exp \\left( - \\left. \\pmb { \\mu } _ { i } - \\pmb { \\mu } _ { j } \\right. _ { \\pmb { \\Sigma } _ { i , j } ^ { - 1 } } ^ { 2 } \\right)$ , which is also the form of the RBF kernel in Eq. 2. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Isotropy vs. Anisotropy. The variance $\\Sigma _ { i }$ is isotropic if its diagonal elements (variances of dimensions) are the same. Then we can write $\\Sigma _ { i } = \\sigma _ { i } ^ { 2 } \\mathbf { I }$ , where $\\mathbf { I }$ is a $3 \\times 3$ identity matrix. The similarity can be written as $\\begin{array} { r } { \\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } ) = \\beta _ { i , j } \\exp \\left( - \\frac { \\vert \\vert \\mu _ { i } - \\mu _ { j } \\vert \\vert ^ { 2 } } { \\alpha _ { i , j } } \\right) } \\end{array}$ , where $\\beta _ { i , j } = \\left( \\left( \\sigma _ { i } / \\sigma _ { j } + \\sigma _ { j } / \\sigma _ { i } \\right) / 2 \\right) ^ { - \\frac { 3 } { 2 } }$ and $\\alpha _ { i , j } = 4 ( \\sigma _ { i } ^ { 2 } + \\sigma _ { j } ^ { 2 } )$ . ",
+        "bbox": [
+            173,
+            819,
+            825,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 INSTANCE GROUPING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            362,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $\\{ i : z _ { i } = k \\}$ be the index set of points having instance $\\textrm { I D } k$ . We take an average of these embeddings to get the embedding $\\mathbf { c } _ { k }$ of instance $k$ , $\\begin{array} { r } { \\mathbf { c } _ { k } = \\frac { 1 } { | \\{ i : z _ { i } = k \\} | } \\sum _ { \\{ i : z _ { i } = k \\} } \\mathbf { e } _ { i } } \\end{array}$ . Since the sum of Gaussian random variables is still a Gaussian random variable, we can derive the following: ",
+        "bbox": [
+            173,
+            128,
+            826,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b019f9bc694d64540ab3f47791c389afebfbbb296e8b7e97eb9fb04752657f2.jpg",
+        "text": "$$\np ( \\mathbf { c } _ { k } ) = { \\mathcal { N } } ( \\mathbf { c } _ { k } ; { \\hat { \\mu } } _ { k } , { \\hat { \\Sigma } } _ { k } ) , \\quad { \\hat { \\mu } } _ { k } = { \\frac { 1 } { | \\left\\{ i : z _ { i } = k \\right\\} | } } \\sum _ { \\left\\{ i : z _ { i } = k \\right\\} } \\mu _ { i } , \\quad { \\hat { \\Sigma } } _ { k } = { \\frac { 1 } { | \\left\\{ i : z _ { i } = k \\right\\} | } } \\sum _ { \\left\\{ i : z _ { i } = k \\right\\} } \\Sigma _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            169,
+            176,
+            805,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now we can measure the similarity between a point and an instance by using $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } )$ . ",
+        "bbox": [
+            171,
+            219,
+            746,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If $z _ { i } = k$ , we want $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } )$ to be close to 1, otherwise 0. We can optimize a binary cross entropy loss function, ",
+        "bbox": [
+            171,
+            239,
+            823,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f8ac0c7d40bb97249d155f596e126aef9d48937b778e8dadfea0e0ca8078ae0.jpg",
+        "text": "$$\n\\mathcal { L } _ { I n s C E } = \\frac { 1 } { N K } \\sum _ { k = 0 } ^ { K - 1 } \\sum _ { i = 1 } ^ { N } \\left\\{ \\begin{array} { l l } { - \\ln \\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } ) , } & { \\mathrm { i f ~ } z _ { i } = k , } \\\\ { - \\ln ( 1 - \\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } ) ) , } & { \\mathrm { o t h e r w i s e } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            270,
+            699,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, in practice, this suffers from a serious foreground-background imbalance problem. To remedy this drawback we propose to use the combined log-Dice loss function (Wong et al. (2018)) instead: ",
+        "bbox": [
+            176,
+            315,
+            823,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3927479dac8084b44af713aea05d704ac5fdb5951d4b530af21bd99cdc5dfd75.jpg",
+        "text": "$$\n\\mathcal { L } _ { I n s } = \\mathcal { L } _ { I n s C E } - \\ln \\frac { 2 \\sum _ { k = 0 } ^ { K - 1 } \\sum _ { i = 1 } ^ { N } \\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } ) \\mathbb { 1 } _ { z _ { i } = k } } { \\sum _ { k = 0 } ^ { K - 1 } \\sum _ { i = 1 } ^ { N } \\left( \\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } ) + \\mathbb { 1 } _ { z _ { i } = k } \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            353,
+            687,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 } _ { z _ { i } = k }$ is an indicator function which equals 1 when $z _ { i } = k$ , 0 otherwise. ",
+        "bbox": [
+            176,
+            393,
+            692,
+            407
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Entropy Regularization. As we can see in Figure 3, when $\\boldsymbol { \\sigma } _ { i } ^ { ( l ) }$ and $\\sigma _ { j } ^ { ( l ) }$ goes to infinity while keeping σ(li $\\sigma _ { i } ^ { ( l ) } = \\sigma _ { j } ^ { ( l ) }$ , $\\beta _ { i , j } = 1$ and the similarity equals to 1 no matter what the value $\\mu _ { i } - \\mu _ { j }$ is. Formally speaking, ",
+        "bbox": [
+            173,
+            421,
+            825,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e3af6a3aa83be02e230672ecdd859017497baa3a1eef664891d2af8abd6e63c.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { \\substack { \\sigma _ { i } ^ { ( l ) }  \\infty , \\sigma _ { j } ^ { ( l ) }  \\infty , \\sigma _ { i } ^ { ( l ) } = \\sigma _ { j } ^ { ( l ) } , l = 1 , 2 , 3 } }  \\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { j } ) = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            472,
+            650,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Consequently, the similarity degenerates to constant 1 for every pair of embeddings. To address this issue, we propose an entropy regularizer, ",
+        "bbox": [
+            176,
+            502,
+            823,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/976ab400dfc0af19fd4f647c7edd0d5b7806e068f51dbb883c86cd2f7504e7a1.jpg",
+        "text": "$$\n\\mathcal { L } _ { R e g } = \\sum _ { i = 1 } ^ { N } \\mathbb { H } ( \\mathbf { e } _ { i } ) = \\sum _ { i = 1 } ^ { N } \\left[ \\frac { 3 } { 2 } \\ln ( 2 \\pi e ) + \\frac { 1 } { 2 } \\ln \\left( \\sigma _ { i } ^ { ( 1 ) } \\sigma _ { i } ^ { ( 2 ) } \\sigma _ { i } ^ { ( 3 ) } \\right) ^ { 2 } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            532,
+            710,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { H } ( \\mathbf { e } _ { i } )$ is the entropy of multivariate Gaussian variable $\\mathbf { e } _ { i }$ . This regularizer is not only able to prevent the similarity degeneration by minimizing the variances along all dimensions, but can also penalize large uncertainties, thus increasing the confidence of the network output as in Grandvalet & Bengio (2005) and Wang et al. (2019a). ",
+        "bbox": [
+            173,
+            579,
+            825,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 SEMANTIC CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            410,
+            665
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Neven et al. (2019) introduces a way to use score maps to find cluster centers. Our main novelty is the new loss function, so our description focuses on this part. We still describe the greedy clustering steps from Neven et al. (2019) for completeness. In Section 4.2, we compare our new center-aware loss Eq 10 to the previously used minimum squared error (MSE) loss by Neven et al. (2019). ",
+        "bbox": [
+            173,
+            676,
+            825,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After defining the similarity measure, we can easily find out all points similar to an instance center. However, during the inference phase, we don’t have the information of ground-truth instance IDs, thus, it is impossible to use Eq. 3 to get instance centers. Therefore, along with distribution parameters $\\{ \\mu _ { i } \\} _ { i = 1 } ^ { N }$ and $\\{ \\pmb { \\sigma } _ { i } \\} _ { i = 1 } ^ { N }$ , we also predict a score map $\\{ { \\bf p } _ { i } \\} _ { i = 1 } ^ { N }$ , where $\\mathbf { p } _ { i } \\in \\mathbb { R } ^ { L }$ and its $l$ -th entry p(l) indicates the probability of $\\mathbf { x } _ { i }$ being an instance center with class label $l$ . Consider $\\tilde { \\mathbf { Q } } \\in \\mathbb { R } ^ { N \\times K }$ , ",
+        "bbox": [
+            173,
+            739,
+            825,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a09eb14658b4aa89035eae512bc9ae5ca45cd81b610ddc5ddf95e101f96fd0d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\tilde { \\mathbf { Q } } [ i , k ] = \\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } ) \\mathbb { 1 } _ { z _ { i } = k } = \\left\\{ { \\begin{array} { l l } { \\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } ) } & { z _ { i } = k , } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } , } \\end{array} } \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            820,
+            671,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where each entry $\\tilde { \\bf Q } [ i , k ]$ can be interpreted as the probability of $\\mathbf { x } _ { i }$ being the center of instance $k$ . Upon this we calculate $\\mathbf { Q } \\in \\mathbb { R } ^ { N \\times \\dot { L } }$ , where $\\mathbf { Q } [ i , l ]$ gives the probability of $\\mathbf { x } _ { i }$ being an instance center with class label $l$ , ",
+        "bbox": [
+            173,
+            861,
+            825,
+            904
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72b721356d2320e26b86f6fd1ed07684291dd6fd5bc0ce8763f3c93c5ec25acc.jpg",
+        "text": "$$\n\\mathbf { Q } [ i , l ] = \\operatorname* { m a x } _ { \\{ k : y ( k ) = l \\} } \\tilde { \\mathbf { Q } } [ i , k ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            900,
+            589,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $y ( k )$ is the class label of instance $k$ , due to the fact that $\\{ { \\bf x } _ { i } : z _ { i } = k \\}$ must have the same class label. (See an illustration in Appendix Figure 7.) ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We design a new loss function, ",
+        "bbox": [
+            176,
+            138,
+            379,
+            154
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be2a0bd691683c764c2573b552852a9f4cdb16112428bb1558ba59328e23b3b6.jpg",
+        "text": "$$\n\\mathcal { L } _ { S c o r e } = \\frac { 1 } { N L } \\sum _ { i = 1 } ^ { N } \\sum _ { l = 1 } ^ { L } - \\mathbf { Q } [ i , l ] \\log \\mathbf { P } [ i , l ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            159,
+            640,
+            203
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathbf { Q }$ is fixed as a target when training. See appendix for a detailed explanation of the loss function. ",
+        "bbox": [
+            173,
+            207,
+            821,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The inference process is done with a greedy approach (Neven et al. (2019)). From foreground score maps $\\{ \\mathbf { P } [ : , 1 ] , \\mathbf { \\bar { P } } [ : , 2 ] , \\ldots , \\mathbf { P } [ : , L ] \\}$ , we sample a point $\\mathbf { x } _ { i _ { 0 } }$ with highest score $\\mathbf { P } [ i _ { 0 } , l _ { 0 } ]$ , where $i _ { 0 }$ is the point index and $l _ { 0 }$ is its class label, ",
+        "bbox": [
+            173,
+            242,
+            825,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/516ca1983673ff1a4b6fd0d661d779bb91843ab84aa5b2a4b3ff31c568f7c65f.jpg",
+        "text": "$$\n\\operatorname * { a r g m a x } _ { l _ { 0 } , l _ { 0 } \\in \\{ 1 , 2 , . . . , L \\} } { \\bf P } [ : , l _ { 0 } ] ( i _ { 0 } , l _ { 0 } ) = \\operatorname * { a r g m a x } _ { i \\in \\{ 1 , 2 , . . . , N \\} , l \\in \\{ 1 , 2 , . . . , L \\} } { \\bf P } [ i , l ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            290,
+            704,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The point $\\mathbf { x } _ { i _ { 0 } }$ is an anchor and we want to find all similar points. Specifically we find all points $\\mathbf { x } _ { i }$ with $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { e } _ { i _ { 0 } } ) \\geq \\tau$ . As a result, the instance $\\mathrm { I D }$ of $\\mathbf { x } _ { i }$ is 0. After that, all points satisfying the inequality are all masked out. Similarly, we sample $\\mathbf { x } _ { i _ { 1 } }$ and mask out points with instance ID 1, sample $\\mathbf { x } _ { i _ { 2 } }$ and mask out points with instance $\\mathrm { I D 2 }$ , and so on. We stop this loop if there is no point left. We use the validation set to fit hyperparameter $\\tau$ , which is 0.35 in our experiments. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            414,
+            281,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We describe the implementation details in the appendix. PartNet (Mo et al. (2019)) provides coarse-, middle- and fine-grained part instance-level annotations for 3D point clouds from ShapeNet (Chang et al. (2015)). It contains 24 object categories, but the number of training samples varies greatly from 92 to 5707 for different categories. In contrast to indoor scene point cloud datasets (e.g., ScanNet by Dai et al. (2017)), instances (object parts) of PartNet require more context to be classified and are connected. Many visually alike parts have different semantic labels, e.g., ping-pong table’s legs and pool table’s legs in the category of table. Also, instance masks should have no overlaps. All these make it a very challenging dataset for instance segmentation. While our main experiments are on PartNet, we provide results on ScanNet in the appendix. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 QUANTITATIVE AND QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            588,
+            517,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We report per-category mean Average Precision (mAP) scores for the PartNet dataset in Table 1.   \nThe IoU threshold is 0.5. We compare our probabilistic embedding algorithm to GSPN (Yi et al.   \n(2019)), PartNet (Mo et al. (2019)) and SGPN (Wang et al. (2018)). The results are averaged over three levels of granularity (fine(3), middle(2), and coarse(1)). It should be noted that GSPN (Yi et al.   \n(2019)) only reports fine-grained results of 4 categories. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            683
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the complete dataset, our method outperforms the best competitor PartNet by $3 . 1 \\%$ average per-category mAP. We can observe that our method has a slightly bigger advantage in fine-grained instance segmentation compared to coarse-grained instance segmentation ( $3 . 2 \\%$ vs. $2 . 5 \\%$ ). We can also observe consistent improvements in categories with little as well as many training samples. While we beat SOTA in all categories with many training samples (Chair, Table, StorageFurniture, and Lamp), PartNet has better results in some of the categories with fewer training samples. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also show visualization examples in Figure 8. Compared to PartNet (Mo et al. (2019)), our method shows great improvement especially when there are many instances in a point cloud. ",
+        "bbox": [
+            174,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ABLATION STUDY AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            446,
+            839
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct the ablation study on all categories of PartNet (Mo et al. (2019)), but we only list detailed values for the four largest categories in Table 2. ",
+        "bbox": [
+            174,
+            852,
+            825,
+            880
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Effect of probabilistic embedding. We compare four different versions of probabilistic embedding. The Gaussian distribution used in the model can either be isotropic or anisotropic, homoscedastic or heteroscedastic. Thus we have isotropic homoscedastic, anisotropic homoscedastic, isotropic heteroscedastic, and anisotropic heteroscedastic. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/27c456a3d6f9ae5d5d9328a16946d9cd9271c76798dd5ad0196933f568587610.jpg",
+        "table_caption": [
+            "Table 1: Instance segmentation results on PartNet (part-category $\\mathbf { m A P \\% }$ , IoU threshold 0.5, fine(3), middle(2), and coarse(1)-grained). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>3     Bog Gaet Coe  o 00     Jaeee         aiue duer donder L.ITITe  p3品M3 s30A</td></tr><tr><td></td><td rowspan=1 colspan=1>SPSS</td><td rowspan=1 colspan=2>１２3[55.7|29.729.5</td><td rowspan=1 colspan=1>38.8 29.8 61.956.972.420.372.289.349.057.8 63.2 68.720.0 63.232.710.050.682.250.671.732.949.2 56.846.6115.41  125.4- 58.1-25.4                121.7-49.4-22.1-30.5 18.9111.8 45.1-19.4 18.2 38.3 78.8 15.4 35.9 37.8-    38.3 14.4-32.7- 18.2 - 21.5 14.6 24.9 36.5</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>46.8</td><td rowspan=1 colspan=1>Avg46.8|38819.053.556939.119.356.284.129.946950.568.720.050.822.910044.282.230.371.728.327.640.941.6</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td></tr><tr><td></td><td rowspan=1 colspan=1>SSSD</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-                                                        =                                    --             26.8                                    18.3                    26.7 21.9</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>|Avg|-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1  =  -  -  -  -  1  -  -  -  -  -  =   =  -   =   -  -  -  -  -  -  -  1</td></tr><tr><td></td><td rowspan=1 colspan=1>Pree</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>37.436.6</td><td rowspan=1 colspan=1>62.664.748463.659.774.442.876.393.352.957769.670.943.958437.2100050.06050080.945.254.271749.823.0      35.5，62.839.7=               -26.9·47.8  35.235.031.0115.0 48.6129.0 32.3 53.3 80.1 17.2 39.4 44.7      45.8 18.7 ·34.8：26.5127.5 23.9 33.7 52.0</td></tr><tr><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>Avg|54.4</td><td rowspan=1 colspan=1>Avg54.464.728.856.159.746.3376 64.186.736.648.657.2 70.943.952.127.6100044.286.037.280.935.936.452.750.9</td></tr><tr><td rowspan=2 colspan=2>s.Ino</td><td rowspan=1 colspan=1>s.Ino</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>40.439.8</td></tr><tr><td rowspan=1 colspan=2>Avg57.5</td><td rowspan=1 colspan=1>Avg57.564.6362 569 7.050.135.6 6.788.741.3 54.9 64.4 71.8 48.660.529.51000462 90.9 39.688.641.232.453.448.</td></tr></table>",
+        "bbox": [
+            171,
+            140,
+            823,
+            387
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9aae9c1ad1dec43cab2d498fdaed4865cd7b8934af5bf3b533bd2c2c4268646f.jpg",
+        "image_caption": [
+            "Figure 4: Top row: ground-truth. Middle row: PartNet. Bottom row: Probabilistic Embedding. We show true positives (IoU threshold 0.5) with the same color as ground truth. False detections are shown in transparent red. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            415,
+            795,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            707,
+            823,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The isotropic homoscedastic probabilistic embedding, learns to predict a single scalar representing the uncertainty of a point cloud. We do not see improvements over its determinisitc counterpart, but there is a large gap between them in large categories which have much more part instances and classes than others. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Similar cases happen in anisotropic homoscedastic and isotropic homoscedastic embedding. The former learns a 3D uncertainty vector for a single point cloud, while the latter learns point-dependent uncertainty scalars. They all show significant improvements over determinisitc embedding on finegrained categories. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, our full model uses anisotropic heteroscedastic probabilistic embedding, which outputs not only point-dependent but also axis-dependent uncertainties. See Figure 5 for an illustration of learned uncertainties. The points at boundary regions have significantly larger uncertainties compared to others. In summary, the full model achieves the best results among all variations. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4aaf43e30c42c7eab28161a4603c2d5615cd28192de05155fa7c9324bdb7164d.jpg",
+        "table_caption": [
+            "Table 2: Ablation study. Center, ExtDim, Prob refer to our proposed center-aware loss for the clustering step, the 6D deterministic embedding, and our proposed probabilistic embedding. Aniso and Hetero refer to the choice of Gaussian: anisotropic and heteroscedastic. AllAvg means taking all levels of granularity and categories into consideration. Large means fine-grained level of four largest categories. Others means fine-grained level of all the other categories. Here we also list the results on four largest categories of fine-grained level. The top two results are marked bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ablation</td><td>Model</td><td>ceeer</td><td>aig </td><td>1STUo</td><td>aH</td><td>BAAIA</td><td>△</td><td>e</td><td>△</td><td>sPett</td><td>△</td><td>Gart</td><td>△</td><td>due</td><td>△</td><td>2</td><td>△</td><td>Jqee</td><td>△</td></tr><tr><td>Loss</td><td></td><td></td><td></td><td>&lt;</td><td></td><td>|54.3</td><td>-0.7</td><td>16.2</td><td>-7.3</td><td>43.1</td><td>3.1</td><td>19.0</td><td>-8.4</td><td>8.8</td><td>-9.6</td><td>29.7</td><td>6.2</td><td>7.1</td><td>-17.4</td></tr><tr><td rowspan=\"2\">Deterministic</td><td rowspan=\"2\">Reference</td><td>M</td><td></td><td></td><td></td><td>55.0</td><td>0.0</td><td>23.4</td><td>0.0</td><td>40.0</td><td>0.0</td><td>27.4</td><td>0.0</td><td>18.5</td><td>0.0</td><td>23.5</td><td>0.0</td><td>24.4</td><td>0.0</td></tr><tr><td></td><td>√</td><td></td><td></td><td>56.2</td><td>1.2</td><td>27.2</td><td>3.7</td><td>41.2</td><td>1.2</td><td>32.8</td><td>5.4</td><td>20.2</td><td>1.7</td><td>29.8</td><td>6.4</td><td>25.8</td><td>1.4</td></tr><tr><td rowspan=\"4\">Probabilistic</td><td></td><td></td><td></td><td></td><td></td><td>54.7</td><td>-0.3</td><td>26.4</td><td>3.0</td><td>39.9</td><td>-0.1</td><td>33.7</td><td>6.3</td><td>17.8</td><td>-0.7</td><td>30.0</td><td>6.5</td><td>24.3</td><td>-0.2</td></tr><tr><td></td><td>区</td><td></td><td></td><td>√</td><td>53.1</td><td>-1.9</td><td>27.4</td><td>3.9</td><td>38.1</td><td>-1.8</td><td>33.6</td><td>6.2</td><td>20.0</td><td>1.5</td><td>30.9</td><td>7.5</td><td>25.0</td><td>0.6</td></tr><tr><td></td><td></td><td>√</td><td>√</td><td></td><td></td><td>55.60.6</td><td>27.3</td><td>3.9</td><td>41.0</td><td>1.1</td><td>33.9</td><td>6.5</td><td>19.5</td><td>1.0</td><td>31.1</td><td>7.6</td><td>24.8</td><td>0.3</td></tr><tr><td>Full</td><td>公</td><td>√</td><td>√</td><td>√</td><td>57.5</td><td>2.5</td><td>28.7</td><td>5.2</td><td>43.0</td><td>3.0</td><td>34.7</td><td>7.3</td><td>20.3</td><td>1.8</td><td>34.2</td><td>10.7</td><td>25.5</td><td>1.1</td></tr></table>",
+        "bbox": [
+            173,
+            196,
+            821,
+            325
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/061579210f0d0b85ff94609c453a44632715c2777bb1eb4bd9023d829df5d84f.jpg",
+        "image_caption": [
+            "Figure 5: Learned Uncertainties. Top left: uncertainties are represented as ellipsoids, where directional scaling shows the value of uncertainties along 3 axes. The other 3 subfigures: uncertainties along 3 axes. We represent large values with red colors and smaller values with blue colors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            371,
+            462,
+            401
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/445c93162d986452a5aab014b737b0b5d64453b744ea7cf75f797abed41d9b72.jpg",
+        "image_caption": [
+            "Figure 6: Comparison of embeddings. Top row: Deterministic embedding. Bottom row: Probabilistic embedding. Left to right: we show a gradual shape transformation between the original point cloud and the embedded point cloud. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            550,
+            349,
+            808,
+            431
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of spatial embedding. Since our full model outputs a 3D center vector and 3D uncertainty vector, in a way, we can regard it as a 6D embedding method (with a totally different similarity kernel). One may wonder: how does it compare with the performance of 6D deterministic embedding? The results in Table 2 show, increasing the dimension of deterministic embedding from 3 to 6 shows some improvement, but less than using probabilistic embedding. Thus the performance of our method, cannot be achieved by simply increasing the dimension of deterministic embedding, which also shows the superiority of the probabilistic embedding. We illustrate the differences between deterministic and probabilistic embedding in 3D in Figure 6. We can observe, that probabilistic embedding introduces much stronger deformations of the geometry. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of center-aware loss. We examine the effect of the center-aware loss in the clustering step. We use the same setup as in our full model except changing the center-aware loss to MSE loss (Neven et al. (2019)). In Table 2, we can see that our proposed loss function is especially stable on large fine-grained datasets $5 . 2 \\%$ vs $- 7 . 3 \\%$ ). ",
+        "bbox": [
+            174,
+            708,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            790,
+            318,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We build on embedding-based instance segmentation to present a framework of probabilistic embedding and a new loss function for the clustering step. We evaluate our framework on a large scale point cloud dataset, PartNet, and achieve state-of-the-art performance. Moreover, the qualitative results show the new framework is robust to point clouds with many instances. Additionally, it is able to estimate uncertainties while increasing the accuracy of instance segmentation. In future work, we hope that the probabilistic embedding can be further applied to other kinds of data representation, e.g., 2D images, 3D volumes, and meshes. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015. 6 ",
+        "bbox": [
+            174,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christopher Choy, JunYoung Gwak, and Silvio Savarese. 4d spatio-temporal convnets: Minkowski convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3075–3084, 2019. 15 ",
+        "bbox": [
+            176,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Angela Dai, Angel X Chang, Manolis Savva, Maciej Halber, Thomas Funkhouser, and Matthias Nießner. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5828–5839, 2017. 6, 13 ",
+        "bbox": [
+            173,
+            232,
+            823,
+            276
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bert De Brabandere, Davy Neven, and Luc Van Gool. Semantic instance segmentation with a discriminative loss function. arXiv preprint arXiv:1708.02551, 2017. 1, 2 ",
+        "bbox": [
+            171,
+            285,
+            825,
+            315
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Garoe Dorta, Sara Vicente, Lourdes Agapito, Neill D. F. Campbell, and Ivor Simpson. Structured uncertainty prediction networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. 1 ",
+        "bbox": [
+            174,
+            325,
+            823,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Francis Engelmann, Martin Bokeloh, Alireza Fathi, Bastian Leibe, and Matthias Nießner. 3dmpa: Multi-proposal aggregation for 3d semantic instance segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9031–9040, 2020. 15 ",
+        "bbox": [
+            174,
+            378,
+            823,
+            421
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alireza Fathi, Zbigniew Wojna, Vivek Rathod, Peng Wang, Hyun Oh Song, Sergio Guadarrama, and Kevin P Murphy. Semantic instance segmentation via deep metric learning. arXiv preprint arXiv:1703.10277, 2017. 1, 2 ",
+        "bbox": [
+            173,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019. 13 ",
+        "bbox": [
+            173,
+            484,
+            823,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick. Fast r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 1440–1448, 2015. 2 ",
+        "bbox": [
+            173,
+            523,
+            823,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Advances in neural information processing systems, pp. 529–536, 2005. 5 ",
+        "bbox": [
+            171,
+            563,
+            823,
+            593
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lei Han, Tian Zheng, Lan Xu, and Lu Fang. Occuseg: Occupancy-aware 3d instance segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2940–2949, 2020. 15 ",
+        "bbox": [
+            173,
+            603,
+            823,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ Proceedings of the IEEE international conference on computer vision, pp. 2961–2969, 2017. 1, 2 ",
+        "bbox": [
+            173,
+            656,
+            821,
+            686
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, and Mu Li. Bag of tricks for image classification with convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 558–567, 2019. 12 ",
+        "bbox": [
+            173,
+            695,
+            823,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tony Jebara, Risi Kondor, and Andrew Howard. Probability product kernels. Journal of Machine Learning Research, 5(Jul):819–844, 2004. 2, 3 ",
+        "bbox": [
+            173,
+            748,
+            823,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Li Jiang, Hengshuang Zhao, Shaoshuai Shi, Shu Liu, Chi-Wing Fu, and Jiaya Jia. Pointgroup: Dualset point grouping for 3d instance segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4867–4876, 2020. 15 ",
+        "bbox": [
+            173,
+            787,
+            823,
+            832
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Kendall and Yarin Gal. What uncertainties do we need in bayesian deep learning for computer vision? In Advances in neural information processing systems, pp. 5574–5584, 2017. 1, 2 ",
+        "bbox": [
+            171,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7482–7491, 2018. 1, 2, 3 ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Salman Khan, Munawar Hayat, Syed Waqas Zamir, Jianbing Shen, and Ling Shao. Striking the right balance with uncertainty. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. 1 ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 13 ",
+        "bbox": [
+            173,
+            156,
+            823,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. 2 ",
+        "bbox": [
+            173,
+            194,
+            823,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shu Kong and Charless C Fowlkes. Recurrent pixel embedding for instance grouping. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9018–9028, 2018. 1 ",
+        "bbox": [
+            173,
+            234,
+            825,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean Lahoud, Bernard Ghanem, Marc Pollefeys, and Martin R Oswald. 3d instance segmentation via multi-task metric learning. arXiv preprint arXiv:1906.08650, 2019. 1, 15 ",
+        "bbox": [
+            173,
+            286,
+            823,
+            315
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaodan Liang, Liang Lin, Yunchao Wei, Xiaohui Shen, Jianchao Yang, and Shuicheng Yan. Proposal-free network for instance-level object segmentation. IEEE transactions on pattern analysis and machine intelligence, 40(12):2978–2991, 2017. 2, 3 ",
+        "bbox": [
+            176,
+            325,
+            821,
+            368
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chao Liu, Jinwei Gu, Kihwan Kim, Srinivasa G. Narasimhan, and Jan Kautz. Neural rgb(r)d sensing: Depth and uncertainty from a video camera. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. 1 ",
+        "bbox": [
+            178,
+            377,
+            823,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shu Liu, Lu Qi, Haifang Qin, Jianping Shi, and Jiaya Jia. Path aggregation network for instance segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8759–8768, 2018. 1, 2 ",
+        "bbox": [
+            174,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaichun Mo, Shilin Zhu, Angel X Chang, Li Yi, Subarna Tripathi, Leonidas J Guibas, and Hao Su. Partnet: A large-scale benchmark for fine-grained and hierarchical part-level 3d object understanding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 909–918, 2019. 1, 2, 6, 12 ",
+        "bbox": [
+            174,
+            484,
+            825,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Davy Neven, Bert De Brabandere, Marc Proesmans, and Luc Van Gool. Instance segmentation by jointly optimizing spatial embeddings and clustering bandwidth. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8837–8845, 2019. 1, 2, 3, 5, 6, 8, 15 ",
+        "bbox": [
+            173,
+            550,
+            825,
+            607
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Novotny, Samuel Albanie, Diane Larlus, and Andrea Vedaldi. Semi-convolutional operators for instance segmentation. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 86–102, 2018. 1, 2, 3 ",
+        "bbox": [
+            173,
+            617,
+            825,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, highperformance deep learning library. In Advances in Neural Information Processing Systems, pp. 8024–8035, 2019. 13 ",
+        "bbox": [
+            173,
+            670,
+            825,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In Advances in neural information processing systems, pp. 5099–5108, 2017. 2, 12 ",
+        "bbox": [
+            173,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems, pp. 91–99, 2015. 2 ",
+        "bbox": [
+            173,
+            790,
+            823,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014. 2 ",
+        "bbox": [
+            171,
+            842,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016. 12 ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dequan Wang, Evan Shelhamer, Bruno Olshausen, and Trevor Darrell. Dynamic scale inference by entropy minimization. arXiv preprint arXiv:1908.03182, 2019a. 5 ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Weiyue Wang, Ronald Yu, Qiangui Huang, and Ulrich Neumann. Sgpn: Similarity group proposal network for 3d point cloud instance segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2569–2578, 2018. 1, 2, 6 ",
+        "bbox": [
+            176,
+            142,
+            821,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xinlong Wang, Shu Liu, Xiaoyong Shen, Chunhua Shen, and Jiaya Jia. Associatively segmenting instances and semantics in point clouds. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4096–4105, 2019b. 1, 2 ",
+        "bbox": [
+            174,
+            194,
+            821,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ken CL Wong, Mehdi Moradi, Hui Tang, and Tanveer Syeda-Mahmood. 3d segmentation with exponential logarithmic loss for highly unbalanced object sizes. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pp. 612–619. Springer, 2018. 5 ",
+        "bbox": [
+            176,
+            247,
+            820,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Li Yi, Wang Zhao, He Wang, Minhyuk Sung, and Leonidas J Guibas. Gspn: Generative shape proposal network for 3d instance segmentation in point cloud. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3947–3956, 2019. 2, 6 ",
+        "bbox": [
+            176,
+            300,
+            821,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            371,
+            299,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 CENTER-AWARE LOSS EXPLANATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            404,
+            473,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We want $\\mathbf { P } \\in \\mathbb { R } ^ { N \\times L }$ , the matrix form of $\\{ { \\bf p } _ { i } \\} _ { i = 1 } ^ { N }$ , to satisfy two conditions: ",
+        "bbox": [
+            173,
+            426,
+            671,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. $\\mathbf { P } [ i , : ]$ is a probability vector and can be used to infer class label $y _ { i }$ of point $\\mathbf { x } _ { i }$ , i.e., $y _ { i } =$ arg $\\mathrm { m a x } _ { l = 1 } ^ { L } \\mathbf { P } [ i , l ]$ .   \n2. For foreground class labels $l \\in \\{ 1 , 2 , \\ldots , L \\} , \\mathbf { P } [ : , l ]$ is a score map of being an instance center with class label $l$ . ",
+        "bbox": [
+            200,
+            457,
+            825,
+            520
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The first condition is easy to satisfy with the cross entropy loss. Assuming $\\mathbf { P } [ i , : ]$ is the output of a softmax function, we can minimize, ",
+        "bbox": [
+            174,
+            531,
+            825,
+            560
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24b6425d638aecb0837812ad7a68640b2b9d48e76aea462cad30090ec1994eb0.jpg",
+        "text": "$$\n\\mathcal { L } _ { C l s C E } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\left( \\frac { 1 } { L } \\sum _ { l = 1 } ^ { L } - \\mathbb { 1 } _ { y _ { i } = l } \\log \\mathbf { P } [ i , l ] \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            566,
+            656,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 } _ { y _ { i } = l }$ is an indicator function which equals 1 when $y _ { i } = l , 0$ otherwise. ",
+        "bbox": [
+            174,
+            617,
+            686,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the second condition, we take into account $\\kappa ( \\mathbf { e } _ { i } , \\mathbf { c } _ { k } )$ , which is the similarity between $\\mathbf { x } _ { i }$ and an instance $k$ . ",
+        "bbox": [
+            174,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We want both $\\mathbf { P } [ : , l ]$ and $\\mathbf { Q } [ : , l ]$ to achieve local maxima at the same points for all $l \\in \\{ 1 , 2 , \\ldots , L \\}$ . When we are doing inference, these local maxima are chosen as instance centers. Therefore, the first condition can be weakened, and only points which are close to instance centers should be classified correctly. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We can view $\\mathcal { L } _ { S c o r e }$ in two ways, ",
+        "bbox": [
+            174,
+            737,
+            397,
+            752
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. First, we switch the order of summation in Eq. 10, ",
+        "bbox": [
+            214,
+            763,
+            563,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f85b018eaa7053c9fc40b371996d8965b4d50d8feb4faf380d9648e777cbe3c2.jpg",
+        "text": "$$\n\\mathcal { L } _ { S c o r e } = \\frac { 1 } { L } \\sum _ { l = 1 } ^ { L } \\left( \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } - \\mathbf { Q } [ i , l ] \\log \\mathbf { P } [ i , l ] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            785,
+            686,
+            829
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The value of this quantity $- \\mathbf { Q } [ i , l ] \\log \\mathbf { P } [ i , l ]$ is high when weight term $\\mathbf { Q } [ i , l ]$ is high, and if we minimize it, we are forcing $- \\log \\mathbf { P } [ i , l ]$ to be small. Consequently, $\\mathbf { P } [ i , l ]$ would be large. This guarantees local maxima of $\\mathbf { Q } [ : , l ]$ are also local maxima of $\\mathbf { P } [ : , l ]$ . And minimizing this loss term is equivalent to minimize the KL-divergence between (unnor$\\mathbf { Q } [ : , l ]$ and (unnormalized probability) $\\begin{array} { r l } { \\mathbf { P } [ : , l ] , \\mathbb { K L } ( \\mathbf { Q } [ : , l ] | \\mathbf { P } [ : , l ] ) } & { { } = } \\end{array}$ $\\begin{array} { r } { \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\mathbf { Q } [ i , l ] \\log \\frac { \\mathbf { Q } [ i , l ] } { \\mathbf { P } [ i , l ] } } \\end{array}$ ",
+        "bbox": [
+            232,
+            835,
+            825,
+            928
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/359305fa325e9e19067d400c67da92c3ea03ef91364d2e1b6db3fe0485191310.jpg",
+        "table_caption": [
+            "Table 3: Activations for different output branches "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Output</td><td>Activation</td></tr><tr><td>Centers</td><td>Oi∈R</td><td>μ = Xi +tanhOi</td></tr><tr><td>Uncert</td><td>ER</td><td>Oi = expoi</td></tr><tr><td>Scores</td><td>PiER</td><td>Pi = softmax(Pi)</td></tr></table>",
+        "bbox": [
+            362,
+            127,
+            635,
+            202
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. Second, we look at the inner summation of Eq. 10, ",
+        "bbox": [
+            212,
+            231,
+            565,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d01f1977e41e14f487620a808277c9ed1a941fb1d47231e2dd44ec8fa2c566a6.jpg",
+        "text": "$$\n\\mathcal { L } _ { S c o r e } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\left( \\frac { 1 } { L } \\sum _ { l = 1 } ^ { L } - \\mathbf { Q } [ i , l ] \\log \\mathbf { P } [ i , l ] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            251,
+            686,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The inner summation inside the round bracket is the cross entropy between $\\mathbf { Q } [ i , : ]$ and $\\mathbf { P } [ i , : ]$ . And it is equivalent to replacing the one-hot vector in Equation 12 with $\\mathbf { Q } [ i , : ]$ . Also, it is the form of label smoothing, a commonly used training trick in image classification (Szegedy et al. (2016); He et al. (2019)). The closer $\\mathbf { Q } [ i , : ]$ is to a one-hot vector, the more confidence we give to the classification loss of point $\\mathbf { x } _ { i }$ . By definition of $\\mathbf { Q } [ i , l ]$ , it can be easily seen that the resulting classifier only classifies near-centers points correctly. Thus we call our new loss function the center-aware loss. ",
+        "bbox": [
+            232,
+            299,
+            825,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            414,
+            344,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For a fair comparison to our main competitor PartNet (Mo et al. (2019)) we keep as much of their structure as possible (Note that PartNet is the name of a dataset as well as an instance segmentation method). We also use PointNet $^ { + + }$ (Qi et al. (2017)) as the feature extraction backbone, with the same parameters as by Mo et al. (2019). We use 3 output heads for centers, uncertainties, and scores as in $\\mathsf { \\bar { f } } ( \\{ \\mathbf { x } _ { i } \\} _ { i = 1 } ^ { N } ) = \\mathsf { \\bar { \\{ } }  \\mu _ { i } , \\pmb { \\sigma } _ { i } , \\mathbf { p } _ { i } \\} _ { i = 1 } ^ { N }$ . The output dimensions are 3, 3 and the number of semantic classes, uncertainties and scores, respectively. We list the activation functions for output heads in Table 3. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Following the notation of PointNet+ $^ +$ Qi et al. (2017), we give the architecture of the feature network: ",
+        "bbox": [
+            173,
+            546,
+            825,
+            574
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6bebc7cdd1139dd934fadc8acb3187f72699f7920596e874a4384a4043ec073.jpg",
+        "text": "$$\n\\begin{array} { r l } & { S A ( 5 1 2 , 0 . 2 , [ 6 4 , 6 4 , 1 2 8 ] ) , } \\\\ & { S A ( 1 2 8 , 0 . 4 , [ 1 2 8 , 1 2 8 , 2 5 6 ] ) , } \\\\ & { S A ( [ 2 5 6 , 5 1 2 , 1 0 2 4 ] ) , } \\\\ & { F P ( 2 5 6 , 2 5 6 ) , } \\\\ & { F P ( 2 5 6 , 1 2 8 ) , } \\\\ & { F P ( 1 2 8 , 1 2 8 ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            579,
+            598,
+            688
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The output head network is: ",
+        "bbox": [
+            174,
+            708,
+            357,
+            722
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "F ullyConnected(128, 256),   \nBatchNorm(256),   \nReLU (),   \nF ullyConnected(256, 128),   \nBatchNorm(128),   \nReLU (),   \nF ullyConnected(128, 128),   \nBatchNorm(128),   \nReLU (),   \nF ullyConnected(128, C), ",
+        "bbox": [
+            400,
+            728,
+            596,
+            904
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5baeeb435abae2f1dd6a5beaea5aa831f9f1138ce902c7095c7ed3866bba6c81.jpg",
+        "image_caption": [
+            "Figure 7: Top row: similarity maps for each part instance $\\tilde { \\mathbf { Q } } [ : , k ]$ . Bottom row: probability map $\\mathbf { Q } [ : , l ]$ . The arrows show that information of instances of the same class is aggregated in Eq. 9. Red means high similarity, while blue means low. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            281,
+            103,
+            714,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e8bbbebbb1f4db61e0733c9bc3e3b0f92e018b62cfbbc9414a37fa36812e29e.jpg",
+        "table_caption": [
+            "Table 4: Instance segmentation results on PartNet. The metric is mAP $( \\% )$ with IoU threshold 0.25. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>Bnoget  o 0     aenee          doider i  383品M3s </td></tr><tr><td rowspan=1 colspan=1>d</td><td rowspan=1 colspan=1>１２3</td><td rowspan=1 colspan=1>70.2|46.745.6</td><td rowspan=1 colspan=1>89.482.3 65.263.178.148.079.197.164.9 64.677.373.958.959.242.510.0 50.092.950.096.357.759.382.752.6144.5       43.0171.3-49.3     =             32.2 1 51.2  45.2146.7 36.5-29.0 52.6-35.3 39.6 59.9 89.3 27.1 56.9 55.0     -49.0 22.6 1 56.9135.6，36.3 28.6 44.8 57.0</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg|</td><td rowspan=1 colspan=1>62.8|</td><td rowspan=1 colspan=1>389.4 51.9 58.9 63.152.143.8 70.193.247.160.8 66.2 73.958.954.132.4100052.792.943.696.346.941.5 63.8 54.8</td></tr><tr><td rowspan=1 colspan=1>s.no</td><td rowspan=1 colspan=1>1123</td><td rowspan=1 colspan=1>72.751.451.6</td><td rowspan=1 colspan=1>82.8 79.6 65.672.082.8 49.183.8 98.375.574.3 83.279.5 59.97.8 45.2 1.050.595.4 51.696.9 60.944.682.9 51.1，55.41  147.1-78.0-48.1                   39.3154.448.853.737.7-44.4 57.2，43.2 45.7 64.8 90.7 34.6 59.3 67.2       53.0 26.0 1 60.0-51.5- 44.4 31.7 50.0 53.9</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Avg|</td><td rowspan=1 colspan=1>66.5</td><td rowspan=1 colspan=1>66.582.8 59.8 61.472.057.747.475.694.552.7 66.8 75.279.559.9 65.936.8100055.095.4 506 96.953.038.0 66.5 52.5</td></tr></table>",
+        "bbox": [
+            173,
+            434,
+            823,
+            574
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $C$ is 3, 3 and the number of classes for centers, uncertainties and scores, respectively. ",
+        "bbox": [
+            171,
+            598,
+            772,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We implemented our method using PyTorch Paszke et al. (2019) and the geometric deep learning library PyTorch Geometric Fey & Lenssen (2019). The final objective function is ",
+        "bbox": [
+            174,
+            619,
+            823,
+            647
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf1f96196bbdff7c98d2d9922c8c275d52b4fcc03707bd26aef7869b311ac504.jpg",
+        "text": "$$\n\\mathcal { L } = \\mathcal { L } _ { I n s } + \\mathcal { L } _ { S c o r e } + 0 . 0 0 1 \\cdot \\mathcal { L } _ { R e g }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            654,
+            619,
+            670
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use random jittering, translation (between $- 0 . 0 1$ and 0.01) and rotation (between $- 1 5 ^ { \\circ }$ and $1 5 ^ { \\circ }$ for each axis) as data augmentation, and use the Adam Kingma & Ba (2014) optimizer. We use a batch-size of 16 and an initial learning rate of 0.001 for 500 epochs with a decay factor of 0.5 at epoch 50 and epoch 150. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            738
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 ADDITIONAL RESULTS ON PARTNET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            755,
+            468,
+            770
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Results of different IoU thresholds We report detailed results of IoU threshold at $2 5 \\%$ and $7 5 \\%$ in Table 4 and Table 5. The metric is mean Average Precision (mAP). ",
+        "bbox": [
+            171,
+            780,
+            823,
+            810
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Qualitive results We present more qualitive results in Figure 8 which shows the instanceawareness of our method. We also demonstrate the 3D models in the attached video. ",
+        "bbox": [
+            174,
+            824,
+            821,
+            853
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 ADDITIONAL RESULTS ON SCANNET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            472,
+            883
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ScanNet (Dai et al. (2017)) is a dataset containing 3D reconstructions of indoor scenes. Different from objects in PartNet, instances are more separated, e.g., chairs and tables usually are not connected, while in PartNet, parts are closely connected together and have more intertwined correspondence. Also PartNet provides detailed and high-granularity semantic and instance information, i.e. the number of instances and classes are often larger than ones of ScanNet. This makes PartNet a more suitable dataset for instance segmentation. However, we still validate our method on ScanNet to show the potential of probabilistic embedding. As baseline method we chose a network based on performance and availability of code. Since the best methods, such as OccuSeg, do not release code for ScanNet, we decided to build our own baseline using MinkowskiNet (Choy et al. (2019)) as feature backbone. MinkowskiNet is a sparse tensor network that achieved great results on indoor semantic scene segmentation. In order to adapt the network to instance segmentation, we re-implement the learnable margin method proposed by Neven et al. (2019). The learnable margin method does well on common image instance segmentation datasets and is well-balanced both in speed and accuracy. This combination of two recent papers gives a strong baseline, but not stateof-the-art results in the metrics. We compare to this baseline, also using MinkowskiNet as feature backbone to make the results directly comparable. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/845999cd80dcb0339daff67531c6a666c321bfcd04f1b9bde1f32a23fc06b313.jpg",
+        "table_caption": [
+            "Table 5: Instance segmentation results on PartNet. The metric is mAP $( \\% )$ with IoU threshold 0.75. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>Avg</td><td>3</td><td>o o0</td><td>eenee duer doider L.ITe 0 阿 S 品 M</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td>22.0 1</td><td>4.2</td><td>47.439.714.6 60.641.458.328.858.384.735.649.148.2 66.310.748.729.698.047.876.150.035.129.943.242.240.5</td></tr><tr><td>ee</td><td>123</td><td>23.5</td><td>-</td><td>21.4 1 = 3.937.9 、</td><td>37.2 1 22.4 19.6 1 32.1 1 16.7 1 22.8 22.0 - 16.6 17.6 29.8 63.2 8.1 27.6 25.8 31.0 13.6 23.9 12.1 18.2 16.4 19.7 34.5</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>- - - 1 -</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>Avg|38.939.77.649.241.432.123.241.773.922038437.066.310.739.820.998.3467.126.335.123.627.23037.5</td></tr><tr><td></td><td>1</td><td>23.8</td><td></td><td>7.1 1 22.8</td><td>50.040.313.3 60.2 60.259.328.261.990.639.159.6542 69.37.465.728.598.047.977.150.542.830.134.840.741.1 -22.0- 35.5- 20.6- 26.121.4 1 -</td></tr><tr><td>，</td><td></td><td>23 |25.7</td><td>- 7.3 38.8</td><td>37.4- 21.3 20.5 17.2 30.0 66.8 10.8 28.2 33.2</td><td>31.5 14.1 21.0 17.4 19.4 38.0</td></tr><tr><td>s.no</td><td></td><td></td><td></td><td>-</td><td>， 25.6 ， 17.1 -</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>Avg|41.740.39.249.5 60.234.2.743.178.723.743.9 43.769.37.448.621.5 98.36477.129.4 42.8 25.724.50039.6</td></tr></table>",
+        "bbox": [
+            173,
+            191,
+            823,
+            332
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ddf38a2b7c8ca8218109b83409407d1b63c79a627cad3c1e1be3de09a03af765.jpg",
+        "image_caption": [
+            "Figure 8: Top row: ground-truth (background points are shown in transparent red). Second and third row: PartNet and Ours (only true positives are shown, and false detections are shown in transparent red). Fourth and fifth row: PartNet and Ours (all detected instances, unclassified points are shown in transparent red). PartNet can group instance points together but fails to give the correct class labels in some cases (e.g., in the first and the third subfigures from left to right, points of table legs are grouped together (fourth row) but they are not true positives (second row). Besides, in the sixth subfigure from left to right, PartNet fails to distinguish different instances of lamp covers (second and fourth row). While our method performs especially better in these cases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            443,
+            764,
+            747
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/29a5401c9877b6c91bbe470ef53788e7c24957b4e7a6572e833561550a3bddff.jpg",
+        "table_caption": [
+            "Table 6: Results on ScanNet. We list the results on both validation and hidden test sets of ScanNet. Note that due to the unique submission policy of ScanNet, we are unable to provide the results of learnable margin on the test set. On validation set, we improve mAP by $4 . 9 \\%$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">validation</td><td colspan=\"3\">test</td></tr><tr><td></td><td>mAP</td><td>AP50</td><td>AP25</td><td>mAP</td><td>AP50</td><td>AP25</td></tr><tr><td>MTML (Lahoud et al. (2019))</td><td>20.3</td><td>40.2</td><td>55.4</td><td>28.2</td><td>54.9</td><td>73.1</td></tr><tr><td>3D-MPA (Engelmann et al. (2020))</td><td>35.3</td><td>59.1</td><td>72.4</td><td>35.5</td><td>61.1</td><td>73.7</td></tr><tr><td>PointGroup (Jiang et al. (2020))</td><td>34.8</td><td>56.9</td><td>71.3</td><td>40.7</td><td>63.6</td><td>77.8</td></tr><tr><td>OccuSeg (Han et al. (2020))</td><td>44.2</td><td>60.7</td><td>71.9</td><td>44.3</td><td>63.4</td><td>73.9</td></tr><tr><td>Learnable margin + MinkowskiNet</td><td>28.1</td><td>50.1</td><td>70.1</td><td>-</td><td>1</td><td>-</td></tr><tr><td>Proposed + MinkowskiNet</td><td>33.0</td><td>57.1</td><td>73.8</td><td>32.8</td><td>56.0</td><td>75.2</td></tr></table>",
+        "bbox": [
+            207,
+            155,
+            790,
+            289
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            314,
+            825,
+            507
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We report the average precision (AP) in Table 6 and compare our method with other leading results on ScanNet. Although we do not have the overall state-of-the-art results, the improvement over the baseline Neven et al. (2019) verifies the impact of probabilistic embedding and demonstrates that our method can be integrated with any embedding-based method and any backbone network. We can improve the validation mAP by $4 . { \\dot { 9 } } \\%$ . ",
+        "bbox": [
+            174,
+            515,
+            825,
+            585
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.5 DIFFERENCES TO LEARNABLE MARGIN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            602,
+            486,
+            616
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Neven et al. (2019) proposed to use a learnable margin for image instance segmentation, which is similar in formulation to our proposed probabilistic embedding. Although we differ in several aspects: ",
+        "bbox": [
+            176,
+            627,
+            823,
+            670
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. The intuition behind learnable margin comes from the hinge loss: give different hinge margin to objects of different sizes. However, our intuition comes from modeling neural network’s output as random variables to estimate uncertainty.   \n2. The parameters have a different meaning in our method compared to Neven et al. (2019). In learnable margin, $\\sigma$ is an instance-specific bandwidth (or margin) per cluster. In our work $\\sigma$ are uncertainties per point.   \n3. The bandwidth $\\sigma$ is influenced by the size of instances (large instances have large $\\sigma$ ). In contrast, our uncertainty $\\sigma$ encodes per-point uncertainty close to the boundary of instances (see Fig. 5).   \n4. Neven et al. (2019) add a loss term to enforce the bandwidths from the same instance to be close. By contrast, we don’t have this kind of restriction. Also, uncertaintes from the same instance can be different as along as they have similar spatial embeddings. ",
+        "bbox": [
+            212,
+            683,
+            825,
+            866
+        ],
+        "page_idx": 14
+    }
+]