Add files using upload-large-folder tool

parse/train/HJgeEh09KQ/HJgeEh09KQ.md

@@ -0,0 +1,337 @@
+# BOOSTING ROBUSTNESS CERTIFICATION OF NEURAL NETWORKS
+
+Gagandeep Singh, Timon Gehr, Markus Puschel, Martin Vechev ¨   
+Department of Computer Science   
+ETH Zurich, Switzerland   
+{gsingh,timon.gehr,pueschel,martin.vechev}@inf.ethz.ch
+
+# ABSTRACT
+
+We present a novel approach for the certification of neural networks against adversarial perturbations which combines scalable overapproximation methods with precise (mixed integer) linear programming. This results in significantly better precision than state-of-the-art verifiers on challenging feedforward and convolutional neural networks with piecewise linear activation functions.
+
+# 1 INTRODUCTION
+
+Neural networks are increasingly applied in critical domains such as autonomous driving (Bojarski et al., 2016), medical diagnosis (Amato et al., 2013), and speech recognition (Hinton et al., 2012). However, it has been shown by Goodfellow et al. (2014) that neural networks can be vulnerable against adversarial attacks, i.e., imperceptible input perturbations cause neural networks to misclassify. To address this challenge and prove that a network is free of adversarial examples (usually, in a region around a given input), recent work has started investigating the use of certification techniques. Current verifiers can be broadly classified as either complete or incomplete.
+
+Complete verifiers are exact, i.e., if the verifier fails to certify a network then the network is nonrobust (and vice-versa). Existing complete verifiers are based on Mixed Integer Linear Programming (MILP) (Lomuscio & Maganti, 2017; Fischetti & Jo, 2018; Dutta et al., 2018; Cheng et al., 2017) or SMT solvers (Katz et al., 2017; Ehlers, 2017). Although precise, these can only handle networks with a small number of layers and neurons. To scale, incomplete verifiers usually employ overapproximation methods and hence they are sound but may fail to prove robustness even if it holds. Incomplete verifiers use methods such as duality (Dvijotham et al., 2018), abstract interpretation (Gehr et al., 2018; Singh et al., 2018; 2019), linear approximations (Weng et al., 2018; Wong & Kolter, 2018; Zhang et al., 2018), semidefinite relaxations (Raghunathan et al., 2018), combination of linear and non-linear approximation (Xiang et al., 2017), or search space discretization (Huang et al., 2017). Incomplete verifiers are more scalable than complete ones, but can suffer from precision loss for deeper networks. In principle, incomplete verifiers can be made asymptotically complete by iteratively refining the input space (Wang et al., 2018a) or the neurons (Wang et al., 2018b); however, in the worst case, this may eliminate any scalability gains and thus defeat the purpose of using overapproximation in the first place.
+
+This work: boosting complete and incomplete verifiers. A key challenge then is to design a verifier which improves the precision of incomplete methods and the scalability of complete ones. In this work, we make a step towards addressing this challenge based on two key ideas: (i) a combination of state-of-the-art overapproximation techniques used by incomplete methods, including LP relaxations, together with MILP solvers, often employed in complete verifiers; (ii) a novel heuristic, which points to neurons whose approximated bounds should be refined. We implemented these ideas in a system called RefineZono, and showed that is is faster than state-of-the-art complete verifiers on small networks while improving precision of existing incomplete verifiers on larger networks.
+
+The recent works of (Wang et al., 2018b) and Tjeng et al. (2019) have also explored the combination of linear programming with overapproximation. However, both use simpler and coarser overapproximations than ours. Our evaluation shows that RefineZono is faster than both for complete verification. For example, RefineZono is faster than the work of Tjeng et al. (2019) for the complete verification of a $3 \times 5 0$ network, while for the larger $9 \times 2 0 0$ network their method does not finish within multiple days on images which RefineZono verifies in $\approx 1 4$ minutes.
+
+![](images/7a0491d129f7a4873853b23672643797418fbf229fbcf01751b183d9521de53e.jpg)  
+Figure 1: Robustness analysis of a toy example neural network using our method. Here, approximation results computed with DeepZ (blue box) are refined using MILP whereas those in green are refined using LP.
+
+Main contributions. Our main contributions are:
+
+• A refinement-based approach for certifying neural network robustness that combines the strengths of fast overapproximation methods with MILP solvers and LP relaxations.   
+• A novel heuristic for selecting neurons whose bounds should be further refined.   
+• A complete end-to-end implementation of our approach in a system called RefineZono, publicly available at https://github.com/eth-sri/eran.   
+• An evaluation, showing that RefineZono is more precise than existing state-of-the-art incomplete verifiers on larger networks and faster (while being complete) than complete verifiers on smaller networks.
+
+# 2 OVERVIEW
+
+We now demonstrate how our method improves the precision of a state-of-the-art incomplete verifier. The main objective here is to provide an intuitive understanding of our approach; full formal details are provided in the next section.
+
+Consider the simple fully connected feedforward neural network with ReLU activations shown in Fig. 1. There are two inputs to the network, both in the range $[ 0 , 1 ]$ . The network consists of an input layer, two hidden layers, and one output layer. Each layer consist of two neurons each. For our explanation, we separate each neuron into two parts: one represents the output of the affine transformation while the other captures the output of the ReLU activation. The weights for the affine transformation are represented by weights on the edges. The bias for each node is shown above or below it. Our goal is to verify that for any input in $[ 0 , 1 ] \times [ 0 , 1 ]$ , the output at neuron $x _ { 1 3 }$ is greater than the output at $x _ { 1 4 }$ .
+
+We now demonstrate how our verifier operates on this network. We assume that the analysis results after the second affine transformation are refined using a MILP formulation of the network whereas the results after the third affine transformation are refined by an LP formulation of the network. In the next section, we will explain our heuristic for selecting MILP or LP formulations of different neurons in the network. Our analysis leverages the Zonotope domain (Ghorbal et al., 2009) together with the abstract Zonotope transformers specialized to neural network activations as used in DeepZ (Singh et al., 2018), a state of the art verifier for neural network robustness. The Zonotope domain associates an affine form $\hat { x }$ with each neuron $x$ in the network:
+
+![](images/c7ab12426daaca803a962f4365b2e0e3c8f9d277b034f448b2cf1ce36e4a2ba9.jpg)  
+Figure 2: ReLU transformers, computing an affine form. Here, $l _ { x } , u _ { x }$ are the original bounds, whereas $l _ { x } ^ { \prime } , u _ { x } ^ { \prime }$ are the refined bounds. The slope of the two non-vertical parallel blue lines is $\lambda = u _ { x } / ( \bar { u } _ { x } - \bar { l } _ { x } )$ and the slope of the two non-vertical parallel green lines is $\lambda ^ { \prime } = u _ { x } ^ { \prime } / ( u _ { x } ^ { \prime } - l _ { x } ^ { \prime } )$ . The blue parallelogram is used to compute an affine form in DeepZ, whereas the green parallelogram is used to compute the output of the refined ReLU transformer considered in this work.
+
+$$
+\hat { x } : = c _ { 0 } + \sum _ { i = 1 } ^ { p } c _ { i } \cdot \eta _ { i }
+$$
+
+Here, $c _ { 0 } , c _ { i } \in \mathbb { R }$ are real coefficients and $\eta _ { i } \in \left[ s _ { i } , t _ { i } \right] \subseteq \left[ - 1 , 1 \right]$ are the noise symbols, which are shared between the affine forms for different neurons. This sharing makes the domain relational and thus more precise than non-relational domains such as Interval (Box). An abstract element in our analysis is an intersection between a Zonotope (given as a list of affine forms) and a bounding box. Thus, for each neuron $x$ , we keep the affine form $\hat { x }$ and an interval $[ l _ { x } , u _ { x } ]$ .
+
+First layer. Our analysis starts by setting
+
+$$
+\hat { x } _ { 1 } = 0 . 5 + 0 . 5 \cdot \eta _ { 1 } , l _ { 1 } = 0 , u _ { 1 } = 1
+$$
+
+and
+
+$$
+\begin{array} { r } { \hat { x } _ { 2 } = 0 . 5 + 0 . 5 \cdot \eta _ { 2 } , l _ { 2 } = 0 , u _ { 2 } = 1 , } \end{array}
+$$
+
+representing the input $[ 0 , 1 ]$ at $x _ { 1 }$ and [0, 1] at $x _ { 2 }$ in our domain, respectively. Next, an affine transformation is applied on the inputs resulting in the output
+
+$$
+\hat { x } _ { 3 } = \hat { x } _ { 1 } + \hat { x } _ { 2 } = 1 + 0 . 5 \cdot \eta _ { 1 } + 0 . 5 \cdot \eta _ { 2 } , l _ { 3 } = 0 , u _ { 3 } = 2
+$$
+
+and
+
+$$
+\hat { x } _ { 4 } = \hat { x } _ { 1 } - \hat { x } _ { 2 } = 0 . 5 \cdot \eta _ { 1 } - 0 . 5 \cdot \eta _ { 2 } , l _ { 4 } = - 1 , u _ { 4 } = 1 .
+$$
+
+Note that the Zonotope affine transformer is exact for this transformation. Next, the Zonotope ReLU transformer is applied. We note that as $l _ { 3 } \geq 0$ , the neuron $x _ { 3 }$ provably takes only non-negative values. Thus, the ReLU Zonotope transformer outputs ${ \hat { x } } _ { 5 } = { \hat { x } } _ { 3 }$ and we set $l _ { 5 } = l _ { 3 } , u _ { 5 } = l _ { 3 }$ which is the exact result. For $x _ { 4 }$ , $l _ { 4 } < 0$ and $u _ { 4 } > 0$ and thus neuron $x _ { 4 }$ can take both positive and negative values. The corresponding output does not have a closed affine form and hence the approximation in blue shown in Fig. 2 is used to compute the result. This approximation minimizes the area of the result in the input-output plane and introduces a new noise symbol $\eta _ { 3 } \in [ - 1 , 1 ]$ . The result is
+
+$$
+\hat { x } _ { 6 } = 0 . 2 5 + 0 . 2 5 \cdot \eta _ { 1 } - 0 . 2 5 \cdot \eta _ { 2 } + 0 . 2 5 \cdot \eta _ { 3 } , l _ { 6 } = - 0 . 5 , u _ { 6 } = 1 .
+$$
+
+Note that the Zonotope approximation for $x _ { 6 }$ from Fig. 2 permits negative values whereas $x _ { 6 }$ can only take non-negative values in the concrete. This overapproximation typically accumulates as the analysis progresses deeper into the network, resulting in overall imprecision and failure to prove properties that actually hold.
+
+MILP-based refinement at second layer. Next, the analysis handles the second affine transformation and computes
+
+$$
+\hat { x } _ { 7 } = \hat { x } _ { 5 } - \hat { x } _ { 6 } + 1 = 1 . 7 5 + 0 . 2 5 \cdot \eta _ { 1 } + 0 . 7 5 \cdot \eta _ { 2 } - 0 . 2 5 \cdot \eta _ { 3 } , l _ { 7 } = 0 . 5 , u _ { 7 } = 3
+$$
+
+and
+
+$$
+\hat { x } _ { 8 } = \hat { x } _ { 5 } - \hat { x } _ { 6 } - 1 = - 0 . 2 5 + 0 . 2 5 \cdot \eta _ { 1 } + 0 . 7 5 \cdot \eta _ { 2 } - 0 . 2 5 \cdot \eta _ { 3 } , l _ { 8 } = - 1 . 5 , u _ { 8 } = 1 .
+$$
+
+Here, $x _ { 7 }$ is provably positive, whereas $x _ { 8 }$ can take both positive and negative values. Due to the approximation for $x _ { 6 }$ , the bounds for $x _ { 7 }$ and $x _ { 8 }$ are imprecise. Note that the DeepZ ReLU transformer for $x _ { 8 }$ applied next will introduce more imprecision and although the ReLU transformer for provably positive inputs such as $x _ { 7 }$ does not lose precision with respect to the input, it still propagates the imprecision in the computation of the abstract values for $x _ { 7 }$ .
+
+Thus, to reduce precision loss, in our method we refine the bounds for both $x _ { 7 }$ and $x _ { 8 }$ by formulating the network up to (and including) the second affine transformation as a MILP instance based on a formulation from Tjeng et al. (2019) and compute bounds for $x _ { 7 }$ and $x _ { 8 }$ , respectively. The MILP solver improves the lower bounds for $x _ { 7 }$ and $x _ { 8 }$ to 1 and $- 1$ , respectively, which then updates the corresponding lower bounds in our abstraction, i.e., $l _ { 7 } = 1$ and $l _ { 8 } = - 1$ .
+
+Next, the ReLU transformer is applied. Since $x _ { 7 }$ is provably positive, we get $\hat { x } _ { 9 } = \hat { x } _ { 7 } , l _ { 9 } = l _ { 7 }$ , and $u _ { 9 } = u _ { 7 }$ . We note that $x _ { 8 }$ can take both positive and negative values and is therefore approximated. However, the ReLU transformer now uses the refined bounds instead of the original bounds and thus the approximation shown in green from Fig. 2 is used. This approximation has smaller area in the input-output plane compared to the blue one and thus reduces the approximation error. The result is
+
+$$
+\hat { x } _ { 1 0 } = 0 . 1 2 5 + 0 . 1 2 5 \cdot \eta _ { 1 } + 0 . 3 7 5 \cdot \eta _ { 2 } - 0 . 1 2 5 \cdot \eta _ { 3 } + 0 . 2 5 \cdot \eta _ { 4 } , l _ { 8 } = - 0 . 5 , u _ { 8 } = 1 .
+$$
+
+LP-based refinement at final layer. Continuing with the analysis, we now process the final affine transformation, which yields
+
+$$
+{ \hat { x } } _ { 1 1 } = 4 . 8 7 5 + 0 . 6 2 5 \cdot \eta _ { 1 } + 1 . 8 7 5 \cdot \eta _ { 2 } - 0 . 6 2 5 \cdot \eta _ { 3 } + 0 . 2 5 \cdot \eta _ { 4 } , l _ { 1 1 } = 1 . 7 5 , u _ { 1 1 } = 8 . 2 5
+$$
+
+and
+
+$$
+{ \hat { x } } _ { 1 2 } = 2 . 6 2 5 + 0 . 1 2 5 \cdot \eta _ { 1 } + 0 . 3 7 5 \cdot \eta _ { 2 } - 0 . 1 2 5 \cdot \eta _ { 3 } - 0 . 2 5 \cdot \eta _ { 4 } , l _ { 1 2 } = 1 . 7 5 , u _ { 1 2 } = 3 . 5 .
+$$
+
+Due to the approximations from previous layers, the computed values can be imprecise. We note that, as the analysis proceeds deeper into the network, refining bounds with MILP becomes expensive. Thus, we refine the bounds by encoding the network up to (and including) the third affine transformation using the faster LP relaxation of the network based on Ehlers (2017) and compute the bounds for $x _ { 1 1 }$ and $x _ { 1 2 }$ , respectively. This leads to better results for $l _ { 1 1 } = 3 . 2 5$ , $l _ { 1 2 } = 2$ , and $u _ { 1 2 } = 3$ . As both $x _ { 1 1 }$ and $x _ { 1 2 }$ are provably positive, the subsequent ReLU transformations set $\hat { x } _ { 1 3 } = \hat { x } _ { 1 1 } , l _ { 1 3 } = l _ { 1 1 } , u _ { 1 3 } = u _ { 1 1 }$ and $\hat { x } _ { 1 4 } = \hat { x } _ { 1 2 } , l _ { 1 4 } = l _ { 1 2 } , u _ { 1 4 } = u _ { 1 2 } .$ .
+
+Proving robustness. Since the lower bound $l _ { 1 3 }$ for $x _ { 1 3 }$ is greater than the upper bound $u _ { 1 4 }$ for $x _ { 1 4 }$ , our analysis can prove that the given neural network provides the same label for all inputs in $[ 0 , 1 ] \times [ 0 , 1 ]$ and is thus robust. In contrast, DeepZ without our refinement would compute
+
+$$
+{ \hat { x } } _ { 1 3 } = 4 . 9 5 + 0 . 6 \cdot \eta _ { 1 } + 1 . 8 \cdot \eta _ { 2 } - 0 . 6 \cdot \eta _ { 3 } + 0 . 3 \cdot \eta _ { 4 } , l _ { 1 3 } = 1 . 6 5 , u _ { 1 3 } = 8 . 2 5
+$$
+
+and
+
+$$
+\hat { x } _ { 1 4 } = 2 . 5 5 + 0 . 1 5 \cdot \eta _ { 1 } + 0 . 4 5 \cdot \eta _ { 2 } - 0 . 1 5 \cdot \eta _ { 3 } - 0 . 3 \cdot \eta _ { 4 } , l _ { 1 4 } = 1 . 5 , u _ { 1 4 } = 3 . 6 .
+$$
+
+As a result, DeepZ fails to prove that $x _ { 1 3 }$ is greater than $x _ { 1 4 }$ , and thus fails to prove robustness.
+
+Generalization to other abstractions. We note that our refinement-based approach is not restricted to the Zonotope domain. It can be extended for refining the results computed by other abstractions such as Polyhedra (Singh et al., 2017) or the abstraction used in DeepPoly (Singh et al., 2019). For example, the ReLU transformer in Singh et al. (2019) also depends on the bounds of input neurons and thus it will benefit from the precise bounds computed using our refinement. Since DeepPoly often produces more precise results than DeepZ, we believe a combination of this work with DeepPoly will further improve verification results.
+
+# 3 OUR APPROACH
+
+We now describe our approach in more formal terms. As in the previous section, we will consider affine transformations and ReLU activations as separate layers. As illustrated earlier, the key idea will be to combine abstract interpretation (Cousot & Cousot, 1977) with exact and inexact MILP formulations of the network, which are then solved, in order to compute more precise results for neuron bounds. We begin by describing the core ingredients of abstract interpretation.
+
+Our approach requires an abstract domain $\mathbb { A } _ { n }$ over $n$ variables (i.e., some set whose elements can be encoded symbolically) such as Interval, Zonotope, the abstraction in DeepPoly, or Polyhedra. An abstract domain has a bottom element $\perp \in \mathbb { A } _ { n }$ as well as the following components:
+
+• A (potentially non-computable) concretization function $\gamma _ { n } \colon \mathbb { A } _ { n } \to { \mathcal { P } } ( \mathbb { R } ^ { n } )$ that associates with each abstract element $a \in \mathbb { A } _ { n }$ the set of concrete points from $\mathbb { R } ^ { n }$ that it abstracts. We have $\gamma _ { n } ( \bot ) = \emptyset$ .   
+• An abstraction function $\alpha _ { n } \colon { \mathbb { B } } _ { n } \to { \mathbb { A } } _ { n }$ , where $\mathbb { X } \subseteq \gamma _ { n } ( \alpha _ { n } ( \mathbb { X } ) )$ for all $\mathbb { X } \in \mathbb { B } _ { n }$ . We assume that $\textstyle \alpha _ { n } ( \prod _ { i } [ l _ { i } , u _ { i } ] )$ is a computable function of $l , \pmb { u } \in \mathbb { R } ^ { n }$ . Here, $\begin{array} { r } { \mathbb { B } _ { n } = \bigcup _ { l , u \in \mathbb { R } ^ { n } } \prod _ { i } [ l _ { i } , u _ { i } ] } \end{array}$ and $\begin{array} { r } { \prod _ { i } [ l _ { i } , u _ { i } ] = \{ \pmb { x } \in \mathbb { R } ^ { n } \ | \ l _ { i } \leq x _ { i } \leq u _ { i } \} . } \end{array}$ . (For many abstract domains, $\alpha _ { n }$ can be defined on a larger domain $\mathbb { B } _ { n }$ , but in this work, we only consider Interval input regions.)   
+• A bounding box function $\iota _ { n } \colon \mathbb { A } _ { n } \to \mathbb { R } ^ { n } \times \mathbb { R } ^ { n }$ , where $\begin{array} { r } { \gamma _ { n } ( a ) \subseteq \prod _ { i } [ l _ { i } , u _ { i } ] } \end{array}$ for $( l , u ) = \iota _ { n } ( a )$ for all $a \in \mathbb { A } _ { n }$ .   
+• A meet operation $a \sqcap L$ for each $a \in \mathbb { A } _ { n }$ and linear constraints $L$ over $n$ real variables, where $\{ x ^ { \prime } \in \gamma _ { n } ( a ) \mid L ( x ) \} \subseteq \gamma _ { n } ( a \cap L )$ .   
+• An affine abstract transformer T #x7→Ax+b : Am → An for each transformation of the form $( { \pmb x } \mapsto { \pmb A } { \pmb x } + { \pmb b } ) \colon \mathbb { R } ^ { m } \to \mathbb { R } ^ { n }$ , where $\{ A x + b \mid x \in \gamma _ { n } ( a ) \} \subseteq \gamma _ { n } ( T _ { x \mapsto A x + b } ^ { \# } ( a ) )$
+
+for all $a \in \mathbb { A } _ { m }$
+
+• A ReLU abstract transformer $T _ { \mathrm { R e L U } | _ { \Pi _ { i } [ l _ { i } , u _ { i } ] } } ^ { \# } : \mathbb { A } _ { n } \to \mathbb { A } _ { n }$ , where
+
+$$
+\{ \mathrm { R e L U } ( { \pmb x } ) \mid { \pmb x } \in \gamma _ { n } ( a ) \cap \prod _ { i } [ l _ { i } , u _ { i } ] \} \subseteq T _ { \mathrm { R e L U } | _ { \prod _ { i } [ l _ { i } , u _ { i } ] } } ^ { \# } ( a )
+$$
+
+for all abstract elements $a \in \mathbb { A } _ { n }$ and for all lower and upper bounds $l , \pmb { u } \in \mathbb { R } ^ { n }$ on input activations of the ReLU operation.
+
+Verification via Abstract interpretation. As first shown by Gehr et al. (2018), any such abstract domain induces a method for robustness certification of neural networks with ReLU activations.
+
+For example, assume that we want to certify that a given neural network $f \colon  { \mathbb { R } } ^ { m } \to  { \mathbb { R } } ^ { n }$ considers class $i$ more likely than class $j$ for all inputs $\bar { \mathbf { x } }$ with $| | \bar { \pmb x } - \pmb x | | _ { \infty } \le \epsilon$ for a given $_ { \textbf { \em x } }$ and $\epsilon$ . We can first use the abstraction function $\alpha _ { m }$ to compute a symbolic overapproximation of the set of possible inputs $\bar { \mathbf { x } }$ , namely
+
+$$
+a _ { \mathrm { i n } } = \alpha _ { m } ( \{ \bar { \pmb { x } } \in \mathbb { R } ^ { m } \ | \ | \bar { \pmb { x } } - \pmb { x } | | _ { \infty } \leq \epsilon \} ) .
+$$
+
+Given that the neural network can be written as a composition of affine functions and ReLU layers, we can then propagate the abstract element $a _ { \mathrm { i n } } ^ { }$ through the corresponding abstract transformers to obtain a symbolic overapproximation $a _ { \mathrm { o u t } }$ of the concrete outputs of the neural network.
+
+For example, if the neural network $f ( \boldsymbol { x } ) = A ^ { \prime } \cdot \mathrm { R e L U } ( A \boldsymbol { x } + \boldsymbol { b } ) + b ^ { \prime }$ has a single hidden layer with $h$ hidden neurons, we first compute T #x7→Ax+b(ain), which is a symbolic overapproximation of the input to the ReLU activation function. We then compute $( l , u ) = \iota _ { h } ( a ^ { \prime } )$ to obtain opposite corners of a bounding box of all possible ReLU input activations, such that we can apply the ReLU abstract transformer:
+
+$$
+a ^ { \prime \prime } = T _ { \mathrm { R e L U } | } ^ { \# } { } _ { \Pi _ { i } \lbrack l _ { i } , u _ { i } \rbrack } ( a ^ { \prime } ) .
+$$
+
+Finally, we apply the affine abstract transformer again to obtain T #x7→A0x+b0 (a00). Using our assumptions, we can conclude that the set $\gamma _ { n } ( a _ { \mathrm { o u t } } )$ contains all output activations that $f$ can possibly produce when given any of the inputs $\bar { \mathbf { x } }$ . Therefore, if $a _ { \mathrm { o u t } } \sqcap ( x _ { i } \leq x _ { j } ) = \bot$ , we have proved the property: for all $\bar { \mathbf { x } }$ , the neural network considers class $i$ more likely than class $j$ .
+
+Incompleteness. While this approach is sound (i.e., whenever we prove the property, it actually holds), it is incomplete (i.e., we might not prove the property, even if it holds), because the abstract transformers produce a superset of the set of concrete outputs that the corresponding concrete executions produce. This can be quite imprecise for deep neural networks, because the overapproximations introduced in each layer accumulate.
+
+Refining the bounds. To combat spurious overapproximation, we use mixed integer linear programming (MILP) to compute refined lower and upper bounds $\mathbf { \Phi } _ { l ^ { \prime } , \mathbf { \Lambda } \mathbf { u } ^ { \prime } }$ after applying each affine abstract transformer (except for the first layer). We then refine the abstract element using the meet operator of the underlying abstract domain and the linear constraints $l _ { i } ^ { \prime } \le x _ { i } \le u _ { i } ^ { \prime }$ for all input activations $i$ , i.e., we replace the current abstract element $a$ by $a ^ { \prime } = a \sqcap ( \bigwedge _ { i } l _ { i } ^ { \prime } \leq x _ { i } \leq u _ { i } ^ { \prime } )$ , and continue analysis with the refined abstract element.
+
+Importantly, we obtain a more refined abstract transformer for ReLU than the one used in DeepZ by leveraging the new lower and upper bounds. That is, using the tighter bounds $l _ { x } ^ { \prime } , u _ { x } ^ { \prime }$ for $x$ , we define the ReLU transformer for $y : = \operatorname* { m a x } ( 0 , x )$ as follows:
+
+$$
+\begin{array} { r } { \hat { y } = \left\{ \begin{array} { l l } { \hat { x } , } & { \mathrm { i f ~ } l _ { x } ^ { \prime } > 0 , } \\ { 0 , } & { \mathrm { i f ~ } u _ { x } ^ { \prime } \leq 0 , } \\ { \lambda \cdot \hat { x } + \mu + \mu \cdot \epsilon _ { \mathrm { n e w } } , } & { \mathrm { o t h e r w i s e } . } \end{array} \right. } \end{array}
+$$
+
+Here $\begin{array} { r } { \lambda = \frac { u _ { x } ^ { \prime } } { u _ { x } ^ { \prime } - l _ { x } ^ { \prime } } } \end{array}$ x− l 0x , µ = − u0x·l0x2·(u0x−l0x) , and new ∈ [−1, 1] is a new noise symbol.
+
+The refined ReLU transformer benefits from the improved bounds. For example, when $l _ { x } < 0$ and $u _ { x } > 0$ holds for the original bounds then after refinement:
+
+• If $l _ { x } ^ { \prime } > 0$ , then the output is the same as the input and no overapproximation is added. • Else if $u _ { x } ^ { \prime } \leq 0$ , then the output is exact. • Otherwise, as shown in Fig. 2, the approximation with the tighter $l _ { x } ^ { \prime }$ and $u _ { x } ^ { \prime }$ has smaller area in the input-output plane than the original transformer that uses the imprecise $l _ { x }$ and $u _ { x }$ .
+
+Obtaining constraints for refinement. To enable refinement with MILP, we need to obtain constraints which fully capture the behavior of the neural network up to the last layer whose abstract transformer has been executed. In our encoding, we have one variable for each neuron and we write $x _ { i } ^ { ( k ) }$ to denote the variable corresponding to the activation of the $i$ -th neuron in the $k$ -th layer, where the input layer has $k = 0$ . Similarly, we write $l _ { i } ^ { ( k ) }$ ) and u(k)i to denote the best derived lower and upper bounds for this neuron.
+
+From the input layer, we obtain constraints of the form $l _ { i } ^ { 0 } \ \leq \ x _ { i } ^ { ( 0 ) } \ \leq \ u _ { i } ^ { 0 }$ , from affine layers, we obtain constraints of the form $\begin{array} { r } { x _ { i } ^ { ( k ) } = \sum _ { j } a _ { i j } ^ { ( k - 1 ) } x _ { j } ^ { ( k - 1 ) } + \bar { b } _ { i } ^ { ( k - 1 ) } } \end{array}$ and from ReLU layers we obtain constraints of the form $x _ { i } ^ { ( k ) } = \operatorname* { m a x } ( 0 , x _ { i } ^ { ( k - 1 ) } )$
+
+MILP. Let $\varphi ^ { ( k ) }$ denote the conjunction of all constraints up to and including those from layer $k$ . To obtain the best possible lower and upper bounds for layer $k$ with $p$ neurons, we need to solve the following $2 \cdot p$ optimization problems:
+
+$$
+\begin{array} { l } { { l _ { i } ^ { \prime ( k ) } = \displaystyle \operatorname* { m i n } _ { x _ { 1 } ^ { ( 0 ) } , \ldots , x _ { p } ^ { ( k ) } } x _ { i } ^ { ( k ) } , \mathrm { f o r } i = 1 , \ldots , p , } } \\ { { \mathrm { s . t . } \varphi ^ { ( k ) } ( x _ { 1 } ^ { ( 0 ) } , \ldots , x _ { p } ^ { ( k ) } ) } } \\ { { u _ { i } ^ { \prime ( k ) } = \displaystyle \operatorname* { m a x } _ { x _ { 1 } ^ { ( 0 ) } , \ldots , x _ { p } ^ { ( k ) } } x _ { i } ^ { ( k ) } , \mathrm { f o r } i = 1 , \ldots , p . } } \\ { { \mathrm { s . t . } \varphi ^ { ( k ) } ( x _ { 1 } ^ { ( 0 ) } , \ldots , x _ { p } ^ { ( k ) } ) } } \end{array}
+$$
+
+As was shown by Tjeng et al. (2019), such optimization problems can be encoded exactly as MILP instances using the bounds computed by abstract interpretation and the instances can then be solved using off-the-shelf MILP solvers to comput e l0(k) and $u _ { i } ^ { \prime ( k ) }$ .
+
+LP relaxation. While not introducing any approximation, unfortunately, current MILP solvers do not scale to larger neural networks. It becomes increasingly more expensive to refine bounds with the MILP-based formulation as the analysis proceeds deeper into the network. However, for soundness it is not crucial that the produced bounds are the best possible: for example, plain abstract interpretation uses sound bounds produced by the bounding box function $\iota$ instead. Therefore, for deeper layers in the network, we explore the trade-off between precision and scalability by also considering an intermediate method, which is faster than exact MILP, but also more precise than abstract interpretation. We relax the constraints in $\varphi ^ { ( k ) }$ using the bounds computed by abstract interpretation in the same way as Ehlers (2017) to obtain a set of weaker linear constraints $\varphi _ { \mathrm { L P } } ^ { ( k ) }$ . We then use the solver to solve the relaxed optimization problems that are constrained by $\varphi _ { \mathrm { L P } } ^ { ( k ) }$ instead of $\varphi ^ { ( k ) }$ , producing possibly looser bounds $\smash { l ^ { \prime } ( k ) }$ and ${ \pmb u } ^ { \prime ( k ) }$ . Note that the encoding of subsequent layers depends on the bounds computed in previous layers, where tighter bounds reduce the amount of newly introduced approximation.
+
+Anytime MILP relaxation. MILP solvers usually provide the option to provide an explicit timeout after which the solver must terminate. In return, the solver may not be able to solve the instance exactly, but it will instead provide lower and upper bounds on the objective function in a best-effort fashion. This provides another way to compute sound but inexact bounds $\smash { l ^ { \prime } ( k ) }$ and ${ \pmb u } ^ { \prime ( k ) }$ .
+
+In practice, we choose a fraction $\theta \in ( 0 , 1 ]$ of neurons in a given layer $k$ and compute bounds for them using MILP with a timeout $T$ in a first step. In the second step, for a fraction $\delta \in [ 0 , 1 - \theta ]$ of neurons in the layer, we set the timeout to $\beta \cdot { \overline { { T } } }$ , where $\overline { T }$ is the average time taken by the MILP solver to solve one of the instances from the first step and $\beta \in [ 0 , 1 ]$ is a parameter.
+
+Neuron selection heuristic. To select the $\theta$ -fraction of neurons for the first step of the anytime MILP relaxation for the $k$ -th layer, we rank the neurons. If the next layer is a ReLU layer, we first ignore all neurons whose activations can be proven to be non-positive using abstract interpretation (i.e., using the bounds produced by $\iota$ ), because in this case it is already known that ReLU will map the activation to 0. The remaining neurons are ordered in up to two different ways, once by width (i.e. neuron $i$ has key u(k)i − l(k)i ), and possibly once by the sum of absolute output weights. i.e., if the next layer is a fully connected layer ${ \pmb x } \mapsto { \pmb A } { \pmb x } + { \pmb b }$ , the key of neuron $i$ is $\textstyle \sum _ { j } | A _ { i , j } |$ . If the next layer is a ReLU layer, we skip the ReLU layer and use the weights from the fully connected layer that follows it (if any). The two ranks of a neuron in both orders are added, and the $\theta$ -fraction with smallest rank sum is selected and their bounds are refined with a timeout of $T$ whereas the next $\delta$ -fraction of neurons are refined with a timeout of $\beta \cdot { \overline { { T } } }$ .
+
+RefineZono: end-to-end approach. To certify robustness of deep neural networks, we combine MILP, LP relaxation, and abstract interpretation. We first pick numbers of layers $k _ { \mathrm { M I L P } } , k _ { \mathrm { L P } } , k _ { \mathrm { A I } }$ that sum to the total number of layers of the neural network. For the analysis of the first $k _ { \mathrm { M I L P } }$ layers, we refine bounds using anytime MILP relaxation with the neuron selection heuristic. As an optimization, we do not perform refinement after the abstract transformer for the first layer in case it is an affine transformation, as the abstract domain computes the tightest possible bounding box for an affine transformation of a box (this is always the case in our experiments). For the next $k _ { \mathrm { L P } }$ layers, we refine bounds using LP relaxation (i.e., the network up to the layer to be refined is encoded using linear constraints) combined with the neuron selection heuristic. For the remaining $k _ { \mathrm { A I } }$ layers, we use abstract interpretation without additional refinement (however, this also benefits from refinement that was performed in previous layers), and compute the bounds using $\iota$ .
+
+Final property certification. Let $k$ be the index of the last layer and $p$ be the number of output classes. We can encode the final certification problem using the output abstract element $a _ { \mathrm { o u t } }$ obtained after applying the abstract transformer for the last layer in the network. If we want to prove that class $i$ is assigned a higher probability than class $j$ , it suffices to show that $a _ { \mathrm { o u t } } \sqcap ( x _ { i } ^ { ( k ) } \leq x _ { j } ^ { ( k ) } ) = \bot$ . If this fails, one can resort to complete verification using MILP: the property is satisfied if and only if the set of constraints $\varphi ^ { ( k ) } ( x _ { 1 } ^ { ( 0 ) } , \dots , x _ { p } ^ { ( k ) } ) \wedge ( x _ { i } ^ { ( k ) } \leq x _ { j } ^ { ( k ) } )$ )) ∧ (x(k)i ≤ is unsatisfiable.
+
+Table 1: Neural network architectures used in our experiments.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>Type</td><td>#Neurons</td><td>#layers</td><td>Defense</td></tr><tr><td>MNIST</td><td>3×50</td><td>fully connected</td><td>160</td><td>3</td><td>None</td></tr><tr><td></td><td>5×100</td><td>fully connected</td><td>510</td><td>5</td><td>DiffAI</td></tr><tr><td></td><td>6×100</td><td>fully connected</td><td>610</td><td>6</td><td>None</td></tr><tr><td></td><td>9 ×100</td><td>fully connected</td><td>910</td><td>9</td><td>None</td></tr><tr><td></td><td>6 ×200</td><td>fully connected</td><td>1210</td><td>6</td><td>None</td></tr><tr><td></td><td>9 ×200</td><td>fully connected</td><td>1810</td><td>9</td><td>None</td></tr><tr><td></td><td>ConvSmall</td><td>convolutional</td><td>3 604</td><td>3</td><td>None</td></tr><tr><td></td><td>ConvBig</td><td>convolutional</td><td>34688</td><td>6</td><td>DiffAI</td></tr><tr><td></td><td>ConvSuper</td><td>convolutional</td><td>88 500</td><td>6</td><td>DiffAI</td></tr><tr><td>CIFAR10</td><td>6 ×100</td><td>fully connected</td><td>610</td><td>6</td><td>None</td></tr><tr><td></td><td>ConvSmall</td><td>convolutional</td><td>4852</td><td>3</td><td>DiffAI</td></tr><tr><td>ACAS Xu</td><td>6×50</td><td>fully connected</td><td>305</td><td>6</td><td>None</td></tr></table>
+
+# 4 EVALUATION
+
+We evaluate the effectiveness of our approach for the robustness verification of ReLU-based feedforward and convolutional neural networks. The results show that our approach enables faster complete verification than the state-of-the-art complete verifiers: Wang et al. (2018b) and Tjeng et al. (2019), and produces more precise results than state-of-the-art incomplete verifiers: DeepZ (Singh et al., 2018) and DeepPoly (Singh et al., 2019), when complete certification becomes infeasible.
+
+We implemented our approach in a system called RefineZono. RefineZono uses Gurobi (Gurobi Optimization, LLC, 2018) for solving MILP and LP instances and is built on top of the ELINA library (eli, 2018; Singh et al., 2017) for numerical abstract domains. All of our code, neural networks, and images used in our experiments are publicly available at https://github.com/eth-sri/eran.
+
+Evaluation datasets. We used the popular MNIST (Lecun et al., 1998), CIFAR10 (Krizhevsky, 2009), and ACAS $\mathrm { X u }$ (Julian et al., 2018) datasets in our experiments. MNIST contains grayscale images of size $2 8 \times 2 8$ pixels whereas CIFAR10 contains RGB images of size $3 2 \times 3 2$ . ACAS Xu contains 5 inputs representing aircraft sensor data.
+
+Neural networks. Table 1 shows 12 different MNIST, CIFAR10, and ACAS Xu feedforward (FNNs) and convolutional networks (CNNs) with ReLU activations used in our experiments. Out of these 4 were trained to be robust against adversarial attacks using DiffAI (Mirman et al., 2018) whereas the remaining 8 had no adversarial training. The largest network in our experiments contains $> 8 8 \mathrm { K }$ neurons whereas the deepest network contains 9 layers.
+
+Robustness properties. For MNIST and CIFAR10, we consider the $L _ { \infty }$ -norm (Carlini & Wagner, 2017) based adversarial region parameterized by $\epsilon \in \mathbb { R }$ . Our goal here is to certify that the network produces the correct label on all points in the adversarial region. For ACAS Xu, our goal is to verify that the property $\phi _ { 9 }$ (Katz et al., 2017) holds for the $6 \times 5 0$ network (known to be hard).
+
+Experimental setup. All experiments for the $3 \times 5 0$ MNIST FNN and all CNNs were carried out on a $2 . 6 \operatorname { G H z } 1 4$ core Intel Xeon CPU E5-2690 with 512 GB of main memory; the remaining FNNs were evaluated on a 3.3 GHz 10 Core Intel i9-7900X Skylake CPU with a main memory of $6 4 \mathrm { G B }$ .
+
+Benchmarks. For each MNIST and CIFAR10 network, we selected the first 100 images from the respective test set and filtered out those images that were not classified correctly. We consider complete certification with RefineZono on the ACAS Xu network and the $3 \times 5 0$ MNIST network. For the $3 \times 5 0$ network, we choose an $\epsilon$ for which the incomplete verifier DeepZ certified $< 4 0 \%$ of all candidate images. We consider incomplete certification for the remaining networks and choose an $\epsilon$ for which complete certification with RefineZono becomes infeasible.
+
+Table 2: Precision and runtime of RefineZono vs. DeepZ and DeepPoly.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>E</td><td colspan="2">DeepZ</td><td colspan="2">DeepPoly</td><td colspan="2">RefineZono</td></tr><tr><td></td><td></td><td></td><td>precision(%)</td><td>time(s)</td><td>precision(%)</td><td>time(s)</td><td>precision(%)</td><td>time(s)</td></tr><tr><td>MNIST</td><td>5×100</td><td>0.07</td><td>38</td><td>0.6</td><td>53</td><td>0.3</td><td>53</td><td>381</td></tr><tr><td></td><td>6×100</td><td>0.02</td><td>31</td><td>0.6</td><td>47</td><td>0.2</td><td>67</td><td>194</td></tr><tr><td></td><td>9×100</td><td>0.02</td><td>28</td><td>1.0</td><td>44</td><td>0.3</td><td>59</td><td>246</td></tr><tr><td></td><td>6×200</td><td>0.015</td><td>13</td><td>1.8</td><td>32</td><td>0.5</td><td>39</td><td>567</td></tr><tr><td></td><td>9×200</td><td>0.015</td><td>12</td><td>3.7</td><td>30</td><td>0.9</td><td>38</td><td>826</td></tr><tr><td></td><td>ConvSmall</td><td>0.12</td><td>7</td><td>1.4</td><td>13</td><td>6.0</td><td>21</td><td>748</td></tr><tr><td></td><td>ConvBig</td><td>0.2</td><td>79</td><td>7</td><td>78</td><td>61</td><td>80</td><td>193</td></tr><tr><td></td><td>ConvSuper</td><td>0.1</td><td>97</td><td>133</td><td>97</td><td>400</td><td>97</td><td>665</td></tr><tr><td>CIFAR10</td><td>6×100</td><td>0.0012</td><td>31</td><td>4.0</td><td>46</td><td>0.6</td><td>46</td><td>765</td></tr><tr><td></td><td>ConvSmall</td><td>0.03</td><td>17</td><td>5.8</td><td>21</td><td>20</td><td>21</td><td>550</td></tr></table>
+
+# 4.1 COMPLETE CERTIFICATION
+
+RefineZono first runs DeepZ analysis on the whole network collecting the bounds for all neurons in the network. If DeepZ fails to certify the network, then the collected bounds are used to encode the robustness certification as a MILP instance (discussed in section 3).
+
+ACAS Xu $6 \times 5 0$ network. As this network has only 5 inputs, we uniformly split the pre-condition defined by $\phi _ { 9 }$ to produce 6 300 smaller input regions. We certify that the post-condition defined by $\phi _ { 9 }$ holds for each region with RefineZono. RefineZono certifies that $\phi _ { 9 }$ holds for the network in 227 seconds which is $> 4 \mathbf { x }$ faster than the fastest verifier for ACAS Xu from Wang et al. (2018b).
+
+MNIST $3 \times 5 0$ network. We use $\epsilon = 0 . 0 3$ for the $L _ { \infty }$ -norm attack. We compare RefineZono against the state-of-the-art complete verifier for MNIST from Tjeng et al. (2019). This approach is also MILP-based like ours, but it uses Interval analysis and LP to determine neuron bounds. We implemented the Interval analysis and LP-based analysis to determine the initial bounds. We call the MILP solver only if LP analysis (or Interval analysis) fails to certify. All complete verifiers certify the neural network to be robust against $L _ { \infty }$ -norm perturbations on ${ \dot { 8 } } 5 \%$ of the images. The average runtime of RefineZono, MILP with bounds from the Interval analysis, and MILP with bounds from the LP analysis are 28, 123, and 35 seconds respectively. Based on our result, we believe that the Zonotope analysis offers a good middle ground between the speed of the Interval analysis and the precision of LP for bound computation, as it produces precise bounds faster than LP.
+
+# 4.2 INCOMPLETE CERTIFICATION
+
+We next compare RefineZono against DeepZ and DeepPoly for the incomplete robustness certification of the remaining networks. We note that DeepZ has the same precision as Fast-Lin (Weng et al., 2018) and DeepPoly has the same precision as CROWN (Zhang et al., 2018). The $\epsilon$ values used for the $L _ { \infty }$ -norm attack are shown in Table 2. The $\epsilon$ values for networks trained to be robust are larger than for networks that are not. For each verifier, we report the average runtime per image in seconds and the precision measured by the $\%$ of images for which the verifier certified the network to be robust. We note that running the Interval analysis to obtain initial bounds is too imprecise for these large networks with the $\epsilon$ values considered in our experiments. As a result, the approach from Tjeng et al. (2019) has to rely on applying LP per neuron to obtain precise bounds for the MILP solver which does not scale. For example, on the $9 \times 2 0 0$ network, determining bounds with LP already takes $> ~ 2 0$ minutes (without calling the MILP solver which is more expensive than LP) whereas RefineZono has an average running time of $\approx 1 4$ minutes.
+
+Parameter values. We experimented with different values of the analysis parameters $k _ { \mathrm { M I L P } } , k _ { \mathrm { L P } }$ , ${ { k } _ { \mathrm { A I } } } , \theta , \delta , \beta , T$ and chose values that offered the best tradeoff between performance and precision for the certification of each neural network. We refine the neuron bounds after all affine transformations that are followed by a ReLU except the first one. In a given layer, we consider all neurons that can take positive values after the affine transformation as refinement candidates.
+
+For the MNIST FNNs, we refine the bounds of the candidate neurons in layers 2-4 with MILP and those in the remaining layers using LP. For MILP based refinement, we use $\theta = \textstyle { \frac { \omega } { 5 ^ { k - 2 } \cdot p } }$ where $\omega$ is the number of candidates and $p$ is the total number of neurons in layer $k$ . For LP based refinement, we use θ = ω2k−5·p . We use timeout $T = 1$ second, $\beta = 0 . 5$ , and $\delta = { \frac { \omega } { p } } - \theta$ for both MILP and LP based refinements. For the CIFAR10 FNN, we use the same values except that we use θ = ω2k−2·p for MILP refinement and set $T = 6$ seconds for both MILP and LP based refinement as it is more expensive to refine neuron bounds in CIFAR10 networks due to these having more input neurons.
+
+For the CNNs, the convolutional layers have large number of candidates so we do not refine these. Instead, we refine all candidates in the fully connected layers with a larger timeout so to compensate for the more difficult problem instances for the solver. For the MNIST ConvSmall, ConvBig and CIFAR10 ConvSmall networks, we refine all the candidate neurons using MILP with $T = 1 0$ seconds. For the MNIST ConvSuper network, we refine similarly but use LP with $T = 1 5$ seconds.
+
+Results for incomplete certification. Table 2 shows the precision and the average runtime of all three verifiers. RefineZono either improves or achieves the precision of the state-of-the-art verifiers on all neural networks. It certifies more images than DeepZ on all networks except the MNIST ConvSuper network. This is because DeepZ is already very precise for the $\epsilon$ considered. We could not try larger $\epsilon$ for this network, as the DeepZ analysis becomes too expensive. RefineZono certifies the network to be more robust on more images than DeepPoly on 6 out of 10 networks.
+
+It can be seen that the number of neurons in the network is not the determining factor for the average runtime of RefineZono. We observe that RefineZono runs faster on the networks trained to be robust and the top three networks with the largest runtime for RefineZono are all networks not trained to be robust. This is because robust networks are relatively easier to certify and produce only a small number of candidate neurons for refinement, which are easier to refine by the solver. For example, even though the same parameter values are used for refining the results on the MNIST ConvSmall and ConvBig networks, the average runtime of RefineZono on the robustly trained ConvBig network with $\approx 3 5 \mathrm { K }$ neurons, 6 layers and a perturbation region defined using $\epsilon = 0 . 2$ is almost 4 times less than on the non-robust ConvSmall network with only 3 604 neurons, 3 layers and a smaller $\epsilon = 0 . 1 2$ .
+
+# 4.3 EFFECT OF NEURON SELECTION HEURISTIC
+
+We use the neuron selection heuristic from section 3 to determine neurons which need to be refined more than others for FNNs, as refining all neurons in a layer with MILP can significantly slow down the analysis. To check whether our heuristic can identify important neurons, we ran the analysis on the MNIST $9 \times 2 0 0$ FNN by keeping all analysis parameters the same, except instead of selecting the neurons with the smallest rank sum first we selected the neurons with the largest rank sum first (thus refining neurons more if our heuristic deems them unimportant). With this change, the average runtime does not change significantly. However, the modified analysis loses precision and fails to certify two images that the analysis refining with our neuron selection heuristic succeeds on.
+
+# 5 CONCLUSION
+
+We presented a novel refinement-based approach for effectively combining overapproximation techniques used by incomplete verifiers with linear-programming-based methods used in complete verifiers. We implemented our method in a system called RefineZono and showed its effectiveness on verification tasks involving feedforward and convolutional neural networks with ReLU activations.
+
+Our evaluation demonstrates that RefineZono can certify robustness properties beyond the reach of existing state-of-the-art complete verifiers (these can fail due to scalability issues) while simultaneously improving on the precision of existing incomplete verifiers (which can fail due to using too coarse of an overapproximation).
+
+Overall, we believe combining the strengths of overapproximation methods with those of mixed integer linear programming as done in this work is a promising direction for further advancing the state-of-the-art in neural network verification.
+
+# REFERENCES
+
+ELINA: ETH Library for Numerical Analysis, 2018. URL http://elina.ethz.ch.
+
+Filippo Amato, Alberto Lopez, Eladia Mar ´ ´ıa Pena-M ˜ endez, Petr Va ´ nhara, Ale ˇ s Hampl, and Josef ˇ Havel. Artificial neural networks in medical diagnosis. Journal of Applied Biomedicine, 11(2):47 – 58, 2013.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, Jake Zhao, and Karol Zieba. End to end learning for self-driving cars. CoRR, abs/1604.07316, 2016.
+
+Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. In Proc. IEEE Symposium on Security and Privacy (SP), pp. 39–57, 2017.
+
+Chih-Hong Cheng, Georg Nuhrenberg, and Harald Ruess. Maximum resilience of artificial neural ¨ networks. In Automated Technology for Verification and Analysis (ATVA), 2017.
+
+Patrick Cousot and Radhia Cousot. Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Proceedings of the 4th ACM symposium on Principles of programming languages (POPL), pp. 238–252, 1977.
+
+Souradeep Dutta, Susmit Jha, Sriram Sankaranarayanan, and Ashish Tiwari. Output range analysis for deep feedforward neural networks. In NASA Formal Methods (NFM), 2018.
+
+Krishnamurthy Dvijotham, Robert Stanforth, Sven Gowal, Timothy A. Mann, and Pushmeet Kohli. A dual approach to scalable verification of deep networks. CoRR, abs/1803.06567, 2018.
+
+Rudiger Ehlers. Formal verification of piece-wise linear feed-forward neural networks. In ¨ Automated Technology for Verification and Analysis (ATVA), 2017.
+
+Matteo Fischetti and Jason Jo. Deep neural networks and mixed integer linear optimization. Constraints, 23(3):296–309, 2018.
+
+T. Gehr, M. Mirman, D. Drachsler-Cohen, P. Tsankov, S. Chaudhuri, and M. Vechev. AI2: Safety and robustness certification of neural networks with abstract interpretation. In Proc. IEEE Symposium on Security and Privacy (SP), volume 00, pp. 948–963, 2018.
+
+Khalil Ghorbal, Eric Goubault, and Sylvie Putot. The zonotope abstract domain taylor1 $^ +$ . In Proc. Computer Aided Verification (CAV), pp. 627–633, 2009.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, abs/1706.07351, 2014.
+
+Gurobi Optimization, LLC. Gurobi optimizer reference manual, 2018. URL http://www. gurobi.com.
+
+G. Hinton, L. Deng, D. Yu, G. E. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+Xiaowei Huang, Marta Kwiatkowska, Sen Wang, and Min Wu. Safety verification of deep neural networks. In Computer Aided Verification (CAV), pp. 3–29, 2017.
+
+Kyle D. Julian, Mykel J. Kochenderfer, and Michael P. Owen. Deep neural network compression for aircraft collision avoidance systems. CoRR, abs/1810.04240, 2018.
+
+Guy Katz, Clark Barrett, David L. Dill, Kyle Julian, and Mykel J. Kochenderfer. Reluplex: An efficient SMT solver for verifying deep neural networks. In Computer Aided Verification (CAV), pp. 97–117, 2017.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Yann Lecun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. In Proc. of the IEEE, pp. 2278–2324, 1998.
+
+Alessio Lomuscio and Lalit Maganti. An approach to reachability analysis for feed-forward ReLU neural networks. CoRR, 2017.
+
+Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In Proc. International Conference on Machine Learning (ICML), pp. 3575–3583, 2018.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 10900–10910. 2018.
+
+Gagandeep Singh, Markus Puschel, and Martin Vechev. Fast polyhedra abstract domain. In ¨ Proc. Principles of Programming Languages (POPL), pp. 46–59, 2017.
+
+Gagandeep Singh, Timon Gehr, Matthew Mirman, Markus Puschel, and Martin Vechev. Fast and ¨ effective robustness certification. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 10825–10836. 2018.
+
+Gagandeep Singh, Timon Gehr, Markus Puschel, and Martin Vechev. An abstract domain for certify- ¨ ing neural networks. Proc. ACM Program. Lang., 3(POPL):41:1–41:30, 2019. ISSN 2475-1421.
+
+Vincent Tjeng, Kai Y. Xiao, and Russ Tedrake. Evaluating robustness of neural networks with mixed integer programming. In Proc. International Conference on Learning Representations (ICLR), 2019.
+
+Shiqi Wang, Kexin Pei, Justin Whitehouse, Junfeng Yang, and Suman Jana. Formal security analysis of neural networks using symbolic intervals. In USENIX Security Symposium (USENIX Security 18), pp. 1599–1614, 2018a.
+
+Shiqi Wang, Kexin Pei, Justin Whitehouse, Junfeng Yang, and Suman Jana. Efficient formal safety analysis of neural networks. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 6369–6379. 2018b.
+
+Lily Weng, Huan Zhang, Hongge Chen, Zhao Song, Cho-Jui Hsieh, Luca Daniel, Duane Boning, and Inderjit Dhillon. Towards fast computation of certified robustness for ReLU networks. In Proc. International Conference on Machine Learning (ICML), volume 80, pp. 5276–5285, 2018.
+
+Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In Proc. International Conference on Machine Learning (ICML), volume 80, pp. 5286–5295, 2018.
+
+Weiming Xiang, Hoang-Dung Tran, and Taylor T. Johnson. Output reachable set estimation and verification for multi-layer neural networks. CoRR, abs/1708.03322, 2017.
+
+Huan Zhang, Tsui-Wei Weng, Pin-Yu Chen, Cho-Jui Hsieh, and Luca Daniel. Efficient neural network robustness certification with general activation functions. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 4944–4953. 2018.

parse/train/HJgeEh09KQ/HJgeEh09KQ_content_list.json

@@ -0,0 +1,1673 @@
+[
+    {
+        "type": "text",
+        "text": "BOOSTING ROBUSTNESS CERTIFICATION OF NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            665,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gagandeep Singh, Timon Gehr, Markus Puschel, Martin Vechev ¨   \nDepartment of Computer Science   \nETH Zurich, Switzerland   \n{gsingh,timon.gehr,pueschel,martin.vechev}@inf.ethz.ch ",
+        "bbox": [
+            184,
+            170,
+            712,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a novel approach for the certification of neural networks against adversarial perturbations which combines scalable overapproximation methods with precise (mixed integer) linear programming. This results in significantly better precision than state-of-the-art verifiers on challenging feedforward and convolutional neural networks with piecewise linear activation functions. ",
+        "bbox": [
+            232,
+            294,
+            764,
+            363
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            390,
+            336,
+            406
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks are increasingly applied in critical domains such as autonomous driving (Bojarski et al., 2016), medical diagnosis (Amato et al., 2013), and speech recognition (Hinton et al., 2012). However, it has been shown by Goodfellow et al. (2014) that neural networks can be vulnerable against adversarial attacks, i.e., imperceptible input perturbations cause neural networks to misclassify. To address this challenge and prove that a network is free of adversarial examples (usually, in a region around a given input), recent work has started investigating the use of certification techniques. Current verifiers can be broadly classified as either complete or incomplete. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Complete verifiers are exact, i.e., if the verifier fails to certify a network then the network is nonrobust (and vice-versa). Existing complete verifiers are based on Mixed Integer Linear Programming (MILP) (Lomuscio & Maganti, 2017; Fischetti & Jo, 2018; Dutta et al., 2018; Cheng et al., 2017) or SMT solvers (Katz et al., 2017; Ehlers, 2017). Although precise, these can only handle networks with a small number of layers and neurons. To scale, incomplete verifiers usually employ overapproximation methods and hence they are sound but may fail to prove robustness even if it holds. Incomplete verifiers use methods such as duality (Dvijotham et al., 2018), abstract interpretation (Gehr et al., 2018; Singh et al., 2018; 2019), linear approximations (Weng et al., 2018; Wong & Kolter, 2018; Zhang et al., 2018), semidefinite relaxations (Raghunathan et al., 2018), combination of linear and non-linear approximation (Xiang et al., 2017), or search space discretization (Huang et al., 2017). Incomplete verifiers are more scalable than complete ones, but can suffer from precision loss for deeper networks. In principle, incomplete verifiers can be made asymptotically complete by iteratively refining the input space (Wang et al., 2018a) or the neurons (Wang et al., 2018b); however, in the worst case, this may eliminate any scalability gains and thus defeat the purpose of using overapproximation in the first place. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This work: boosting complete and incomplete verifiers. A key challenge then is to design a verifier which improves the precision of incomplete methods and the scalability of complete ones. In this work, we make a step towards addressing this challenge based on two key ideas: (i) a combination of state-of-the-art overapproximation techniques used by incomplete methods, including LP relaxations, together with MILP solvers, often employed in complete verifiers; (ii) a novel heuristic, which points to neurons whose approximated bounds should be refined. We implemented these ideas in a system called RefineZono, and showed that is is faster than state-of-the-art complete verifiers on small networks while improving precision of existing incomplete verifiers on larger networks. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The recent works of (Wang et al., 2018b) and Tjeng et al. (2019) have also explored the combination of linear programming with overapproximation. However, both use simpler and coarser overapproximations than ours. Our evaluation shows that RefineZono is faster than both for complete verification. For example, RefineZono is faster than the work of Tjeng et al. (2019) for the complete verification of a $3 \\times 5 0$ network, while for the larger $9 \\times 2 0 0$ network their method does not finish within multiple days on images which RefineZono verifies in $\\approx 1 4$ minutes. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a0491d129f7a4873853b23672643797418fbf229fbcf01751b183d9521de53e.jpg",
+        "image_caption": [
+            "Figure 1: Robustness analysis of a toy example neural network using our method. Here, approximation results computed with DeepZ (blue box) are refined using MILP whereas those in green are refined using LP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            816,
+            380
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            462,
+            823,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Main contributions. Our main contributions are: ",
+        "bbox": [
+            173,
+            506,
+            511,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• A refinement-based approach for certifying neural network robustness that combines the strengths of fast overapproximation methods with MILP solvers and LP relaxations.   \n• A novel heuristic for selecting neurons whose bounds should be further refined.   \n• A complete end-to-end implementation of our approach in a system called RefineZono, publicly available at https://github.com/eth-sri/eran.   \n• An evaluation, showing that RefineZono is more precise than existing state-of-the-art incomplete verifiers on larger networks and faster (while being complete) than complete verifiers on smaller networks. ",
+        "bbox": [
+            215,
+            534,
+            825,
+            661
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            681,
+            297,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We now demonstrate how our method improves the precision of a state-of-the-art incomplete verifier. The main objective here is to provide an intuitive understanding of our approach; full formal details are provided in the next section. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider the simple fully connected feedforward neural network with ReLU activations shown in Fig. 1. There are two inputs to the network, both in the range $[ 0 , 1 ]$ . The network consists of an input layer, two hidden layers, and one output layer. Each layer consist of two neurons each. For our explanation, we separate each neuron into two parts: one represents the output of the affine transformation while the other captures the output of the ReLU activation. The weights for the affine transformation are represented by weights on the edges. The bias for each node is shown above or below it. Our goal is to verify that for any input in $[ 0 , 1 ] \\times [ 0 , 1 ]$ , the output at neuron $x _ { 1 3 }$ is greater than the output at $x _ { 1 4 }$ . ",
+        "bbox": [
+            173,
+            762,
+            825,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We now demonstrate how our verifier operates on this network. We assume that the analysis results after the second affine transformation are refined using a MILP formulation of the network whereas the results after the third affine transformation are refined by an LP formulation of the network. In the next section, we will explain our heuristic for selecting MILP or LP formulations of different neurons in the network. Our analysis leverages the Zonotope domain (Ghorbal et al., 2009) together with the abstract Zonotope transformers specialized to neural network activations as used in DeepZ (Singh et al., 2018), a state of the art verifier for neural network robustness. The Zonotope domain associates an affine form $\\hat { x }$ with each neuron $x$ in the network: ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7ab12426daaca803a962f4365b2e0e3c8f9d277b034f448b2cf1ce36e4a2ba9.jpg",
+        "image_caption": [
+            "Figure 2: ReLU transformers, computing an affine form. Here, $l _ { x } , u _ { x }$ are the original bounds, whereas $l _ { x } ^ { \\prime } , u _ { x } ^ { \\prime }$ are the refined bounds. The slope of the two non-vertical parallel blue lines is $\\lambda = u _ { x } / ( \\bar { u } _ { x } - \\bar { l } _ { x } )$ and the slope of the two non-vertical parallel green lines is $\\lambda ^ { \\prime } = u _ { x } ^ { \\prime } / ( u _ { x } ^ { \\prime } - l _ { x } ^ { \\prime } )$ . The blue parallelogram is used to compute an affine form in DeepZ, whereas the green parallelogram is used to compute the output of the refined ReLU transformer considered in this work. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            102,
+            738,
+            267
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            373,
+            826,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb149edf1b1d4571f8a8227df4b1ead24a6bc52a2b4c058987fba3e03b0c678c.jpg",
+        "text": "$$\n\\hat { x } : = c _ { 0 } + \\sum _ { i = 1 } ^ { p } c _ { i } \\cdot \\eta _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            446,
+            568,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $c _ { 0 } , c _ { i } \\in \\mathbb { R }$ are real coefficients and $\\eta _ { i } \\in \\left[ s _ { i } , t _ { i } \\right] \\subseteq \\left[ - 1 , 1 \\right]$ are the noise symbols, which are shared between the affine forms for different neurons. This sharing makes the domain relational and thus more precise than non-relational domains such as Interval (Box). An abstract element in our analysis is an intersection between a Zonotope (given as a list of affine forms) and a bounding box. Thus, for each neuron $x$ , we keep the affine form $\\hat { x }$ and an interval $[ l _ { x } , u _ { x } ]$ . ",
+        "bbox": [
+            173,
+            493,
+            825,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "First layer. Our analysis starts by setting ",
+        "bbox": [
+            174,
+            579,
+            457,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2e4c609a563a138d9e5a7fe56313eb2dc14ff9139f954fbff12fe6bac7c70c23.jpg",
+        "text": "$$\n\\hat { x } _ { 1 } = 0 . 5 + 0 . 5 \\cdot \\eta _ { 1 } , l _ { 1 } = 0 , u _ { 1 } = 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            599,
+            617,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            622,
+            200,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4499e160e9b1679276184707d166bca8cf97e098b4e69eb28ca739b506d04e0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { x } _ { 2 } = 0 . 5 + 0 . 5 \\cdot \\eta _ { 2 } , l _ { 2 } = 0 , u _ { 2 } = 1 , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            636,
+            617,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "representing the input $[ 0 , 1 ]$ at $x _ { 1 }$ and [0, 1] at $x _ { 2 }$ in our domain, respectively. Next, an affine transformation is applied on the inputs resulting in the output ",
+        "bbox": [
+            173,
+            654,
+            823,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a5b3627850c7483c524014598df25313ee97b86edf082156869b1c84ee975e1.jpg",
+        "text": "$$\n\\hat { x } _ { 3 } = \\hat { x } _ { 1 } + \\hat { x } _ { 2 } = 1 + 0 . 5 \\cdot \\eta _ { 1 } + 0 . 5 \\cdot \\eta _ { 2 } , l _ { 3 } = 0 , u _ { 3 } = 2\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            689,
+            681,
+            705
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            712,
+            200,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7bfb3686c765d8773fd45b13f40778fde41cc8ae2aab953abda2eb7970fa1ff.jpg",
+        "text": "$$\n\\hat { x } _ { 4 } = \\hat { x } _ { 1 } - \\hat { x } _ { 2 } = 0 . 5 \\cdot \\eta _ { 1 } - 0 . 5 \\cdot \\eta _ { 2 } , l _ { 4 } = - 1 , u _ { 4 } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            723,
+            674,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that the Zonotope affine transformer is exact for this transformation. Next, the Zonotope ReLU transformer is applied. We note that as $l _ { 3 } \\geq 0$ , the neuron $x _ { 3 }$ provably takes only non-negative values. Thus, the ReLU Zonotope transformer outputs ${ \\hat { x } } _ { 5 } = { \\hat { x } } _ { 3 }$ and we set $l _ { 5 } = l _ { 3 } , u _ { 5 } = l _ { 3 }$ which is the exact result. For $x _ { 4 }$ , $l _ { 4 } < 0$ and $u _ { 4 } > 0$ and thus neuron $x _ { 4 }$ can take both positive and negative values. The corresponding output does not have a closed affine form and hence the approximation in blue shown in Fig. 2 is used to compute the result. This approximation minimizes the area of the result in the input-output plane and introduces a new noise symbol $\\eta _ { 3 } \\in [ - 1 , 1 ]$ . The result is ",
+        "bbox": [
+            173,
+            742,
+            826,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/411201585491c94c83c92a3deda5dd509a08b9ae2d0a3f07a3c738274e56b72e.jpg",
+        "text": "$$\n\\hat { x } _ { 6 } = 0 . 2 5 + 0 . 2 5 \\cdot \\eta _ { 1 } - 0 . 2 5 \\cdot \\eta _ { 2 } + 0 . 2 5 \\cdot \\eta _ { 3 } , l _ { 6 } = - 0 . 5 , u _ { 6 } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            845,
+            714,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that the Zonotope approximation for $x _ { 6 }$ from Fig. 2 permits negative values whereas $x _ { 6 }$ can only take non-negative values in the concrete. This overapproximation typically accumulates as the analysis progresses deeper into the network, resulting in overall imprecision and failure to prove properties that actually hold. ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MILP-based refinement at second layer. Next, the analysis handles the second affine transformation and computes ",
+        "bbox": [
+            168,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de7ca21e912cd4fdfb88449560df5f89c93a172ac18350e79b21c2f3d991c916.jpg",
+        "text": "$$\n\\hat { x } _ { 7 } = \\hat { x } _ { 5 } - \\hat { x } _ { 6 } + 1 = 1 . 7 5 + 0 . 2 5 \\cdot \\eta _ { 1 } + 0 . 7 5 \\cdot \\eta _ { 2 } - 0 . 2 5 \\cdot \\eta _ { 3 } , l _ { 7 } = 0 . 5 , u _ { 7 } = 3\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            140,
+            759,
+            156
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            164,
+            200,
+            178
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab512405f427729e9ef6226936b844aa1da9ea3c1002377c55c704c5271606be.jpg",
+        "text": "$$\n\\hat { x } _ { 8 } = \\hat { x } _ { 5 } - \\hat { x } _ { 6 } - 1 = - 0 . 2 5 + 0 . 2 5 \\cdot \\eta _ { 1 } + 0 . 7 5 \\cdot \\eta _ { 2 } - 0 . 2 5 \\cdot \\eta _ { 3 } , l _ { 8 } = - 1 . 5 , u _ { 8 } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            185,
+            772,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $x _ { 7 }$ is provably positive, whereas $x _ { 8 }$ can take both positive and negative values. Due to the approximation for $x _ { 6 }$ , the bounds for $x _ { 7 }$ and $x _ { 8 }$ are imprecise. Note that the DeepZ ReLU transformer for $x _ { 8 }$ applied next will introduce more imprecision and although the ReLU transformer for provably positive inputs such as $x _ { 7 }$ does not lose precision with respect to the input, it still propagates the imprecision in the computation of the abstract values for $x _ { 7 }$ . ",
+        "bbox": [
+            173,
+            208,
+            825,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus, to reduce precision loss, in our method we refine the bounds for both $x _ { 7 }$ and $x _ { 8 }$ by formulating the network up to (and including) the second affine transformation as a MILP instance based on a formulation from Tjeng et al. (2019) and compute bounds for $x _ { 7 }$ and $x _ { 8 }$ , respectively. The MILP solver improves the lower bounds for $x _ { 7 }$ and $x _ { 8 }$ to 1 and $- 1$ , respectively, which then updates the corresponding lower bounds in our abstraction, i.e., $l _ { 7 } = 1$ and $l _ { 8 } = - 1$ . ",
+        "bbox": [
+            173,
+            285,
+            825,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, the ReLU transformer is applied. Since $x _ { 7 }$ is provably positive, we get $\\hat { x } _ { 9 } = \\hat { x } _ { 7 } , l _ { 9 } = l _ { 7 }$ , and $u _ { 9 } = u _ { 7 }$ . We note that $x _ { 8 }$ can take both positive and negative values and is therefore approximated. However, the ReLU transformer now uses the refined bounds instead of the original bounds and thus the approximation shown in green from Fig. 2 is used. This approximation has smaller area in the input-output plane compared to the blue one and thus reduces the approximation error. The result is ",
+        "bbox": [
+            173,
+            361,
+            825,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/419ea58adec70b77376e120b3318ade63ceb4aadfe60d5f25116bc174be1604c.jpg",
+        "text": "$$\n\\hat { x } _ { 1 0 } = 0 . 1 2 5 + 0 . 1 2 5 \\cdot \\eta _ { 1 } + 0 . 3 7 5 \\cdot \\eta _ { 2 } - 0 . 1 2 5 \\cdot \\eta _ { 3 } + 0 . 2 5 \\cdot \\eta _ { 4 } , l _ { 8 } = - 0 . 5 , u _ { 8 } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            439,
+            772,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "LP-based refinement at final layer. Continuing with the analysis, we now process the final affine transformation, which yields ",
+        "bbox": [
+            173,
+            469,
+            825,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95c7f263957e23ba1430210c00266deb685c78ac8c74d35066a9c48a076dbee7.jpg",
+        "text": "$$\n{ \\hat { x } } _ { 1 1 } = 4 . 8 7 5 + 0 . 6 2 5 \\cdot \\eta _ { 1 } + 1 . 8 7 5 \\cdot \\eta _ { 2 } - 0 . 6 2 5 \\cdot \\eta _ { 3 } + 0 . 2 5 \\cdot \\eta _ { 4 } , l _ { 1 1 } = 1 . 7 5 , u _ { 1 1 } = 8 . 2 5\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            507,
+            785,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            531,
+            200,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5dd5eaa4eef42060385d310b699fcd597982bb0af56803fc58db38c967cf371c.jpg",
+        "text": "$$\n{ \\hat { x } } _ { 1 2 } = 2 . 6 2 5 + 0 . 1 2 5 \\cdot \\eta _ { 1 } + 0 . 3 7 5 \\cdot \\eta _ { 2 } - 0 . 1 2 5 \\cdot \\eta _ { 3 } - 0 . 2 5 \\cdot \\eta _ { 4 } , l _ { 1 2 } = 1 . 7 5 , u _ { 1 2 } = 3 . 5 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            553,
+            784,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Due to the approximations from previous layers, the computed values can be imprecise. We note that, as the analysis proceeds deeper into the network, refining bounds with MILP becomes expensive. Thus, we refine the bounds by encoding the network up to (and including) the third affine transformation using the faster LP relaxation of the network based on Ehlers (2017) and compute the bounds for $x _ { 1 1 }$ and $x _ { 1 2 }$ , respectively. This leads to better results for $l _ { 1 1 } = 3 . 2 5$ , $l _ { 1 2 } = 2$ , and $u _ { 1 2 } = 3$ . As both $x _ { 1 1 }$ and $x _ { 1 2 }$ are provably positive, the subsequent ReLU transformations set $\\hat { x } _ { 1 3 } = \\hat { x } _ { 1 1 } , l _ { 1 3 } = l _ { 1 1 } , u _ { 1 3 } = u _ { 1 1 }$ and $\\hat { x } _ { 1 4 } = \\hat { x } _ { 1 2 } , l _ { 1 4 } = l _ { 1 2 } , u _ { 1 4 } = u _ { 1 2 } .$ . ",
+        "bbox": [
+            173,
+            575,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proving robustness. Since the lower bound $l _ { 1 3 }$ for $x _ { 1 3 }$ is greater than the upper bound $u _ { 1 4 }$ for $x _ { 1 4 }$ , our analysis can prove that the given neural network provides the same label for all inputs in $[ 0 , 1 ] \\times [ 0 , 1 ]$ and is thus robust. In contrast, DeepZ without our refinement would compute ",
+        "bbox": [
+            173,
+            689,
+            825,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/605b4de206c5c745298bf942e5a8d949d209ce64b9488237ead48151accd3c47.jpg",
+        "text": "$$\n{ \\hat { x } } _ { 1 3 } = 4 . 9 5 + 0 . 6 \\cdot \\eta _ { 1 } + 1 . 8 \\cdot \\eta _ { 2 } - 0 . 6 \\cdot \\eta _ { 3 } + 0 . 3 \\cdot \\eta _ { 4 } , l _ { 1 3 } = 1 . 6 5 , u _ { 1 3 } = 8 . 2 5\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            739,
+            753,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            763,
+            200,
+            776
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb5d1c62f868a94b9f263b8b0626a8500516d4c7fb58bd2ce47cb0f25ee87180.jpg",
+        "text": "$$\n\\hat { x } _ { 1 4 } = 2 . 5 5 + 0 . 1 5 \\cdot \\eta _ { 1 } + 0 . 4 5 \\cdot \\eta _ { 2 } - 0 . 1 5 \\cdot \\eta _ { 3 } - 0 . 3 \\cdot \\eta _ { 4 } , l _ { 1 4 } = 1 . 5 , u _ { 1 4 } = 3 . 6 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            776,
+            758,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As a result, DeepZ fails to prove that $x _ { 1 3 }$ is greater than $x _ { 1 4 }$ , and thus fails to prove robustness. ",
+        "bbox": [
+            173,
+            796,
+            794,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generalization to other abstractions. We note that our refinement-based approach is not restricted to the Zonotope domain. It can be extended for refining the results computed by other abstractions such as Polyhedra (Singh et al., 2017) or the abstraction used in DeepPoly (Singh et al., 2019). For example, the ReLU transformer in Singh et al. (2019) also depends on the bounds of input neurons and thus it will benefit from the precise bounds computed using our refinement. Since DeepPoly often produces more precise results than DeepZ, we believe a combination of this work with DeepPoly will further improve verification results. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 OUR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            341,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now describe our approach in more formal terms. As in the previous section, we will consider affine transformations and ReLU activations as separate layers. As illustrated earlier, the key idea will be to combine abstract interpretation (Cousot & Cousot, 1977) with exact and inexact MILP formulations of the network, which are then solved, in order to compute more precise results for neuron bounds. We begin by describing the core ingredients of abstract interpretation. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our approach requires an abstract domain $\\mathbb { A } _ { n }$ over $n$ variables (i.e., some set whose elements can be encoded symbolically) such as Interval, Zonotope, the abstraction in DeepPoly, or Polyhedra. An abstract domain has a bottom element $\\perp \\in \\mathbb { A } _ { n }$ as well as the following components: ",
+        "bbox": [
+            176,
+            209,
+            825,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• A (potentially non-computable) concretization function $\\gamma _ { n } \\colon \\mathbb { A } _ { n } \\to { \\mathcal { P } } ( \\mathbb { R } ^ { n } )$ that associates with each abstract element $a \\in \\mathbb { A } _ { n }$ the set of concrete points from $\\mathbb { R } ^ { n }$ that it abstracts. We have $\\gamma _ { n } ( \\bot ) = \\emptyset$ .   \n• An abstraction function $\\alpha _ { n } \\colon { \\mathbb { B } } _ { n } \\to { \\mathbb { A } } _ { n }$ , where $\\mathbb { X } \\subseteq \\gamma _ { n } ( \\alpha _ { n } ( \\mathbb { X } ) )$ for all $\\mathbb { X } \\in \\mathbb { B } _ { n }$ . We assume that $\\textstyle \\alpha _ { n } ( \\prod _ { i } [ l _ { i } , u _ { i } ] )$ is a computable function of $l , \\pmb { u } \\in \\mathbb { R } ^ { n }$ . Here, $\\begin{array} { r } { \\mathbb { B } _ { n } = \\bigcup _ { l , u \\in \\mathbb { R } ^ { n } } \\prod _ { i } [ l _ { i } , u _ { i } ] } \\end{array}$ and $\\begin{array} { r } { \\prod _ { i } [ l _ { i } , u _ { i } ] = \\{ \\pmb { x } \\in \\mathbb { R } ^ { n } \\ | \\ l _ { i } \\leq x _ { i } \\leq u _ { i } \\} . } \\end{array}$ . (For many abstract domains, $\\alpha _ { n }$ can be defined on a larger domain $\\mathbb { B } _ { n }$ , but in this work, we only consider Interval input regions.)   \n• A bounding box function $\\iota _ { n } \\colon \\mathbb { A } _ { n } \\to \\mathbb { R } ^ { n } \\times \\mathbb { R } ^ { n }$ , where $\\begin{array} { r } { \\gamma _ { n } ( a ) \\subseteq \\prod _ { i } [ l _ { i } , u _ { i } ] } \\end{array}$ for $( l , u ) = \\iota _ { n } ( a )$ for all $a \\in \\mathbb { A } _ { n }$ .   \n• A meet operation $a \\sqcap L$ for each $a \\in \\mathbb { A } _ { n }$ and linear constraints $L$ over $n$ real variables, where $\\{ x ^ { \\prime } \\in \\gamma _ { n } ( a ) \\mid L ( x ) \\} \\subseteq \\gamma _ { n } ( a \\cap L )$ .   \n• An affine abstract transformer T #x7→Ax+b : Am → An for each transformation of the form $( { \\pmb x } \\mapsto { \\pmb A } { \\pmb x } + { \\pmb b } ) \\colon \\mathbb { R } ^ { m } \\to \\mathbb { R } ^ { n }$ , where $\\{ A x + b \\mid x \\in \\gamma _ { n } ( a ) \\} \\subseteq \\gamma _ { n } ( T _ { x \\mapsto A x + b } ^ { \\# } ( a ) )$ ",
+        "bbox": [
+            215,
+            261,
+            825,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for all $a \\in \\mathbb { A } _ { m }$ ",
+        "bbox": [
+            230,
+            488,
+            334,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• A ReLU abstract transformer $T _ { \\mathrm { R e L U } | _ { \\Pi _ { i } [ l _ { i } , u _ { i } ] } } ^ { \\# } : \\mathbb { A } _ { n } \\to \\mathbb { A } _ { n }$ , where ",
+        "bbox": [
+            217,
+            505,
+            643,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d5ae1d1ceb928320593017184979c96e4d90764b9bdb43c83dae84ea1fae07e.jpg",
+        "text": "$$\n\\{ \\mathrm { R e L U } ( { \\pmb x } ) \\mid { \\pmb x } \\in \\gamma _ { n } ( a ) \\cap \\prod _ { i } [ l _ { i } , u _ { i } ] \\} \\subseteq T _ { \\mathrm { R e L U } | _ { \\prod _ { i } [ l _ { i } , u _ { i } ] } } ^ { \\# } ( a )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            530,
+            717,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for all abstract elements $a \\in \\mathbb { A } _ { n }$ and for all lower and upper bounds $l , \\pmb { u } \\in \\mathbb { R } ^ { n }$ on input activations of the ReLU operation. ",
+        "bbox": [
+            232,
+            563,
+            823,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Verification via Abstract interpretation. As first shown by Gehr et al. (2018), any such abstract domain induces a method for robustness certification of neural networks with ReLU activations. ",
+        "bbox": [
+            171,
+            606,
+            823,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For example, assume that we want to certify that a given neural network $f \\colon  { \\mathbb { R } } ^ { m } \\to  { \\mathbb { R } } ^ { n }$ considers class $i$ more likely than class $j$ for all inputs $\\bar { \\mathbf { x } }$ with $| | \\bar { \\pmb x } - \\pmb x | | _ { \\infty } \\le \\epsilon$ for a given $_ { \\textbf { \\em x } }$ and $\\epsilon$ . We can first use the abstraction function $\\alpha _ { m }$ to compute a symbolic overapproximation of the set of possible inputs $\\bar { \\mathbf { x } }$ , namely ",
+        "bbox": [
+            173,
+            641,
+            825,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/455cd6f3beda4cf7229014e34b7104f83b1ecdcc6a8e6b242ecb3320cea89b38.jpg",
+        "text": "$$\na _ { \\mathrm { i n } } = \\alpha _ { m } ( \\{ \\bar { \\pmb { x } } \\in \\mathbb { R } ^ { m } \\ | \\ | \\bar { \\pmb { x } } - \\pmb { x } | | _ { \\infty } \\leq \\epsilon \\} ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            695,
+            633,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given that the neural network can be written as a composition of affine functions and ReLU layers, we can then propagate the abstract element $a _ { \\mathrm { i n } } ^ { }$ through the corresponding abstract transformers to obtain a symbolic overapproximation $a _ { \\mathrm { o u t } }$ of the concrete outputs of the neural network. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For example, if the neural network $f ( \\boldsymbol { x } ) = A ^ { \\prime } \\cdot \\mathrm { R e L U } ( A \\boldsymbol { x } + \\boldsymbol { b } ) + b ^ { \\prime }$ has a single hidden layer with $h$ hidden neurons, we first compute T #x7→Ax+b(ain), which is a symbolic overapproximation of the input to the ReLU activation function. We then compute $( l , u ) = \\iota _ { h } ( a ^ { \\prime } )$ to obtain opposite corners of a bounding box of all possible ReLU input activations, such that we can apply the ReLU abstract transformer: ",
+        "bbox": [
+            173,
+            767,
+            825,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98502c4ba8a3a877e178cd369eccfab89b17977e80120db35cf25321f41c4efa.jpg",
+        "text": "$$\na ^ { \\prime \\prime } = T _ { \\mathrm { R e L U } | } ^ { \\# } { } _ { \\Pi _ { i } \\lbrack l _ { i } , u _ { i } \\rbrack } ( a ^ { \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            838,
+            578,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, we apply the affine abstract transformer again to obtain T #x7→A0x+b0 (a00). Using our assumptions, we can conclude that the set $\\gamma _ { n } ( a _ { \\mathrm { o u t } } )$ contains all output activations that $f$ can possibly produce when given any of the inputs $\\bar { \\mathbf { x } }$ . Therefore, if $a _ { \\mathrm { o u t } } \\sqcap ( x _ { i } \\leq x _ { j } ) = \\bot$ , we have proved the property: for all $\\bar { \\mathbf { x } }$ , the neural network considers class $i$ more likely than class $j$ . ",
+        "bbox": [
+            174,
+            866,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Incompleteness. While this approach is sound (i.e., whenever we prove the property, it actually holds), it is incomplete (i.e., we might not prove the property, even if it holds), because the abstract transformers produce a superset of the set of concrete outputs that the corresponding concrete executions produce. This can be quite imprecise for deep neural networks, because the overapproximations introduced in each layer accumulate. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Refining the bounds. To combat spurious overapproximation, we use mixed integer linear programming (MILP) to compute refined lower and upper bounds $\\mathbf { \\Phi } _ { l ^ { \\prime } , \\mathbf { \\Lambda } \\mathbf { u } ^ { \\prime } }$ after applying each affine abstract transformer (except for the first layer). We then refine the abstract element using the meet operator of the underlying abstract domain and the linear constraints $l _ { i } ^ { \\prime } \\le x _ { i } \\le u _ { i } ^ { \\prime }$ for all input activations $i$ , i.e., we replace the current abstract element $a$ by $a ^ { \\prime } = a \\sqcap ( \\bigwedge _ { i } l _ { i } ^ { \\prime } \\leq x _ { i } \\leq u _ { i } ^ { \\prime } )$ , and continue analysis with the refined abstract element. ",
+        "bbox": [
+            173,
+            188,
+            825,
+            272
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Importantly, we obtain a more refined abstract transformer for ReLU than the one used in DeepZ by leveraging the new lower and upper bounds. That is, using the tighter bounds $l _ { x } ^ { \\prime } , u _ { x } ^ { \\prime }$ for $x$ , we define the ReLU transformer for $y : = \\operatorname* { m a x } ( 0 , x )$ as follows: ",
+        "bbox": [
+            174,
+            279,
+            825,
+            321
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7da363694cafff36b6e0432f339ef435524e66d1a7748619d31cfc0a80e4783.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { y } = \\left\\{ \\begin{array} { l l } { \\hat { x } , } & { \\mathrm { i f ~ } l _ { x } ^ { \\prime } > 0 , } \\\\ { 0 , } & { \\mathrm { i f ~ } u _ { x } ^ { \\prime } \\leq 0 , } \\\\ { \\lambda \\cdot \\hat { x } + \\mu + \\mu \\cdot \\epsilon _ { \\mathrm { n e w } } , } & { \\mathrm { o t h e r w i s e } . } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            338,
+            630,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here $\\begin{array} { r } { \\lambda = \\frac { u _ { x } ^ { \\prime } } { u _ { x } ^ { \\prime } - l _ { x } ^ { \\prime } } } \\end{array}$ x− l 0x , µ = − u0x·l0x2·(u0x−l0x) , and \u000fnew ∈ [−1, 1] is a new noise symbol. ",
+        "bbox": [
+            176,
+            393,
+            676,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The refined ReLU transformer benefits from the improved bounds. For example, when $l _ { x } < 0$ and $u _ { x } > 0$ holds for the original bounds then after refinement: ",
+        "bbox": [
+            176,
+            421,
+            825,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• If $l _ { x } ^ { \\prime } > 0$ , then the output is the same as the input and no overapproximation is added. • Else if $u _ { x } ^ { \\prime } \\leq 0$ , then the output is exact. • Otherwise, as shown in Fig. 2, the approximation with the tighter $l _ { x } ^ { \\prime }$ and $u _ { x } ^ { \\prime }$ has smaller area in the input-output plane than the original transformer that uses the imprecise $l _ { x }$ and $u _ { x }$ . ",
+        "bbox": [
+            215,
+            462,
+            825,
+            529
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Obtaining constraints for refinement. To enable refinement with MILP, we need to obtain constraints which fully capture the behavior of the neural network up to the last layer whose abstract transformer has been executed. In our encoding, we have one variable for each neuron and we write $x _ { i } ^ { ( k ) }$ to denote the variable corresponding to the activation of the $i$ -th neuron in the $k$ -th layer, where the input layer has $k = 0$ . Similarly, we write $l _ { i } ^ { ( k ) }$ ) and u(k)i to denote the best derived lower and upper bounds for this neuron. ",
+        "bbox": [
+            173,
+            541,
+            825,
+            635
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "From the input layer, we obtain constraints of the form $l _ { i } ^ { 0 } \\ \\leq \\ x _ { i } ^ { ( 0 ) } \\ \\leq \\ u _ { i } ^ { 0 }$ , from affine layers, we obtain constraints of the form $\\begin{array} { r } { x _ { i } ^ { ( k ) } = \\sum _ { j } a _ { i j } ^ { ( k - 1 ) } x _ { j } ^ { ( k - 1 ) } + \\bar { b } _ { i } ^ { ( k - 1 ) } } \\end{array}$ and from ReLU layers we obtain constraints of the form $x _ { i } ^ { ( k ) } = \\operatorname* { m a x } ( 0 , x _ { i } ^ { ( k - 1 ) } )$ ",
+        "bbox": [
+            173,
+            640,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MILP. Let $\\varphi ^ { ( k ) }$ denote the conjunction of all constraints up to and including those from layer $k$ . To obtain the best possible lower and upper bounds for layer $k$ with $p$ neurons, we need to solve the following $2 \\cdot p$ optimization problems: ",
+        "bbox": [
+            173,
+            712,
+            823,
+            755
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d53f7950c88b3cc5d47a03fcab0123653b81944357585c78ae6b212f440914db.jpg",
+        "text": "$$\n\\begin{array} { l } { { l _ { i } ^ { \\prime ( k ) } = \\displaystyle \\operatorname* { m i n } _ { x _ { 1 } ^ { ( 0 ) } , \\ldots , x _ { p } ^ { ( k ) } } x _ { i } ^ { ( k ) } , \\mathrm { f o r } i = 1 , \\ldots , p , } } \\\\ { { \\mathrm { s . t . } \\varphi ^ { ( k ) } ( x _ { 1 } ^ { ( 0 ) } , \\ldots , x _ { p } ^ { ( k ) } ) } } \\\\ { { u _ { i } ^ { \\prime ( k ) } = \\displaystyle \\operatorname* { m a x } _ { x _ { 1 } ^ { ( 0 ) } , \\ldots , x _ { p } ^ { ( k ) } } x _ { i } ^ { ( k ) } , \\mathrm { f o r } i = 1 , \\ldots , p . } } \\\\ { { \\mathrm { s . t . } \\varphi ^ { ( k ) } ( x _ { 1 } ^ { ( 0 ) } , \\ldots , x _ { p } ^ { ( k ) } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            758,
+            660,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As was shown by Tjeng et al. (2019), such optimization problems can be encoded exactly as MILP instances using the bounds computed by abstract interpretation and the instances can then be solved using off-the-shelf MILP solvers to comput e l0(k) and $u _ { i } ^ { \\prime ( k ) }$ . ",
+        "bbox": [
+            173,
+            877,
+            825,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "LP relaxation. While not introducing any approximation, unfortunately, current MILP solvers do not scale to larger neural networks. It becomes increasingly more expensive to refine bounds with the MILP-based formulation as the analysis proceeds deeper into the network. However, for soundness it is not crucial that the produced bounds are the best possible: for example, plain abstract interpretation uses sound bounds produced by the bounding box function $\\iota$ instead. Therefore, for deeper layers in the network, we explore the trade-off between precision and scalability by also considering an intermediate method, which is faster than exact MILP, but also more precise than abstract interpretation. We relax the constraints in $\\varphi ^ { ( k ) }$ using the bounds computed by abstract interpretation in the same way as Ehlers (2017) to obtain a set of weaker linear constraints $\\varphi _ { \\mathrm { L P } } ^ { ( k ) }$ . We then use the solver to solve the relaxed optimization problems that are constrained by $\\varphi _ { \\mathrm { L P } } ^ { ( k ) }$ instead of $\\varphi ^ { ( k ) }$ , producing possibly looser bounds $\\smash { l ^ { \\prime } ( k ) }$ and ${ \\pmb u } ^ { \\prime ( k ) }$ . Note that the encoding of subsequent layers depends on the bounds computed in previous layers, where tighter bounds reduce the amount of newly introduced approximation. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Anytime MILP relaxation. MILP solvers usually provide the option to provide an explicit timeout after which the solver must terminate. In return, the solver may not be able to solve the instance exactly, but it will instead provide lower and upper bounds on the objective function in a best-effort fashion. This provides another way to compute sound but inexact bounds $\\smash { l ^ { \\prime } ( k ) }$ and ${ \\pmb u } ^ { \\prime ( k ) }$ . ",
+        "bbox": [
+            174,
+            320,
+            825,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In practice, we choose a fraction $\\theta \\in ( 0 , 1 ]$ of neurons in a given layer $k$ and compute bounds for them using MILP with a timeout $T$ in a first step. In the second step, for a fraction $\\delta \\in [ 0 , 1 - \\theta ]$ of neurons in the layer, we set the timeout to $\\beta \\cdot { \\overline { { T } } }$ , where $\\overline { T }$ is the average time taken by the MILP solver to solve one of the instances from the first step and $\\beta \\in [ 0 , 1 ]$ is a parameter. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Neuron selection heuristic. To select the $\\theta$ -fraction of neurons for the first step of the anytime MILP relaxation for the $k$ -th layer, we rank the neurons. If the next layer is a ReLU layer, we first ignore all neurons whose activations can be proven to be non-positive using abstract interpretation (i.e., using the bounds produced by $\\iota$ ), because in this case it is already known that ReLU will map the activation to 0. The remaining neurons are ordered in up to two different ways, once by width (i.e. neuron $i$ has key u(k)i − l(k)i ), and possibly once by the sum of absolute output weights. i.e., if the next layer is a fully connected layer ${ \\pmb x } \\mapsto { \\pmb A } { \\pmb x } + { \\pmb b }$ , the key of neuron $i$ is $\\textstyle \\sum _ { j } | A _ { i , j } |$ . If the next layer is a ReLU layer, we skip the ReLU layer and use the weights from the fully connected layer that follows it (if any). The two ranks of a neuron in both orders are added, and the $\\theta$ -fraction with smallest rank sum is selected and their bounds are refined with a timeout of $T$ whereas the next $\\delta$ -fraction of neurons are refined with a timeout of $\\beta \\cdot { \\overline { { T } } }$ . ",
+        "bbox": [
+            174,
+            469,
+            825,
+            627
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RefineZono: end-to-end approach. To certify robustness of deep neural networks, we combine MILP, LP relaxation, and abstract interpretation. We first pick numbers of layers $k _ { \\mathrm { M I L P } } , k _ { \\mathrm { L P } } , k _ { \\mathrm { A I } }$ that sum to the total number of layers of the neural network. For the analysis of the first $k _ { \\mathrm { M I L P } }$ layers, we refine bounds using anytime MILP relaxation with the neuron selection heuristic. As an optimization, we do not perform refinement after the abstract transformer for the first layer in case it is an affine transformation, as the abstract domain computes the tightest possible bounding box for an affine transformation of a box (this is always the case in our experiments). For the next $k _ { \\mathrm { L P } }$ layers, we refine bounds using LP relaxation (i.e., the network up to the layer to be refined is encoded using linear constraints) combined with the neuron selection heuristic. For the remaining $k _ { \\mathrm { A I } }$ layers, we use abstract interpretation without additional refinement (however, this also benefits from refinement that was performed in previous layers), and compute the bounds using $\\iota$ . ",
+        "bbox": [
+            173,
+            654,
+            825,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Final property certification. Let $k$ be the index of the last layer and $p$ be the number of output classes. We can encode the final certification problem using the output abstract element $a _ { \\mathrm { o u t } }$ obtained after applying the abstract transformer for the last layer in the network. If we want to prove that class $i$ is assigned a higher probability than class $j$ , it suffices to show that $a _ { \\mathrm { o u t } } \\sqcap ( x _ { i } ^ { ( k ) } \\leq x _ { j } ^ { ( k ) } ) = \\bot$ . If this fails, one can resort to complete verification using MILP: the property is satisfied if and only if the set of constraints $\\varphi ^ { ( k ) } ( x _ { 1 } ^ { ( 0 ) } , \\dots , x _ { p } ^ { ( k ) } ) \\wedge ( x _ { i } ^ { ( k ) } \\leq x _ { j } ^ { ( k ) } )$ )) ∧ (x(k)i ≤ is unsatisfiable. ",
+        "bbox": [
+            173,
+            833,
+            825,
+            925
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e98c392227089bb527b72fb2cf0a794d6529ef90db65a95da031d2220026619c.jpg",
+        "table_caption": [
+            "Table 1: Neural network architectures used in our experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Model</td><td>Type</td><td>#Neurons</td><td>#layers</td><td>Defense</td></tr><tr><td>MNIST</td><td>3×50</td><td>fully connected</td><td>160</td><td>3</td><td>None</td></tr><tr><td></td><td>5×100</td><td>fully connected</td><td>510</td><td>5</td><td>DiffAI</td></tr><tr><td></td><td>6×100</td><td>fully connected</td><td>610</td><td>6</td><td>None</td></tr><tr><td></td><td>9 ×100</td><td>fully connected</td><td>910</td><td>9</td><td>None</td></tr><tr><td></td><td>6 ×200</td><td>fully connected</td><td>1210</td><td>6</td><td>None</td></tr><tr><td></td><td>9 ×200</td><td>fully connected</td><td>1810</td><td>9</td><td>None</td></tr><tr><td></td><td>ConvSmall</td><td>convolutional</td><td>3 604</td><td>3</td><td>None</td></tr><tr><td></td><td>ConvBig</td><td>convolutional</td><td>34688</td><td>6</td><td>DiffAI</td></tr><tr><td></td><td>ConvSuper</td><td>convolutional</td><td>88 500</td><td>6</td><td>DiffAI</td></tr><tr><td>CIFAR10</td><td>6 ×100</td><td>fully connected</td><td>610</td><td>6</td><td>None</td></tr><tr><td></td><td>ConvSmall</td><td>convolutional</td><td>4852</td><td>3</td><td>DiffAI</td></tr><tr><td>ACAS Xu</td><td>6×50</td><td>fully connected</td><td>305</td><td>6</td><td>None</td></tr></table>",
+        "bbox": [
+            253,
+            127,
+            741,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            315,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the effectiveness of our approach for the robustness verification of ReLU-based feedforward and convolutional neural networks. The results show that our approach enables faster complete verification than the state-of-the-art complete verifiers: Wang et al. (2018b) and Tjeng et al. (2019), and produces more precise results than state-of-the-art incomplete verifiers: DeepZ (Singh et al., 2018) and DeepPoly (Singh et al., 2019), when complete certification becomes infeasible. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We implemented our approach in a system called RefineZono. RefineZono uses Gurobi (Gurobi Optimization, LLC, 2018) for solving MILP and LP instances and is built on top of the ELINA library (eli, 2018; Singh et al., 2017) for numerical abstract domains. All of our code, neural networks, and images used in our experiments are publicly available at https://github.com/eth-sri/eran. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            540
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluation datasets. We used the popular MNIST (Lecun et al., 1998), CIFAR10 (Krizhevsky, 2009), and ACAS $\\mathrm { X u }$ (Julian et al., 2018) datasets in our experiments. MNIST contains grayscale images of size $2 8 \\times 2 8$ pixels whereas CIFAR10 contains RGB images of size $3 2 \\times 3 2$ . ACAS Xu contains 5 inputs representing aircraft sensor data. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            611
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Neural networks. Table 1 shows 12 different MNIST, CIFAR10, and ACAS Xu feedforward (FNNs) and convolutional networks (CNNs) with ReLU activations used in our experiments. Out of these 4 were trained to be robust against adversarial attacks using DiffAI (Mirman et al., 2018) whereas the remaining 8 had no adversarial training. The largest network in our experiments contains $> 8 8 \\mathrm { K }$ neurons whereas the deepest network contains 9 layers. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Robustness properties. For MNIST and CIFAR10, we consider the $L _ { \\infty }$ -norm (Carlini & Wagner, 2017) based adversarial region parameterized by $\\epsilon \\in \\mathbb { R }$ . Our goal here is to certify that the network produces the correct label on all points in the adversarial region. For ACAS Xu, our goal is to verify that the property $\\phi _ { 9 }$ (Katz et al., 2017) holds for the $6 \\times 5 0$ network (known to be hard). ",
+        "bbox": [
+            174,
+            710,
+            823,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup. All experiments for the $3 \\times 5 0$ MNIST FNN and all CNNs were carried out on a $2 . 6 \\operatorname { G H z } 1 4$ core Intel Xeon CPU E5-2690 with 512 GB of main memory; the remaining FNNs were evaluated on a 3.3 GHz 10 Core Intel i9-7900X Skylake CPU with a main memory of $6 4 \\mathrm { G B }$ . ",
+        "bbox": [
+            174,
+            782,
+            823,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Benchmarks. For each MNIST and CIFAR10 network, we selected the first 100 images from the respective test set and filtered out those images that were not classified correctly. We consider complete certification with RefineZono on the ACAS Xu network and the $3 \\times 5 0$ MNIST network. For the $3 \\times 5 0$ network, we choose an $\\epsilon$ for which the incomplete verifier DeepZ certified $< 4 0 \\%$ of all candidate images. We consider incomplete certification for the remaining networks and choose an $\\epsilon$ for which complete certification with RefineZono becomes infeasible. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/44be9f172be59b393c69b56cc38c73451bd336b4e9fa94e1f150d17f69205d75.jpg",
+        "table_caption": [
+            "Table 2: Precision and runtime of RefineZono vs. DeepZ and DeepPoly. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Model</td><td>E</td><td colspan=\"2\">DeepZ</td><td colspan=\"2\">DeepPoly</td><td colspan=\"2\">RefineZono</td></tr><tr><td></td><td></td><td></td><td>precision(%)</td><td>time(s)</td><td>precision(%)</td><td>time(s)</td><td>precision(%)</td><td>time(s)</td></tr><tr><td>MNIST</td><td>5×100</td><td>0.07</td><td>38</td><td>0.6</td><td>53</td><td>0.3</td><td>53</td><td>381</td></tr><tr><td></td><td>6×100</td><td>0.02</td><td>31</td><td>0.6</td><td>47</td><td>0.2</td><td>67</td><td>194</td></tr><tr><td></td><td>9×100</td><td>0.02</td><td>28</td><td>1.0</td><td>44</td><td>0.3</td><td>59</td><td>246</td></tr><tr><td></td><td>6×200</td><td>0.015</td><td>13</td><td>1.8</td><td>32</td><td>0.5</td><td>39</td><td>567</td></tr><tr><td></td><td>9×200</td><td>0.015</td><td>12</td><td>3.7</td><td>30</td><td>0.9</td><td>38</td><td>826</td></tr><tr><td></td><td>ConvSmall</td><td>0.12</td><td>7</td><td>1.4</td><td>13</td><td>6.0</td><td>21</td><td>748</td></tr><tr><td></td><td>ConvBig</td><td>0.2</td><td>79</td><td>7</td><td>78</td><td>61</td><td>80</td><td>193</td></tr><tr><td></td><td>ConvSuper</td><td>0.1</td><td>97</td><td>133</td><td>97</td><td>400</td><td>97</td><td>665</td></tr><tr><td>CIFAR10</td><td>6×100</td><td>0.0012</td><td>31</td><td>4.0</td><td>46</td><td>0.6</td><td>46</td><td>765</td></tr><tr><td></td><td>ConvSmall</td><td>0.03</td><td>17</td><td>5.8</td><td>21</td><td>20</td><td>21</td><td>550</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            826,
+            330
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMPLETE CERTIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            401,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "RefineZono first runs DeepZ analysis on the whole network collecting the bounds for all neurons in the network. If DeepZ fails to certify the network, then the collected bounds are used to encode the robustness certification as a MILP instance (discussed in section 3). ",
+        "bbox": [
+            174,
+            383,
+            823,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACAS Xu $6 \\times 5 0$ network. As this network has only 5 inputs, we uniformly split the pre-condition defined by $\\phi _ { 9 }$ to produce 6 300 smaller input regions. We certify that the post-condition defined by $\\phi _ { 9 }$ holds for each region with RefineZono. RefineZono certifies that $\\phi _ { 9 }$ holds for the network in 227 seconds which is $> 4 \\mathbf { x }$ faster than the fastest verifier for ACAS Xu from Wang et al. (2018b). ",
+        "bbox": [
+            174,
+            443,
+            823,
+            498
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MNIST $3 \\times 5 0$ network. We use $\\epsilon = 0 . 0 3$ for the $L _ { \\infty }$ -norm attack. We compare RefineZono against the state-of-the-art complete verifier for MNIST from Tjeng et al. (2019). This approach is also MILP-based like ours, but it uses Interval analysis and LP to determine neuron bounds. We implemented the Interval analysis and LP-based analysis to determine the initial bounds. We call the MILP solver only if LP analysis (or Interval analysis) fails to certify. All complete verifiers certify the neural network to be robust against $L _ { \\infty }$ -norm perturbations on ${ \\dot { 8 } } 5 \\%$ of the images. The average runtime of RefineZono, MILP with bounds from the Interval analysis, and MILP with bounds from the LP analysis are 28, 123, and 35 seconds respectively. Based on our result, we believe that the Zonotope analysis offers a good middle ground between the speed of the Interval analysis and the precision of LP for bound computation, as it produces precise bounds faster than LP. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 INCOMPLETE CERTIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            672,
+            415,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We next compare RefineZono against DeepZ and DeepPoly for the incomplete robustness certification of the remaining networks. We note that DeepZ has the same precision as Fast-Lin (Weng et al., 2018) and DeepPoly has the same precision as CROWN (Zhang et al., 2018). The $\\epsilon$ values used for the $L _ { \\infty }$ -norm attack are shown in Table 2. The $\\epsilon$ values for networks trained to be robust are larger than for networks that are not. For each verifier, we report the average runtime per image in seconds and the precision measured by the $\\%$ of images for which the verifier certified the network to be robust. We note that running the Interval analysis to obtain initial bounds is too imprecise for these large networks with the $\\epsilon$ values considered in our experiments. As a result, the approach from Tjeng et al. (2019) has to rely on applying LP per neuron to obtain precise bounds for the MILP solver which does not scale. For example, on the $9 \\times 2 0 0$ network, determining bounds with LP already takes $> ~ 2 0$ minutes (without calling the MILP solver which is more expensive than LP) whereas RefineZono has an average running time of $\\approx 1 4$ minutes. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Parameter values. We experimented with different values of the analysis parameters $k _ { \\mathrm { M I L P } } , k _ { \\mathrm { L P } }$ , ${ { k } _ { \\mathrm { A I } } } , \\theta , \\delta , \\beta , T$ and chose values that offered the best tradeoff between performance and precision for the certification of each neural network. We refine the neuron bounds after all affine transformations that are followed by a ReLU except the first one. In a given layer, we consider all neurons that can take positive values after the affine transformation as refinement candidates. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For the MNIST FNNs, we refine the bounds of the candidate neurons in layers 2-4 with MILP and those in the remaining layers using LP. For MILP based refinement, we use $\\theta = \\textstyle { \\frac { \\omega } { 5 ^ { k - 2 } \\cdot p } }$ where $\\omega$ is the number of candidates and $p$ is the total number of neurons in layer $k$ . For LP based refinement, we use θ = ω2k−5·p . We use timeout $T = 1$ second, $\\beta = 0 . 5$ , and $\\delta = { \\frac { \\omega } { p } } - \\theta$ for both MILP and LP based refinements. For the CIFAR10 FNN, we use the same values except that we use θ = ω2k−2·p for MILP refinement and set $T = 6$ seconds for both MILP and LP based refinement as it is more expensive to refine neuron bounds in CIFAR10 networks due to these having more input neurons. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            243
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For the CNNs, the convolutional layers have large number of candidates so we do not refine these. Instead, we refine all candidates in the fully connected layers with a larger timeout so to compensate for the more difficult problem instances for the solver. For the MNIST ConvSmall, ConvBig and CIFAR10 ConvSmall networks, we refine all the candidate neurons using MILP with $T = 1 0$ seconds. For the MNIST ConvSuper network, we refine similarly but use LP with $T = 1 5$ seconds. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Results for incomplete certification. Table 2 shows the precision and the average runtime of all three verifiers. RefineZono either improves or achieves the precision of the state-of-the-art verifiers on all neural networks. It certifies more images than DeepZ on all networks except the MNIST ConvSuper network. This is because DeepZ is already very precise for the $\\epsilon$ considered. We could not try larger $\\epsilon$ for this network, as the DeepZ analysis becomes too expensive. RefineZono certifies the network to be more robust on more images than DeepPoly on 6 out of 10 networks. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            419
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "It can be seen that the number of neurons in the network is not the determining factor for the average runtime of RefineZono. We observe that RefineZono runs faster on the networks trained to be robust and the top three networks with the largest runtime for RefineZono are all networks not trained to be robust. This is because robust networks are relatively easier to certify and produce only a small number of candidate neurons for refinement, which are easier to refine by the solver. For example, even though the same parameter values are used for refining the results on the MNIST ConvSmall and ConvBig networks, the average runtime of RefineZono on the robustly trained ConvBig network with $\\approx 3 5 \\mathrm { K }$ neurons, 6 layers and a perturbation region defined using $\\epsilon = 0 . 2$ is almost 4 times less than on the non-robust ConvSmall network with only 3 604 neurons, 3 layers and a smaller $\\epsilon = 0 . 1 2$ . ",
+        "bbox": [
+            174,
+            425,
+            825,
+            551
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT OF NEURON SELECTION HEURISTIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            513,
+            582
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We use the neuron selection heuristic from section 3 to determine neurons which need to be refined more than others for FNNs, as refining all neurons in a layer with MILP can significantly slow down the analysis. To check whether our heuristic can identify important neurons, we ran the analysis on the MNIST $9 \\times 2 0 0$ FNN by keeping all analysis parameters the same, except instead of selecting the neurons with the smallest rank sum first we selected the neurons with the largest rank sum first (thus refining neurons more if our heuristic deems them unimportant). With this change, the average runtime does not change significantly. However, the modified analysis loses precision and fails to certify two images that the analysis refining with our neuron selection heuristic succeeds on. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            724,
+            318,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented a novel refinement-based approach for effectively combining overapproximation techniques used by incomplete verifiers with linear-programming-based methods used in complete verifiers. We implemented our method in a system called RefineZono and showed its effectiveness on verification tasks involving feedforward and convolutional neural networks with ReLU activations. ",
+        "bbox": [
+            174,
+            756,
+            823,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our evaluation demonstrates that RefineZono can certify robustness properties beyond the reach of existing state-of-the-art complete verifiers (these can fail due to scalability issues) while simultaneously improving on the precision of existing incomplete verifiers (which can fail due to using too coarse of an overapproximation). ",
+        "bbox": [
+            174,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Overall, we believe combining the strengths of overapproximation methods with those of mixed integer linear programming as done in this work is a promising direction for further advancing the state-of-the-art in neural network verification. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ELINA: ETH Library for Numerical Analysis, 2018. URL http://elina.ethz.ch. ",
+        "bbox": [
+            171,
+            126,
+            761,
+            141
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Filippo Amato, Alberto Lopez, Eladia Mar ´ ´ıa Pena-M ˜ endez, Petr Va ´ nhara, Ale ˇ s Hampl, and Josef ˇ Havel. Artificial neural networks in medical diagnosis. Journal of Applied Biomedicine, 11(2):47 – 58, 2013. ",
+        "bbox": [
+            173,
+            150,
+            823,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, Jake Zhao, and Karol Zieba. End to end learning for self-driving cars. CoRR, abs/1604.07316, 2016. ",
+        "bbox": [
+            174,
+            203,
+            823,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. In Proc. IEEE Symposium on Security and Privacy (SP), pp. 39–57, 2017. ",
+        "bbox": [
+            176,
+            256,
+            823,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chih-Hong Cheng, Georg Nuhrenberg, and Harald Ruess. Maximum resilience of artificial neural ¨ networks. In Automated Technology for Verification and Analysis (ATVA), 2017. ",
+        "bbox": [
+            174,
+            295,
+            820,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patrick Cousot and Radhia Cousot. Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Proceedings of the 4th ACM symposium on Principles of programming languages (POPL), pp. 238–252, 1977. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            377
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Souradeep Dutta, Susmit Jha, Sriram Sankaranarayanan, and Ashish Tiwari. Output range analysis for deep feedforward neural networks. In NASA Formal Methods (NFM), 2018. ",
+        "bbox": [
+            174,
+            386,
+            823,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Krishnamurthy Dvijotham, Robert Stanforth, Sven Gowal, Timothy A. Mann, and Pushmeet Kohli. A dual approach to scalable verification of deep networks. CoRR, abs/1803.06567, 2018. ",
+        "bbox": [
+            176,
+            425,
+            821,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rudiger Ehlers. Formal verification of piece-wise linear feed-forward neural networks. In ¨ Automated Technology for Verification and Analysis (ATVA), 2017. ",
+        "bbox": [
+            171,
+            464,
+            821,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matteo Fischetti and Jason Jo. Deep neural networks and mixed integer linear optimization. Constraints, 23(3):296–309, 2018. ",
+        "bbox": [
+            171,
+            503,
+            823,
+            532
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "T. Gehr, M. Mirman, D. Drachsler-Cohen, P. Tsankov, S. Chaudhuri, and M. Vechev. AI2: Safety and robustness certification of neural networks with abstract interpretation. In Proc. IEEE Symposium on Security and Privacy (SP), volume 00, pp. 948–963, 2018. ",
+        "bbox": [
+            176,
+            541,
+            823,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Khalil Ghorbal, Eric Goubault, and Sylvie Putot. The zonotope abstract domain taylor1 $^ +$ . In Proc. Computer Aided Verification (CAV), pp. 627–633, 2009. ",
+        "bbox": [
+            174,
+            594,
+            820,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, abs/1706.07351, 2014. ",
+        "bbox": [
+            173,
+            633,
+            823,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gurobi Optimization, LLC. Gurobi optimizer reference manual, 2018. URL http://www. gurobi.com. ",
+        "bbox": [
+            173,
+            672,
+            821,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "G. Hinton, L. Deng, D. Yu, G. E. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            767
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaowei Huang, Marta Kwiatkowska, Sen Wang, and Min Wu. Safety verification of deep neural networks. In Computer Aided Verification (CAV), pp. 3–29, 2017. ",
+        "bbox": [
+            171,
+            777,
+            823,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyle D. Julian, Mykel J. Kochenderfer, and Michael P. Owen. Deep neural network compression for aircraft collision avoidance systems. CoRR, abs/1810.04240, 2018. ",
+        "bbox": [
+            171,
+            818,
+            825,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guy Katz, Clark Barrett, David L. Dill, Kyle Julian, and Mykel J. Kochenderfer. Reluplex: An efficient SMT solver for verifying deep neural networks. In Computer Aided Verification (CAV), pp. 97–117, 2017. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            898
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            171,
+            909,
+            803,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann Lecun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. In Proc. of the IEEE, pp. 2278–2324, 1998. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alessio Lomuscio and Lalit Maganti. An approach to reachability analysis for feed-forward ReLU neural networks. CoRR, 2017. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In Proc. International Conference on Machine Learning (ICML), pp. 3575–3583, 2018. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 10900–10910. 2018. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gagandeep Singh, Markus Puschel, and Martin Vechev. Fast polyhedra abstract domain. In ¨ Proc. Principles of Programming Languages (POPL), pp. 46–59, 2017. ",
+        "bbox": [
+            173,
+            281,
+            821,
+            311
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gagandeep Singh, Timon Gehr, Matthew Mirman, Markus Puschel, and Martin Vechev. Fast and ¨ effective robustness certification. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 10825–10836. 2018. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gagandeep Singh, Timon Gehr, Markus Puschel, and Martin Vechev. An abstract domain for certify- ¨ ing neural networks. Proc. ACM Program. Lang., 3(POPL):41:1–41:30, 2019. ISSN 2475-1421. ",
+        "bbox": [
+            174,
+            371,
+            821,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vincent Tjeng, Kai Y. Xiao, and Russ Tedrake. Evaluating robustness of neural networks with mixed integer programming. In Proc. International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shiqi Wang, Kexin Pei, Justin Whitehouse, Junfeng Yang, and Suman Jana. Formal security analysis of neural networks using symbolic intervals. In USENIX Security Symposium (USENIX Security 18), pp. 1599–1614, 2018a. ",
+        "bbox": [
+            173,
+            460,
+            823,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shiqi Wang, Kexin Pei, Justin Whitehouse, Junfeng Yang, and Suman Jana. Efficient formal safety analysis of neural networks. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 6369–6379. 2018b. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lily Weng, Huan Zhang, Hongge Chen, Zhao Song, Cho-Jui Hsieh, Luca Daniel, Duane Boning, and Inderjit Dhillon. Towards fast computation of certified robustness for ReLU networks. In Proc. International Conference on Machine Learning (ICML), volume 80, pp. 5276–5285, 2018. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In Proc. International Conference on Machine Learning (ICML), volume 80, pp. 5286–5295, 2018. ",
+        "bbox": [
+            173,
+            614,
+            823,
+            659
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weiming Xiang, Hoang-Dung Tran, and Taylor T. Johnson. Output reachable set estimation and verification for multi-layer neural networks. CoRR, abs/1708.03322, 2017. ",
+        "bbox": [
+            169,
+            666,
+            825,
+            695
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Huan Zhang, Tsui-Wei Weng, Pin-Yu Chen, Cho-Jui Hsieh, and Luca Daniel. Efficient neural network robustness certification with general activation functions. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 4944–4953. 2018. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            748
+        ],
+        "page_idx": 11
+    }
+]

parse/train/Hkg4TI9xl/Hkg4TI9xl.md

@@ -0,0 +1,246 @@
+# A BASELINE FOR DETECTING MISCLASSIFIED ANDOUT-OF-DISTRIBUTION EXAMPLESIN NEURAL NETWORKS
+
+Dan Hendrycks∗ University of California, Berkeley hendrycks@berkeley.edu
+
+Kevin Gimpel   
+Toyota Technological Institute at Chicago   
+kgimpel@ttic.edu
+
+# ABSTRACT
+
+We consider the two related problems of detecting if an example is misclassified or out-of-distribution. We present a simple baseline that utilizes probabilities from softmax distributions. Correctly classified examples tend to have greater maximum softmax probabilities than erroneously classified and out-of-distribution examples, allowing for their detection. We assess performance by defining several tasks in computer vision, natural language processing, and automatic speech recognition, showing the effectiveness of this baseline across all. We then show the baseline can sometimes be surpassed, demonstrating the room for future research on these underexplored detection tasks.
+
+# 1 INTRODUCTION
+
+When machine learning classifiers are employed in real-world tasks, they tend to fail when the training and test distributions differ. Worse, these classifiers often fail silently by providing highconfidence predictions while being woefully incorrect (Goodfellow et al., 2015; Amodei et al., 2016). Classifiers failing to indicate when they are likely mistaken can limit their adoption or cause serious accidents. For example, a medical diagnosis model may consistently classify with high confidence, even while it should flag difficult examples for human intervention. The resulting unflagged, erroneous diagnoses could blockade future machine learning technologies in medicine. More generally and importantly, estimating when a model is in error is of great concern to AI Safety (Amodei et al., 2016).
+
+These high-confidence predictions are frequently produced by softmaxes because softmax probabilities are computed with the fast-growing exponential function. Thus minor additions to the softmax inputs, i.e. the logits, can lead to substantial changes in the output distribution. Since the softmax function is a smooth approximation of an indicator function, it is uncommon to see a uniform distribution outputted for out-of-distribution examples. Indeed, random Gaussian noise fed into an MNIST image classifier gives a “prediction confidence” or predicted class probability of $91 \%$ , as we show later. Throughout our experiments we establish that the prediction probability from a softmax distribution has a poor direct correspondence to confidence. This is consistent with a great deal of anecdotal evidence from researchers (Nguyen & O’Connor, 2015; Yu et al., 2010; Provost et al., 1998; Nguyen et al., 2015).
+
+However, in this work we also show the prediction probability of incorrect and out-of-distribution examples tends to be lower than the prediction probability for correct examples. Therefore, capturing prediction probability statistics about correct or in-sample examples is often sufficient for detecting whether an example is in error or abnormal, even though the prediction probability viewed in isolation can be misleading.
+
+These prediction probabilities form our detection baseline, and we demonstrate its efficacy through various computer vision, natural language processing, and automatic speech recognition tasks. While these prediction probabilities create a consistently useful baseline, at times they are less effective, revealing room for improvement. To give ideas for future detection research, we contribute one method which outperforms the baseline on some (but not all) tasks. This new method evaluates the quality of a neural network’s input reconstruction to determine if an example is abnormal.
+
+In addition to the baseline methods, another contribution of this work is the designation of standard tasks and evaluation metrics for assessing the automatic detection of errors and out-of-distribution examples. We use a large number of well-studied tasks across three research areas, using standard neural network architectures that perform well on them. For out-of-distribution detection, we provide ways to supply the out-of-distribution examples at test time like using images from different datasets and realistically distorting inputs. We hope that other researchers will pursue these tasks in future work and surpass the performance of our baselines.
+
+In summary, while softmax classifier probabilities are not directly useful as confidence estimates, estimating model confidence is not as bleak as previously believed. Simple statistics derived from softmax distributions provide a surprisingly effective way to determine whether an example is misclassified or from a different distribution from the training data, as demonstrated by our experimental results spanning computer vision, natural language processing, and speech recognition tasks. This creates a strong baseline for detecting errors and out-of-distribution examples which we hope future research surpasses.
+
+# 2 PROBLEM FORMULATION AND EVALUATION
+
+In this paper, we are interested in two related problems. The first is error and success prediction: can we predict whether a trained classifier will make an error on a particular held-out test example; can we predict if it will correctly classify said example? The second is in- and out-of-distribution detection: can we predict whether a test example is from a different distribution from the training data; can we predict if it is from within the same distribution?1 Below we present a simple baseline for solving these two problems. To evaluate our solution, we use two evaluation metrics.
+
+Before mentioning the two evaluation metrics, we first note that comparing detectors is not as straightforward as using accuracy. For detection we have two classes, and the detector outputs a score for both the positive and negative class. If the negative class is far more likely than the positive class, a model may always guess the negative class and obtain high accuracy, which can be misleading (Provost et al., 1998). We must then specify a score threshold so that some positive examples are classified correctly, but this depends upon the trade-off between false negatives (fn) and false positives (fp).
+
+Faced with this issue, we employ the Area Under the Receiver Operating Characteristic curve (AUROC) metric, which is a threshold-independent performance evaluation (Davis & Goadrich, 2006). The ROC curve is a graph showing the true positive rate $( \mathrm { t p r = t p / ( t p + f n ) } )$ ) and the false positive rate $( \mathrm { f p r = f p / ( f p + t n ) } )$ against each other. Moreover, the AUROC can be interpreted as the probability that a positive example has a greater detector score/value than a negative example (Fawcett, 2005). Consequently, a random positive example detector corresponds to a $50 \%$ AUROC, and a “perfect” classifier corresponds to $100 \%$ .2
+
+The AUROC sidesteps the issue of threshold selection, as does the Area Under the Precision-Recall curve (AUPR) which is sometimes deemed more informative (Manning & Schutze ¨ , 1999). This is because the AUROC is not ideal when the positive class and negative class have greatly differing base rates, and the AUPR adjusts for these different positive and negative base rates. For this reason, the AUPR is our second evaluation metric. The PR curve plots the precision $( \mathrm { t p } / ( \mathrm { t p } + \mathrm { f p } ) )$ and recall $( \mathrm { t p } / ( \mathrm { t p } + \mathrm { f n } ) )$ ) against each other. The baseline detector has an AUPR approximately equal to the precision (Saito & Rehmsmeier, 2015), and a “perfect” classifier has an AUPR of $1 0 0 \%$ . Consequently, the base rate of the positive class greatly influences the AUPR, so for detection we must specify which class is positive. In view of this, we show the AUPRs when we treat success/normal classes as positive, and then we show the areas when we treat the error/abnormal classes as positive. We can treat the error/abnormal classes as positive by multiplying the scores by $- 1$ and labeling them positive. Note that treating error/abnormal classes as positive classes does not change the AU
+
+ROC since if $S$ is a score for a successfully classified value, and $E$ is the score for an erroneously classified value, $\mathrm { A U R O C } = P ( S > E ) = { \dot { P } } ( - E > - S )$ .
+
+We begin our experiments in Section 3 where we describe a simple baseline which uses the maximum probability from the softmax label distribution in neural network classifiers. Then in Section 4 we describe a method that uses an additional, auxiliary model component trained to reconstruct the input.
+
+# 3 SOFTMAX PREDICTION PROBABILITY AS A BASELINE
+
+In what follows we retrieve the maximum/predicted class probability from a softmax distribution and thereby detect whether an example is erroneously classified or out-of-distribution. Specifically, we separate correctly and incorrectly classified test set examples and, for each example, compute the softmax probability of the predicted class, i.e., the maximum softmax probability.3 From these two groups we obtain the area under PR and ROC curves. These areas summarize the performance of a binary classifier discriminating with values/scores (in this case, maximum probabilities from the softmaxes) across different thresholds. This description treats correctly classified examples as the positive class, denoted “Success” or “Succ” in our tables. In “Error” or “Err” we treat the the incorrectly classified examples as the positive class; to do this we label incorrectly classified examples as positive and take the negatives of the softmax probabilities of the predicted classes as the scores.
+
+For “In,” we treat the in-distribution, correctly classified test set examples as positive and use the softmax probability for the predicted class as a score, while for “Out” we treat the out-of-distribution examples as positive and use the negative of the aforementioned probability. Since the AUPRs for Success, Error, In, Out classifiers depend on the rate of positive examples, we list what area a random detector would achieve with “Base” values. Also in the upcoming results we list the mean predicted class probability of wrongly classified examples (Pred Prob Wrong (mean)) to demonstrate that the softmax prediction probability is a misleading confidence proxy when viewed in isolation. The “Pred. Prob (mean)” columns show this same shortcoming but for out-of-distribution examples.
+
+Table labels aside, we begin experimentation with datasets from vision then consider tasks in natural language processing and automatic speech recognition. In all of the following experiments, the AUROCs differ from the random baselines with high statistical significance according to the Wilcoxon rank-sum test.
+
+# 3.1 COMPUTER VISION
+
+In the following computer vision tasks, we use three datasets: MNIST, CIFAR-10, and CIFAR100 (Krizhevsky, 2009). MNIST is a dataset of handwritten digits, consisting of 60000 training and 10000 testing examples. Meanwhile, CIFAR-10 has colored images belonging to 10 different classes, with 50000 training and 10000 testing examples. CIFAR-100 is more difficult, as it has 100 different classes with 50000 training and 10000 testing examples.
+
+In Table 1, we see that correctly classified and incorrectly classified examples are sufficiently distinct and thus allow reliable discrimination. Note that the area under the curves degrade with image recognizer test error.
+
+Next, let us consider using softmax distributions to determine whether an example is in- or outof-distribution. We use all test set examples as the in-distribution (positive) examples. For out-ofdistribution (negative) examples, we use realistic images and noise. For CIFAR-10 and CIFAR-100, we use realistic images from the Scene UNderstanding dataset (SUN), which consists of 397 different scenes (Xiao et al., 2010). For MNIST, we use grayscale realistic images from three sources. Omniglot (Lake et al., 2015) images are handwritten characters rather than the handwritten digits in MNIST. Next, notMNIST (Bulatov, 2011) consists of typeface characters. Last of the realistic images, CIFAR-10bw are black and white rescaled CIFAR-10 images. The synthetic “Gaussian” data is random normal noise, and “Uniform” data is random uniform noise. Images are resized when necessary.
+
+Table 1: The softmax predicted class probability allows for discrimination between correctly and incorrectly classified test set examples. “Pred. Prob Wrong(mean)” is the mean softmax probability for wrongly classified examples, showcasing its shortcoming as a direct measure of confidence. Succ/Err Base values are the AUROCs or AUPRs achieved by random classifiers. All entries are percentages.   
+
+<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>MNIST</td><td>97/50</td><td>100/98</td><td>48/1.7</td><td>86</td><td>1.69</td></tr><tr><td>CIFAR-10</td><td>93/50</td><td>100/95</td><td>43/5</td><td>80</td><td>4.96</td></tr><tr><td>CIFAR-100</td><td>87/50</td><td>96/79</td><td>62/21</td><td>66</td><td>20.7</td></tr></table>
+
+Table 2: Distinguishing in- and out-of-distribution test set data for image classification. CIFAR10/All is the same as CIFAR-10/(SUN, Gaussian). All values are percentages.   
+
+<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In /Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>CIFAR-10/SUN</td><td>95/50</td><td>89/33</td><td>97/67</td><td>72</td></tr><tr><td>CIFAR-10/Gaussian</td><td>97/50</td><td>98/49</td><td>95/51</td><td>77</td></tr><tr><td>CIFAR-10/AIl</td><td>96/50</td><td>88/24</td><td>98/76</td><td>74</td></tr><tr><td>CIFAR-100/SUN</td><td>91/50</td><td>83/27</td><td>96/73</td><td>56</td></tr><tr><td>CIFAR-100/Gaussian</td><td>88/50</td><td>92/43</td><td>80/57</td><td>77</td></tr><tr><td>CIFAR-100/AIl</td><td>90/50</td><td>81/21</td><td>96/79</td><td>63</td></tr><tr><td>MNIST/Omniglot</td><td>96/50</td><td>97/52</td><td>96/48</td><td>86</td></tr><tr><td>MNIST/notMNIST</td><td>85/50</td><td>86/50</td><td>88/50</td><td>92</td></tr><tr><td>MNIST/CIFAR-10bw</td><td>95/50</td><td>95/50</td><td>95/50</td><td>87</td></tr><tr><td>MNIST/Gaussian</td><td>90/50</td><td>90/50</td><td>91/50</td><td>91</td></tr><tr><td>MNIST/Uniform</td><td>99/50</td><td>99/50</td><td>98/50</td><td>83</td></tr><tr><td>MNIST/AII</td><td>91/50</td><td>76/20</td><td>98/80</td><td>89</td></tr></table>
+
+The results are shown in Table 2. Notice that the mean predicted/maximum class probabilities (Pred. Prob (mean)) are above $7 5 \%$ , but if the prediction probability alone is translated to confidence, the softmax distribution should be more uniform for CIFAR-100. This again shows softmax probabilities should not be viewed as a direct representation of confidence. Fortunately, out-of-distribution examples sufficiently differ in the prediction probabilities from in-distribution examples, allowing for successful detection and generally high area under PR and ROC curves.
+
+For reproducibility, let us specify the model architectures. The MNIST classifier is a three-layer, 256 neuron-wide, fully-connected network trained for 30 epochs with Adam (Kingma & Ba, 2015). It uses a GELU nonlinearity (Hendrycks & Gimpel, 2016b), $x \Phi ( x )$ , where $\Phi ( x )$ is the CDF of the standard normal distribution. We initialize our weights according to (Hendrycks & Gimpel, 2016c), as it is suited for arbitrary nonlinearities. For CIFAR-10 and CIFAR-100, we train a 40-4 wide residual network (Zagoruyko & Komodakis, 2016) for 50 epochs with stochastic gradient descent using restarts (Loshchilov & Hutter, 2016), the GELU nonlinearity, and standard mirroring and cropping data augmentation.
+
+# 3.2 NATURAL LANGUAGE PROCESSING
+
+Let us turn to a variety of tasks and architectures used in natural language processing.
+
+# 3.2.1 SENTIMENT CLASSIFICATION
+
+The first NLP task is binary sentiment classification using the IMDB dataset (Maas et al., 2011), a dataset of polarized movie reviews with 25000 training and 25000 test reviews. This task allows us to determine if classifiers trained on a relatively small dataset still produce informative softmax distributions. For this task we use a linear classifier taking as input the average of trainable, randomly initialized word vectors with dimension 50 (Joulin et al., 2016; Iyyer et al., 2015). We train for 15 epochs with Adam and early stopping based upon 5000 held-out training reviews. Again, Table 3 shows that the softmax distributions differ between correctly and incorrectly classified examples, so prediction probabilities allow us to detect reliably which examples are right and wrong.
+
+Table 3: Detecting correct and incorrect classifications for binary sentiment classification.   
+
+<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>IMDB</td><td>82/50</td><td>97/88</td><td>36/12</td><td>74</td><td>11.9</td></tr></table>
+
+Table 4: Distinguishing in- and out-of-distribution test set data for binary sentiment classification. IMDB/All is the same as IMDB/(Customer Reviews, Movie Reviews). All values are percentages.   
+
+<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In /Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>IMDB/Customer Reviews</td><td>95/50</td><td>99/89</td><td>60/11</td><td>62</td></tr><tr><td>IMDB/Movie Reviews</td><td>94/50</td><td>98/72</td><td>80/28</td><td>63</td></tr><tr><td>IMDB/All</td><td>94/50</td><td>97/66</td><td>84/34</td><td>63</td></tr></table>
+
+Now we use the Customer Review (Hu & Liu, 2004) and Movie Review (Pang et al., 2002) datasets as out-of-distribution examples. The Customer Review dataset has reviews of products rather than only movies, and the Movie Review dataset has snippets from professional movie reviewers rather than full-length amateur reviews. We leave all test set examples from IMDB as in-distribution examples, and out-of-distribution examples are the 500 or 1000 test reviews from Customer Review and Movie Review datasets, respectively. Table 4 displays detection results, showing a similar story to Table 2.
+
+# 3.2.2 TEXT CATEGORIZATION
+
+We turn to text categorization tasks to determine whether softmax distributions are useful for detecting similar but out-of-distribution examples. In the following text categorization tasks, we train classifiers to predict the subject of the text they are processing. In the 20 Newsgroups dataset (Lang, 1995), there are 20 different newsgroup subjects with a total of 20000 documents for the whole dataset. The Reuters 8 (Lewis et al., 2004) dataset has eight different news subjects with nearly 8000 stories in total. The Reuters 52 dataset has 52 news subjects with slightly over 9000 news stories; this dataset can have as few as three stories for a single subject.
+
+For the 20 Newsgroups dataset we train a linear classifier on 30-dimensional word vectors for 20 epochs. Meanwhile, Reuters 8 and Retuers 52 use one-layer neural networks with a bag-of-words input and a GELU nonlinearity, all optimized with Adam for 5 epochs. We train on a subset of subjects, leaving out 5 newsgroup subjects from 20 Newsgroups, 2 news subjects from Reuters 8, and 12 news subjects from Reuters 52, leaving the rest as out-of-distribution examples. Table 5 shows that with these datasets and architectures, we can detect errors dependably, and Table 6 informs us that the softmax prediction probabilities allow for detecting out-of-distribution subjects.
+
+Table 5: Detecting correct and incorrect classifications for text categorization.   
+
+<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>15 Newsgroups</td><td>89/50</td><td>99/93</td><td>42/7.3</td><td>53</td><td>7.31</td></tr><tr><td>Reuters 6</td><td>89/50</td><td>100/98</td><td>35/2.5</td><td>77</td><td>2.53</td></tr><tr><td>Reuters 40</td><td>91/50</td><td>99/92</td><td>45/7.6</td><td>62</td><td>7.55</td></tr></table>
+
+Table 6: Distinguishing in- and out-of-distribution test set data for text categorization.   
+
+<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In/Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>15/5 Newsgroups</td><td>75/50</td><td>92/84</td><td>45/16</td><td>65</td></tr><tr><td>Reuters6/Reuters2</td><td>92/50</td><td>100/95</td><td>56/4.5</td><td>72</td></tr><tr><td>Reuters40/Reuters12</td><td>95/50</td><td>100/93</td><td>60/7.2</td><td>47</td></tr></table>
+
+Table 7: Detecting correct and incorrect classifications for part-of-speech tagging.   
+
+<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>WSJ</td><td>96/50</td><td>100/96</td><td>51/3.7</td><td>71</td><td>3.68</td></tr><tr><td>Twitter</td><td>89/50</td><td>98/87</td><td>53/13</td><td>69</td><td>12.59</td></tr></table>
+
+# 3.2.3 PART-OF-SPEECH TAGGING
+
+Part-of-speech (POS) tagging of newswire and social media text is our next challenge. We use the Wall Street Journal portion of the Penn Treebank (Marcus et al., 1993) which contains 45 distinct POS tags. For social media, we use POS-annotated tweets (Gimpel et al., 2011; Owoputi et al., 2013) which contain 25 tags. For the WSJ tagger, we train a bidirectional long short-term memory recurrent neural network (Hochreiter & Schmidhuber, 1997) with three layers, 128 neurons per layer, with randomly initialized word vectors, and this is trained on $9 0 \%$ of the corpus for 10 epochs with stochastic gradient descent with a batch size of 32. The tweet tagger is simpler, as it is twolayer neural network with a GELU nonlinearity, a weight initialization according to (Hendrycks & Gimpel, 2016c), pretrained word vectors trained on a corpus of 56 million tweets (Owoputi et al., 2013), and a hidden layer size of 256, all while training on 1000 tweets for 30 epochs with Adam and early stopping with 327 validation tweets. Error detection results are in Table 7. For out-ofdistribution detection, we use the WSJ tagger on the tweets as well as weblog data from the English Web Treebank (Bies et al., 2012). The results are shown in Table 8. Since the weblog data is closer in style to newswire than are the tweets, it is harder to detect whether a weblog sentence is outof-distribution than a tweet. Indeed, since POS tagging is done at the word-level, we are detecting whether each word is out-of-distribution given the word and contextual features. With this in mind, we see that it is easier to detect words as out-of-distribution if they are from tweets than from blogs.
+
+<table><tr><td>In-Distribution/ Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In/Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>WSJ/Twitter</td><td>80/50</td><td>98/92</td><td>41/7.7</td><td>81</td></tr><tr><td>WSJ/Weblog*</td><td>61/50</td><td>88/86</td><td>30/14</td><td>93</td></tr></table>
+
+Table 8: Detecting out-of-distribution tweets and blog articles for part-of-speech tagging. All values are percentages. \*These examples are atypically close to the training distribution.
+
+# 3.3 AUTOMATIC SPEECH RECOGNITION
+
+Now we consider a task which uses softmax values to construct entire sequences rather than determine an input’s class. Our sequence prediction system uses a bidirectional LSTM with two-layers and a clipped GELU nonlinearity, optimized for 60 epochs with RMSProp trained on $8 0 \%$ of the TIMIT corpus (Garofolo et al., 1993). The LSTM is trained with connectionist temporal classification (CTC) (Graves et al., 2006) for predicting sequences of phones given MFCCs, energy, and first and second deltas of a 25ms frame. When trained with CTC, the LSTM learns to have its phone label probabilities spike momentarily while mostly predicting blank symbols otherwise. In this way, the softmax is used differently from typical classification problems, providing a unique test for our detection methods.
+
+We do not show how the system performs on correctness/incorrectness detection because errors are not binary and instead lie along a range of edit distances. However, we can perform out-ofdistribution detection. Mixing the TIMIT audio with realistic noises from the Aurora-2 dataset (Hirsch & Pearce, 2000), we keep the TIMIT audio volume at $100 \%$ and noise volume at $30 \%$ , giving a mean SNR of approximately 5. Speakers are still clearly audible to the human ear but confuse the phone recognizer because the prediction edit distance more than doubles. For more outof-distribution examples, we use the test examples from the THCHS-30 dataset (Wang & Zhang, 2015), a Chinese speech corpus. Table 9 shows the results. Crucially, when performing detection, we compute the softmax probabilities while ignoring the blank symbol’s logit. With the blank symbol’s presence, the softmax distributions at most time steps predict a blank symbol with high confidence, but without the blank symbol we can better differentiate between normal and abnormal distributions. With this modification, the softmax prediction probabilities allow us to detect whether an example is out-of-distribution.
+
+Table 9: Detecting out-of-distribution distorted speech. All values are percentages.   
+
+<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In/Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>TIMIT/TIMIT+Airport</td><td>99/50</td><td>99/50</td><td>99/50</td><td>59</td></tr><tr><td>TIMIT/TIMIT+Babble</td><td>100/50</td><td>100/50</td><td>100/50</td><td>55</td></tr><tr><td>TIMIT/TIMIT+Car</td><td>98/50</td><td>98/50</td><td>98/50</td><td>59</td></tr><tr><td>TIMIT/TIMIT+Exhibition</td><td>100/50</td><td>100/50</td><td>100/50</td><td>57</td></tr><tr><td>TIMIT/TIMIT+Restaurant</td><td>98/50</td><td>98/50</td><td>98/50</td><td>60</td></tr><tr><td>TIMIT/TIMIT+Street</td><td>100/50</td><td>100/50</td><td>100/50</td><td>52</td></tr><tr><td>TIMIT/TIMIT+Subway</td><td>100/50</td><td>100/50</td><td>100/50</td><td>56</td></tr><tr><td>TIMIT/TIMIT+Train</td><td>100/50</td><td>100/50</td><td>100/50</td><td>58</td></tr><tr><td>TIMIT/Chinese</td><td>85/50</td><td>80/34</td><td>90/66</td><td>64</td></tr><tr><td>TIMIT/AII</td><td>97/50</td><td>79/10</td><td>100/90</td><td>58</td></tr></table>
+
+# 4 ABNORMALITY DETECTION WITH AUXILIARY DECODERS
+
+Having seen that softmax prediction probabilities enable abnormality detection, we now show there is other information sometimes more useful for detection. To demonstrate this, we exploit the learned internal representations of neural networks. We start by training a normal classifier and append an auxiliary decoder which reconstructs the input, shown in Figure 1. Auxiliary decoders are sometimes known to increase classification performance (Zhang et al., 2016). The decoder and scorer are trained jointly on in-distribution examples. Thereafter, the blue layers in Figure 1 are frozen. Then we train red layers on clean and noised training examples, and the sigmoid output of the red layers scores how normal the input is. Consequently, noised examples are in the abnormal class, clean examples are of the normal class, and the sigmoid is trained to output to which class an input belongs. After training we consequently have a normal classifier, an auxiliary decoder, and what we call an abnormality module. The gains from the abnormality module demonstrate there are possible research avenues for outperforming the baseline.
+
+# 4.1 TIMIT
+
+We test the abnormality module by revisiting the TIMIT task with a different architecture and show how these auxiliary components can greatly improve detection. The system is a three-layer, 1024- neuron wide classifier with an auxiliary decoder and abnormality module. This network takes as input 11 frames and must predict the phone of the center frame, 26 features per frame. Weights are initialized according to (Hendrycks & Gimpel, 2016c). This network trains for 20 epochs, and the abnormality module trains for two. The abnormality module sees clean examples and, as negative examples, TIMIT examples distorted with either white noise, brown noise (noise with its spectral density proportional to $\bar { 1 } / f ^ { 2 } )$ , or pink noise (noise with its spectral density proportional to $\bar { 1 } / f$ ) at various volumes.
+
+We note that the abnormality module is not trained on the same type of noise added to the test examples. Nonetheless, Table 10 shows that simple noised examples translate to effective detection of realistically distorted audio. We detect abnormal examples by comparing the typical abnormality module outputs for clean examples with the outputs for the distorted examples. The noises are from Aurora-2 and are added to TIMIT examples with $30 \%$ volume. We also use the THCHS-30 dataset for Chinese speech. Unlike before, we use the THCHS-30 training examples rather than test set examples because fully connected networks can evaluate the whole training set sufficiently quickly. It is worth mentioning that fully connected deep neural networks are noise robust (Seltzer et al., 2013), yet the abnormality module can still detect whether an example is out-of-distribution. To see why this is remarkable, note that the network’s frame classification error is $2 9 . 6 9 \%$ on the entire test (not core) dataset, and the average classification error for distorted examples is $3 0 . 4 3 \%$ —this is unlike the bidirectional LSTM which had a more pronounced performance decline. Because the classification degradation was only slight, the softmax statistics alone did not provide useful outof-distribution detection. In contrast, the abnormality module provided scores which allowed the detection of different-but-similar examples. In practice, it may be important to determine whether an example is out-of-distribution even if it does not greatly confuse the network, and the abnormality module facilitates this.
+
+Table 10: Abnormality modules can generalize to novel distortions and detect out-of-distribution examples even when they do not severely degrade accuracy. All values are percentages.   
+
+<table><tr><td>In-Distribution/ Out-of-Distribution</td><td>AUROC /Base Softmax</td><td>AUROC /Base AbMod</td><td>AUPR In/Base Softmax</td><td>AUPR In/Base AbMod</td><td>AUPR Out/Base Softmax</td><td>AUPR Out/Base AbMod</td></tr><tr><td>TIMIT/+Airport</td><td>75/50</td><td>100/50</td><td>77/41</td><td>100/41</td><td>73/59</td><td>100/59</td></tr><tr><td>TIMIT/+Babble TIMIT/+Car</td><td>94/50</td><td>100/50</td><td>95/41</td><td>100/41</td><td>91/59</td><td>100/59</td></tr><tr><td>TIMIT/+Exhib.</td><td>70/50</td><td>98/50</td><td>69/41</td><td>98/41</td><td>70/59</td><td>98/59</td></tr><tr><td>TIMIT/+Rest.</td><td>91/50</td><td>98/50</td><td>92/41</td><td>98/41</td><td>91/59</td><td>98/59</td></tr><tr><td>TIMIT/+Subway</td><td>68/50 76/50</td><td>95/50</td><td>70/41</td><td>96/41</td><td>67/59</td><td>95/59</td></tr><tr><td>TIMIT/+Street</td><td>89/50</td><td>96/50 98/50</td><td>77/41</td><td>96/41</td><td>74/59</td><td>96/59</td></tr><tr><td></td><td>80/50</td><td>100/50</td><td>91/41</td><td>99/41</td><td>85/59</td><td>98/59</td></tr><tr><td>TIMIT/+Train</td><td>79/50</td><td></td><td>82/41</td><td>100/41 66/12</td><td>77/59</td><td>100/59</td></tr><tr><td>TIMIT/Chinese</td><td>80</td><td>90/50 97</td><td>41/12 77</td><td></td><td>96/88</td><td>98/88</td></tr><tr><td>Average</td><td></td><td></td><td></td><td>95</td><td>80</td><td>98</td></tr></table>
+
+Table 11: Improved detection using the abnormality module. All values are percentages.   
+
+<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base Softmax</td><td>AUROC /Base AbMod</td><td>AUPR In/Base Softmax</td><td>AUPR In/Base AbMod</td><td>AUPR Out/Base Softmax</td><td>AUPR Out/Base</td></tr><tr><td>MNIST/Omniglot</td><td>95/50</td><td>100/50</td><td>95/52</td><td>100/52</td><td>95/48</td><td>AbMod 100/48</td></tr><tr><td>MNIST/notMNIST</td><td>87/50</td><td>100/50</td><td>88/50</td><td>100/50</td><td>90/50</td><td>100/50</td></tr><tr><td>MNIST/CIFAR-10bw</td><td>98/50</td><td>100/50</td><td>98/50</td><td>100/50</td><td>98/50</td><td>100/50</td></tr><tr><td>MNIST/Gaussian</td><td>88/50</td><td>100/50</td><td>88/50</td><td>100/50</td><td>90/50</td><td>100/50</td></tr><tr><td>MNIST/Uniform</td><td>99/50</td><td>100/50</td><td>99/50</td><td>100/50</td><td>99/50</td><td>100/50</td></tr><tr><td>Average</td><td>93</td><td>100</td><td>94</td><td>100</td><td>94</td><td>100</td></tr></table>
+
+# 4.2 MNIST
+
+Finally, much like in a previous experiment, we train an MNIST classifier with three layers of width 256. This time, we also use an auxiliary decoder and abnormality module rather than relying on only softmax statistics. For abnormal examples we blur, rotate, or add Gaussian noise to training images. Gains from the abnormality module are shown in Table 11, and there is a consistent out-of-sample detection improvement compared to softmax prediction probabilities. Even for highly dissimilar examples the abnormality module can further improve detection.
+
+# 5 DISCUSSION AND FUTURE WORK
+
+The abnormality module demonstrates that in some cases the baseline can be beaten by exploiting the representations of a network, suggesting myriad research directions. Some promising future avenues may utilize the intra-class variance: if the distance from an example to another of the same predicted class is abnormally high, it may be out-of-distribution (Giryes et al., 2015). Another path is to feed in a vector summarizing a layer’s activations into an RNN, one vector for each layer. The RNN may determine that the activation patterns are abnormal for out-of-distribution examples. Others could make the detections fine-grained: is the out-of-distribution example a known-unknown or an unknown-unknown? A different avenue is not just to detect correct classifications but to output the probability of a correct detection. These are but a few ideas for improving error and out-of-distribution detection.
+
+We hope that any new detection methods are tested on a variety of tasks and architectures of the researcher’s choice. A basic demonstration could include the following datasets: MNIST, CIFAR, IMDB, and tweets because vision-only demonstrations may not transfer well to other architectures and datasets. Reporting the AUPR and AUROC values is important, and so is the underlying classifier’s accuracy since an always-wrong classifier gets a maximum AUPR for error detection if error is the positive class. Also, future research need not use the exact values from this paper for comparisons. Machine learning systems evolve, so tethering the evaluations to the exact architectures and datasets in this paper is needless. Instead, one could simply choose a variety of datasets and architectures possibly like those above and compare their detection method with a detector based on the softmax prediction probabilities from their classifiers. These are our basic recommendations for others who try to surpass the baseline on this underexplored challenge.
+
+# 6 CONCLUSION
+
+We demonstrated a softmax prediction probability baseline for error and out-of-distribution detection across several architectures and numerous datasets. We then presented the abnormality module, which provided superior scores for discriminating between normal and abnormal examples on tested cases. The abnormality module demonstrates that the baseline can be beaten in some cases, and this implies there is room for future research. Our hope is that other researchers investigate architectures which make predictions in view of abnormality estimates, and that others pursue more reliable methods for detecting errors and out-of-distribution inputs because knowing when a machine learning system fails strikes us as highly important.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank John Wieting, Hao Tang, Karen Livescu, Greg Shakhnarovich, and our reviewers for their suggestions. We would also like to thank NVIDIA Corporation for donating several TITAN X GPUs used in this research.
+
+# REFERENCES
+
+Dario Amodei, Chris Olah, Jacob Steinhardt, Paul Christiano, John Schulman, and Dan Mane. Con- ´ crete problems in ai safety. arXiv, 2016.
+
+Ann Bies, Justin Mott, Colin Warner, and Seth Kulick. English Web Treebank, 2012.
+
+Yaroslav Bulatov. notMNIST dataset. 2011.
+
+Jesse Davis and Mark Goadrich. The relationship between precision-recall and ROC curves. In International Conference on Machine Learning (ICML), 2006.
+
+Tom Fawcett. An introduction to ROC analysis. Pattern Recognition Letters, 2005.
+
+John Garofolo, Lori Lamel, William Fisher, Jonathan Fiscus, David Pallett, Nancy Dahlgren, and Victor Zue. TIMIT Acoustic-Phonetic Continuous Speech Corpus. Linguistic Data Consortium, 1993.
+
+Kevin Gimpel, Nathan Schneider, Brendan $\mathrm { O ^ { \prime } }$ Connor, Dipanjan Das, Daniel Mills, Jacob Eisenstein, Michael Heilman, Dani Yogatama, Jeffrey Flanigan, and Noah A. Smith. Part-of-Speech Tagging for Twitter: Annotation, Features, and Experiments. Association for Computational Linguistics (ACL), 2011.
+
+Raja Giryes, Guillermo Sapiro, and Alex M. Bronstein. Deep neural networks with random gaussian weights: A universal classification strategy? arXiv, 2015.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations (ICLR), 2015.
+
+Alex Graves, Santiago Fernandez, Faustino Gomez, and J ´ urgen Schmidhuber. Connectionist tem- ¨ poral classification: Labeling unsegmented sequence data with recurrent neural networks. In International Conference on Machine Learning (ICML), 2006.
+
+Dan Hendrycks and Kevin Gimpel. Methods for detecting adversarial images and a colorful saliency map. arXiv, 2016a.
+
+Dan Hendrycks and Kevin Gimpel. Bridging nonlinearities and stochastic regularizers with Gaussian error linear units. arXiv, 2016b.
+
+Dan Hendrycks and Kevin Gimpel. Adjusting for dropout variance in batch normalization and weight initialization. arXiv, 2016c.
+
+Hans-Gunter Hirsch and David Pearce. The Aurora experimental framework for the performance¨ evaluation of speech recognition systems under noisy conditions. ISCA ITRW ASR2000, 2000.
+
+Sepp Hochreiter and Jurgen Schmidhuber. ¨ Long short-term memory. Neural Computation, 1997.
+
+Minqing Hu and Bing Liu. Mining and Summarizing Customer Reviews. Knowledge Discovery and Data Mining (KDD), 2004.
+
+Mohit Iyyer, Varun Manjunatha, Jordan Boyd-Graber, and Hal Daume Iii. ´ Deep Unordered Composition Rivals Syntactic Methods for Text Classification. Association for Computational Linguistics (ACL), 2015.
+
+Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. arXiv, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. International Conference for Learning Representations (ICLR), 2015.
+
+Alex Krizhevsky. Learning Multiple Layers of Features from Tiny Images, 2009.
+
+Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 2015.
+
+Ken Lang. Newsweeder: Learning to filter netnews. In International Conference on Machine Learning (ICML), 1995.
+
+David D. Lewis, Yiming Yang, Tony G. Rose, and Fan Li. Rcv1: A new benchmark collection for text categorization research. Journal of Machine Learning Research (JMLR), 2004.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with restarts. arXiv, 2016.
+
+Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Association for Computational Linguistics (ACL), 2011.
+
+Chris Manning and Hinrich Schutze. ¨ Foundations of Statistical Natural Language Processing. MIT Press, 1999.
+
+Mitchell P. Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of English: The Penn Treebank. Computational linguistics, 1993.
+
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In Computer Vision and Pattern Recognition (CVPR), 2015.
+
+Khanh Nguyen and Brendan O’Connor. Posterior calibration and exploratory analysis for natural language processing models. In Empirical Methods in Natural Language Processing (EMNLP), 2015.
+
+Olutobi Owoputi, Brendan O’Connor, Chris Dyer, Kevin Gimpel, Nathan Schneider, and Noah A. Smith. Improved part-of-speech tagging for online conversational text with word clusters. In North American Chapter of the Association for Computational Linguistics (NAACL), 2013.
+
+Bo Pang, Lillian Lee, and Shivakumar Vaithyanathan. Thumbs up? sentiment classification using machine learning techniques. In Empirical Methods in Natural Language Processing (EMNLP), 2002.
+
+Foster Provost, Tom Fawcett, and Ron Kohavi. The case against accuracy estimation for comparing induction algorithms. In International Conference on Machine Learning (ICML), 1998.
+
+Takaya Saito and Marc Rehmsmeier. The precision-recall plot is more informative than the ROC plot when evaluating binary classifiers on imbalanced datasets. In PLoS ONE. 2015.
+
+Michael L. Seltzer, Dong Yu, and Yongqiang Wang. Investigation of deep neural networks for noise robust speech recognition. In IEEE International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2013.
+
+Jacob Steinhardt and Percy Liang. Unsupervised risk estimation using only conditional independence structure. In Neural Information Processing Systems (NIPS), 2016.
+
+Dong Wang and Xuewei Zhang. Thchs-30 : A free chinese speech corpus. In Technical Report, 2015.
+
+Gethin Williams and Steve Renals. Confidence measures for hybrid hmm/ann speech recognition. In Proceedings of EuroSpeech, 1997.
+
+Jianxiong Xiao, James Hays, Krista A. Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2010.
+
+Dong Yu, Jinyu Li, and Li Deng. Calibration of confidence measures in speech recognition. In IEEE Transactions on Audio, Speech, and Language, 2010.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. British Machine Vision Conference, 2016.
+
+Yuting Zhang, Kibok Lee, and Honglak Lee. Augmenting supervised neural networks with unsupervised objectives for large-scale image classification. In International Conference on Machine Learning (ICML), 2016.
+
+# A ABNORMALITY MODULE EXAMPLE
+
+![](images/4beb57de31bda8242253be43662a1c5fae8e3fd3913d61f222a67c58469a7a8a.jpg)  
+Figure 1: A neural network classifying a diamond image with an auxiliary decoder and an abnormality module. Circles are neurons, either having a GELU or sigmoid activation. The blurred diamond reconstruction precedes subtraction and elementwise squaring. The probability vector is the softmax probability vector. Blue layers train on in-distribution data, and red layers train on both in- and out-of-distribution examples.

parse/train/Hkg4TI9xl/Hkg4TI9xl_content_list.json

@@ -0,0 +1,1365 @@
+[
+    {
+        "type": "text",
+        "text": "A BASELINE FOR DETECTING MISCLASSIFIED ANDOUT-OF-DISTRIBUTION EXAMPLESIN NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks∗ University of California, Berkeley hendrycks@berkeley.edu ",
+        "bbox": [
+            184,
+            195,
+            408,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kevin Gimpel   \nToyota Technological Institute at Chicago   \nkgimpel@ttic.edu ",
+        "bbox": [
+            483,
+            195,
+            758,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            273,
+            544,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider the two related problems of detecting if an example is misclassified or out-of-distribution. We present a simple baseline that utilizes probabilities from softmax distributions. Correctly classified examples tend to have greater maximum softmax probabilities than erroneously classified and out-of-distribution examples, allowing for their detection. We assess performance by defining several tasks in computer vision, natural language processing, and automatic speech recognition, showing the effectiveness of this baseline across all. We then show the baseline can sometimes be surpassed, demonstrating the room for future research on these underexplored detection tasks. ",
+        "bbox": [
+            233,
+            306,
+            764,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            458,
+            334,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When machine learning classifiers are employed in real-world tasks, they tend to fail when the training and test distributions differ. Worse, these classifiers often fail silently by providing highconfidence predictions while being woefully incorrect (Goodfellow et al., 2015; Amodei et al., 2016). Classifiers failing to indicate when they are likely mistaken can limit their adoption or cause serious accidents. For example, a medical diagnosis model may consistently classify with high confidence, even while it should flag difficult examples for human intervention. The resulting unflagged, erroneous diagnoses could blockade future machine learning technologies in medicine. More generally and importantly, estimating when a model is in error is of great concern to AI Safety (Amodei et al., 2016). ",
+        "bbox": [
+            174,
+            489,
+            825,
+            614
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These high-confidence predictions are frequently produced by softmaxes because softmax probabilities are computed with the fast-growing exponential function. Thus minor additions to the softmax inputs, i.e. the logits, can lead to substantial changes in the output distribution. Since the softmax function is a smooth approximation of an indicator function, it is uncommon to see a uniform distribution outputted for out-of-distribution examples. Indeed, random Gaussian noise fed into an MNIST image classifier gives a “prediction confidence” or predicted class probability of $91 \\%$ , as we show later. Throughout our experiments we establish that the prediction probability from a softmax distribution has a poor direct correspondence to confidence. This is consistent with a great deal of anecdotal evidence from researchers (Nguyen & O’Connor, 2015; Yu et al., 2010; Provost et al., 1998; Nguyen et al., 2015). ",
+        "bbox": [
+            174,
+            622,
+            825,
+            761
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, in this work we also show the prediction probability of incorrect and out-of-distribution examples tends to be lower than the prediction probability for correct examples. Therefore, capturing prediction probability statistics about correct or in-sample examples is often sufficient for detecting whether an example is in error or abnormal, even though the prediction probability viewed in isolation can be misleading. ",
+        "bbox": [
+            174,
+            768,
+            823,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These prediction probabilities form our detection baseline, and we demonstrate its efficacy through various computer vision, natural language processing, and automatic speech recognition tasks. While these prediction probabilities create a consistently useful baseline, at times they are less effective, revealing room for improvement. To give ideas for future detection research, we contribute one method which outperforms the baseline on some (but not all) tasks. This new method evaluates the quality of a neural network’s input reconstruction to determine if an example is abnormal. ",
+        "bbox": [
+            176,
+            844,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to the baseline methods, another contribution of this work is the designation of standard tasks and evaluation metrics for assessing the automatic detection of errors and out-of-distribution examples. We use a large number of well-studied tasks across three research areas, using standard neural network architectures that perform well on them. For out-of-distribution detection, we provide ways to supply the out-of-distribution examples at test time like using images from different datasets and realistically distorting inputs. We hope that other researchers will pursue these tasks in future work and surpass the performance of our baselines. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, while softmax classifier probabilities are not directly useful as confidence estimates, estimating model confidence is not as bleak as previously believed. Simple statistics derived from softmax distributions provide a surprisingly effective way to determine whether an example is misclassified or from a different distribution from the training data, as demonstrated by our experimental results spanning computer vision, natural language processing, and speech recognition tasks. This creates a strong baseline for detecting errors and out-of-distribution examples which we hope future research surpasses. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PROBLEM FORMULATION AND EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            366,
+            573,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we are interested in two related problems. The first is error and success prediction: can we predict whether a trained classifier will make an error on a particular held-out test example; can we predict if it will correctly classify said example? The second is in- and out-of-distribution detection: can we predict whether a test example is from a different distribution from the training data; can we predict if it is from within the same distribution?1 Below we present a simple baseline for solving these two problems. To evaluate our solution, we use two evaluation metrics. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            483
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Before mentioning the two evaluation metrics, we first note that comparing detectors is not as straightforward as using accuracy. For detection we have two classes, and the detector outputs a score for both the positive and negative class. If the negative class is far more likely than the positive class, a model may always guess the negative class and obtain high accuracy, which can be misleading (Provost et al., 1998). We must then specify a score threshold so that some positive examples are classified correctly, but this depends upon the trade-off between false negatives (fn) and false positives (fp). ",
+        "bbox": [
+            174,
+            491,
+            825,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Faced with this issue, we employ the Area Under the Receiver Operating Characteristic curve (AUROC) metric, which is a threshold-independent performance evaluation (Davis & Goadrich, 2006). The ROC curve is a graph showing the true positive rate $( \\mathrm { t p r = t p / ( t p + f n ) } )$ ) and the false positive rate $( \\mathrm { f p r = f p / ( f p + t n ) } )$ against each other. Moreover, the AUROC can be interpreted as the probability that a positive example has a greater detector score/value than a negative example (Fawcett, 2005). Consequently, a random positive example detector corresponds to a $50 \\%$ AUROC, and a “perfect” classifier corresponds to $100 \\%$ .2 ",
+        "bbox": [
+            174,
+            594,
+            825,
+            691
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The AUROC sidesteps the issue of threshold selection, as does the Area Under the Precision-Recall curve (AUPR) which is sometimes deemed more informative (Manning & Schutze ¨ , 1999). This is because the AUROC is not ideal when the positive class and negative class have greatly differing base rates, and the AUPR adjusts for these different positive and negative base rates. For this reason, the AUPR is our second evaluation metric. The PR curve plots the precision $( \\mathrm { t p } / ( \\mathrm { t p } + \\mathrm { f p } ) )$ and recall $( \\mathrm { t p } / ( \\mathrm { t p } + \\mathrm { f n } ) )$ ) against each other. The baseline detector has an AUPR approximately equal to the precision (Saito & Rehmsmeier, 2015), and a “perfect” classifier has an AUPR of $1 0 0 \\%$ . Consequently, the base rate of the positive class greatly influences the AUPR, so for detection we must specify which class is positive. In view of this, we show the AUPRs when we treat success/normal classes as positive, and then we show the areas when we treat the error/abnormal classes as positive. We can treat the error/abnormal classes as positive by multiplying the scores by $- 1$ and labeling them positive. Note that treating error/abnormal classes as positive classes does not change the AU",
+        "bbox": [
+            174,
+            699,
+            825,
+            866
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ROC since if $S$ is a score for a successfully classified value, and $E$ is the score for an erroneously classified value, $\\mathrm { A U R O C } = P ( S > E ) = { \\dot { P } } ( - E > - S )$ . ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We begin our experiments in Section 3 where we describe a simple baseline which uses the maximum probability from the softmax label distribution in neural network classifiers. Then in Section 4 we describe a method that uses an additional, auxiliary model component trained to reconstruct the input. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            194
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SOFTMAX PREDICTION PROBABILITY AS A BASELINE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            215,
+            653,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In what follows we retrieve the maximum/predicted class probability from a softmax distribution and thereby detect whether an example is erroneously classified or out-of-distribution. Specifically, we separate correctly and incorrectly classified test set examples and, for each example, compute the softmax probability of the predicted class, i.e., the maximum softmax probability.3 From these two groups we obtain the area under PR and ROC curves. These areas summarize the performance of a binary classifier discriminating with values/scores (in this case, maximum probabilities from the softmaxes) across different thresholds. This description treats correctly classified examples as the positive class, denoted “Success” or “Succ” in our tables. In “Error” or “Err” we treat the the incorrectly classified examples as the positive class; to do this we label incorrectly classified examples as positive and take the negatives of the softmax probabilities of the predicted classes as the scores. ",
+        "bbox": [
+            173,
+            247,
+            825,
+            400
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For “In,” we treat the in-distribution, correctly classified test set examples as positive and use the softmax probability for the predicted class as a score, while for “Out” we treat the out-of-distribution examples as positive and use the negative of the aforementioned probability. Since the AUPRs for Success, Error, In, Out classifiers depend on the rate of positive examples, we list what area a random detector would achieve with “Base” values. Also in the upcoming results we list the mean predicted class probability of wrongly classified examples (Pred Prob Wrong (mean)) to demonstrate that the softmax prediction probability is a misleading confidence proxy when viewed in isolation. The “Pred. Prob (mean)” columns show this same shortcoming but for out-of-distribution examples. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            518
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table labels aside, we begin experimentation with datasets from vision then consider tasks in natural language processing and automatic speech recognition. In all of the following experiments, the AUROCs differ from the random baselines with high statistical significance according to the Wilcoxon rank-sum test. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 COMPUTER VISION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            349,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following computer vision tasks, we use three datasets: MNIST, CIFAR-10, and CIFAR100 (Krizhevsky, 2009). MNIST is a dataset of handwritten digits, consisting of 60000 training and 10000 testing examples. Meanwhile, CIFAR-10 has colored images belonging to 10 different classes, with 50000 training and 10000 testing examples. CIFAR-100 is more difficult, as it has 100 different classes with 50000 training and 10000 testing examples. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Table 1, we see that correctly classified and incorrectly classified examples are sufficiently distinct and thus allow reliable discrimination. Note that the area under the curves degrade with image recognizer test error. ",
+        "bbox": [
+            176,
+            702,
+            820,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, let us consider using softmax distributions to determine whether an example is in- or outof-distribution. We use all test set examples as the in-distribution (positive) examples. For out-ofdistribution (negative) examples, we use realistic images and noise. For CIFAR-10 and CIFAR-100, we use realistic images from the Scene UNderstanding dataset (SUN), which consists of 397 different scenes (Xiao et al., 2010). For MNIST, we use grayscale realistic images from three sources. Omniglot (Lake et al., 2015) images are handwritten characters rather than the handwritten digits in MNIST. Next, notMNIST (Bulatov, 2011) consists of typeface characters. Last of the realistic images, CIFAR-10bw are black and white rescaled CIFAR-10 images. The synthetic “Gaussian” data is random normal noise, and “Uniform” data is random uniform noise. Images are resized when necessary. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/772550cc9dfaf4d29934c2b849d3d5fa6fd04b1084d5cf1acd048d63e6f2a5e8.jpg",
+        "table_caption": [
+            "Table 1: The softmax predicted class probability allows for discrimination between correctly and incorrectly classified test set examples. “Pred. Prob Wrong(mean)” is the mean softmax probability for wrongly classified examples, showcasing its shortcoming as a direct measure of confidence. Succ/Err Base values are the AUROCs or AUPRs achieved by random classifiers. All entries are percentages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>MNIST</td><td>97/50</td><td>100/98</td><td>48/1.7</td><td>86</td><td>1.69</td></tr><tr><td>CIFAR-10</td><td>93/50</td><td>100/95</td><td>43/5</td><td>80</td><td>4.96</td></tr><tr><td>CIFAR-100</td><td>87/50</td><td>96/79</td><td>62/21</td><td>66</td><td>20.7</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/ea86698cc3d80e49169ddebf24234ca760eddcd48ab7eaaf64ddeb0564299894.jpg",
+        "table_caption": [
+            "Table 2: Distinguishing in- and out-of-distribution test set data for image classification. CIFAR10/All is the same as CIFAR-10/(SUN, Gaussian). All values are percentages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In /Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>CIFAR-10/SUN</td><td>95/50</td><td>89/33</td><td>97/67</td><td>72</td></tr><tr><td>CIFAR-10/Gaussian</td><td>97/50</td><td>98/49</td><td>95/51</td><td>77</td></tr><tr><td>CIFAR-10/AIl</td><td>96/50</td><td>88/24</td><td>98/76</td><td>74</td></tr><tr><td>CIFAR-100/SUN</td><td>91/50</td><td>83/27</td><td>96/73</td><td>56</td></tr><tr><td>CIFAR-100/Gaussian</td><td>88/50</td><td>92/43</td><td>80/57</td><td>77</td></tr><tr><td>CIFAR-100/AIl</td><td>90/50</td><td>81/21</td><td>96/79</td><td>63</td></tr><tr><td>MNIST/Omniglot</td><td>96/50</td><td>97/52</td><td>96/48</td><td>86</td></tr><tr><td>MNIST/notMNIST</td><td>85/50</td><td>86/50</td><td>88/50</td><td>92</td></tr><tr><td>MNIST/CIFAR-10bw</td><td>95/50</td><td>95/50</td><td>95/50</td><td>87</td></tr><tr><td>MNIST/Gaussian</td><td>90/50</td><td>90/50</td><td>91/50</td><td>91</td></tr><tr><td>MNIST/Uniform</td><td>99/50</td><td>99/50</td><td>98/50</td><td>83</td></tr><tr><td>MNIST/AII</td><td>91/50</td><td>76/20</td><td>98/80</td><td>89</td></tr></table>",
+        "bbox": [
+            173,
+            273,
+            825,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            544,
+            823,
+            573
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Table 2. Notice that the mean predicted/maximum class probabilities (Pred. Prob (mean)) are above $7 5 \\%$ , but if the prediction probability alone is translated to confidence, the softmax distribution should be more uniform for CIFAR-100. This again shows softmax probabilities should not be viewed as a direct representation of confidence. Fortunately, out-of-distribution examples sufficiently differ in the prediction probabilities from in-distribution examples, allowing for successful detection and generally high area under PR and ROC curves. ",
+        "bbox": [
+            174,
+            579,
+            823,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For reproducibility, let us specify the model architectures. The MNIST classifier is a three-layer, 256 neuron-wide, fully-connected network trained for 30 epochs with Adam (Kingma & Ba, 2015). It uses a GELU nonlinearity (Hendrycks & Gimpel, 2016b), $x \\Phi ( x )$ , where $\\Phi ( x )$ is the CDF of the standard normal distribution. We initialize our weights according to (Hendrycks & Gimpel, 2016c), as it is suited for arbitrary nonlinearities. For CIFAR-10 and CIFAR-100, we train a 40-4 wide residual network (Zagoruyko & Komodakis, 2016) for 50 epochs with stochastic gradient descent using restarts (Loshchilov & Hutter, 2016), the GELU nonlinearity, and standard mirroring and cropping data augmentation. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 NATURAL LANGUAGE PROCESSING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            799,
+            460,
+            814
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us turn to a variety of tasks and architectures used in natural language processing. ",
+        "bbox": [
+            174,
+            825,
+            732,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 SENTIMENT CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            431,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first NLP task is binary sentiment classification using the IMDB dataset (Maas et al., 2011), a dataset of polarized movie reviews with 25000 training and 25000 test reviews. This task allows us to determine if classifiers trained on a relatively small dataset still produce informative softmax distributions. For this task we use a linear classifier taking as input the average of trainable, randomly initialized word vectors with dimension 50 (Joulin et al., 2016; Iyyer et al., 2015). We train for 15 epochs with Adam and early stopping based upon 5000 held-out training reviews. Again, Table 3 shows that the softmax distributions differ between correctly and incorrectly classified examples, so prediction probabilities allow us to detect reliably which examples are right and wrong. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/58d9eefd6b749a2bcfccb66c07181d707c022f043679afb79030bce5335bcf63.jpg",
+        "table_caption": [
+            "Table 3: Detecting correct and incorrect classifications for binary sentiment classification. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>IMDB</td><td>82/50</td><td>97/88</td><td>36/12</td><td>74</td><td>11.9</td></tr></table>",
+        "bbox": [
+            174,
+            101,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/30c59ea47f501785b78599fc2ec4b639df1e727b6058c16049f5b7279232e6fa.jpg",
+        "table_caption": [
+            "Table 4: Distinguishing in- and out-of-distribution test set data for binary sentiment classification. IMDB/All is the same as IMDB/(Customer Reviews, Movie Reviews). All values are percentages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In /Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>IMDB/Customer Reviews</td><td>95/50</td><td>99/89</td><td>60/11</td><td>62</td></tr><tr><td>IMDB/Movie Reviews</td><td>94/50</td><td>98/72</td><td>80/28</td><td>63</td></tr><tr><td>IMDB/All</td><td>94/50</td><td>97/66</td><td>84/34</td><td>63</td></tr></table>",
+        "bbox": [
+            173,
+            199,
+            823,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            353,
+            825,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now we use the Customer Review (Hu & Liu, 2004) and Movie Review (Pang et al., 2002) datasets as out-of-distribution examples. The Customer Review dataset has reviews of products rather than only movies, and the Movie Review dataset has snippets from professional movie reviewers rather than full-length amateur reviews. We leave all test set examples from IMDB as in-distribution examples, and out-of-distribution examples are the 500 or 1000 test reviews from Customer Review and Movie Review datasets, respectively. Table 4 displays detection results, showing a similar story to Table 2. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 TEXT CATEGORIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            397,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We turn to text categorization tasks to determine whether softmax distributions are useful for detecting similar but out-of-distribution examples. In the following text categorization tasks, we train classifiers to predict the subject of the text they are processing. In the 20 Newsgroups dataset (Lang, 1995), there are 20 different newsgroup subjects with a total of 20000 documents for the whole dataset. The Reuters 8 (Lewis et al., 2004) dataset has eight different news subjects with nearly 8000 stories in total. The Reuters 52 dataset has 52 news subjects with slightly over 9000 news stories; this dataset can have as few as three stories for a single subject. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the 20 Newsgroups dataset we train a linear classifier on 30-dimensional word vectors for 20 epochs. Meanwhile, Reuters 8 and Retuers 52 use one-layer neural networks with a bag-of-words input and a GELU nonlinearity, all optimized with Adam for 5 epochs. We train on a subset of subjects, leaving out 5 newsgroup subjects from 20 Newsgroups, 2 news subjects from Reuters 8, and 12 news subjects from Reuters 52, leaving the rest as out-of-distribution examples. Table 5 shows that with these datasets and architectures, we can detect errors dependably, and Table 6 informs us that the softmax prediction probabilities allow for detecting out-of-distribution subjects. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0f6124d4188ed03290469fe4653c513a0ca1c11c5d8b655f805f5ff1399201a.jpg",
+        "table_caption": [
+            "Table 5: Detecting correct and incorrect classifications for text categorization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>15 Newsgroups</td><td>89/50</td><td>99/93</td><td>42/7.3</td><td>53</td><td>7.31</td></tr><tr><td>Reuters 6</td><td>89/50</td><td>100/98</td><td>35/2.5</td><td>77</td><td>2.53</td></tr><tr><td>Reuters 40</td><td>91/50</td><td>99/92</td><td>45/7.6</td><td>62</td><td>7.55</td></tr></table>",
+        "bbox": [
+            173,
+            816,
+            825,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/6ba1527e88c616592331bb66be3e864b314772f8e0e351efd8926958f63965d1.jpg",
+        "table_caption": [
+            "Table 6: Distinguishing in- and out-of-distribution test set data for text categorization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In/Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>15/5 Newsgroups</td><td>75/50</td><td>92/84</td><td>45/16</td><td>65</td></tr><tr><td>Reuters6/Reuters2</td><td>92/50</td><td>100/95</td><td>56/4.5</td><td>72</td></tr><tr><td>Reuters40/Reuters12</td><td>95/50</td><td>100/93</td><td>60/7.2</td><td>47</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7a6ca5b8f4da7a71e52963aa3f2fb7b2e8b9155a16ca217fe377e6d37e92e14b.jpg",
+        "table_caption": [
+            "Table 7: Detecting correct and incorrect classifications for part-of-speech tagging. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>AUROC /Base</td><td>AUPR Succ/Base</td><td>AUPR Err/Base</td><td>Pred.Prob Wrong(mean)</td><td>Test Set Error</td></tr><tr><td>WSJ</td><td>96/50</td><td>100/96</td><td>51/3.7</td><td>71</td><td>3.68</td></tr><tr><td>Twitter</td><td>89/50</td><td>98/87</td><td>53/13</td><td>69</td><td>12.59</td></tr></table>",
+        "bbox": [
+            174,
+            217,
+            825,
+            277
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 PART-OF-SPEECH TAGGING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            333,
+            418,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Part-of-speech (POS) tagging of newswire and social media text is our next challenge. We use the Wall Street Journal portion of the Penn Treebank (Marcus et al., 1993) which contains 45 distinct POS tags. For social media, we use POS-annotated tweets (Gimpel et al., 2011; Owoputi et al., 2013) which contain 25 tags. For the WSJ tagger, we train a bidirectional long short-term memory recurrent neural network (Hochreiter & Schmidhuber, 1997) with three layers, 128 neurons per layer, with randomly initialized word vectors, and this is trained on $9 0 \\%$ of the corpus for 10 epochs with stochastic gradient descent with a batch size of 32. The tweet tagger is simpler, as it is twolayer neural network with a GELU nonlinearity, a weight initialization according to (Hendrycks & Gimpel, 2016c), pretrained word vectors trained on a corpus of 56 million tweets (Owoputi et al., 2013), and a hidden layer size of 256, all while training on 1000 tweets for 30 epochs with Adam and early stopping with 327 validation tweets. Error detection results are in Table 7. For out-ofdistribution detection, we use the WSJ tagger on the tweets as well as weblog data from the English Web Treebank (Bies et al., 2012). The results are shown in Table 8. Since the weblog data is closer in style to newswire than are the tweets, it is harder to detect whether a weblog sentence is outof-distribution than a tweet. Indeed, since POS tagging is done at the word-level, we are detecting whether each word is out-of-distribution given the word and contextual features. With this in mind, we see that it is easier to detect words as out-of-distribution if they are from tweets than from blogs. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/18cb56c81d8b5fe071e65565f596e4e77a571bc7492c77194ad6e55b04fefd86.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>In-Distribution/ Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In/Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>WSJ/Twitter</td><td>80/50</td><td>98/92</td><td>41/7.7</td><td>81</td></tr><tr><td>WSJ/Weblog*</td><td>61/50</td><td>88/86</td><td>30/14</td><td>93</td></tr></table>",
+        "bbox": [
+            173,
+            608,
+            823,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 8: Detecting out-of-distribution tweets and blog articles for part-of-speech tagging. All values are percentages. \\*These examples are atypically close to the training distribution. ",
+        "bbox": [
+            174,
+            684,
+            823,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 AUTOMATIC SPEECH RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            737,
+            462,
+            752
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now we consider a task which uses softmax values to construct entire sequences rather than determine an input’s class. Our sequence prediction system uses a bidirectional LSTM with two-layers and a clipped GELU nonlinearity, optimized for 60 epochs with RMSProp trained on $8 0 \\%$ of the TIMIT corpus (Garofolo et al., 1993). The LSTM is trained with connectionist temporal classification (CTC) (Graves et al., 2006) for predicting sequences of phones given MFCCs, energy, and first and second deltas of a 25ms frame. When trained with CTC, the LSTM learns to have its phone label probabilities spike momentarily while mostly predicting blank symbols otherwise. In this way, the softmax is used differently from typical classification problems, providing a unique test for our detection methods. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We do not show how the system performs on correctness/incorrectness detection because errors are not binary and instead lie along a range of edit distances. However, we can perform out-ofdistribution detection. Mixing the TIMIT audio with realistic noises from the Aurora-2 dataset (Hirsch & Pearce, 2000), we keep the TIMIT audio volume at $100 \\%$ and noise volume at $30 \\%$ , giving a mean SNR of approximately 5. Speakers are still clearly audible to the human ear but confuse the phone recognizer because the prediction edit distance more than doubles. For more outof-distribution examples, we use the test examples from the THCHS-30 dataset (Wang & Zhang, 2015), a Chinese speech corpus. Table 9 shows the results. Crucially, when performing detection, we compute the softmax probabilities while ignoring the blank symbol’s logit. With the blank symbol’s presence, the softmax distributions at most time steps predict a blank symbol with high confidence, but without the blank symbol we can better differentiate between normal and abnormal distributions. With this modification, the softmax prediction probabilities allow us to detect whether an example is out-of-distribution. ",
+        "bbox": [
+            173,
+            896,
+            821,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/99c94d77ffbca54814dbc43f0f74335954f2cbe0dfafe85f9554e81e8fc7c51c.jpg",
+        "table_caption": [
+            "Table 9: Detecting out-of-distribution distorted speech. All values are percentages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base</td><td>AUPR In/Base</td><td>AUPR Out/Base</td><td>Pred.Prob (mean)</td></tr><tr><td>TIMIT/TIMIT+Airport</td><td>99/50</td><td>99/50</td><td>99/50</td><td>59</td></tr><tr><td>TIMIT/TIMIT+Babble</td><td>100/50</td><td>100/50</td><td>100/50</td><td>55</td></tr><tr><td>TIMIT/TIMIT+Car</td><td>98/50</td><td>98/50</td><td>98/50</td><td>59</td></tr><tr><td>TIMIT/TIMIT+Exhibition</td><td>100/50</td><td>100/50</td><td>100/50</td><td>57</td></tr><tr><td>TIMIT/TIMIT+Restaurant</td><td>98/50</td><td>98/50</td><td>98/50</td><td>60</td></tr><tr><td>TIMIT/TIMIT+Street</td><td>100/50</td><td>100/50</td><td>100/50</td><td>52</td></tr><tr><td>TIMIT/TIMIT+Subway</td><td>100/50</td><td>100/50</td><td>100/50</td><td>56</td></tr><tr><td>TIMIT/TIMIT+Train</td><td>100/50</td><td>100/50</td><td>100/50</td><td>58</td></tr><tr><td>TIMIT/Chinese</td><td>85/50</td><td>80/34</td><td>90/66</td><td>64</td></tr><tr><td>TIMIT/AII</td><td>97/50</td><td>79/10</td><td>100/90</td><td>58</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            821,
+            270
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            329,
+            825,
+            481
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 ABNORMALITY DETECTION WITH AUXILIARY DECODERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            687,
+            520
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Having seen that softmax prediction probabilities enable abnormality detection, we now show there is other information sometimes more useful for detection. To demonstrate this, we exploit the learned internal representations of neural networks. We start by training a normal classifier and append an auxiliary decoder which reconstructs the input, shown in Figure 1. Auxiliary decoders are sometimes known to increase classification performance (Zhang et al., 2016). The decoder and scorer are trained jointly on in-distribution examples. Thereafter, the blue layers in Figure 1 are frozen. Then we train red layers on clean and noised training examples, and the sigmoid output of the red layers scores how normal the input is. Consequently, noised examples are in the abnormal class, clean examples are of the normal class, and the sigmoid is trained to output to which class an input belongs. After training we consequently have a normal classifier, an auxiliary decoder, and what we call an abnormality module. The gains from the abnormality module demonstrate there are possible research avenues for outperforming the baseline. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            703
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 TIMIT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            263,
+            737
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We test the abnormality module by revisiting the TIMIT task with a different architecture and show how these auxiliary components can greatly improve detection. The system is a three-layer, 1024- neuron wide classifier with an auxiliary decoder and abnormality module. This network takes as input 11 frames and must predict the phone of the center frame, 26 features per frame. Weights are initialized according to (Hendrycks & Gimpel, 2016c). This network trains for 20 epochs, and the abnormality module trains for two. The abnormality module sees clean examples and, as negative examples, TIMIT examples distorted with either white noise, brown noise (noise with its spectral density proportional to $\\bar { 1 } / f ^ { 2 } )$ , or pink noise (noise with its spectral density proportional to $\\bar { 1 } / f$ ) at various volumes. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We note that the abnormality module is not trained on the same type of noise added to the test examples. Nonetheless, Table 10 shows that simple noised examples translate to effective detection of realistically distorted audio. We detect abnormal examples by comparing the typical abnormality module outputs for clean examples with the outputs for the distorted examples. The noises are from Aurora-2 and are added to TIMIT examples with $30 \\%$ volume. We also use the THCHS-30 dataset for Chinese speech. Unlike before, we use the THCHS-30 training examples rather than test set examples because fully connected networks can evaluate the whole training set sufficiently quickly. It is worth mentioning that fully connected deep neural networks are noise robust (Seltzer et al., 2013), yet the abnormality module can still detect whether an example is out-of-distribution. To see why this is remarkable, note that the network’s frame classification error is $2 9 . 6 9 \\%$ on the entire test (not core) dataset, and the average classification error for distorted examples is $3 0 . 4 3 \\%$ —this is unlike the bidirectional LSTM which had a more pronounced performance decline. Because the classification degradation was only slight, the softmax statistics alone did not provide useful outof-distribution detection. In contrast, the abnormality module provided scores which allowed the detection of different-but-similar examples. In practice, it may be important to determine whether an example is out-of-distribution even if it does not greatly confuse the network, and the abnormality module facilitates this. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c159d89e39ea40c09ad147e35aab3c416f3079059337102075505861a175dcad.jpg",
+        "table_caption": [
+            "Table 10: Abnormality modules can generalize to novel distortions and detect out-of-distribution examples even when they do not severely degrade accuracy. All values are percentages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>In-Distribution/ Out-of-Distribution</td><td>AUROC /Base Softmax</td><td>AUROC /Base AbMod</td><td>AUPR In/Base Softmax</td><td>AUPR In/Base AbMod</td><td>AUPR Out/Base Softmax</td><td>AUPR Out/Base AbMod</td></tr><tr><td>TIMIT/+Airport</td><td>75/50</td><td>100/50</td><td>77/41</td><td>100/41</td><td>73/59</td><td>100/59</td></tr><tr><td>TIMIT/+Babble TIMIT/+Car</td><td>94/50</td><td>100/50</td><td>95/41</td><td>100/41</td><td>91/59</td><td>100/59</td></tr><tr><td>TIMIT/+Exhib.</td><td>70/50</td><td>98/50</td><td>69/41</td><td>98/41</td><td>70/59</td><td>98/59</td></tr><tr><td>TIMIT/+Rest.</td><td>91/50</td><td>98/50</td><td>92/41</td><td>98/41</td><td>91/59</td><td>98/59</td></tr><tr><td>TIMIT/+Subway</td><td>68/50 76/50</td><td>95/50</td><td>70/41</td><td>96/41</td><td>67/59</td><td>95/59</td></tr><tr><td>TIMIT/+Street</td><td>89/50</td><td>96/50 98/50</td><td>77/41</td><td>96/41</td><td>74/59</td><td>96/59</td></tr><tr><td></td><td>80/50</td><td>100/50</td><td>91/41</td><td>99/41</td><td>85/59</td><td>98/59</td></tr><tr><td>TIMIT/+Train</td><td>79/50</td><td></td><td>82/41</td><td>100/41 66/12</td><td>77/59</td><td>100/59</td></tr><tr><td>TIMIT/Chinese</td><td>80</td><td>90/50 97</td><td>41/12 77</td><td></td><td>96/88</td><td>98/88</td></tr><tr><td>Average</td><td></td><td></td><td></td><td>95</td><td>80</td><td>98</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            825,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7305d125355391e5f155bbb272e56b8d8dfb864db03f41bcdbaf840cafb93b67.jpg",
+        "table_caption": [
+            "Table 11: Improved detection using the abnormality module. All values are percentages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>In-Distribution / Out-of-Distribution</td><td>AUROC /Base Softmax</td><td>AUROC /Base AbMod</td><td>AUPR In/Base Softmax</td><td>AUPR In/Base AbMod</td><td>AUPR Out/Base Softmax</td><td>AUPR Out/Base</td></tr><tr><td>MNIST/Omniglot</td><td>95/50</td><td>100/50</td><td>95/52</td><td>100/52</td><td>95/48</td><td>AbMod 100/48</td></tr><tr><td>MNIST/notMNIST</td><td>87/50</td><td>100/50</td><td>88/50</td><td>100/50</td><td>90/50</td><td>100/50</td></tr><tr><td>MNIST/CIFAR-10bw</td><td>98/50</td><td>100/50</td><td>98/50</td><td>100/50</td><td>98/50</td><td>100/50</td></tr><tr><td>MNIST/Gaussian</td><td>88/50</td><td>100/50</td><td>88/50</td><td>100/50</td><td>90/50</td><td>100/50</td></tr><tr><td>MNIST/Uniform</td><td>99/50</td><td>100/50</td><td>99/50</td><td>100/50</td><td>99/50</td><td>100/50</td></tr><tr><td>Average</td><td>93</td><td>100</td><td>94</td><td>100</td><td>94</td><td>100</td></tr></table>",
+        "bbox": [
+            173,
+            363,
+            825,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            569,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 MNIST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            269,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, much like in a previous experiment, we train an MNIST classifier with three layers of width 256. This time, we also use an auxiliary decoder and abnormality module rather than relying on only softmax statistics. For abnormal examples we blur, rotate, or add Gaussian noise to training images. Gains from the abnormality module are shown in Table 11, and there is a consistent out-of-sample detection improvement compared to softmax prediction probabilities. Even for highly dissimilar examples the abnormality module can further improve detection. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            485,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The abnormality module demonstrates that in some cases the baseline can be beaten by exploiting the representations of a network, suggesting myriad research directions. Some promising future avenues may utilize the intra-class variance: if the distance from an example to another of the same predicted class is abnormally high, it may be out-of-distribution (Giryes et al., 2015). Another path is to feed in a vector summarizing a layer’s activations into an RNN, one vector for each layer. The RNN may determine that the activation patterns are abnormal for out-of-distribution examples. Others could make the detections fine-grained: is the out-of-distribution example a known-unknown or an unknown-unknown? A different avenue is not just to detect correct classifications but to output the probability of a correct detection. These are but a few ideas for improving error and out-of-distribution detection. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We hope that any new detection methods are tested on a variety of tasks and architectures of the researcher’s choice. A basic demonstration could include the following datasets: MNIST, CIFAR, IMDB, and tweets because vision-only demonstrations may not transfer well to other architectures and datasets. Reporting the AUPR and AUROC values is important, and so is the underlying classifier’s accuracy since an always-wrong classifier gets a maximum AUPR for error detection if error is the positive class. Also, future research need not use the exact values from this paper for comparisons. Machine learning systems evolve, so tethering the evaluations to the exact architectures and datasets in this paper is needless. Instead, one could simply choose a variety of datasets and architectures possibly like those above and compare their detection method with a detector based on the softmax prediction probabilities from their classifiers. These are our basic recommendations for others who try to surpass the baseline on this underexplored challenge. ",
+        "bbox": [
+            174,
+            280,
+            825,
+            431
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            453,
+            318,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We demonstrated a softmax prediction probability baseline for error and out-of-distribution detection across several architectures and numerous datasets. We then presented the abnormality module, which provided superior scores for discriminating between normal and abnormal examples on tested cases. The abnormality module demonstrates that the baseline can be beaten in some cases, and this implies there is room for future research. Our hope is that other researchers investigate architectures which make predictions in view of abnormality estimates, and that others pursue more reliable methods for detecting errors and out-of-distribution inputs because knowing when a machine learning system fails strikes us as highly important. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            595
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            617,
+            356,
+            632
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank John Wieting, Hao Tang, Karen Livescu, Greg Shakhnarovich, and our reviewers for their suggestions. We would also like to thank NVIDIA Corporation for donating several TITAN X GPUs used in this research. ",
+        "bbox": [
+            176,
+            647,
+            825,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            285,
+            726
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dario Amodei, Chris Olah, Jacob Steinhardt, Paul Christiano, John Schulman, and Dan Mane. Con- ´ crete problems in ai safety. arXiv, 2016. ",
+        "bbox": [
+            174,
+            734,
+            823,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ann Bies, Justin Mott, Colin Warner, and Seth Kulick. English Web Treebank, 2012. ",
+        "bbox": [
+            173,
+            771,
+            728,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Bulatov. notMNIST dataset. 2011. ",
+        "bbox": [
+            176,
+            796,
+            464,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jesse Davis and Mark Goadrich. The relationship between precision-recall and ROC curves. In International Conference on Machine Learning (ICML), 2006. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tom Fawcett. An introduction to ROC analysis. Pattern Recognition Letters, 2005. ",
+        "bbox": [
+            174,
+            857,
+            717,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Garofolo, Lori Lamel, William Fisher, Jonathan Fiscus, David Pallett, Nancy Dahlgren, and Victor Zue. TIMIT Acoustic-Phonetic Continuous Speech Corpus. Linguistic Data Consortium, 1993. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kevin Gimpel, Nathan Schneider, Brendan $\\mathrm { O ^ { \\prime } }$ Connor, Dipanjan Das, Daniel Mills, Jacob Eisenstein, Michael Heilman, Dani Yogatama, Jeffrey Flanigan, and Noah A. Smith. Part-of-Speech Tagging for Twitter: Annotation, Features, and Experiments. Association for Computational Linguistics (ACL), 2011. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raja Giryes, Guillermo Sapiro, and Alex M. Bronstein. Deep neural networks with random gaussian weights: A universal classification strategy? arXiv, 2015. ",
+        "bbox": [
+            173,
+            169,
+            821,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            173,
+            207,
+            821,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Santiago Fernandez, Faustino Gomez, and J ´ urgen Schmidhuber. Connectionist tem- ¨ poral classification: Labeling unsegmented sequence data with recurrent neural networks. In International Conference on Machine Learning (ICML), 2006. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            289
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Kevin Gimpel. Methods for detecting adversarial images and a colorful saliency map. arXiv, 2016a. ",
+        "bbox": [
+            174,
+            297,
+            823,
+            327
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Kevin Gimpel. Bridging nonlinearities and stochastic regularizers with Gaussian error linear units. arXiv, 2016b. ",
+        "bbox": [
+            174,
+            335,
+            821,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Kevin Gimpel. Adjusting for dropout variance in batch normalization and weight initialization. arXiv, 2016c. ",
+        "bbox": [
+            174,
+            375,
+            821,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hans-Gunter Hirsch and David Pearce. The Aurora experimental framework for the performance¨ evaluation of speech recognition systems under noisy conditions. ISCA ITRW ASR2000, 2000. ",
+        "bbox": [
+            174,
+            411,
+            820,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. ¨ Long short-term memory. Neural Computation, 1997. ",
+        "bbox": [
+            176,
+            450,
+            808,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minqing Hu and Bing Liu. Mining and Summarizing Customer Reviews. Knowledge Discovery and Data Mining (KDD), 2004. ",
+        "bbox": [
+            173,
+            474,
+            821,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohit Iyyer, Varun Manjunatha, Jordan Boyd-Graber, and Hal Daume Iii. ´ Deep Unordered Composition Rivals Syntactic Methods for Text Classification. Association for Computational Linguistics (ACL), 2015. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. arXiv, 2016. ",
+        "bbox": [
+            171,
+            564,
+            823,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. International Conference for Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            173,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning Multiple Layers of Features from Tiny Images, 2009. ",
+        "bbox": [
+            174,
+            641,
+            707,
+            657
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 2015. ",
+        "bbox": [
+            171,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ken Lang. Newsweeder: Learning to filter netnews. In International Conference on Machine Learning (ICML), 1995. ",
+        "bbox": [
+            174,
+            704,
+            823,
+            733
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David D. Lewis, Yiming Yang, Tony G. Rose, and Fan Li. Rcv1: A new benchmark collection for text categorization research. Journal of Machine Learning Research (JMLR), 2004. ",
+        "bbox": [
+            173,
+            742,
+            823,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with restarts. arXiv, 2016. ",
+        "bbox": [
+            171,
+            780,
+            797,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Association for Computational Linguistics (ACL), 2011. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris Manning and Hinrich Schutze. ¨ Foundations of Statistical Natural Language Processing. MIT Press, 1999. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P. Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of English: The Penn Treebank. Computational linguistics, 1993. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In Computer Vision and Pattern Recognition (CVPR), 2015. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Khanh Nguyen and Brendan O’Connor. Posterior calibration and exploratory analysis for natural language processing models. In Empirical Methods in Natural Language Processing (EMNLP), 2015. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olutobi Owoputi, Brendan O’Connor, Chris Dyer, Kevin Gimpel, Nathan Schneider, and Noah A. Smith. Improved part-of-speech tagging for online conversational text with word clusters. In North American Chapter of the Association for Computational Linguistics (NAACL), 2013. ",
+        "bbox": [
+            174,
+            205,
+            826,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bo Pang, Lillian Lee, and Shivakumar Vaithyanathan. Thumbs up? sentiment classification using machine learning techniques. In Empirical Methods in Natural Language Processing (EMNLP), 2002. ",
+        "bbox": [
+            174,
+            257,
+            826,
+            300
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Foster Provost, Tom Fawcett, and Ron Kohavi. The case against accuracy estimation for comparing induction algorithms. In International Conference on Machine Learning (ICML), 1998. ",
+        "bbox": [
+            174,
+            309,
+            823,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takaya Saito and Marc Rehmsmeier. The precision-recall plot is more informative than the ROC plot when evaluating binary classifiers on imbalanced datasets. In PLoS ONE. 2015. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael L. Seltzer, Dong Yu, and Yongqiang Wang. Investigation of deep neural networks for noise robust speech recognition. In IEEE International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2013. ",
+        "bbox": [
+            173,
+            385,
+            825,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Steinhardt and Percy Liang. Unsupervised risk estimation using only conditional independence structure. In Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            173,
+            436,
+            823,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Wang and Xuewei Zhang. Thchs-30 : A free chinese speech corpus. In Technical Report, 2015. ",
+        "bbox": [
+            174,
+            473,
+            823,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gethin Williams and Steve Renals. Confidence measures for hybrid hmm/ann speech recognition. In Proceedings of EuroSpeech, 1997. ",
+        "bbox": [
+            173,
+            512,
+            823,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jianxiong Xiao, James Hays, Krista A. Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2010. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Yu, Jinyu Li, and Li Deng. Calibration of confidence measures in speech recognition. In IEEE Transactions on Audio, Speech, and Language, 2010. ",
+        "bbox": [
+            171,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. British Machine Vision Conference, 2016. ",
+        "bbox": [
+            171,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuting Zhang, Kibok Lee, and Honglak Lee. Augmenting supervised neural networks with unsupervised objectives for large-scale image classification. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            173,
+            676,
+            821,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ABNORMALITY MODULE EXAMPLE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            509,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/4beb57de31bda8242253be43662a1c5fae8e3fd3913d61f222a67c58469a7a8a.jpg",
+        "image_caption": [
+            "Figure 1: A neural network classifying a diamond image with an auxiliary decoder and an abnormality module. Circles are neurons, either having a GELU or sigmoid activation. The blurred diamond reconstruction precedes subtraction and elementwise squaring. The probability vector is the softmax probability vector. Blue layers train on in-distribution data, and red layers train on both in- and out-of-distribution examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            138,
+            816,
+            523
+        ],
+        "page_idx": 11
+    }
+]

parse/train/TmLqkYn71gV/TmLqkYn71gV.md

@@ -0,0 +1,263 @@
+# Learning to Iteratively Solve Routing Problems with Dual-Aspect Collaborative Transformer
+
+Yining $\mathbf { M } \mathbf { a } ^ { 1 }$ , Jingwen $\mathbf { L i } ^ { 1 }$ , Zhiguang $\mathbf { C a o ^ { 2 , * } }$ , Wen Song3,∗, Le Zhang4, Zhenghua Chen5, Jing Tang6
+
+1National University of Singapore 2Singapore Institute of Manufacturing Technology, A\*STAR 3Institute of Marine Science and Technology, Shandong University 4University of Electronic Science and Technology of China 5Institute for Infocomm Research, A\*STAR 6The Hong Kong University of Science and Technology {yiningma, lijingwen}@u.nus.edu, zhiguangcao@outlook.com, wensong@email.sdu.edu.cn, zhangleuestc@gmail.com, chen0832@e.ntu.edu.sg, jingtang@ust.hk
+
+# Abstract
+
+Recently, Transformer has become a prevailing deep architecture for solving vehicle routing problems (VRPs). However, it is less effective in learning improvement models for VRP because its positional encoding (PE) method is not suitable in representing VRP solutions. This paper presents a novel Dual-Aspect Collaborative Transformer (DACT) to learn embeddings for the node and positional features separately, instead of fusing them together as done in existing ones, so as to avoid potential noises and incompatible correlations. Moreover, the positional features are embedded through a novel cyclic positional encoding (CPE) method to allow Transformer to effectively capture the circularity and symmetry of VRP solutions (i.e., cyclic sequences). We train DACT using Proximal Policy Optimization and design a curriculum learning strategy for better sample efficiency. We apply DACT to solve the traveling salesman problem (TSP) and capacitated vehicle routing problem (CVRP). Results show that our DACT outperforms existing Transformer based improvement models, and exhibits much better generalization performance across different problem sizes on synthetic and benchmark instances, respectively.
+
+# 1 Introduction
+
+Vehicle Routing problems (VRPs), such as the Traveling Salesman Problem (TSP) and the Capacitated Vehicle Routing Problem (CVRP) which consider finding the optimal route for a single or fleet of vehicles to serve a set of customers, have ubiquitous real-world applications [1, 2]. Despite being intensively studied in the Operations Research (OR) community, VRPs still remain challenging due to their NP-hard nature [3]. Recent studies on learning neural heuristics are gathering attention as promising extensions to traditional hand-crafted ones (e.g., [4–14]), where reinforcement learning (RL) [15] is usually exploited to train a deep neural network as an efficient solver without hand-crafted rules. A salient motivation is that deep neural networks may learn better heuristics by identifying useful patterns in an end-to-end and data-driven fashion.
+
+Solutions to VRPs, i.e., routes, are sequences of nodes (customer and depot locations). Naturally, deep models for Natural Language Processing (NLP), which deal with sequence data as well, are ideal choices for encoding VRP solutions. Given its remarkable performance in NLP tasks, Transformer [16] is standing at the forefront in the learning based methods for VRPs (e.g., [5, 7, 8, 11–13, 17]). The original Transformer encodes a sentence, i.e., a sequence of words, into a unified set of embeddings by injecting word positional information into its word embeddings through positional encoding (PE). When it comes to VRPs, while is not required in construction models, positional information is critical for deep models that learn improvement heuristics since the input are solutions to be improved.
+
+![](images/17403d04b62870e5603e11128aad37f05c9529785e72e7e24fbc237438272fea.jpg)  
+Figure 1: Transformer frameworks for VRPs. (a) $\mathrm { W u }$ et al. [11] (the original one); (b) DACT (ours).
+
+Although some success has been achieved, learning improvement heuristics for VRPs based on the original Transformer encoder is yet lacking from our perspective. Firstly, directly applying addition operation on PE vectors and the embeddings in absolute PE method (i.e., Figure 1(a)) could limit the representation of the model [18], as the mixed correlations2 existing in the self-attention can bring unreasonable noises and random biases to the encoder (details in Appendix A). Secondly, existing PE methods tend to fuse the node and positional information into one unified representation. NLP tasks such as translation may benefit from this owing to the deterministic and instructive nature of the positional information. However, such design may not be optimal for routing tasks because the positional information therein can be non-deterministic and sometimes even random. This may cause disharmony or disturbance in the encoder and may thus deteriorate the performance. Finally, most VRPs seek the shortest loop of the nodes, making their solutions to be cyclic sequences. However, existing PE methods are only designated to encode linear sequences3, which may fail to identify such circular input. As will be shown in our experiments, this could severely damage the generalization performance, since the cyclic feature of VRP solutions is not correctly reflected by the encoder.
+
+In this paper, we address the above issues and contribute to the line of using RL to learn neural improvement heuristics for VRPs. We introduce the Dual-Aspect Collaborative Transformer (DACT), where we revisit the solution representations and propose to learn separated groups of embeddings for the node and positional features of a VRP solution as shown in Figure 1(b). Our DACT follows the encoder-decoder structure. In the encoder, each set of embeddings encodes the solution mainly from its own aspect, and at the same time exploits a cross-aspect referential attention mechanism for better perceiving the consistence and differentiation with respect to the other aspect. The decoder then collects action distribution proposals from the two aspects and synthesizes them to output the final one. Meanwhile, we design a novel cyclic positional encoding (CPE) method to capture the circularity and symmetry of VRP solutions, which allows Transformer to encode cyclic inputs, and also boost the generalization performance for solving VRPs. As the last contribution, we design a simple yet effective curriculum learning strategy to improve the sample efficiency. This further leads to faster and more stable convergence of RL training. Extensive experiments show that our DACT can outperform existing Transformer based improvement models with fewer parameters, and also generalizes well across different sizes of synthetic and benchmark instances, respectively.
+
+# 2 Related work
+
+# 2.1 Positional encoding (PE) in Transformer.
+
+The original Transformer adopted the absolute PE method to describe the absolute position of elements in the sequence [16], especially for NLP. As formulated in Eq. (1), each generated positional embedding $p _ { i } \in \mathbb { R } ^ { d }$ is added together with the $i$ -th word embedding $x _ { i }$ in the first layer of the encoder,
+
+$$
+\alpha _ { i , j } ^ { \mathrm { A b s } } = \frac { 1 } { \sqrt { d } } ( ( x _ { i } + p _ { i } ) W ^ { Q } ) ( ( x _ { j } + p _ { j } ) W ^ { K } ) ^ { T } .
+$$
+
+The relative PE method was further proposed in Shaw et al. [19] to better capture the relative order information. On the basis of absolute PE, it introduces an inductive bias to the attention as follows,
+
+$$
+\alpha _ { i , j } ^ { \mathrm { R e l } } = \frac { 1 } { \sqrt { d } } ( ( x _ { i } + p _ { i } ) W ^ { Q } ) ( ( x _ { j } + p _ { j } ) W ^ { K } + a _ { j - i } ) ^ { T } ,
+$$
+
+where $a _ { j - i } \in \mathbb { R } ^ { d }$ is learnable parameters for encoding the relative position $j - i$ . To avoid the mixed and noisy correlations between word semantics and positional information in the above two PEs, the Transformer with United Positional Encoding (TUPE) [18] was proposed for NLP which utilizes separated projection metrics $W _ { x }$ and $W _ { p }$ for each information as follows,
+
+$$
+\alpha _ { i , j } ^ { \mathrm { T U P E } } = \frac { 1 } { \sqrt { 2 d } } ( x _ { i } W _ { x } ^ { Q } ) ( x _ { j } W _ { x } ^ { K } ) ^ { T } + \frac { 1 } { \sqrt { 2 d } } ( p _ { i } W _ { p } ^ { Q } ) ( p _ { j } W _ { p } ^ { K } ) ^ { T } + b _ { j - i } .
+$$
+
+However, as mentioned previously, existing PE methods are less effective for VRPs since they simply fuse the node and positional information into one unified set of embeddings during or after the calculation of the attention correlation $\alpha _ { i , j }$ . Meanwhile, they are also unable to properly encode and handle cyclic input sequences as in VRP solutions.
+
+# 2.2 Deep models for VRP.
+
+Various deep architectures such as Recurrent Neural Network (RNN), Graph Neural Network (GNN), and Transformer have been employed in solving VRPs.
+
+RNN based models. As the pioneering work of neural VRP solvers, Pointer Network adopted RNN and supervised learning to solve TSP [20] (extended to RL in Bello et al. [21] and CVRP in Nazari et al. [22]). While the models in [20–23] learn construction heuristics, NeuRewriter [4] learns improvement heuristic for CVRP using LSTM to encode the positional information of a solution. In Hottung et al. [13], the conditional variational autoencoder was adopted to learn a continuous and latent search space for VRP, where high-quality solutions were taken as input and encoded by RNNs. However, recurrence structures in RNN are less efficient in both representation and computation [5].
+
+GNN based models. In Dai et al. [24], GNN was combined with Q-learning for solving TSP. Based on supervised learning, Joshi et al. [6] used GNN to learn heatmaps that prescribe the probability of each edge appearing in the optimal TSP tour. This idea was extended in Fu et al. [25] with additional components such as graph sampling and heatmap merging to enable generalization to larger TSP instances. These models often require post-processing to construct feasible solutions from heatmaps (e.g., beam search [6], Monte-Carlo tree search [25], and dynamic programming [26]).
+
+Transformer based models. The Attention Model (AM) by Kool et al. [5] was recognized as the first success of Transformer based models for VRPs. Based on AM, Xin et al. [7] proposed a MultiDecoder AM that learns multiple diverse policies for better performance. In Kwon et al. [8], the RL algorithm of AM was improved which leaded to a new solver, i.e., POMO (Policy Optimization with Multiple Optima), and achieved the state-of-the-art performance. However, POMO is still lacking in generalization. Besides these construction models, Transformer was also explored to learn improvement heuristics. Hottung and Tierney [27] learned first neural large neighborhood search algorithm for VRPs. Lu et al. [12] proposed the L2I model that learns to select local search operators from a pool of traditional ones. Both methods used a Transformer-style encoder, but the positional information is captured in the node features (information of previous and next nodes) instead of using PE methods. Though L2I was shown to outperform LKH3 [28], it is limited to CVRP and the required time is considerably long. Wu et al. [11] proposed a Transformer model which learns to pick node pair in each step to perform a pairwise local operator (e.g., 2-opt). However, it suffers from the inaccurate representation of positional information given the original Transformer encoder.
+
+![](images/5ace11ce359bbb755998396b80534ff05688295f43970028840cdf0661b073b3.jpg)  
+Figure 3: Architecture of our policy network, dual-aspect collaborative Transformer (DACT).
+
+# 3 Problem formulation
+
+We define a VRP instance as a group of $N$ nodes to visit, where the node feature $x _ { i }$ of node $i$ contains 2-dim coordinates and other problem-specific features (e.g., customer demand). A solution $\delta$ consists of a sequence of nodes visited in order where we denote $p _ { i }$ to be the position (indices) of node $i$ in the solution which is deemed as the positional feature of node $i$ . The objective is to minimize the total travel distance $D ( \delta )$ under certain problem-specific constraints.
+
+Starting with an initial yet complete solution, our neural RL policy tries to improve the solution iteratively. At each step, the policy automatically selects a pair of nodes and locally adjusts the solution using a preset pairwise operator such as 2-opt, insert, or swap. As illustrated in Figure 2, given a node pair $( i , j )$ , the 2-opt operator adjusts a solution by reversing the segment between node $i$ and node $j$ ; the insert operator adjusts a solution by placing node $i$ after node $j$ ; and the swap operator adjusts a solution by exchanging the position of node $i$ and node $j$ . Such operation is repeated until reaching the step limit $T$ and we model it in the form of Markov Decision Process (MDP) as follows.
+
+![](images/3abc3c66ae47d31052903aafee9790f52c0e269b59a1a7ed0217c149d678c265.jpg)  
+Figure 2: Illustration examples of three pairwise operators for routing problems when node pair $( i = 2 , j = 1 )$ ) is specified for operating. From left to right: 2-opt, insert, and swap.
+
+State. For an instance with $N$ nodes, a state describes current solution $\delta _ { t }$ using its node and positional features of each node, i.e., $s _ { t } = \Psi ( \delta _ { t } ) = \{ x _ { 1 } ^ { t } , . . . , x _ { N } ^ { t } , p _ { 1 } ^ { t } , . . . , p _ { N } ^ { t } \}$ .
+
+Action. The action $a _ { t } = ( i , j )$ specifies a node pair $( i , j )$ for the pairwise operator.
+
+Reward. The reward function is defined as, $r _ { t } = D ( \delta _ { t } ^ { * } ) - m i n \left[ D ( \delta _ { t + 1 } ) , D ( \delta _ { t } ^ { * } ) \right]$ where $\delta _ { t } ^ { * }$ is the best incumbent solution found until time $t$ . It refers to the immediate reduced cost at each step with respects to the best incumbent solution, which ensures the cumulative reward equal to the total reduced cost over the initial solution. Hence the reward $r _ { t } > 0$ if and only if a better solution is found. Policy. The policy $\pi _ { \theta }$ is parameterized by the proposed DACT model with parameters $\theta$ . At each time step, the action $( i , j )$ is obtained by sampling the stochastic policy for both training and inference.
+
+Transition. The next state $s _ { t + 1 }$ is originated from $s _ { t }$ by performing the preset pairwise operator on the given node pair (action). Our state transient is deterministic, in the sense that it always accepts the next solution as the next state (infeasible solutions will be masked), regardless of its objective value. With such simple rule, the RL agent is expected to automatically learn how to combine multiple steps of simple local movements to achieve better solutions, even if some of them may worsen the current solution. Note that the step limit $T$ can be any user-specified value according to the allowed time budget. Hence, our MDP can have infinite horizon and we consider the reward discount factor $\gamma < 1$ .
+
+# 4 Dual-aspect collaborative Transformer model
+
+We now present the details of our Dual-Aspect Collaborative Transformer (DACT). The concrete architecture of DACT is presented in Figure 3, where we take the TSP with $N$ nodes as an illustration example. Our DACT leverages separate aspects of embeddings to encode a VRP solution. In the DAC encoder, the self-attention correlations are computed individually for each aspect, and a cross-aspect referential attention mechanism is proposed to enable one aspect to effectively exploit attention correlations from the other aspect as optional references. The DAC decoder then collects action distribution proposals from both aspects and synthesize them to the final one.
+
+![](images/89f6fef802cd35891d1ed76d002b348f40ea6b89b2545c5f6d954311286d8b4a.jpg)  
+Figure 5: Comparison of our CPE method with absolute PE method on a TSP instance with 20 nodes. (a) the embedding vectors, (b) the correlations (dot products) between every two embeddings, and (c) the top two principal components after PCA (principal component analysis) projection.   
+Figure 4: An example of cyclic Gray code where 4 digits are used to encode $N { = } 1 6$ nodes. The top left shows the base symmetry pattern $\cdot _ { 1 0 0 1 }$ ’ in Gray code, and the top right plots its representation in our method.
+
+# 4.1 Dual-aspect solution representation
+
+Specifically, we propose to learn two sets of embeddings, i.e., the node feature embeddings (NFEs) for node representation and the positional feature embeddings (PFEs) for positional representation.
+
+NFEs. Following [5, 11], the NFE $h _ { i }$ of node $i$ is initialized as the linear projection of its node feature $x _ { i }$ with output dimension4 $d i m = 6 4$ .
+
+PFEs. The PFE $g _ { i }$ of the positional feature $p _ { i }$ is initialized as a real-valued vector $( d i m = 6 4 )$ by applying our cyclic positional encoding (CPE), which is designed based on cyclic Gray codes [29].
+
+<table><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>15</td><td rowspan=1 colspan=1>16</td></tr><tr><td rowspan=2 colspan=1>11</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr></table>
+
+As illustrated in Figure 4, the cyclic Gray codes present a cyclic property (‘1110’ in the last column is adjacent to ‘1111’ in the first column) and an adjacency similarity property (any codes in adjacent columns only differ in one digit), both of which are desirable for cyclic sequences. To preserve these properties in designing our CPE, we follow two observed patterns: 1) each numerical digit contains a periodic cycle with reflectional symmetry, e.g., the $\mathbf { \dot { \rho } } _ { 1 0 | 0 1 } ,$ in the lowest digit; and 2) the higher the numerical digit, the longer the period. Accordingly, we create similar patterns based on the sinusoidal functions in Eq. (4), where a periodic function with period $\frac { 4 \pi } { \omega _ { d } }$ (induced by modulus) is used to generate one base symmetry pattern (the top right in Figure 4),
+
+$$
+\begin{array} { r } { \overrightarrow { g _ { i } ^ { \prime } } ^ { ( d ) } : = \left\{ \begin{array} { l l } { s i n ( \omega _ { d } \cdot \mathrm { \Gamma } ( z ( i ) \bmod \frac { 4 \pi } { \omega _ { d } } ) - \frac { 2 \pi } { \omega _ { d } } \mathrm { \Gamma } ) , \mathrm { ~ i f ~ } d \mathrm { ~ i s ~ e v e n } } \\ { c o s ( \omega _ { d } \cdot \mathrm { \Gamma } ( z ( i ) \bmod \frac { 4 \pi } { \omega _ { d } } ) - \frac { 2 \pi } { \omega _ { d } } \mathrm { \Gamma } ) , \mathrm { ~ i f ~ } d \mathrm { ~ i s ~ o d d } } \end{array} \right. } \end{array}
+$$
+
+$\begin{array} { r } { z ( i ) = \frac { i - 1 } { N } \frac { 2 \pi } { \omega _ { d } } \left\lceil \frac { N + 1 } { 2 \pi / \omega _ { d } } \right\rceil } \end{array}$ is to make $N$ nodes linearly spaced in the generated pattern; the angular frequency $\omega _ { d }$ is decreasing along the dimension to make the wavelength longer within the range $[ N ^ { \frac { 1 } { [ d i m / 2 ] } } , N ]$ (see Appendix B for details). In Figure 5, we visualize the comparison between the absolute PE and our CPE for encoding a TSP instance of 20 nodes. Figure 5(a) demonstrates that our real-valued base symmetry pattern has a longer cyclic period as the digit grows. Figure 5(b) indicates that our method (blue) is able to correctly reflect the adjacency between the head and tail of the cyclic sequence whereas the PE method (red) fails to do so. Figure 5(c) verifies that our CPE vectors are well distributed in space with desired cyclic and adjacency similarity properties.
+
+# 4.2 The encoder
+
+The encoder consists of $L = 3$ stacked DAC encoders. In each DAC encoder, we retain relatively independent encoding stream for NFEs and PFEs as in Eq. (5) and Eq. (6), respectively, each of which consists of a shared Dual-Aspect Collaborative Attention (DAC-Att) sub-layer and an independent feed-forward network (FFN) sub-layer. DAC-Att takes both sets of embeddings as input and then outputs their respective enhanced embeddings, i.e., NFEs $\{ \tilde { h } \} _ { i = 1 } ^ { N }$ and PFEs $\{ \tilde { g } \} _ { i = 1 } ^ { N }$ . Each sub-layer is followed by skip connection [30] and layer normalization [31] as same as the original Transformer.
+
+$$
+\begin{array} { r } { h _ { i } ^ { ( l ) } = \mathbf { L N } \Big ( h _ { i } ^ { \prime } + \mathbf { F F N } _ { h } ^ { ( l ) } ( h _ { i } ^ { \prime } ) \Big ) , h _ { i } ^ { \prime } = \mathbf { L N } \Big ( h _ { i } ^ { ( l - 1 ) } + \tilde { h } _ { i } ^ { ( l ) } \Big ) , } \\ { g _ { i } ^ { ( l ) } = \mathbf { L N } \Big ( g _ { i } ^ { \prime } + \mathbf { F F N } _ { g } ^ { ( l ) } ( g _ { i } ^ { \prime } ) \Big ) , g _ { i } ^ { \prime } = \mathbf { L N } \Big ( g _ { i } ^ { ( l - 1 ) } + \tilde { g } _ { i } ^ { ( l ) } \Big ) . } \end{array}
+$$
+
+DAC-Att. The DAC-Att sub-layer enhances each set of embedding from its own aspect, while leveraging attention correlations from the other aspect to achieve the synergy. Given the two sets of embeddings5, $\{ h _ { i } \} _ { i = 1 } ^ { N }$ and $\{ g _ { i } \} _ { i = 1 } ^ { N }$ , we first compute the self-attention correlation from both aspects,
+
+$$
+\alpha _ { i , j } ^ { h } = \frac { 1 } { \sqrt { d _ { k } } } \left( h _ { i } W _ { h } ^ { Q } \right) \left( h _ { j } W _ { h } ^ { K } \right) ^ { T } , \quad \alpha _ { i , j } ^ { g } = \frac { 1 } { \sqrt { d _ { k } } } \left( g _ { i } W _ { g } ^ { Q } \right) \left( g _ { j } W _ { g } ^ { K } \right) ^ { T } ,
+$$
+
+where independent matrices $W _ { h } ^ { Q } , W _ { h } ^ { K } , W _ { g } ^ { Q }$ and $W _ { g } ^ { K } \in \mathbb { R } ^ { d i m \times d _ { k } }$ are used to calculate queries and keys. The obtained correlations are further normalized to $\tilde { \alpha } _ { i , j } ^ { h }$ and $\tilde { \alpha } _ { i , j } ^ { g }$ via Softmax. Note that the correlations are computed from their own aspect, which eliminates possible noises and conduces to correctly describe the incompatible node pair relationships in different aspects of VRP solutions.
+
+We then exploit a cross-aspect referential attention mechanism, which allows computed correlations to be shared between each other, as additional references for both contradistinction and collaboration,
+
+$$
+\mathrm { o u t } _ { i } ^ { h } = \mathrm { C o n c a t } \left[ \sum _ { j = 1 } ^ { N } \tilde { \alpha } _ { i , j } ^ { h } \left( h _ { j } W _ { h } ^ { V } \right) , \sum _ { j = 1 } ^ { N } \tilde { \alpha } _ { i , j } ^ { g } \left( h _ { j } W _ { h } ^ { V r e f } \right) \right] ,
+$$
+
+$$
+\mathrm { o u t } _ { i } ^ { g } = \mathrm { C o n c a t } \left[ \sum _ { j = 1 } ^ { N } { \tilde { \alpha } } _ { i , j } ^ { g } \left( g _ { j } W _ { g } ^ { V } \right) , \sum _ { j = 1 } ^ { N } { \tilde { \alpha } } _ { i , j } ^ { h } \left( g _ { j } W _ { g } ^ { V r e f } \right) \right] ,
+$$
+
+wheand $W _ { h } ^ { V } , W _ { g } ^ { V } \in \mathbb R ^ { d i m \times d _ { v } }$ are trainable parameter matrices for formulating values in each aspect; are parameter matrices for each aspect to generate referential values. $W _ { h } ^ { V r e f } , W _ { g } ^ { V r e f } \in \mathbb R ^ { d i m \times d _ { v } }$ We finally use the multi-head attention to get NFEs $\tilde { h } _ { i }$ and PFEs $\tilde { g } _ { i }$ as follows,
+
+$$
+\begin{array} { r } { \begin{array} { c } { \tilde { h } _ { i } , \tilde { g } _ { i } = \mathbf { D A C - A t t } \left( W ^ { Q } , ~ W ^ { K } , W ^ { V } , W ^ { V _ { r e f } } , W ^ { O } \right) , } \\ { \tilde { h } _ { i } = \mathbf { C o n c a t } \left[ \mathrm { h e a d } _ { i , 1 } ^ { h } , . . . , \mathrm { h e a d } _ { i , m } ^ { h } \right] W _ { h } ^ { O } , ~ \tilde { g } _ { i } = \mathbf { C o n c a t } \left[ \mathrm { h e a d } _ { i , 1 } ^ { g } , . . . , \mathrm { h e a d } _ { i , m } ^ { g } \right] W _ { g } ^ { O } , } \end{array} } \end{array}
+$$
+
+where h $\mathbf { e a d } _ { i , k } ^ { h } = o u t _ { i , k } ^ { h }$ , $\mathbf { h e a d } _ { i , k } ^ { g } = o u t _ { i , k } ^ { g }$ , and $W _ { h } ^ { O } , W _ { g } ^ { O } \ \in \ \mathbb { R } ^ { 2 m d _ { v } \times d i m }$ are trainable parameter matrices. In our model, we adopt $m = 4$ and $d _ { k } = d _ { v } = 1 6$ .
+
+FFN. Our FFN sub-layer has only one hidden layer with 64 hidden unites and adopts the ReLU activation function. The parameters of $\mathbf { F F N } _ { h }$ and $\mathbf { F F N } _ { g }$ are different for each group of embeddings.
+
+# 4.3 The decoder
+
+In the DAC decoder, the two sets of embeddings $\{ h _ { i } ^ { ( L ) } \} _ { i = 1 } ^ { N }$ and $\{ g _ { i } ^ { ( L ) } \} _ { i = 1 } ^ { N }$ are first passed through a Max-pooling sub-layer and a multi-head compatibility (MHC) sub-layer to independently generate diversified node-pair selection proposals from their own aspect, which are then aggregated through a feed-forward aggregation (FFA) sub-layer for output.
+
+Max-pooling. For each set of embeddings, we adopt the max-pooling sub-layer in Wu et al. [11] to aggregate the global representation of all $N$ embeddings into each respective one6.
+
+MHC. The compatibility sub-layer computes the attention correlations for each embedding pair, where the obtained correlations with size $N \times N$ will be deemed as a proposal distribution for node pair selection. Our correlations are computed based on multiple heads for diversity. And we calculate separated attention score matrices $\boldsymbol { Y } _ { k } ^ { h } , \boldsymbol { \dot { Y } } _ { k } ^ { g } \in \mathbb { R } ^ { N \times N }$ (of head $k$ ) from the two aspects independently. Accordingly, the action distribution proposals would be different due to their aspect-specific focus and cognitions of the current solution, which will provide the subsequent FFA layer with a rich pool of proposals and allow our model to be more flexible and robust.
+
+FFA. Once all proposals from two aspects are collected, a FFN with four layers (dimensions are $2 m$ , 32, 32 and 1, respectively) and ReLU activation is used to aggregate them,
+
+$$
+\tilde { Y } _ { i , j } = \mathbf { F } \mathbf { F } \mathbf { A } \left( Y _ { i , j , 1 } ^ { g } , . . . , Y _ { i , j , m } ^ { g } , Y _ { i , j , 1 } ^ { h } , . . . Y _ { i , j , m } ^ { h } \right) ,
+$$
+
+where $m = 4$ is the number of heads; and the output $\tilde { Y } _ { i , j }$ is a scalar indicating the likelihood of selecting node pair $( i , j )$ as an action. Afterwards, we apply $\hat { Y } _ { i j } = C \cdot \mathrm { T a n h } ( \tilde { Y } _ { i , j } )$ with $C = 6$ to control the entropy, and mask 7 the infeasible node pairs $( i ^ { \prime } , j ^ { \prime } )$ as $\hat { Y } _ { i ^ { \prime } j ^ { \prime } } = - \infty$ . Lastly, the likelihoods are normalized using Softmax function to obtain the final action distribution $P _ { i , j }$ .
+
+# 4.4 Reinforcement learning algorithm
+
+We adopt the proximal policy optimization [32] with $n$ -step return estimation for training (details are given in Appendix C), and design a curriculum learning (CL) strategy for better sample efficiency.
+
+Curriculum learning strategy. The strategy in Wu et al. [11] sets a maximum of $T _ { t r a i n }$ steps for training and estimates future returns by bootstrapping [33]. However, due to the concern of training cost, $T _ { t r a i n }$ is usually much smaller than actual $T$ for inference (e.g., 200 v.s. 10k), which may leave the agent a poor chance of observing high-quality solutions (states) during training. Consequently, it may cause high variance for bootstrapping because the value function is mostly fitted on low-quality solutions and may render it less knowledgeable in estimating long-term future returns accurately. In this paper, we tackle this issue by a simple yet efficient strategy which gradually prescribes higher-quality solutions as the initial states for training. In doing so, 1) it increases the probability for the agent to observe better solutions and thus reduce the variance of the value function; 2) it increases the difficulty of the learning task (higher-quality solutions are harder to improve) in a gradual manner and achieves better sample efficiency [34]. In practice, those higher-quality solutions can be easily achieved by improving the randomly generated ones using the current policy for a few $T _ { i n i t }$ steps, where $T _ { i n i t }$ could be slightly increased as the epoch grows.
+
+# 5 Experiments
+
+We evaluate our DACT model on two representative routing problems, i.e., TSP and CVRP [5, 8, 11]. For each problem, we abide by existing conventions to randomly generate instances on the fly for three sizes, i.e., $N = 2 0$ , 50 and 100. Initial experiments with three operators including 2-opt, swap and insert show that 2-opt performs best for both TSP and CVRP (with insert better than swap), hence we report results of our method based on 2-opt. Following [4, 11, 27] we use randomly generated initial solutions for training and the solutions generated by the greedy algorithm for inference. Since each problem has its own constraints and node features, we adjust the input, feasibility masks, and problem-dependent hyperparameters for each problem, the details of which are provided in Appendix D and E. The DACT is trained and tested on a server equipped with TITAN RTX GPU cards and Intel i9-10940X CPU at $3 . 3 0 \mathrm { G H z }$ . Our code in PyTorch are available here8.
+
+Table 1: Comparison with various baselines on TSP and CVRP.   
+
+<table><tr><td rowspan="2" colspan="2">Method</td><td colspan="3">N=20</td><td colspan="3">N=50</td><td colspan="3">N=100</td></tr><tr><td>Obj.</td><td>Gap</td><td>Time</td><td>Obj.</td><td>Gap</td><td>Time</td><td>Obj.</td><td>Gap</td><td>Time</td></tr><tr><td rowspan="10">LKH P</td><td>Concorde</td><td>3.83</td><td>=</td><td>(3m)</td><td>5.70</td><td></td><td>(10m)</td><td>7.76</td><td></td><td>(1h)</td></tr><tr><td></td><td>3.83</td><td>0.00%</td><td>(38s)</td><td>5.70</td><td>0.00%</td><td>(5m)</td><td>7.76</td><td>0.00%</td><td>(20m)</td></tr><tr><td>OR-Tools</td><td>3.86</td><td>0.94%</td><td>(42s)</td><td>5.85</td><td>2.87%</td><td>(5m)</td><td>8.06</td><td>3.86%</td><td>(23m)</td></tr><tr><td>Neural-2-Opt [23]</td><td>3.84</td><td>0.00%</td><td>(15m)</td><td>5.70</td><td>0.12%</td><td>(29m)</td><td>7.83</td><td>0.87%</td><td>(41m)</td></tr><tr><td>Wu et al. [11] (T=5k)</td><td>3.83</td><td>0.00%</td><td>(1h)</td><td>5.70</td><td>0.20%</td><td>(1.5h)</td><td>7.87</td><td>1.42%</td><td>(2h)</td></tr><tr><td>DACT (T=1k)</td><td>3.83</td><td>0.04%</td><td>{7s}(24s)</td><td>5.70</td><td>0.14%</td><td>{16s}(1m)</td><td>7.89</td><td>1.62%</td><td>{48s}(4m)</td></tr><tr><td>DACT (T=5k)</td><td>3.83</td><td>0.00%</td><td>{32s}(2m)</td><td>5.70</td><td>0.02%</td><td>{2m}(6m)</td><td>7.81</td><td>0.61%</td><td>{4m}(18m)</td></tr><tr><td>DACT (T=10k)</td><td>3.83</td><td>0.00%</td><td>{1m}(5m)</td><td>5.70</td><td>0.01%</td><td>{3m}(13m)</td><td>7.79</td><td>0.37%</td><td>{8m}(40m)</td></tr><tr><td>DACT×4 augment</td><td>3.83</td><td>0.00%</td><td>{3m}(10m)</td><td>5.70</td><td>0.00%</td><td>{10m}(1h)</td><td>7.77</td><td>0.09%</td><td>{29m}(2.5h)</td></tr><tr><td>GCN-BS [6]</td><td>3.84</td><td>0.01%</td><td>(12m)</td><td>5.70</td><td>0.01%</td><td>(18m)</td><td>7.87</td><td>1.39%</td><td>(40m)</td></tr><tr><td>AM-sampling [5]</td><td>3.84</td><td>0.08%</td><td>(5m)</td><td>5.73</td><td>0.52%</td><td>(24m)</td><td>7.94</td><td>2.26%</td><td>(1h)</td></tr><tr><td>MDAM-BS[7]</td><td>3.84t</td><td>0.00%</td><td>(3m)</td><td>5.70</td><td>0.03%</td><td>(14m)</td><td>7.79</td><td>0.38%</td><td>(44m)</td></tr><tr><td>POMO [8]</td><td>3.83</td><td>0.04%</td><td>(1s)</td><td>5.70</td><td>0.21%</td><td>(2s)</td><td>7.80</td><td>0.46%</td><td>(11s)</td></tr><tr><td>POMO×8 augment [8]</td><td>3.83</td><td>0.00%</td><td>(3s)</td><td>5.69t</td><td>0.03%</td><td>(16s)</td><td>7.78</td><td>0.15%</td><td>(1m)</td></tr><tr><td>DPDP(100k) [26]</td><td>-</td><td></td><td></td><td>-</td><td></td><td>=</td><td>7.77+</td><td>0.00%</td><td>(3h)</td></tr><tr><td rowspan="9">LKH OR-Tools NeuRewriter [4] NLNS [27]</td><td rowspan="9">CVAE-Opt-DE [13]</td><td>1</td><td>0.00%#</td><td>11m#</td><td>-</td><td>0.02%#</td><td>22m#</td><td>-</td><td>0.34%#</td><td>55m#</td></tr><tr><td></td><td>0.00%</td><td></td><td></td><td></td><td>4h</td><td>15.68</td><td></td><td></td></tr><tr><td>6.14 6.46</td><td>5.68%</td><td>1h 2m</td><td>10.38 11.27</td><td>0.00% 8.61%</td><td>13m</td><td>17.12</td><td>0.00% 9.54%</td><td>8h 46m</td></tr><tr><td>6.15#</td><td></td><td>6m#</td><td>10.51#</td><td></td><td>11m#</td><td>16.10#</td><td></td><td></td></tr><tr><td>6.19#</td><td>=</td><td>6m#</td><td>10.54#</td><td></td><td>11m#</td><td>15.99#</td><td>=</td><td>17m# 16m#</td></tr><tr><td>Wu et al. [11] (T=5k) 6.12</td><td>0.39%</td><td>(2h)</td><td>10.45</td><td>0.70%</td><td>(4h)</td><td>16.03t</td><td>= 2.47%</td><td></td></tr><tr><td>DACT (T=1k)</td><td>0.28%</td><td>{16s}(33s)</td><td>10.61</td><td>2.13%</td><td>{43s}(2m)</td><td>16.17</td><td>3.18%</td><td>(5h) {2m}(5m)</td></tr><tr><td>DACT (T=5k)</td><td>6.15 6.13 -0.00%</td><td>{1m}(3m)</td><td>10.48</td><td>1.01%</td><td>{3m}(8m)</td><td>15.92</td><td>1.55%</td><td>{8m}(23m)</td></tr><tr><td>DACT (T=10k)</td><td>-0.04%</td><td>{2m}(6m)</td><td>10.46</td><td>0.79%</td><td>{6m}(16m)</td><td>15.85</td><td>1.12%</td><td>{16m}(45m)</td></tr><tr><td rowspan="2">DACT×6 augment</td><td>6.13 6.13</td><td>-0.08%</td><td>{11m}(35m)</td><td>10.39</td><td>0.14%</td><td>{32m}(1.5h)</td><td>15.71</td><td>0.19%</td><td>{1.5h}(4.5h)</td></tr><tr><td>AM-sampling [5]</td><td>1.87%</td><td>(6m)</td><td>10.62</td><td>2.40%</td><td>(28m)</td><td></td><td></td><td></td></tr><tr><td rowspan="2">MDAM-BS[7]</td><td>6.25 6.14</td><td>0.18%</td><td>(5m)</td><td>10.48</td><td>0.98%</td><td>(15m)</td><td>16.23 15.99#</td><td>3.72% 2.23%</td><td>(2h)</td></tr><tr><td></td><td>0.82%</td><td>(1s)</td><td>10.49</td><td>1.14%</td><td>(4s)</td><td>15.83</td><td>0.98%</td><td>(1h) (19s)</td></tr><tr><td>POMO [8] POMO×8 augment [8]</td><td>6.17 6.14</td><td>0.21%</td><td>(5s)</td><td>10.42</td><td>0.45%</td><td>(26s)</td><td>15.73</td><td>0.32%</td><td>(2m)</td></tr><tr><td>DPDP(100k)[26]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>15.69</td><td>0.31%</td><td></td></tr><tr><td>CVAE-Opt-DE [13]</td><td>= 6.14#</td><td></td><td>= 21m#</td><td>= 10.40#</td><td></td><td>41m#</td><td>15.75#</td><td></td><td>(6h) 1.5h#</td></tr></table>
+
+# the obj. values, gaps or time are obtained based on 2,000 instances in their original papers, and not directly comparable to ours. ‡ the obj. values obtained by Concorde or LKH may be slightly different from ours since the 10,000 instances are randomly generated. E.g., for TSP50, the optimal values according to our running of Concorde is 5.70, while 5.69 in POMO and Wu et al.. We thus focus more on gaps.
+
+# 5.1 Comparison studies
+
+In Table 1, we compare our DACT with, (1) learning based improvement methods, including Wu et al. [11], Neural-2-Opt [23] (TSP only), NeuRewriter [4] (CVRP only), NLNS [27] (CVRP only), (2) learning based construction methods, including AM-sampling [5], GCN-BS [6] (TSP only), MDAM-BS [7], POMO [8], (3) conventional optimization algorithms equipped with learning based component(s), including DPDP [26], CVAE-Opt-DE [13], and (4) strong conventional solvers including Concorde [35], LKH [28, 36], and OR-Tools [37]. Though L2I [12] can outstrip LKH on CVRP, we do not inlude it as a baseline since it requires a prohibitively longer inference time than others9. All results are averaged over 10,000 randomly generated instances unless specified otherwise (e.g., the ones marked with # only infer 2,000 instances), and we report the metrics of objective values, (optimality) gaps and run time. Regarding baselines, we follow the results reported in their original papers, which may not include all the three metrics. For TSP, Concorde is adopted to get the optimal solutions, based on which the optimality gaps of other methods are calculated. CVRP is harder to be solved optimally, and the gaps are calculated based on solutions of LKH. Note that even for the baselines which infer 10,000 random instances, their objective values might be slightly different from ours (e.g., the ones marked with $\ddagger .$ ), therefore we focus more on gaps for fair comparison. The run time is also hard to compare due to various factors (e.g., GPU/CPU models, batch sizes, Python v.s. $\mathrm { C } { + + }$ ). For DACT, we report the time for inferring all 10,000 instances with multiple GPU cards in $^ { 6 6 } ( ) "$ , and a small batch (512 instances) with one single GPU card in “{}".
+
+Pertaining to TSP, our DACT with inference step limit of 5,000 $\mathrm { ( T = 5 k }$ ) outperforms the traditional solver OR-Tools and all improvement models in terms of optimality gap, including Wu et al. [11] which directly adopted the original Transformer encoder. It also outstrips construction methods
+
+Table 2: Generalization performance. (a) DACT v.s. baselines on benchmark datasets (up to 200 customers, see Appendix E.4 for detailed results and discussion); (b) PE v.s. CPE on different sizes.   
+
+<table><tr><td>Method</td><td>TSPLIB</td><td>CVRPLIB</td></tr><tr><td>OR-Tools [37]</td><td>3.34%</td><td>8.06%</td></tr><tr><td>AM-sampling [5]</td><td>22.83%</td><td>26.66%</td></tr><tr><td>POMO [8]</td><td>10.06%</td><td>6.10%</td></tr><tr><td>Wu et al. [11]</td><td>4.17%</td><td>5.20%</td></tr><tr><td>DACT</td><td>2.07%</td><td>3.41%</td></tr></table>
+
+(a)
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">N=20</td><td colspan="2">N=100</td></tr><tr><td>Obj.</td><td>Gap</td><td>Obj.</td><td>Gap</td></tr><tr><td>DACT-PE (T=5k)</td><td>3.84</td><td>0.21%</td><td>8.38</td><td>7.93%</td></tr><tr><td>DACT-CPE (T=5k)</td><td>3.83</td><td>0.10%</td><td>7.99</td><td>2.98%</td></tr><tr><td>Wu et al.[11] (T=5k)</td><td>3.91</td><td>2.14%</td><td>9.03</td><td>16.37%</td></tr><tr><td>OR-Tools [37]</td><td>3.83</td><td>0.00%</td><td>8.06</td><td>3.87%</td></tr></table>
+
+(b)
+
+Table 3: Dual v.s. single aspect representation   
+
+<table><tr><td>Steps</td><td>Method</td><td>#Params</td><td>N=50</td><td>N=100</td></tr><tr><td rowspan="2">T=1k</td><td>SA-T</td><td>0.37M</td><td>0.35% (1m)</td><td>3.49% (3m)</td></tr><tr><td>DACT</td><td>0.29M</td><td>0.14% (1m)</td><td>1.62% (4m)</td></tr><tr><td rowspan="2">T=5k</td><td>SA-T</td><td>0.37M</td><td>0.05% (5m)</td><td>1.55% (16m)</td></tr><tr><td>DACT</td><td>0.29M</td><td>0.02% (6m)</td><td>0.61% (18m)</td></tr></table>
+
+including AM-sampling and GCN-BS on TSP100. With larger step limit $\mathrm { T } { = } 1 0 \mathrm { k }$ , our DACT further boosts the solution qualities and outperforms other construction methods including MDAM-BS (beam search), and POMO (the current state-of-the-art). To further reduce the gaps, we also leverage the data augmentation technique in POMO (which considers flipping node coordinates without changing the optimal solution) to solve same instances multiple times in different ways. Although the inference time increases (we run data augmentation in serial on the same GPUs), our DACT with 4 augments not only outstrips POMO with 8 augments but also achieves the lowest objective values and gaps among all purely learning based models. In particular, our method almost optimally solved TSP20 and TSP50 with gap lower than $0 . 0 0 5 \%$ , and $0 . 0 9 \%$ on TSP100, which is superior to most of the recent neural solvers. Pertaining to CVRP, our DACT with $\mathrm { T } { = } 5 \mathrm { k }$ produces lower gaps than that of improvement models including NeuRewriter and NLNS. It also performs much better than Wu et al. [11] except on CVRP50. With $\mathrm { T } { = } 1 0 \mathrm { k }$ and 6 augments10, our DACT exhibits even better performance than the highly specialized heuristic solver LKH on CVRP20 and delivers the smallest gap of $0 . 1 9 \%$ on CVRP100 against other neural solvers including POMO with 8 augments. Besides, our DACT is also competitive to DPDP which leverages learnt heatmap and dynamic programming to search solutions. Though DPDP (100k) can solve TSP100 instances almost optimally, our DACT is more efficient than DPDP on CVRP100. Compared with CVAE-Opt-DE, despite that it is averaged over fewer instances and integrated with differential evolution, our objective values are still lower.
+
+In terms of the inference time, our DACT is highly competitive against all neural solvers except POMO which learns a construction model by sampling diverse trajectories. However, when it comes to the generalization performance on benchmark datasets, i.e., TSPLIB [38] and CVRPLIB [39] in Table 2(a), DACT produces significantly lower average gaps than the POMO with 8 augments, which indicates that our DACT is more advantageous in practice despite its longer inference time. On the other hand, it is possible to adopt a similar diverse rollout strategy for DACT to find better solutions earlier, or explore other model compression techniques such as the knowledge distillation [40] to learn a lighter DACT model for faster inference. Since our focus is to ameliorate Transformer for neural improvement solvers, we will investigate these possibilities in the future.
+
+# 5.2 Ablation studies
+
+Dual-aspect representation. In Table 3, we evaluate the effectiveness of our dual-aspect representation against the single-aspect one (SA-T) on TSP50 and TSP100, where SA-T mainly follows the Transformer in $\mathbf { W } \mathbf { u }$ et al. [11] but equipped with the CPE, multi-head attentions and CL strategy for fair comparison. We observe that our DACT with fewer parameters consistently outperforms SA-T, which verifies the effectiveness of the dual-aspect representation.
+
+![](images/2102778a136af66f4a0dae7bc32cd3d938ae977b3f9616db51da4c7cf94b2d1f.jpg)  
+Figure 6: Visualization of the attention scores for the encoder when a trained model is used to solve instances with a larger size. (a) using PE method; (b) using CPE method (ours).
+
+Cyclic positional encoding. Here we show that CPE significantly improves the generalization performance across different problem sizes. In Table 2(b), we record the results of our DACT with PE and CPE, and Wu et al. [11], when the model trained on TSP50 is directly used to solve instances from TSP20 and TSP100 with $\mathrm { T } { = } 5 \mathrm { k }$ . We see that even with PE, our DACT outperforms Wu et al. [11]. Further equipped with CPE, DACT outstrips DACT-PE and OR-Tools on TSP100. We continue to compare the two DACT variants by visualizing their attention scores. As depicted in Figure 6(a), although the absolute PE is designed for linear sequences, it did attempt to capture the circularity of
+
+![](images/dcaf347b7b825fb752b6ddcd50ad1a4968c6104e02beab829841e1b66d04fde2.jpg)  
+Figure 7: Training curves of PPO with and without CL on CVRP20 (random seeds 1-5).
+
+VRP solutions (as highlighted in the green boxes) after training. However, the ability to perceive such properties significantly drops when generalizing over different problem size, which instead engenders random attention scores when generalizing to larger size (see right side of Figure 6(a)). In contrast, our DACT with CPE is able to capture the circularity as depicted in Figure 6(b), which verifies the effectiveness of CPE in representing cyclic sequences (i.e., VRP solutions).
+
+Curriculum learning (CL) strategy. In Figure 7, we plot the training curves of PPO algorithm with and without our CL strategy, where the results are averaged over 5 independent runs with $90 \%$ confidence intervals. It shows that our CL strategy significantly improves the sample efficiency while reducing the variance of training, which aligns with our analysis in Section 4.4.
+
+# 6 Conclusions and future work
+
+In this paper, we present a novel DACT model for routing problems. It learns separate groups of embeddings for the node and positional features, and is equipped with cyclic positional encoding (CPE) to capture the circularity and symmetry of VRP solutions. A curriculum learning (CL) strategy is also exploited to improve the RL training efficiency. Extensive experiments on both synthetic and benchmark datasets justified the effectiveness of DACT in terms of both inference and generalization. A potential limitation is that DACT is more useful for learning improvement models at present. In the future, we will investigate how to extend DACT to construction models, and how to speed up the DACT through diverse rollouts or model compression techniques. It is also interesting to apply the proposed CPE to develop Transformer based model for other tasks where the cyclic property is also important, e.g., encoding circular DNA/RNA structures in computational biology [41, 42].
+
+# Acknowledgments and Disclosure of Funding
+
+This work was supported in part by the National Natural Science Foundation of China under Grant 61803104 and Grant 62102228, in part by the Young Scholar Future Plan of Shandong University under Grant 62420089964188, and in part by the A\*STAR CyberPhysical Production System (CPPS) - Towards Contextual and Intelligent Response Research Program, under the RIE2020 IAF-PP Grant A19C1a0018, and Model Factory $@$ SIMTech.
+
+References   
+[1] Paolo Toth and Daniele Vigo. Vehicle routing: problems, methods, and applications. SIAM press, 2014.   
+[2] Michael Schneider, Andreas Stenger, and Dominik Goeke. The electric vehicle-routing problem with time windows and recharging stations. Transportation Science, 48(4):500–520, 2014.   
+[3] Jan Karel Lenstra and AHG Rinnooy Kan. Complexity of vehicle routing and scheduling problems. Networks, 11(2):221–227, 1981.   
+[4] Xinyun Chen and Yuandong Tian. Learning to perform local rewriting for combinatorial optimization. In Advances in Neural Information Processing Systems, volume 32, pages 6281–6292, 2019.   
+[5] Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! In International Conference on Learning Representations, 2018.   
+[6] Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arxiv preprint arxiv:1906.01227, ArXiV, 2019.   
+[7] Liang Xin, Wen Song, Zhiguang Cao, and Jie Zhang. Multi-decoder attention model with embedding glimpse for solving vehicle routing problems. In Proceedings of 35th AAAI Conference on Artificial Intelligence, pages 12042–12049, 2021.   
+[8] Yeong-Dae Kwon, Jinho Choo, Byoungjip Kim, Iljoo Yoon, Youngjune Gwon, and Seungjai Min. POMO: Policy optimization with multiple optima for reinforcement learning. In Advances in Neural Information Processing Systems, volume 33, pages 21188–21198, 2020.   
+[9] Liang Xin, Wen Song, Zhiguang Cao, and Jie Zhang. Step-wise deep learning models for solving routing problems. IEEE Transactions on Industrial Informatics, 17(7):4861–4871, 2020.   
+[10] Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Xu Chi. Learning to dispatch for job shop scheduling via deep reinforcement learning. In Advances in Neural Information Processing Systems, volume 33, pages 1621–1632, 2020.   
+[11] Yaoxin Wu, Wen Song, Zhiguang Cao, Jie Zhang, and Andrew Lim. Learning improvement heuristics for solving routing problems. IEEE Transactions on Neural Networks and Learning Systems, 2021.   
+[12] Hao Lu, Xingwen Zhang, and Shuang Yang. A learning-based iterative method for solving vehicle routing problems. In International Conference on Learning Representations, 2019.   
+[13] André Hottung, Bhanu Bhandari, and Kevin Tierney. Learning a latent search space for routing problems using variational autoencoders. In International Conference on Learning Representations, 2021.   
+[14] Jingwen Li, Yining Ma, Ruize Gao, Zhiguang Cao, Andrew Lim, Wen Song, and Jie Zhang. Deep reinforcement learning for solving the heterogeneous capacitated vehicle routing problem. IEEE Transactions on Cybernetics, 2021.   
+[15] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   
+[16] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, volume 30, pages 6000–6010, 2017.   
+[17] Jingwen Li, Liang Xin, Zhiguang Cao, Andrew Lim, Wen Song, and Jie Zhang. Heterogeneous attentions for solving pickup and delivery problem via deep reinforcement learning. IEEE Transactions on Intelligent Transportation Systems, 2021.   
+[18] Guolin Ke, Di He, and Tie-Yan Liu. Rethinking the positional encoding in language pre-training. In International Conference on Learning Representations, 2020.   
+[19] Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations. In North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 464–468, 2018.   
+[20] Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, volume 28, pages 2692–2700, 2015.   
+[21] Irwan Bello, Hieu Pham, Quoc V Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. In International Conference on Machine Learning (Workshop), 2017.   
+[22] Mohammadreza Nazari, Afshin Oroojlooy, Martin Takác, and Lawrence V Snyder. Reinforcement learning ˇ for solving the vehicle routing problem. In Advances in Neural Information Processing Systems, pages 9861–9871, 2018.   
+[23] Paulo R d O Costa, Jason Rhuggenaath, Yingqian Zhang, and Alp Akcay. Learning 2-opt heuristics for the traveling salesman problem via deep reinforcement learning. In Asian Conference on Machine Learning, pages 465–480, 2020.   
+[24] Hanjun Dai, Elias B Khalil, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, pages 6351–6361, 2017.   
+[25] Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a small pre-trained model to arbitrarily large TSP instances. In AAAI Conference on Artificial Intelligence, 2021.   
+[26] Wouter Kool, Herke van Hoof, Joaquim Gromicho, and Max Welling. Deep policy dynamic programming for vehicle routing problems. arXiv preprint arXiv:2102.11756, 2021.   
+[27] André Hottung and Kevin Tierney. Neural large neighborhood search for the capacitated vehicle routing problem. In European Conference on Artificial Intelligence, 2020.   
+[28] Keld Helsgaun. LKH-3 (version 3.0.6), 2019. URL http://webhotel4.ruc.dk/\~keld/research/ LKH-3/.   
+[29] Wikipedia. Gray code, 2021. URL: https://en.wikipedia.org/wiki/Gray_code. Last visited on 2020/05/19.   
+[30] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.   
+[31] Lei Jimmy Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. Corr: abs/1607.06450, ArXiV, 2016.   
+[32] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arxiv preprint arxiv:1707.06347, ArXiV, 2017.   
+[33] Fabio Pardo, Arash Tavakoli, Vitaly Levdik, and Petar Kormushev. Time limits in reinforcement learning. In International Conference on Machine Learning, pages 4045–4054, 2018.   
+[34] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In International Conference on Machine Learning, pages 41–48, 2009.   
+[35] David L Applegate, Robert E Bixby, Vašek Chvátal, and William J Cook. Concorde TSP Solver, 2020. URL http://www.math.uwaterloo.ca/tsp/concorde/.   
+[36] Keld Helsgaun. LKH (version 2.0.9), 2018. URL http://webhotel4.ruc.dk/\~keld/research/ LKH/.   
+[37] Laurent Perron and Vincent Furnon. OR-Tools (version 7.2), 2019. URL https://developers.google. com/optimization/.   
+[38] Gerhard Reinelt. TSPLIB-A traveling salesman problem library. ORSA journal on computing, 3(4): 376–384, 1991.   
+[39] Eduardo Uchoa, Diego Pecin, Artur Pessoa, Marcus Poggi, Thibaut Vidal, and Anand Subramanian. New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858, 2017.   
+[40] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.   
+[41] Chun-Ying Yu, Tung-Cheng Li, Yi-Ying Wu, Chan-Hsien Yeh, Wei Chiang, Ching-Yu Chuang, and Hung-Chih Kuo. The circular rna circbirc6 participates in the molecular circuitry controlling human pluripotency. Nature communications, 8(1):1–15, 2017.   
+[42] Chengyu Liu, Yu-Chen Liu, Hsien-Da Huang, and Wei Wang. Biogenesis mechanisms of circular rna can be categorized through feature extraction of a machine learning model. Bioinformatics, 35(23):4867–4870, 2019.   
+[43] Logan Engstrom, Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Firdaus Janoos, Larry Rudolph, and Aleksander Madry. Implementation matters in deep policy gradients: A case study on PPO and TRPO. In International Conference on Learning Representations, 2020.

parse/train/TmLqkYn71gV/TmLqkYn71gV_content_list.json

@@ -0,0 +1,1156 @@
+[
+    {
+        "type": "text",
+        "text": "Learning to Iteratively Solve Routing Problems with Dual-Aspect Collaborative Transformer ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            122,
+            816,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yining $\\mathbf { M } \\mathbf { a } ^ { 1 }$ , Jingwen $\\mathbf { L i } ^ { 1 }$ , Zhiguang $\\mathbf { C a o ^ { 2 , * } }$ , Wen Song3,∗, Le Zhang4, Zhenghua Chen5, Jing Tang6 ",
+        "bbox": [
+            258,
+            224,
+            740,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1National University of Singapore 2Singapore Institute of Manufacturing Technology, A\\*STAR 3Institute of Marine Science and Technology, Shandong University 4University of Electronic Science and Technology of China 5Institute for Infocomm Research, A\\*STAR 6The Hong Kong University of Science and Technology {yiningma, lijingwen}@u.nus.edu, zhiguangcao@outlook.com, wensong@email.sdu.edu.cn, zhangleuestc@gmail.com, chen0832@e.ntu.edu.sg, jingtang@ust.hk ",
+        "bbox": [
+            254,
+            267,
+            741,
+            397
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            431,
+            535,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Transformer has become a prevailing deep architecture for solving vehicle routing problems (VRPs). However, it is less effective in learning improvement models for VRP because its positional encoding (PE) method is not suitable in representing VRP solutions. This paper presents a novel Dual-Aspect Collaborative Transformer (DACT) to learn embeddings for the node and positional features separately, instead of fusing them together as done in existing ones, so as to avoid potential noises and incompatible correlations. Moreover, the positional features are embedded through a novel cyclic positional encoding (CPE) method to allow Transformer to effectively capture the circularity and symmetry of VRP solutions (i.e., cyclic sequences). We train DACT using Proximal Policy Optimization and design a curriculum learning strategy for better sample efficiency. We apply DACT to solve the traveling salesman problem (TSP) and capacitated vehicle routing problem (CVRP). Results show that our DACT outperforms existing Transformer based improvement models, and exhibits much better generalization performance across different problem sizes on synthetic and benchmark instances, respectively. ",
+        "bbox": [
+            232,
+            462,
+            764,
+            669
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            691,
+            310,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vehicle Routing problems (VRPs), such as the Traveling Salesman Problem (TSP) and the Capacitated Vehicle Routing Problem (CVRP) which consider finding the optimal route for a single or fleet of vehicles to serve a set of customers, have ubiquitous real-world applications [1, 2]. Despite being intensively studied in the Operations Research (OR) community, VRPs still remain challenging due to their NP-hard nature [3]. Recent studies on learning neural heuristics are gathering attention as promising extensions to traditional hand-crafted ones (e.g., [4–14]), where reinforcement learning (RL) [15] is usually exploited to train a deep neural network as an efficient solver without hand-crafted rules. A salient motivation is that deep neural networks may learn better heuristics by identifying useful patterns in an end-to-end and data-driven fashion. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Solutions to VRPs, i.e., routes, are sequences of nodes (customer and depot locations). Naturally, deep models for Natural Language Processing (NLP), which deal with sequence data as well, are ideal choices for encoding VRP solutions. Given its remarkable performance in NLP tasks, Transformer [16] is standing at the forefront in the learning based methods for VRPs (e.g., [5, 7, 8, 11–13, 17]). The original Transformer encodes a sentence, i.e., a sequence of words, into a unified set of embeddings by injecting word positional information into its word embeddings through positional encoding (PE). When it comes to VRPs, while is not required in construction models, positional information is critical for deep models that learn improvement heuristics since the input are solutions to be improved. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            882
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/17403d04b62870e5603e11128aad37f05c9529785e72e7e24fbc237438272fea.jpg",
+        "image_caption": [
+            "Figure 1: Transformer frameworks for VRPs. (a) $\\mathrm { W u }$ et al. [11] (the original one); (b) DACT (ours). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            87,
+            692,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            351,
+            825,
+            435
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although some success has been achieved, learning improvement heuristics for VRPs based on the original Transformer encoder is yet lacking from our perspective. Firstly, directly applying addition operation on PE vectors and the embeddings in absolute PE method (i.e., Figure 1(a)) could limit the representation of the model [18], as the mixed correlations2 existing in the self-attention can bring unreasonable noises and random biases to the encoder (details in Appendix A). Secondly, existing PE methods tend to fuse the node and positional information into one unified representation. NLP tasks such as translation may benefit from this owing to the deterministic and instructive nature of the positional information. However, such design may not be optimal for routing tasks because the positional information therein can be non-deterministic and sometimes even random. This may cause disharmony or disturbance in the encoder and may thus deteriorate the performance. Finally, most VRPs seek the shortest loop of the nodes, making their solutions to be cyclic sequences. However, existing PE methods are only designated to encode linear sequences3, which may fail to identify such circular input. As will be shown in our experiments, this could severely damage the generalization performance, since the cyclic feature of VRP solutions is not correctly reflected by the encoder. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we address the above issues and contribute to the line of using RL to learn neural improvement heuristics for VRPs. We introduce the Dual-Aspect Collaborative Transformer (DACT), where we revisit the solution representations and propose to learn separated groups of embeddings for the node and positional features of a VRP solution as shown in Figure 1(b). Our DACT follows the encoder-decoder structure. In the encoder, each set of embeddings encodes the solution mainly from its own aspect, and at the same time exploits a cross-aspect referential attention mechanism for better perceiving the consistence and differentiation with respect to the other aspect. The decoder then collects action distribution proposals from the two aspects and synthesizes them to output the final one. Meanwhile, we design a novel cyclic positional encoding (CPE) method to capture the circularity and symmetry of VRP solutions, which allows Transformer to encode cyclic inputs, and also boost the generalization performance for solving VRPs. As the last contribution, we design a simple yet effective curriculum learning strategy to improve the sample efficiency. This further leads to faster and more stable convergence of RL training. Extensive experiments show that our DACT can outperform existing Transformer based improvement models with fewer parameters, and also generalizes well across different sizes of synthetic and benchmark instances, respectively. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            848
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            318,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Positional encoding (PE) in Transformer. ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            119,
+            496,
+            135
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The original Transformer adopted the absolute PE method to describe the absolute position of elements in the sequence [16], especially for NLP. As formulated in Eq. (1), each generated positional embedding $p _ { i } \\in \\mathbb { R } ^ { d }$ is added together with the $i$ -th word embedding $x _ { i }$ in the first layer of the encoder, ",
+        "bbox": [
+            173,
+            145,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/06c8617b60f87154a9c18b93350fe384c2b92dcbc879ec3ead141f3979fd5a3f.jpg",
+        "text": "$$\n\\alpha _ { i , j } ^ { \\mathrm { A b s } } = \\frac { 1 } { \\sqrt { d } } ( ( x _ { i } + p _ { i } ) W ^ { Q } ) ( ( x _ { j } + p _ { j } ) W ^ { K } ) ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            195,
+            651,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The relative PE method was further proposed in Shaw et al. [19] to better capture the relative order information. On the basis of absolute PE, it introduces an inductive bias to the attention as follows, ",
+        "bbox": [
+            176,
+            229,
+            821,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb1536b0cd4bebe430402cd1ff3c8d032df2e5351e5010caf10bb27d09a60901.jpg",
+        "text": "$$\n\\alpha _ { i , j } ^ { \\mathrm { R e l } } = \\frac { 1 } { \\sqrt { d } } ( ( x _ { i } + p _ { i } ) W ^ { Q } ) ( ( x _ { j } + p _ { j } ) W ^ { K } + a _ { j - i } ) ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            260,
+            674,
+            292
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $a _ { j - i } \\in \\mathbb { R } ^ { d }$ is learnable parameters for encoding the relative position $j - i$ . To avoid the mixed and noisy correlations between word semantics and positional information in the above two PEs, the Transformer with United Positional Encoding (TUPE) [18] was proposed for NLP which utilizes separated projection metrics $W _ { x }$ and $W _ { p }$ for each information as follows, ",
+        "bbox": [
+            173,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cde20607c5d2e4f5c92239343ac4f181cb00350f92f6445069b5ef43e3a4815c.jpg",
+        "text": "$$\n\\alpha _ { i , j } ^ { \\mathrm { T U P E } } = \\frac { 1 } { \\sqrt { 2 d } } ( x _ { i } W _ { x } ^ { Q } ) ( x _ { j } W _ { x } ^ { K } ) ^ { T } + \\frac { 1 } { \\sqrt { 2 d } } ( p _ { i } W _ { p } ^ { Q } ) ( p _ { j } W _ { p } ^ { K } ) ^ { T } + b _ { j - i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            358,
+            727,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, as mentioned previously, existing PE methods are less effective for VRPs since they simply fuse the node and positional information into one unified set of embeddings during or after the calculation of the attention correlation $\\alpha _ { i , j }$ . Meanwhile, they are also unable to properly encode and handle cyclic input sequences as in VRP solutions. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Deep models for VRP. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            364,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Various deep architectures such as Recurrent Neural Network (RNN), Graph Neural Network (GNN), and Transformer have been employed in solving VRPs. ",
+        "bbox": [
+            174,
+            489,
+            823,
+            518
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RNN based models. As the pioneering work of neural VRP solvers, Pointer Network adopted RNN and supervised learning to solve TSP [20] (extended to RL in Bello et al. [21] and CVRP in Nazari et al. [22]). While the models in [20–23] learn construction heuristics, NeuRewriter [4] learns improvement heuristic for CVRP using LSTM to encode the positional information of a solution. In Hottung et al. [13], the conditional variational autoencoder was adopted to learn a continuous and latent search space for VRP, where high-quality solutions were taken as input and encoded by RNNs. However, recurrence structures in RNN are less efficient in both representation and computation [5]. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GNN based models. In Dai et al. [24], GNN was combined with Q-learning for solving TSP. Based on supervised learning, Joshi et al. [6] used GNN to learn heatmaps that prescribe the probability of each edge appearing in the optimal TSP tour. This idea was extended in Fu et al. [25] with additional components such as graph sampling and heatmap merging to enable generalization to larger TSP instances. These models often require post-processing to construct feasible solutions from heatmaps (e.g., beam search [6], Monte-Carlo tree search [25], and dynamic programming [26]). ",
+        "bbox": [
+            174,
+            627,
+            825,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformer based models. The Attention Model (AM) by Kool et al. [5] was recognized as the first success of Transformer based models for VRPs. Based on AM, Xin et al. [7] proposed a MultiDecoder AM that learns multiple diverse policies for better performance. In Kwon et al. [8], the RL algorithm of AM was improved which leaded to a new solver, i.e., POMO (Policy Optimization with Multiple Optima), and achieved the state-of-the-art performance. However, POMO is still lacking in generalization. Besides these construction models, Transformer was also explored to learn improvement heuristics. Hottung and Tierney [27] learned first neural large neighborhood search algorithm for VRPs. Lu et al. [12] proposed the L2I model that learns to select local search operators from a pool of traditional ones. Both methods used a Transformer-style encoder, but the positional information is captured in the node features (information of previous and next nodes) instead of using PE methods. Though L2I was shown to outperform LKH3 [28], it is limited to CVRP and the required time is considerably long. Wu et al. [11] proposed a Transformer model which learns to pick node pair in each step to perform a pairwise local operator (e.g., 2-opt). However, it suffers from the inaccurate representation of positional information given the original Transformer encoder. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ace11ce359bbb755998396b80534ff05688295f43970028840cdf0661b073b3.jpg",
+        "image_caption": [
+            "Figure 3: Architecture of our policy network, dual-aspect collaborative Transformer (DACT). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            812,
+            271
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Problem formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            325,
+            380,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We define a VRP instance as a group of $N$ nodes to visit, where the node feature $x _ { i }$ of node $i$ contains 2-dim coordinates and other problem-specific features (e.g., customer demand). A solution $\\delta$ consists of a sequence of nodes visited in order where we denote $p _ { i }$ to be the position (indices) of node $i$ in the solution which is deemed as the positional feature of node $i$ . The objective is to minimize the total travel distance $D ( \\delta )$ under certain problem-specific constraints. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Starting with an initial yet complete solution, our neural RL policy tries to improve the solution iteratively. At each step, the policy automatically selects a pair of nodes and locally adjusts the solution using a preset pairwise operator such as 2-opt, insert, or swap. As illustrated in Figure 2, given a node pair $( i , j )$ , the 2-opt operator adjusts a solution by reversing the segment between node $i$ and node $j$ ; the insert operator adjusts a solution by placing node $i$ after node $j$ ; and the swap operator adjusts a solution by exchanging the position of node $i$ and node $j$ . Such operation is repeated until reaching the step limit $T$ and we model it in the form of Markov Decision Process (MDP) as follows. ",
+        "bbox": [
+            174,
+            434,
+            503,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/3abc3c66ae47d31052903aafee9790f52c0e269b59a1a7ed0217c149d678c265.jpg",
+        "image_caption": [
+            "Figure 2: Illustration examples of three pairwise operators for routing problems when node pair $( i = 2 , j = 1 )$ ) is specified for operating. From left to right: 2-opt, insert, and swap. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            521,
+            444,
+            813,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            573,
+            825,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "State. For an instance with $N$ nodes, a state describes current solution $\\delta _ { t }$ using its node and positional features of each node, i.e., $s _ { t } = \\Psi ( \\delta _ { t } ) = \\{ x _ { 1 } ^ { t } , . . . , x _ { N } ^ { t } , p _ { 1 } ^ { t } , . . . , p _ { N } ^ { t } \\}$ . ",
+        "bbox": [
+            171,
+            606,
+            823,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Action. The action $a _ { t } = ( i , j )$ specifies a node pair $( i , j )$ for the pairwise operator. ",
+        "bbox": [
+            176,
+            636,
+            714,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Reward. The reward function is defined as, $r _ { t } = D ( \\delta _ { t } ^ { * } ) - m i n \\left[ D ( \\delta _ { t + 1 } ) , D ( \\delta _ { t } ^ { * } ) \\right]$ where $\\delta _ { t } ^ { * }$ is the best incumbent solution found until time $t$ . It refers to the immediate reduced cost at each step with respects to the best incumbent solution, which ensures the cumulative reward equal to the total reduced cost over the initial solution. Hence the reward $r _ { t } > 0$ if and only if a better solution is found. Policy. The policy $\\pi _ { \\theta }$ is parameterized by the proposed DACT model with parameters $\\theta$ . At each time step, the action $( i , j )$ is obtained by sampling the stochastic policy for both training and inference. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transition. The next state $s _ { t + 1 }$ is originated from $s _ { t }$ by performing the preset pairwise operator on the given node pair (action). Our state transient is deterministic, in the sense that it always accepts the next solution as the next state (infeasible solutions will be masked), regardless of its objective value. With such simple rule, the RL agent is expected to automatically learn how to combine multiple steps of simple local movements to achieve better solutions, even if some of them may worsen the current solution. Note that the step limit $T$ can be any user-specified value according to the allowed time budget. Hence, our MDP can have infinite horizon and we consider the reward discount factor $\\gamma < 1$ . ",
+        "bbox": [
+            173,
+            733,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Dual-aspect collaborative Transformer model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            584,
+            867
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now present the details of our Dual-Aspect Collaborative Transformer (DACT). The concrete architecture of DACT is presented in Figure 3, where we take the TSP with $N$ nodes as an illustration example. Our DACT leverages separate aspects of embeddings to encode a VRP solution. In the DAC encoder, the self-attention correlations are computed individually for each aspect, and a cross-aspect referential attention mechanism is proposed to enable one aspect to effectively exploit attention correlations from the other aspect as optional references. The DAC decoder then collects action distribution proposals from both aspects and synthesize them to the final one. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/89f6fef802cd35891d1ed76d002b348f40ea6b89b2545c5f6d954311286d8b4a.jpg",
+        "image_caption": [
+            "Figure 5: Comparison of our CPE method with absolute PE method on a TSP instance with 20 nodes. (a) the embedding vectors, (b) the correlations (dot products) between every two embeddings, and (c) the top two principal components after PCA (principal component analysis) projection. ",
+            "Figure 4: An example of cyclic Gray code where 4 digits are used to encode $N { = } 1 6$ nodes. The top left shows the base symmetry pattern $\\cdot _ { 1 0 0 1 }$ ’ in Gray code, and the top right plots its representation in our method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            87,
+            818,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            275,
+            825,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Dual-aspect solution representation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            459,
+            382
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we propose to learn two sets of embeddings, i.e., the node feature embeddings (NFEs) for node representation and the positional feature embeddings (PFEs) for positional representation. ",
+        "bbox": [
+            173,
+            395,
+            825,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "NFEs. Following [5, 11], the NFE $h _ { i }$ of node $i$ is initialized as the linear projection of its node feature $x _ { i }$ with output dimension4 $d i m = 6 4$ . ",
+        "bbox": [
+            173,
+            429,
+            501,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "PFEs. The PFE $g _ { i }$ of the positional feature $p _ { i }$ is initialized as a real-valued vector $( d i m = 6 4 )$ by applying our cyclic positional encoding (CPE), which is designed based on cyclic Gray codes [29]. ",
+        "bbox": [
+            173,
+            478,
+            503,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/ccfccd4ff2eed9413b669543d02262098d302494abdd216c4cef68c8aa0a0d67.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>15</td><td rowspan=1 colspan=1>16</td></tr><tr><td rowspan=2 colspan=1>11</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr></table>",
+        "bbox": [
+            517,
+            429,
+            813,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in Figure 4, the cyclic Gray codes present a cyclic property (‘1110’ in the last column is adjacent to ‘1111’ in the first column) and an adjacency similarity property (any codes in adjacent columns only differ in one digit), both of which are desirable for cyclic sequences. To preserve these properties in designing our CPE, we follow two observed patterns: 1) each numerical digit contains a periodic cycle with reflectional symmetry, e.g., the $\\mathbf { \\dot { \\rho } } _ { 1 0 | 0 1 } ,$ in the lowest digit; and 2) the higher the numerical digit, the longer the period. Accordingly, we create similar patterns based on the sinusoidal functions in Eq. (4), where a periodic function with period $\\frac { 4 \\pi } { \\omega _ { d } }$ (induced by modulus) is used to generate one base symmetry pattern (the top right in Figure 4), ",
+        "bbox": [
+            173,
+            540,
+            501,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            594,
+            826,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/761131c312918e281f2f5384381e85ec2923a640ca9e38a2d9d86de612f763b2.jpg",
+        "text": "$$\n\\begin{array} { r } { \\overrightarrow { g _ { i } ^ { \\prime } } ^ { ( d ) } : = \\left\\{ \\begin{array} { l l } { s i n ( \\omega _ { d } \\cdot \\mathrm { \\Gamma } ( z ( i ) \\bmod \\frac { 4 \\pi } { \\omega _ { d } } ) - \\frac { 2 \\pi } { \\omega _ { d } } \\mathrm { \\Gamma } ) , \\mathrm { ~ i f ~ } d \\mathrm { ~ i s ~ e v e n } } \\\\ { c o s ( \\omega _ { d } \\cdot \\mathrm { \\Gamma } ( z ( i ) \\bmod \\frac { 4 \\pi } { \\omega _ { d } } ) - \\frac { 2 \\pi } { \\omega _ { d } } \\mathrm { \\Gamma } ) , \\mathrm { ~ i f ~ } d \\mathrm { ~ i s ~ o d d } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            690,
+            679,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { z ( i ) = \\frac { i - 1 } { N } \\frac { 2 \\pi } { \\omega _ { d } } \\left\\lceil \\frac { N + 1 } { 2 \\pi / \\omega _ { d } } \\right\\rceil } \\end{array}$ is to make $N$ nodes linearly spaced in the generated pattern; the angular frequency $\\omega _ { d }$ is decreasing along the dimension to make the wavelength longer within the range $[ N ^ { \\frac { 1 } { [ d i m / 2 ] } } , N ]$ (see Appendix B for details). In Figure 5, we visualize the comparison between the absolute PE and our CPE for encoding a TSP instance of 20 nodes. Figure 5(a) demonstrates that our real-valued base symmetry pattern has a longer cyclic period as the digit grows. Figure 5(b) indicates that our method (blue) is able to correctly reflect the adjacency between the head and tail of the cyclic sequence whereas the PE method (red) fails to do so. Figure 5(c) verifies that our CPE vectors are well distributed in space with desired cyclic and adjacency similarity properties. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 The encoder ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            299,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The encoder consists of $L = 3$ stacked DAC encoders. In each DAC encoder, we retain relatively independent encoding stream for NFEs and PFEs as in Eq. (5) and Eq. (6), respectively, each of which consists of a shared Dual-Aspect Collaborative Attention (DAC-Att) sub-layer and an independent feed-forward network (FFN) sub-layer. DAC-Att takes both sets of embeddings as input and then outputs their respective enhanced embeddings, i.e., NFEs $\\{ \\tilde { h } \\} _ { i = 1 } ^ { N }$ and PFEs $\\{ \\tilde { g } \\} _ { i = 1 } ^ { N }$ . Each sub-layer is followed by skip connection [30] and layer normalization [31] as same as the original Transformer. ",
+        "bbox": [
+            173,
+            116,
+            826,
+            204
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3c27f072c19590bb60be7226f1f0fd9cb7fd14ba92fa17514b83d481ad23218.jpg",
+        "text": "$$\n\\begin{array} { r } { h _ { i } ^ { ( l ) } = \\mathbf { L N } \\Big ( h _ { i } ^ { \\prime } + \\mathbf { F F N } _ { h } ^ { ( l ) } ( h _ { i } ^ { \\prime } ) \\Big ) , h _ { i } ^ { \\prime } = \\mathbf { L N } \\Big ( h _ { i } ^ { ( l - 1 ) } + \\tilde { h } _ { i } ^ { ( l ) } \\Big ) , } \\\\ { g _ { i } ^ { ( l ) } = \\mathbf { L N } \\Big ( g _ { i } ^ { \\prime } + \\mathbf { F F N } _ { g } ^ { ( l ) } ( g _ { i } ^ { \\prime } ) \\Big ) , g _ { i } ^ { \\prime } = \\mathbf { L N } \\Big ( g _ { i } ^ { ( l - 1 ) } + \\tilde { g } _ { i } ^ { ( l ) } \\Big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            213,
+            683,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DAC-Att. The DAC-Att sub-layer enhances each set of embedding from its own aspect, while leveraging attention correlations from the other aspect to achieve the synergy. Given the two sets of embeddings5, $\\{ h _ { i } \\} _ { i = 1 } ^ { N }$ and $\\{ g _ { i } \\} _ { i = 1 } ^ { N }$ , we first compute the self-attention correlation from both aspects, ",
+        "bbox": [
+            173,
+            290,
+            825,
+            335
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e1058866e25e4d647cc2fd0b0d63302df8fedbe20722e8773d594addc8589b4.jpg",
+        "text": "$$\n\\alpha _ { i , j } ^ { h } = \\frac { 1 } { \\sqrt { d _ { k } } } \\left( h _ { i } W _ { h } ^ { Q } \\right) \\left( h _ { j } W _ { h } ^ { K } \\right) ^ { T } , \\quad \\alpha _ { i , j } ^ { g } = \\frac { 1 } { \\sqrt { d _ { k } } } \\left( g _ { i } W _ { g } ^ { Q } \\right) \\left( g _ { j } W _ { g } ^ { K } \\right) ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            343,
+            736,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where independent matrices $W _ { h } ^ { Q } , W _ { h } ^ { K } , W _ { g } ^ { Q }$ and $W _ { g } ^ { K } \\in \\mathbb { R } ^ { d i m \\times d _ { k } }$ are used to calculate queries and keys. The obtained correlations are further normalized to $\\tilde { \\alpha } _ { i , j } ^ { h }$ and $\\tilde { \\alpha } _ { i , j } ^ { g }$ via Softmax. Note that the correlations are computed from their own aspect, which eliminates possible noises and conduces to correctly describe the incompatible node pair relationships in different aspects of VRP solutions. ",
+        "bbox": [
+            173,
+            382,
+            826,
+            444
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We then exploit a cross-aspect referential attention mechanism, which allows computed correlations to be shared between each other, as additional references for both contradistinction and collaboration, ",
+        "bbox": [
+            171,
+            449,
+            826,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6345560f8ea0e3a7ce2dd7e14bffaf039c3fa79d48bbc491342cf315f04e49d.jpg",
+        "text": "$$\n\\mathrm { o u t } _ { i } ^ { h } = \\mathrm { C o n c a t } \\left[ \\sum _ { j = 1 } ^ { N } \\tilde { \\alpha } _ { i , j } ^ { h } \\left( h _ { j } W _ { h } ^ { V } \\right) , \\sum _ { j = 1 } ^ { N } \\tilde { \\alpha } _ { i , j } ^ { g } \\left( h _ { j } W _ { h } ^ { V r e f } \\right) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            488,
+            681,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a48535120551d7df98fe87035c01b8a5d7d6f7b1f42271786b1c469f93da9c7.jpg",
+        "text": "$$\n\\mathrm { o u t } _ { i } ^ { g } = \\mathrm { C o n c a t } \\left[ \\sum _ { j = 1 } ^ { N } { \\tilde { \\alpha } } _ { i , j } ^ { g } \\left( g _ { j } W _ { g } ^ { V } \\right) , \\sum _ { j = 1 } ^ { N } { \\tilde { \\alpha } } _ { i , j } ^ { h } \\left( g _ { j } W _ { g } ^ { V r e f } \\right) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            546,
+            679,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "wheand $W _ { h } ^ { V } , W _ { g } ^ { V } \\in \\mathbb R ^ { d i m \\times d _ { v } }$ are trainable parameter matrices for formulating values in each aspect; are parameter matrices for each aspect to generate referential values. $W _ { h } ^ { V r e f } , W _ { g } ^ { V r e f } \\in \\mathbb R ^ { d i m \\times d _ { v } }$ We finally use the multi-head attention to get NFEs $\\tilde { h } _ { i }$ and PFEs $\\tilde { g } _ { i }$ as follows, ",
+        "bbox": [
+            176,
+            602,
+            826,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b68e363878666ea949f94c4dd3c67f66b6ae414ba43bbab76187fd699f625cc7.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { c } { \\tilde { h } _ { i } , \\tilde { g } _ { i } = \\mathbf { D A C - A t t } \\left( W ^ { Q } , ~ W ^ { K } , W ^ { V } , W ^ { V _ { r e f } } , W ^ { O } \\right) , } \\\\ { \\tilde { h } _ { i } = \\mathbf { C o n c a t } \\left[ \\mathrm { h e a d } _ { i , 1 } ^ { h } , . . . , \\mathrm { h e a d } _ { i , m } ^ { h } \\right] W _ { h } ^ { O } , ~ \\tilde { g } _ { i } = \\mathbf { C o n c a t } \\left[ \\mathrm { h e a d } _ { i , 1 } ^ { g } , . . . , \\mathrm { h e a d } _ { i , m } ^ { g } \\right] W _ { g } ^ { O } , } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            660,
+            766,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where h $\\mathbf { e a d } _ { i , k } ^ { h } = o u t _ { i , k } ^ { h }$ , $\\mathbf { h e a d } _ { i , k } ^ { g } = o u t _ { i , k } ^ { g }$ , and $W _ { h } ^ { O } , W _ { g } ^ { O } \\ \\in \\ \\mathbb { R } ^ { 2 m d _ { v } \\times d i m }$ are trainable parameter matrices. In our model, we adopt $m = 4$ and $d _ { k } = d _ { v } = 1 6$ . ",
+        "bbox": [
+            176,
+            717,
+            823,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "FFN. Our FFN sub-layer has only one hidden layer with 64 hidden unites and adopts the ReLU activation function. The parameters of $\\mathbf { F F N } _ { h }$ and $\\mathbf { F F N } _ { g }$ are different for each group of embeddings. ",
+        "bbox": [
+            173,
+            756,
+            823,
+            786
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 The decoder ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            299,
+            818
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the DAC decoder, the two sets of embeddings $\\{ h _ { i } ^ { ( L ) } \\} _ { i = 1 } ^ { N }$ and $\\{ g _ { i } ^ { ( L ) } \\} _ { i = 1 } ^ { N }$ are first passed through a Max-pooling sub-layer and a multi-head compatibility (MHC) sub-layer to independently generate diversified node-pair selection proposals from their own aspect, which are then aggregated through a feed-forward aggregation (FFA) sub-layer for output. ",
+        "bbox": [
+            173,
+            824,
+            825,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Max-pooling. For each set of embeddings, we adopt the max-pooling sub-layer in Wu et al. [11] to aggregate the global representation of all $N$ embeddings into each respective one6. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MHC. The compatibility sub-layer computes the attention correlations for each embedding pair, where the obtained correlations with size $N \\times N$ will be deemed as a proposal distribution for node pair selection. Our correlations are computed based on multiple heads for diversity. And we calculate separated attention score matrices $\\boldsymbol { Y } _ { k } ^ { h } , \\boldsymbol { \\dot { Y } } _ { k } ^ { g } \\in \\mathbb { R } ^ { N \\times N }$ (of head $k$ ) from the two aspects independently. Accordingly, the action distribution proposals would be different due to their aspect-specific focus and cognitions of the current solution, which will provide the subsequent FFA layer with a rich pool of proposals and allow our model to be more flexible and robust. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "FFA. Once all proposals from two aspects are collected, a FFN with four layers (dimensions are $2 m$ , 32, 32 and 1, respectively) and ReLU activation is used to aggregate them, ",
+        "bbox": [
+            171,
+            228,
+            825,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a1d3544bbc2ae4bb92727490faabc0cdc3a752492a632c084015c7fdfdfeba67.jpg",
+        "text": "$$\n\\tilde { Y } _ { i , j } = \\mathbf { F } \\mathbf { F } \\mathbf { A } \\left( Y _ { i , j , 1 } ^ { g } , . . . , Y _ { i , j , m } ^ { g } , Y _ { i , j , 1 } ^ { h } , . . . Y _ { i , j , m } ^ { h } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            270,
+            651,
+            290
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $m = 4$ is the number of heads; and the output $\\tilde { Y } _ { i , j }$ is a scalar indicating the likelihood of selecting node pair $( i , j )$ as an action. Afterwards, we apply $\\hat { Y } _ { i j } = C \\cdot \\mathrm { T a n h } ( \\tilde { Y } _ { i , j } )$ with $C = 6$ to control the entropy, and mask 7 the infeasible node pairs $( i ^ { \\prime } , j ^ { \\prime } )$ as $\\hat { Y } _ { i ^ { \\prime } j ^ { \\prime } } = - \\infty$ . Lastly, the likelihoods are normalized using Softmax function to obtain the final action distribution $P _ { i , j }$ . ",
+        "bbox": [
+            174,
+            303,
+            825,
+            367
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Reinforcement learning algorithm ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            388,
+            449,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We adopt the proximal policy optimization [32] with $n$ -step return estimation for training (details are given in Appendix C), and design a curriculum learning (CL) strategy for better sample efficiency. ",
+        "bbox": [
+            173,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Curriculum learning strategy. The strategy in Wu et al. [11] sets a maximum of $T _ { t r a i n }$ steps for training and estimates future returns by bootstrapping [33]. However, due to the concern of training cost, $T _ { t r a i n }$ is usually much smaller than actual $T$ for inference (e.g., 200 v.s. 10k), which may leave the agent a poor chance of observing high-quality solutions (states) during training. Consequently, it may cause high variance for bootstrapping because the value function is mostly fitted on low-quality solutions and may render it less knowledgeable in estimating long-term future returns accurately. In this paper, we tackle this issue by a simple yet efficient strategy which gradually prescribes higher-quality solutions as the initial states for training. In doing so, 1) it increases the probability for the agent to observe better solutions and thus reduce the variance of the value function; 2) it increases the difficulty of the learning task (higher-quality solutions are harder to improve) in a gradual manner and achieves better sample efficiency [34]. In practice, those higher-quality solutions can be easily achieved by improving the randomly generated ones using the current policy for a few $T _ { i n i t }$ steps, where $T _ { i n i t }$ could be slightly increased as the epoch grows. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            312,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our DACT model on two representative routing problems, i.e., TSP and CVRP [5, 8, 11]. For each problem, we abide by existing conventions to randomly generate instances on the fly for three sizes, i.e., $N = 2 0$ , 50 and 100. Initial experiments with three operators including 2-opt, swap and insert show that 2-opt performs best for both TSP and CVRP (with insert better than swap), hence we report results of our method based on 2-opt. Following [4, 11, 27] we use randomly generated initial solutions for training and the solutions generated by the greedy algorithm for inference. Since each problem has its own constraints and node features, we adjust the input, feasibility masks, and problem-dependent hyperparameters for each problem, the details of which are provided in Appendix D and E. The DACT is trained and tested on a server equipped with TITAN RTX GPU cards and Intel i9-10940X CPU at $3 . 3 0 \\mathrm { G H z }$ . Our code in PyTorch are available here8. ",
+        "bbox": [
+            173,
+            690,
+            826,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a5a1b6f0e80b2409834bf4f4c112e90e12459f5074bcf9746c847b6e5821cb01.jpg",
+        "table_caption": [
+            "Table 1: Comparison with various baselines on TSP and CVRP. "
+        ],
+        "table_footnote": [
+            "# the obj. values, gaps or time are obtained based on 2,000 instances in their original papers, and not directly comparable to ours. ‡ the obj. values obtained by Concorde or LKH may be slightly different from ours since the 10,000 instances are randomly generated. E.g., for TSP50, the optimal values according to our running of Concorde is 5.70, while 5.69 in POMO and Wu et al.. We thus focus more on gaps. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\">Method</td><td colspan=\"3\">N=20</td><td colspan=\"3\">N=50</td><td colspan=\"3\">N=100</td></tr><tr><td>Obj.</td><td>Gap</td><td>Time</td><td>Obj.</td><td>Gap</td><td>Time</td><td>Obj.</td><td>Gap</td><td>Time</td></tr><tr><td rowspan=\"10\">LKH P</td><td>Concorde</td><td>3.83</td><td>=</td><td>(3m)</td><td>5.70</td><td></td><td>(10m)</td><td>7.76</td><td></td><td>(1h)</td></tr><tr><td></td><td>3.83</td><td>0.00%</td><td>(38s)</td><td>5.70</td><td>0.00%</td><td>(5m)</td><td>7.76</td><td>0.00%</td><td>(20m)</td></tr><tr><td>OR-Tools</td><td>3.86</td><td>0.94%</td><td>(42s)</td><td>5.85</td><td>2.87%</td><td>(5m)</td><td>8.06</td><td>3.86%</td><td>(23m)</td></tr><tr><td>Neural-2-Opt [23]</td><td>3.84</td><td>0.00%</td><td>(15m)</td><td>5.70</td><td>0.12%</td><td>(29m)</td><td>7.83</td><td>0.87%</td><td>(41m)</td></tr><tr><td>Wu et al. [11] (T=5k)</td><td>3.83</td><td>0.00%</td><td>(1h)</td><td>5.70</td><td>0.20%</td><td>(1.5h)</td><td>7.87</td><td>1.42%</td><td>(2h)</td></tr><tr><td>DACT (T=1k)</td><td>3.83</td><td>0.04%</td><td>{7s}(24s)</td><td>5.70</td><td>0.14%</td><td>{16s}(1m)</td><td>7.89</td><td>1.62%</td><td>{48s}(4m)</td></tr><tr><td>DACT (T=5k)</td><td>3.83</td><td>0.00%</td><td>{32s}(2m)</td><td>5.70</td><td>0.02%</td><td>{2m}(6m)</td><td>7.81</td><td>0.61%</td><td>{4m}(18m)</td></tr><tr><td>DACT (T=10k)</td><td>3.83</td><td>0.00%</td><td>{1m}(5m)</td><td>5.70</td><td>0.01%</td><td>{3m}(13m)</td><td>7.79</td><td>0.37%</td><td>{8m}(40m)</td></tr><tr><td>DACT×4 augment</td><td>3.83</td><td>0.00%</td><td>{3m}(10m)</td><td>5.70</td><td>0.00%</td><td>{10m}(1h)</td><td>7.77</td><td>0.09%</td><td>{29m}(2.5h)</td></tr><tr><td>GCN-BS [6]</td><td>3.84</td><td>0.01%</td><td>(12m)</td><td>5.70</td><td>0.01%</td><td>(18m)</td><td>7.87</td><td>1.39%</td><td>(40m)</td></tr><tr><td>AM-sampling [5]</td><td>3.84</td><td>0.08%</td><td>(5m)</td><td>5.73</td><td>0.52%</td><td>(24m)</td><td>7.94</td><td>2.26%</td><td>(1h)</td></tr><tr><td>MDAM-BS[7]</td><td>3.84t</td><td>0.00%</td><td>(3m)</td><td>5.70</td><td>0.03%</td><td>(14m)</td><td>7.79</td><td>0.38%</td><td>(44m)</td></tr><tr><td>POMO [8]</td><td>3.83</td><td>0.04%</td><td>(1s)</td><td>5.70</td><td>0.21%</td><td>(2s)</td><td>7.80</td><td>0.46%</td><td>(11s)</td></tr><tr><td>POMO×8 augment [8]</td><td>3.83</td><td>0.00%</td><td>(3s)</td><td>5.69t</td><td>0.03%</td><td>(16s)</td><td>7.78</td><td>0.15%</td><td>(1m)</td></tr><tr><td>DPDP(100k) [26]</td><td>-</td><td></td><td></td><td>-</td><td></td><td>=</td><td>7.77+</td><td>0.00%</td><td>(3h)</td></tr><tr><td rowspan=\"9\">LKH OR-Tools NeuRewriter [4] NLNS [27]</td><td rowspan=\"9\">CVAE-Opt-DE [13]</td><td>1</td><td>0.00%#</td><td>11m#</td><td>-</td><td>0.02%#</td><td>22m#</td><td>-</td><td>0.34%#</td><td>55m#</td></tr><tr><td></td><td>0.00%</td><td></td><td></td><td></td><td>4h</td><td>15.68</td><td></td><td></td></tr><tr><td>6.14 6.46</td><td>5.68%</td><td>1h 2m</td><td>10.38 11.27</td><td>0.00% 8.61%</td><td>13m</td><td>17.12</td><td>0.00% 9.54%</td><td>8h 46m</td></tr><tr><td>6.15#</td><td></td><td>6m#</td><td>10.51#</td><td></td><td>11m#</td><td>16.10#</td><td></td><td></td></tr><tr><td>6.19#</td><td>=</td><td>6m#</td><td>10.54#</td><td></td><td>11m#</td><td>15.99#</td><td>=</td><td>17m# 16m#</td></tr><tr><td>Wu et al. [11] (T=5k) 6.12</td><td>0.39%</td><td>(2h)</td><td>10.45</td><td>0.70%</td><td>(4h)</td><td>16.03t</td><td>= 2.47%</td><td></td></tr><tr><td>DACT (T=1k)</td><td>0.28%</td><td>{16s}(33s)</td><td>10.61</td><td>2.13%</td><td>{43s}(2m)</td><td>16.17</td><td>3.18%</td><td>(5h) {2m}(5m)</td></tr><tr><td>DACT (T=5k)</td><td>6.15 6.13 -0.00%</td><td>{1m}(3m)</td><td>10.48</td><td>1.01%</td><td>{3m}(8m)</td><td>15.92</td><td>1.55%</td><td>{8m}(23m)</td></tr><tr><td>DACT (T=10k)</td><td>-0.04%</td><td>{2m}(6m)</td><td>10.46</td><td>0.79%</td><td>{6m}(16m)</td><td>15.85</td><td>1.12%</td><td>{16m}(45m)</td></tr><tr><td rowspan=\"2\">DACT×6 augment</td><td>6.13 6.13</td><td>-0.08%</td><td>{11m}(35m)</td><td>10.39</td><td>0.14%</td><td>{32m}(1.5h)</td><td>15.71</td><td>0.19%</td><td>{1.5h}(4.5h)</td></tr><tr><td>AM-sampling [5]</td><td>1.87%</td><td>(6m)</td><td>10.62</td><td>2.40%</td><td>(28m)</td><td></td><td></td><td></td></tr><tr><td rowspan=\"2\">MDAM-BS[7]</td><td>6.25 6.14</td><td>0.18%</td><td>(5m)</td><td>10.48</td><td>0.98%</td><td>(15m)</td><td>16.23 15.99#</td><td>3.72% 2.23%</td><td>(2h)</td></tr><tr><td></td><td>0.82%</td><td>(1s)</td><td>10.49</td><td>1.14%</td><td>(4s)</td><td>15.83</td><td>0.98%</td><td>(1h) (19s)</td></tr><tr><td>POMO [8] POMO×8 augment [8]</td><td>6.17 6.14</td><td>0.21%</td><td>(5s)</td><td>10.42</td><td>0.45%</td><td>(26s)</td><td>15.73</td><td>0.32%</td><td>(2m)</td></tr><tr><td>DPDP(100k)[26]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>15.69</td><td>0.31%</td><td></td></tr><tr><td>CVAE-Opt-DE [13]</td><td>= 6.14#</td><td></td><td>= 21m#</td><td>= 10.40#</td><td></td><td>41m#</td><td>15.75#</td><td></td><td>(6h) 1.5h#</td></tr></table>",
+        "bbox": [
+            173,
+            126,
+            823,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 Comparison studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            349,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 1, we compare our DACT with, (1) learning based improvement methods, including Wu et al. [11], Neural-2-Opt [23] (TSP only), NeuRewriter [4] (CVRP only), NLNS [27] (CVRP only), (2) learning based construction methods, including AM-sampling [5], GCN-BS [6] (TSP only), MDAM-BS [7], POMO [8], (3) conventional optimization algorithms equipped with learning based component(s), including DPDP [26], CVAE-Opt-DE [13], and (4) strong conventional solvers including Concorde [35], LKH [28, 36], and OR-Tools [37]. Though L2I [12] can outstrip LKH on CVRP, we do not inlude it as a baseline since it requires a prohibitively longer inference time than others9. All results are averaged over 10,000 randomly generated instances unless specified otherwise (e.g., the ones marked with # only infer 2,000 instances), and we report the metrics of objective values, (optimality) gaps and run time. Regarding baselines, we follow the results reported in their original papers, which may not include all the three metrics. For TSP, Concorde is adopted to get the optimal solutions, based on which the optimality gaps of other methods are calculated. CVRP is harder to be solved optimally, and the gaps are calculated based on solutions of LKH. Note that even for the baselines which infer 10,000 random instances, their objective values might be slightly different from ours (e.g., the ones marked with $\\ddagger .$ ), therefore we focus more on gaps for fair comparison. The run time is also hard to compare due to various factors (e.g., GPU/CPU models, batch sizes, Python v.s. $\\mathrm { C } { + + }$ ). For DACT, we report the time for inferring all 10,000 instances with multiple GPU cards in $^ { 6 6 } ( ) \"$ , and a small batch (512 instances) with one single GPU card in “{}\". ",
+        "bbox": [
+            174,
+            584,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pertaining to TSP, our DACT with inference step limit of 5,000 $\\mathrm { ( T = 5 k }$ ) outperforms the traditional solver OR-Tools and all improvement models in terms of optimality gap, including Wu et al. [11] which directly adopted the original Transformer encoder. It also outstrips construction methods ",
+        "bbox": [
+            178,
+            839,
+            821,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/41ddc55113bc20c00330d1d54f1fb2f1085c8a072a1b553c83fdd329e09b3ee4.jpg",
+        "table_caption": [
+            "Table 2: Generalization performance. (a) DACT v.s. baselines on benchmark datasets (up to 200 customers, see Appendix E.4 for detailed results and discussion); (b) PE v.s. CPE on different sizes. "
+        ],
+        "table_footnote": [
+            "(a) "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>TSPLIB</td><td>CVRPLIB</td></tr><tr><td>OR-Tools [37]</td><td>3.34%</td><td>8.06%</td></tr><tr><td>AM-sampling [5]</td><td>22.83%</td><td>26.66%</td></tr><tr><td>POMO [8]</td><td>10.06%</td><td>6.10%</td></tr><tr><td>Wu et al. [11]</td><td>4.17%</td><td>5.20%</td></tr><tr><td>DACT</td><td>2.07%</td><td>3.41%</td></tr></table>",
+        "bbox": [
+            222,
+            137,
+            447,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/081993af0c54bd66251b078601ab5ac12b18fda9eb3f644704622f30a657c213.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">N=20</td><td colspan=\"2\">N=100</td></tr><tr><td>Obj.</td><td>Gap</td><td>Obj.</td><td>Gap</td></tr><tr><td>DACT-PE (T=5k)</td><td>3.84</td><td>0.21%</td><td>8.38</td><td>7.93%</td></tr><tr><td>DACT-CPE (T=5k)</td><td>3.83</td><td>0.10%</td><td>7.99</td><td>2.98%</td></tr><tr><td>Wu et al.[11] (T=5k)</td><td>3.91</td><td>2.14%</td><td>9.03</td><td>16.37%</td></tr><tr><td>OR-Tools [37]</td><td>3.83</td><td>0.00%</td><td>8.06</td><td>3.87%</td></tr></table>",
+        "bbox": [
+            488,
+            138,
+            779,
+            220
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(b) ",
+        "bbox": [
+            624,
+            229,
+            643,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3e514a6a6f3e64798484b6231ff48235bab57d2952f3272297517edb6831f287.jpg",
+        "table_caption": [
+            "Table 3: Dual v.s. single aspect representation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Steps</td><td>Method</td><td>#Params</td><td>N=50</td><td>N=100</td></tr><tr><td rowspan=\"2\">T=1k</td><td>SA-T</td><td>0.37M</td><td>0.35% (1m)</td><td>3.49% (3m)</td></tr><tr><td>DACT</td><td>0.29M</td><td>0.14% (1m)</td><td>1.62% (4m)</td></tr><tr><td rowspan=\"2\">T=5k</td><td>SA-T</td><td>0.37M</td><td>0.05% (5m)</td><td>1.55% (16m)</td></tr><tr><td>DACT</td><td>0.29M</td><td>0.02% (6m)</td><td>0.61% (18m)</td></tr></table>",
+        "bbox": [
+            336,
+            295,
+            656,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "including AM-sampling and GCN-BS on TSP100. With larger step limit $\\mathrm { T } { = } 1 0 \\mathrm { k }$ , our DACT further boosts the solution qualities and outperforms other construction methods including MDAM-BS (beam search), and POMO (the current state-of-the-art). To further reduce the gaps, we also leverage the data augmentation technique in POMO (which considers flipping node coordinates without changing the optimal solution) to solve same instances multiple times in different ways. Although the inference time increases (we run data augmentation in serial on the same GPUs), our DACT with 4 augments not only outstrips POMO with 8 augments but also achieves the lowest objective values and gaps among all purely learning based models. In particular, our method almost optimally solved TSP20 and TSP50 with gap lower than $0 . 0 0 5 \\%$ , and $0 . 0 9 \\%$ on TSP100, which is superior to most of the recent neural solvers. Pertaining to CVRP, our DACT with $\\mathrm { T } { = } 5 \\mathrm { k }$ produces lower gaps than that of improvement models including NeuRewriter and NLNS. It also performs much better than Wu et al. [11] except on CVRP50. With $\\mathrm { T } { = } 1 0 \\mathrm { k }$ and 6 augments10, our DACT exhibits even better performance than the highly specialized heuristic solver LKH on CVRP20 and delivers the smallest gap of $0 . 1 9 \\%$ on CVRP100 against other neural solvers including POMO with 8 augments. Besides, our DACT is also competitive to DPDP which leverages learnt heatmap and dynamic programming to search solutions. Though DPDP (100k) can solve TSP100 instances almost optimally, our DACT is more efficient than DPDP on CVRP100. Compared with CVAE-Opt-DE, despite that it is averaged over fewer instances and integrated with differential evolution, our objective values are still lower. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In terms of the inference time, our DACT is highly competitive against all neural solvers except POMO which learns a construction model by sampling diverse trajectories. However, when it comes to the generalization performance on benchmark datasets, i.e., TSPLIB [38] and CVRPLIB [39] in Table 2(a), DACT produces significantly lower average gaps than the POMO with 8 augments, which indicates that our DACT is more advantageous in practice despite its longer inference time. On the other hand, it is possible to adopt a similar diverse rollout strategy for DACT to find better solutions earlier, or explore other model compression techniques such as the knowledge distillation [40] to learn a lighter DACT model for faster inference. Since our focus is to ameliorate Transformer for neural improvement solvers, we will investigate these possibilities in the future. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 Ablation studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            326,
+            805
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dual-aspect representation. In Table 3, we evaluate the effectiveness of our dual-aspect representation against the single-aspect one (SA-T) on TSP50 and TSP100, where SA-T mainly follows the Transformer in $\\mathbf { W } \\mathbf { u }$ et al. [11] but equipped with the CPE, multi-head attentions and CL strategy for fair comparison. We observe that our DACT with fewer parameters consistently outperforms SA-T, which verifies the effectiveness of the dual-aspect representation. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2102778a136af66f4a0dae7bc32cd3d938ae977b3f9616db51da4c7cf94b2d1f.jpg",
+        "image_caption": [
+            "Figure 6: Visualization of the attention scores for the encoder when a trained model is used to solve instances with a larger size. (a) using PE method; (b) using CPE method (ours). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            85,
+            743,
+            202
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cyclic positional encoding. Here we show that CPE significantly improves the generalization performance across different problem sizes. In Table 2(b), we record the results of our DACT with PE and CPE, and Wu et al. [11], when the model trained on TSP50 is directly used to solve instances from TSP20 and TSP100 with $\\mathrm { T } { = } 5 \\mathrm { k }$ . We see that even with PE, our DACT outperforms Wu et al. [11]. Further equipped with CPE, DACT outstrips DACT-PE and OR-Tools on TSP100. We continue to compare the two DACT variants by visualizing their attention scores. As depicted in Figure 6(a), although the absolute PE is designed for linear sequences, it did attempt to capture the circularity of ",
+        "bbox": [
+            174,
+            268,
+            526,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/dcaf347b7b825fb752b6ddcd50ad1a4968c6104e02beab829841e1b66d04fde2.jpg",
+        "image_caption": [
+            "Figure 7: Training curves of PPO with and without CL on CVRP20 (random seeds 1-5). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            571,
+            272,
+            789,
+            393
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "VRP solutions (as highlighted in the green boxes) after training. However, the ability to perceive such properties significantly drops when generalizing over different problem size, which instead engenders random attention scores when generalizing to larger size (see right side of Figure 6(a)). In contrast, our DACT with CPE is able to capture the circularity as depicted in Figure 6(b), which verifies the effectiveness of CPE in representing cyclic sequences (i.e., VRP solutions). ",
+        "bbox": [
+            174,
+            448,
+            825,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Curriculum learning (CL) strategy. In Figure 7, we plot the training curves of PPO algorithm with and without our CL strategy, where the results are averaged over 5 independent runs with $90 \\%$ confidence intervals. It shows that our CL strategy significantly improves the sample efficiency while reducing the variance of training, which aligns with our analysis in Section 4.4. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions and future work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            446,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a novel DACT model for routing problems. It learns separate groups of embeddings for the node and positional features, and is equipped with cyclic positional encoding (CPE) to capture the circularity and symmetry of VRP solutions. A curriculum learning (CL) strategy is also exploited to improve the RL training efficiency. Extensive experiments on both synthetic and benchmark datasets justified the effectiveness of DACT in terms of both inference and generalization. A potential limitation is that DACT is more useful for learning improvement models at present. In the future, we will investigate how to extend DACT to construction models, and how to speed up the DACT through diverse rollouts or model compression techniques. It is also interesting to apply the proposed CPE to develop Transformer based model for other tasks where the cyclic property is also important, e.g., encoding circular DNA/RNA structures in computational biology [41, 42]. ",
+        "bbox": [
+            173,
+            646,
+            825,
+            786
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            553,
+            825
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was supported in part by the National Natural Science Foundation of China under Grant 61803104 and Grant 62102228, in part by the Young Scholar Future Plan of Shandong University under Grant 62420089964188, and in part by the A\\*STAR CyberPhysical Production System (CPPS) - Towards Contextual and Intelligent Response Research Program, under the RIE2020 IAF-PP Grant A19C1a0018, and Model Factory $@$ SIMTech. ",
+        "bbox": [
+            173,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Paolo Toth and Daniele Vigo. Vehicle routing: problems, methods, and applications. SIAM press, 2014.   \n[2] Michael Schneider, Andreas Stenger, and Dominik Goeke. The electric vehicle-routing problem with time windows and recharging stations. Transportation Science, 48(4):500–520, 2014.   \n[3] Jan Karel Lenstra and AHG Rinnooy Kan. Complexity of vehicle routing and scheduling problems. Networks, 11(2):221–227, 1981.   \n[4] Xinyun Chen and Yuandong Tian. Learning to perform local rewriting for combinatorial optimization. In Advances in Neural Information Processing Systems, volume 32, pages 6281–6292, 2019.   \n[5] Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! In International Conference on Learning Representations, 2018.   \n[6] Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arxiv preprint arxiv:1906.01227, ArXiV, 2019.   \n[7] Liang Xin, Wen Song, Zhiguang Cao, and Jie Zhang. Multi-decoder attention model with embedding glimpse for solving vehicle routing problems. In Proceedings of 35th AAAI Conference on Artificial Intelligence, pages 12042–12049, 2021.   \n[8] Yeong-Dae Kwon, Jinho Choo, Byoungjip Kim, Iljoo Yoon, Youngjune Gwon, and Seungjai Min. POMO: Policy optimization with multiple optima for reinforcement learning. In Advances in Neural Information Processing Systems, volume 33, pages 21188–21198, 2020.   \n[9] Liang Xin, Wen Song, Zhiguang Cao, and Jie Zhang. Step-wise deep learning models for solving routing problems. IEEE Transactions on Industrial Informatics, 17(7):4861–4871, 2020.   \n[10] Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Xu Chi. Learning to dispatch for job shop scheduling via deep reinforcement learning. In Advances in Neural Information Processing Systems, volume 33, pages 1621–1632, 2020.   \n[11] Yaoxin Wu, Wen Song, Zhiguang Cao, Jie Zhang, and Andrew Lim. Learning improvement heuristics for solving routing problems. IEEE Transactions on Neural Networks and Learning Systems, 2021.   \n[12] Hao Lu, Xingwen Zhang, and Shuang Yang. A learning-based iterative method for solving vehicle routing problems. In International Conference on Learning Representations, 2019.   \n[13] André Hottung, Bhanu Bhandari, and Kevin Tierney. Learning a latent search space for routing problems using variational autoencoders. In International Conference on Learning Representations, 2021.   \n[14] Jingwen Li, Yining Ma, Ruize Gao, Zhiguang Cao, Andrew Lim, Wen Song, and Jie Zhang. Deep reinforcement learning for solving the heterogeneous capacitated vehicle routing problem. IEEE Transactions on Cybernetics, 2021.   \n[15] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   \n[16] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, volume 30, pages 6000–6010, 2017.   \n[17] Jingwen Li, Liang Xin, Zhiguang Cao, Andrew Lim, Wen Song, and Jie Zhang. Heterogeneous attentions for solving pickup and delivery problem via deep reinforcement learning. IEEE Transactions on Intelligent Transportation Systems, 2021.   \n[18] Guolin Ke, Di He, and Tie-Yan Liu. Rethinking the positional encoding in language pre-training. In International Conference on Learning Representations, 2020.   \n[19] Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations. In North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 464–468, 2018.   \n[20] Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, volume 28, pages 2692–2700, 2015.   \n[21] Irwan Bello, Hieu Pham, Quoc V Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. In International Conference on Machine Learning (Workshop), 2017.   \n[22] Mohammadreza Nazari, Afshin Oroojlooy, Martin Takác, and Lawrence V Snyder. Reinforcement learning ˇ for solving the vehicle routing problem. In Advances in Neural Information Processing Systems, pages 9861–9871, 2018.   \n[23] Paulo R d O Costa, Jason Rhuggenaath, Yingqian Zhang, and Alp Akcay. Learning 2-opt heuristics for the traveling salesman problem via deep reinforcement learning. In Asian Conference on Machine Learning, pages 465–480, 2020.   \n[24] Hanjun Dai, Elias B Khalil, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, pages 6351–6361, 2017.   \n[25] Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a small pre-trained model to arbitrarily large TSP instances. In AAAI Conference on Artificial Intelligence, 2021.   \n[26] Wouter Kool, Herke van Hoof, Joaquim Gromicho, and Max Welling. Deep policy dynamic programming for vehicle routing problems. arXiv preprint arXiv:2102.11756, 2021.   \n[27] André Hottung and Kevin Tierney. Neural large neighborhood search for the capacitated vehicle routing problem. In European Conference on Artificial Intelligence, 2020.   \n[28] Keld Helsgaun. LKH-3 (version 3.0.6), 2019. URL http://webhotel4.ruc.dk/\\~keld/research/ LKH-3/.   \n[29] Wikipedia. Gray code, 2021. URL: https://en.wikipedia.org/wiki/Gray_code. Last visited on 2020/05/19.   \n[30] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.   \n[31] Lei Jimmy Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. Corr: abs/1607.06450, ArXiV, 2016.   \n[32] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arxiv preprint arxiv:1707.06347, ArXiV, 2017.   \n[33] Fabio Pardo, Arash Tavakoli, Vitaly Levdik, and Petar Kormushev. Time limits in reinforcement learning. In International Conference on Machine Learning, pages 4045–4054, 2018.   \n[34] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In International Conference on Machine Learning, pages 41–48, 2009.   \n[35] David L Applegate, Robert E Bixby, Vašek Chvátal, and William J Cook. Concorde TSP Solver, 2020. URL http://www.math.uwaterloo.ca/tsp/concorde/.   \n[36] Keld Helsgaun. LKH (version 2.0.9), 2018. URL http://webhotel4.ruc.dk/\\~keld/research/ LKH/.   \n[37] Laurent Perron and Vincent Furnon. OR-Tools (version 7.2), 2019. URL https://developers.google. com/optimization/.   \n[38] Gerhard Reinelt. TSPLIB-A traveling salesman problem library. ORSA journal on computing, 3(4): 376–384, 1991.   \n[39] Eduardo Uchoa, Diego Pecin, Artur Pessoa, Marcus Poggi, Thibaut Vidal, and Anand Subramanian. New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858, 2017.   \n[40] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.   \n[41] Chun-Ying Yu, Tung-Cheng Li, Yi-Ying Wu, Chan-Hsien Yeh, Wei Chiang, Ching-Yu Chuang, and Hung-Chih Kuo. The circular rna circbirc6 participates in the molecular circuitry controlling human pluripotency. Nature communications, 8(1):1–15, 2017.   \n[42] Chengyu Liu, Yu-Chen Liu, Hsien-Da Huang, and Wei Wang. Biogenesis mechanisms of circular rna can be categorized through feature extraction of a machine learning model. Bioinformatics, 35(23):4867–4870, 2019.   \n[43] Logan Engstrom, Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Firdaus Janoos, Larry Rudolph, and Aleksander Madry. Implementation matters in deep policy gradients: A case study on PPO and TRPO. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            171,
+            80,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            78,
+            828,
+            916
+        ],
+        "page_idx": 11
+    }
+]

parse/train/rkgsvoA9K7/rkgsvoA9K7.md

@@ -0,0 +1,373 @@
+# DIRICHLET VARIATIONAL AUTOENCODER
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+This paper proposes Dirichlet Variational Autoencoder (DirVAE) using a Dirichlet prior for a continuous latent variable that exhibits the characteristic of the categorical probabilities. To infer the parameters of DirVAE, we utilize the stochastic gradient method by approximating the Gamma distribution, which is a component of the Dirichlet distribution, with the inverse Gamma CDF approximation. Additionally, we reshape the component collapsing issue by investigating two problem sources, which are decoder weight collapsing and latent value collapsing, and we show that DirVAE has no component collapsing; while Gaussian VAE exhibits the decoder weight collapsing and Stick-Breaking VAE shows the latent value collapsing. The experimental results show that 1) DirVAE models the latent representation result with the best log-likelihood compared to the baselines; and 2) DirVAE produces more interpretable latent values with no collapsing issues which the baseline models suffer from. Also, we show that the learned latent representation from the DirVAE achieves the best classification accuracy in the semi-supervised and the supervised classification tasks on MNIST, OMNIGLOT, and SVHN compared to the baseline VAEs. Finally, we demonstrated that the DirVAE augmented topic models show better performances in most cases.
+
+# 1 INTRODUCTION
+
+A Variational Autoencoder (VAE) (Kingma & Welling, 2014c) brought success in deep generative models (DGMs) with a Gaussian distribution as a prior distribution (Jiang et al., 2017; Miao et al., 2016; 2017; Srivastava & Sutton, 2017). If we focus on the VAE, the VAE assumes the prior distribution to be $\mathcal { N } ( \mathbf { 0 } , \pmb { I } )$ with the learning on the approximated $\hat { \mu }$ and $\hat { \Sigma }$ . Also, Stick-Breaking VAE (SBVAE) (Nalisnick & Smyth, 2017) is a nonparametric version of the VAE, which modeled the latent dimension to be infinite using a stick-breaking process (Ishwaran & James, 2001).
+
+While these VAEs assume that the prior distribution of the latent variables to be continuous random variables, recent studies introduce the approximations on discrete priors with continuous random variables (Jang et al., 2017; Maddison et al., 2017; Rolfe, 2017). The key of these approximations is enabling the backpropagation with the reparametrization technique, or the stochastic gradient variational Bayes (SGVB) estimator, while the modeled prior follows a discrete distribution. The applications of these approximations on discrete priors include the prior modeling of a multinomial distribution which is frequently used in the probabilistic graphical models (PGMs). Inherently, the multinomial distributions can take a Dirichlet distribution as a conjugate prior, and the demands on such prior have motivated the works like Jang et al. (2017); Maddison et al. (2017); Rolfe (2017) that support the multinomial distribution posterior without explicit modeling on a Dirichlet prior.
+
+When we survey the work with a explicit modeling on the Dirichlet prior, we found a frequent approach such as utilizing a softmax Laplace approximation (Srivastava & Sutton, 2017). We argue that this approach has a limitation from the multi-modality perspective. The Dirichlet distribution can exhibit a multi-modal distribution with parameter settings, see Figure 1, which is infeasible to generate with the Gaussian distribution with a softmax function. Therefore, the previous continuous domain VAEs cannot be a perfect substitute for the direct approximation on the Dirichlet distribution.
+
+Utilizing a Dirichlet distribution as a conjugate prior to a multinomial distribution has an advantage compared to the usage of a softmax function on a Gaussian distribution. For instance, Figure 1 illustrates the potential difficulties in utilizing the softmax function with the Gaussian distribution.
+
+![](images/4e46a06df419f01b1140bba9ea064365667a8840917b4f3b41c93dc6c5553b03.jpg)  
+Figure 1: Illustrated probability simplex with Gaussian-Softmax, GEM, and Dirichlet distributions. Unlike the Gaussian-Softmax or the GEM distribution, the Dirichlet distribution is able to capture the multi-modality that illustrates multiple peaks at the vertices of the probability simplex.
+
+Given the three-dimensional probability simplex, the Gaussian-Softmax distribution cannot generate the illustrated case of the Dirichlet distribution with a high probability measure at the vertices of the simplex, i.e. the multi-modality where the necessity was emphasized in Hoffman & Johnson (2016). Additionally, the Griffiths-Engen-McCloskey (GEM) distribution (Pitman, 2002), which is the prior distribution of the SBVAE, is difficult to model the multi-modality because the sampling procedure of the GEM distribution is affected by the rich-get-richer phenomenon, so a few components tend to dominate the weight of the samples. This is different from the Dirichlet distribution that does not exhibit such phenomenon, and the Dirichlet distribution can fairly distribute the weights to the components, and the Dirichlet distribution is more likely to capture the multi-modality by controlling the prior hyper-parameter (Blei et al., 2003). Then, we conjecture that an enhanced modeling on Dirichlet prior is still needed 1) because there are cases that the Gaussian-Softmax approaches, or the softmax Laplace approximation, cannot imitate the Dirichlet distribution; and 2) because the nonparametric approaches could be influenced by the biases that the Dirichlet distribution does not suffer from.
+
+Given these motivations for modeling the Dirichlet distribution with the SGVB estimator, this paper introduces the Dirichlet Variational Autoencoder (DirVAE) that shows the same characteristics of the Dirichlet distribution. The DirVAE is able to model the multi-modal distribution that was not possible with the Gaussian-Softmax and the GEM approaches. These characteristics allow the DirVAE to be the prior of the discrete latent distribution, as the original Dirichlet distribution is.
+
+Introducing the DirVAE requires the configuration of the SGVB estimator on the Dirichlet distribution. Specifically, the Dirichlet distribution is a composition of the Gamma random variables, so we approximate the inverse Gamma cumulative distribution function (CDF) with the asymptotic approximation. This approximation on the inverse Gamma CDF becomes the component of approximating the Dirichlet distribution. We compared this approach to the previously suggested approximations, i.e. approaches with the Weibull distribution and with the softmax Gaussian distribution, and our approximation shows the best log-likelihood among the compared approximations.
+
+Moreover, we report that we had to investigate the component collapsing along with the research on DirVAE. It has been known that the component collapsing issue is resolved by the SBVAE because of the meaningful decoder weights from the latent layer to the next layer. However, we found that SBVAE has latent value collapsing issue resulting in many near-zero values on the latent dimensions that leads to the incomplete utilization of the latent dimension. Hence, we argue that Gaussian VAE (GVAE) suffers from the decoder weight collapsing, previously limitedly defined as component collapsing; and SBVAE has a problem of the latent value collapsing. Finally, we suggest that the definition of component collapsing should be expanded to represent both cases of decoder weight and latent value collapsings. The proposed DirVAE shows neither the near-zero decoder weights nor the near-zero latent values, so the reconstruction uses the full latent dimension information in most cases. We investigated this issue because our performance gain comes from resolving the expanded version of the component collapsing. Due to the component collapsing issues, the existing VAEs have less meaningful latent values or could not effectively use its latent representation. Meanwhile, DirVAE does not have component collapsing due to the multi-modal prior which possibly leads to superior qualitative and quantitative performances. We experimentally showed that the DirVAE has more meaningful or disentangled latent representation by image generation and latent value visualizations.
+
+Technically, the new approximation provides the closed-form loss function derived from the evidence lower bound (ELBO) of the DirVAE. The optimization on the ELBO enables the representation learning with the DirVAE, and we test the learned representation from the DirVAE in two folds. Firstly, we test the representation learning quality by performing the supervised and the semi-supervised classification tasks on MNIST, OMNIGLOT, and SVHN. These classification tasks conclude that DirVAE has the best classification performances with its learned representation. Secondly, we test the applicability of DirVAE to the existing models, such as topic models with DirVAE priors on 20Newsgroup and RCV1-v2. This experiment shows that the augmentation of DirVAE to the existing neural variational topic models improves the perplexity and the topic coherence, and most of best performers were DirVAE augmented.
+
+# 2 PRELIMINARIES
+
+# 2.1 VARIATIONAL AUTOENCODERS
+
+A VAE is composed of two parts: a generative sub-model and an inference sub-model. In the generative part, a probabilistic decoder reproduces $\hat { \bf x }$ close to an observation $\mathbf { x }$ from a latent variable $\bar { \mathbf { z } } \sim p ( \mathbf { z } )$ , i.e. $\mathbf { \bar { x } } \sim p _ { \theta } ( \mathbf { x } | \mathbf { z } ) = p _ { \theta } ( \mathbf { x } | \zeta )$ where $\zeta = \mathrm { M L P } ( \mathbf { z } )$ is obtained from a latent variable $\mathbf { z }$ by a multilayer perceptron (MLP). In the inference part, a probabilistic encoder outputs a latent variable $\mathbf { z } \sim q _ { \phi } ( \mathbf { z } | \mathbf { x } ) = q _ { \phi } ( \mathbf { z } | \pmb { \eta } )$ where $\pmb { \eta } = \mathbf { M } \mathbf { L } \mathbf { P } ( \mathbf { x } )$ is computed from the observation $\mathbf { x }$ by a MLP. Model parameters, $\theta$ and $\phi$ , are jointly learned by optimizing the below ELBO with the stochastic gradient method through the backpropagations as the ordinary neural networks by using the SGVB estimators on the random nodes.
+
+$$
+\log p ( \mathbf { x } ) \geq \mathcal { L } ( \mathbf { x } ) = \mathbb { E } _ { q _ { \phi ( \mathbf { z } | \mathbf { x } ) } } [ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } ) ] - \mathrm { K L } ( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p _ { \theta } ( \mathbf { z } ) )
+$$
+
+In GVAE (Kingma & Welling, 2014c), the prior distribution of $p ( \mathbf { z } )$ is assumed to be a standard Gaussian distribution. In SBVAE (Nalisnick & Smyth, 2017), the prior distribution becomes a GEM distribution that produces samples with a Beta distribution and a stick-breaking algorithm.
+
+# 2.2 DIRICHLET DISTRIBUTION AS A COMPOSITION OF GAMMA RANDOM VARIABLES
+
+The Dirichlet distribution is a composition of multiple Gamma random variables. Note that the probability density functions (PDFs) of Dirichlet and Gamma distributions are as follows:
+
+$$
+\mathrm { D i r i c h l e t } ( \mathbf { x } ; \alpha ) = { \frac { \Gamma ( \sum \alpha _ { k } ) } { \prod \Gamma ( \alpha _ { k } ) } } \prod x _ { k } ^ { \alpha _ { k } - 1 } , \mathrm { G a m m a } ( x ; \alpha , \beta ) = { \frac { \beta ^ { \alpha } } { \Gamma ( \alpha ) } } x ^ { \alpha - 1 } e ^ { - \beta x }
+$$
+
+where $\alpha _ { k } , \alpha , \beta > 0$ . In detail, if there are $K$ independent random variables following the Gamma distributions $X _ { k } \sim \mathrm { G a m m a } ( \alpha _ { k } , \beta )$ or $\mathbf { X } \sim \mathbf { M u l t i G a m m a } ( \alpha , \beta \cdot \mathbf { 1 } _ { K } )$ where $\alpha _ { k } , \beta > 0$ for $k =$ $1 , \cdots , K$ , then we have $\mathbf { Y } \sim$ Dirichlet $( \alpha )$ where $Y _ { k } = X _ { k } / \Sigma X _ { i }$ . It should be noted that the rate parameter, $\beta$ , should be the same for every Gamma distribution in the composition. Then, the KL divergence can be derived as the following:
+
+$$
+\begin{array} { r } { \mathrm { K L } ( Q | | P ) = \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) + \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \psi ( \hat { \alpha } _ { k } ) } \end{array}
+$$
+
+for $P = \mathrm { \bf M u l t i G a m m a } ( \alpha , \beta \cdot { \bf 1 } _ { K } )$ and $Q = \mathbf { M u l t i G a m m a } ( \hat { \boldsymbol { \alpha } } , \beta \cdot { \mathbf { 1 } } _ { K } )$ where $\psi$ is a digamma function.   
+The detailed derivation is provided in Appendix B.
+
+# 2.3 SGVB FOR GAMMA RANDOM VARIABLE AND APPROXIMATION ON DIRICHLET DISTRIBUTION
+
+This section discusses several ways of approximating the Dirichlet random variable; or the SGVB estimators for the Gamma random variables which compose a Dirichlet distribution. Utilizing SGVB requires a differentiable non-centered parametrization (DNCP) for the distribution (Kingma & Welling, 2014d). The main SGVB for Gamma random variables, used in DirVAE, is using the inverse Gamma CDF approximation explained in the next section. Prior works include two approaches: the use of the Weibull distribution and the softmax Gaussian distribution, and the two approaches are explained in this section.
+
+Approximation with Weibull distribution. Because of the similar PDFs between the Weibull distribution and the Gamma distribution, some prior works used the Weibull distribution as a posterior distribution of the prior Gamma distribution (Zhang et al., 2018):
+
+$$
+\operatorname { W e i b u l l } ( x ; k , \lambda ) = { \frac { k } { \lambda } } { \Big ( } { \frac { x } { \lambda } } { \Big ) } ^ { k - 1 } e ^ { - ( x / \lambda ) ^ { k } } { \mathrm { ~ w h e r e ~ } } k , \lambda > 0 .
+$$
+
+The paper Zhang et al. (2018) pointed out that there are two useful characteristics when approximating the Gamma distribution with the Weibull distribution. One useful property is that the KL divergence expressed in a closed form, and the other is the simple reparametrization trick with a closed form of the inverse CDF from the Weibull distribution. However, we noticed that the Weibull distribution has a component of $e ^ { - ( x / \lambda ) ^ { k } }$ , and the Gamma distribution does not have the additional power term of $k$ in the component. Since $k$ is placed in the exponential component, small changes on $k$ can cause a significant difference that limits the optimization.
+
+Approximation with softmax Gaussian distribution. As in MacKay (1998); Srivastava & Sutton (2017), a Dirichlet distribution can be approximated by a softmax Gaussian distribution by using a softmax Laplace approximation. The relation between the Dirichlet parameter $_ { \pmb { \alpha } }$ and the Gaussian parameters $\mu , \Sigma$ is explained as the following:
+
+$$
+\mu _ { k } = \log \alpha _ { k } - \frac { 1 } { K } \sum _ { i } \log \alpha _ { i } , \ \Sigma _ { k } = \frac { 1 } { \alpha _ { k } } \Big ( 1 - \frac { 2 } { K } \Big ) + \frac { 1 } { K ^ { 2 } } \sum _ { i } \frac { 1 } { \alpha _ { i } } \ ,
+$$
+
+where $\pmb { \Sigma }$ is assumed to be a diagonal matrix, and we use the reparametrization trick in the usual GVAE for the SGVB estimator.
+
+# 3 MODEL DESCRIPTION
+
+Along with the inverse Gamma CDF approximation, we describe two sub-models in this section: the generative sub-model and the inference sub-model. Figure 2 describes the graphical notations of various VAEs and the neural network view of our model.
+
+![](images/e03c8b4b2a4d44d3ca99536284d29f48dd4c75602ddd758f600d4008e852b6e6.jpg)  
+Figure 2: Sub-figures 2a, 2b, and 2c are the graphical notations of the VAEs as latent variable models. The solid lines indicate the generative sub-models where the waved lines denote a prior distribution of the latent variables. The dotted lines indicate the inference sub-models. Sub-figure 2d denotes a neural network structure corresponding to Sub-figure 2c. Red nodes denote the random nodes which allow the backpropagation flows to the input.
+
+Generative sub-model. The key difference between the generative models between the DirVAE and the GVAE is the prior distribution assumption on the latent variable $\mathbf { z }$ . Instead of using the standard Gaussian distribution, we use the Dirichlet distribution which is a conjugate prior distribution of the multinomial distribution.
+
+$$
+\mathbf { z } \sim p ( \mathbf { z } ) = { \mathrm { D i r i c h l e t } } ( \alpha ) , \mathbf { x } \sim p _ { \theta } ( \mathbf { x } | \mathbf { z } )
+$$
+
+Inference sub-model. The probabilistic encoder with an approximating posterior distribution $q _ { \phi } ( { \bf z } | { \bf x } )$ is designed to be Dirichlet $( \hat { \pmb { \alpha } } )$ . The approximated posterior parameter $\hat { \pmb { \alpha } }$ is derived by the MLP from the observation $\mathbf { x }$ with the softplus output function, so the outputs can be positive values constrained by the Dirichlet distribution. Here, we do not directly sample $\mathbf { z }$ from the Dirichlet distribution. Instead, we use the Gamma composition method described in Section 2.2. Firstly, we draw $\mathbf { v } \sim \mathrm { M u l t i G a m m a } ( \alpha , \beta \cdot { \bf 1 } _ { K } ) .$ . Afterwards, we normalize $\mathbf { v }$ with its summation $\sum v _ { i }$ .
+
+The objective function to optimize the model parameters, $\theta$ and $\phi$ , is composed of Equation (1) and (3). Equation (7) is the loss function to optimize after the composition. The inverse Gamma CDF method explained in the next paragraph enables the backpropagation flows to the input with the stochastic gradient method. Here, for the fair comparison of expressing the Dirichlet distribution between the inverse Gamma CDF approximation method and the softmax Gaussian method, we set $\alpha _ { k } = 1 - 1 / K$ when $\mu _ { k } = 0$ and $\Sigma _ { k } = 1$ by using Equation (5); and $\beta = 1$ .
+
+$$
+\begin{array} { r } { \mathcal { L } ( \mathbf { x } ) = \mathbb { E } _ { q _ { \phi ( \mathbf { z } | \mathbf { x } ) } } [ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } ) ] - ( \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) + \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \psi ( \hat { \alpha } _ { k } ) ) } \end{array}
+$$
+
+Approximation with inverse Gamma CDF. A previous work Knowles (2015) suggested that, if $X \sim \operatorname { G a m m a } ( \alpha , \beta )$ , and if $F ( x ; \alpha , \beta )$ is a CDF of the random variable $X$ , the inverse CDF can be approximated as $F ^ { - 1 } ( u ; \alpha , \beta ) \approx \beta ^ { - 1 } ( u \alpha \Gamma ( \alpha ) ) ^ { 1 / \alpha }$ . Hence, we can introduce an auxiliary variable $u \sim \mathrm { U n i f o r m } ( 0 , 1 )$ to take over all the randomness of $X$ , and we treat the Gamma sampled $X$ as a deterministic value in terms of $\alpha$ and $\beta$ .
+
+It should be noted that there has been a practice of utilizing the combination of decomposing a Dirichlet distribution and approximating each Gamma component with inverse Gamma CDF. However, such practices have not been examined with its learning properties and applicabilities. The following section shows a new aspect of component collapsing that can be remedied by this combination on Dirichlet prior in VAE, and the section illustrates the performance gains in a certain set of applications, i.e. topic modeling.
+
+# 4 EXPERIMENTAL RESULTS
+
+This section reports the experimental results with the following experiment settings: 1) a pure VAE model; 2) a semi-supervised classification task with VAEs; 3) a supervised classification task with VAEs; and 4) topic models with DirVAE augmentations.
+
+# 4.1 EXPERIMENTS FOR REPRESENTATION LEARNING OF VAES
+
+Baseline models. We select the following models as baseline alternatives of the DirVAE: 1) the standard GVAE; 2) the GVAE with softmax (GVAE-Softmax) approximating the Dirichlet distribution with the softmax Gaussian distribution; 3) the SBVAE with the Kumaraswamy distribution (SBVAE-Kuma) $\&$ the Gamma composition (SBVAE-Gamma) described in Nalisnick & Smyth (2017); and 4) the DirVAE with the Weibull distribution (DirVAE-Weibull) approximating the Gamma distribution with the Weibull distribution described in Zhang et al. (2018). We use the following benchmark datasets for the experiments: 1) MNIST; 2) MNIST with rotations (MNIST+rot); 3) OMNIGLOT; and 4) SVHN with PCA transformation. We provide the details on the datasets in Appendix D.1.
+
+Experimental setting. As a pure VAE model, we compare the DirVAE with the following models: GVAE, GVAE-Softmax, SBVAE-Kuma, SBVAE-Gamma, and DirVAE-Weibull. We use 50- dimension and 100-dimension latent variables for MNIST and OMNIGLOT, respectively. We provide the details of the network structure and optimization in Appendix D.2. We set ${ \pmb { \alpha } } = 0 . 9 8 \cdot { \bf 1 } _ { 5 0 }$ for MNIST and ${ \pmb { \alpha } } = 0 . 9 9 \cdot { \bf 1 } _ { 1 0 0 }$ for OMNIGLOT for the fair comparison to GVAEs by using Equation (5). All experiments use the Adam optimizer (Kingma & Ba, 2014a) for the parameter learning. Finally, we acknowledge that the hyper-parameter could be updated as Appendix C, and the experiment result with the update is separately reported in Appendix D.2.
+
+Quantitative result. For the quantitative comparison among the VAEs, we calculated the MonteCarlo estimation on the marginal negative log-likelihood, the negative ELBO, and the reconstruction loss. The marginal log-likelihood is approximated as $\begin{array} { r } { p ( \mathbf { x } ) \approx et { } { ' } \sum _ { i } \frac { p ( \mathbf { x } | \mathbf { z } _ { i } ) p ( \mathbf { z } _ { i } ) } { q ( \mathbf { z } _ { i } ) } } \end{array}$ p(x|zi)p(zi) for single instance x where $q ( \mathbf { z } )$ is a posterior distribution of a prior distribution $p ( \mathbf { z } )$ , which is further derived in Appendix A. Table 1 shows the overall performance of the alternative VAEs. The DirVAE outperforms all baselines in both datasets from the log-likelihood perspective. The value of DirVAE comes from the better encoding of the latent variables that can be used for classification tasks which we examine in the next experiments. While the DirVAE-Weibull follows the prior modeling with the Dirichlet distribution, the Weibull based approximation can be improved by adopting the proposed approach with the inverse Gamma CDF.
+
+Table 1: Negative log-likelihood, negative ELBO, and reconstruction loss of the VAEs for MNIST and OMNIGLOT dataset. The lower values are the better for all measures.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">MNIST (K= 50)</td><td colspan="3">OMNIGLOT (K= 100)</td></tr><tr><td>Neg.LL</td><td>Neg.ELBO</td><td>Reconst. Loss</td><td>Neg. LL</td><td>Neg.ELBO</td><td>Reconst. Loss</td></tr><tr><td>GVAE(Nalisnick&amp; Smyth,2017)</td><td>96.80</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SBVAE-Kuma (Nalisnick &amp; Smyth,2017)</td><td>98.01</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SBVAE-Gamma (Nalisnick &amp; Smyth,2017)</td><td>100.74</td><td>1</td><td>一</td><td>一</td><td>一</td><td>一</td></tr><tr><td>GVAE</td><td>94.54±0.79</td><td>98.58±0.04</td><td>74.31±0.13</td><td>119.29±0.44</td><td>126.42±0.24</td><td>98.90±0.36</td></tr><tr><td>GVAE-Softmax</td><td>98.18±0.61</td><td>103.49±0.16</td><td>79.36±0.82</td><td>130.01±1.16</td><td>139.73±0.81</td><td>123.34±1.43</td></tr><tr><td>SBVAE-Kuma</td><td>99.27±0.48</td><td>102.60±1.81</td><td>83.90±0.82</td><td>130.73±2.17</td><td>132.86±3.03</td><td>119.25±1.00</td></tr><tr><td>SBVAE-Gamma</td><td>102.14±0.69</td><td>135.30±0.24</td><td>113.89±0.25</td><td>128.82±1.82</td><td>149.30±0.82</td><td>136.36±1.53</td></tr><tr><td>DirVAE-Weibull</td><td>114.59±11.15</td><td>183.33±2.96</td><td>150.92±3.70</td><td>140.89±3.21</td><td>198.01±2.46</td><td>145.52±3.13</td></tr><tr><td>DirVAE</td><td>87.64±0.64</td><td>100.47±0.35</td><td>81.50±0.27</td><td>108.24±0.42</td><td>120.06±0.35</td><td>99.78±0.36</td></tr></table>
+
+Qualitative result. As a qualitative result, we report the latent dimension-wise reconstructions which are decoder outputs with each one-hot vector in the latent dimension. Figure 3a shows 50 reconstructed images corresponding to each latent dimension from GVAE-Softmax, SBVAE, and DirVAE. We manually ordered the digit-like figures in the ascending order for GVAE-Softmax and DirVAE. We can see that the GVAE-Softmax and the SBVAE have components without significant semantic information, which we will discuss further in Section 4.2, and the DirVAE has interpretable latent dimensions in most of the latent dimensions. Figure 3b also supports the quality of the latent values from DirVAE by visualizing learned latent values through t-SNE (Maaten & Hinton, 2008).
+
+![](images/e25bbbee687f1c767cdb7fa59c6803261aada1c3a718369faa500ec9ea560162.jpg)  
+Figure 3: Latent dimension visualization with reconstruction images and t-SNE latent embeddings.
+
+# 4.2 DISCUSSION ON COMPONENT COLLAPSING
+
+Decoder weight collapsing, a.k.a. component collapsing. One main issue of GVAE is component collapsing that there are a significant number of near-zero decoder weights from the latent neurons to the next decoder neurons. If these weights become near-zero, the values of the latent dimensions loose influence to the next decoder, and this means an inefficient learning given a neural network structure. The same issue occurs when we use the GVAE-Softmax. We rename this component collapsing phenomenon as decoder weight collapsing to specifically address the collapsing source.
+
+Latent value collapsing. SBVAE claims that SBVAE solved the decoder weight collapsing by learning the meaningful weights as shown in Figure 4a. However, we notice that SBVAE produces the output values, not the weight parameters, from the latent dimension to be near-zero in many latent dimensions after averaging many samples obtained from the test dataset. Figure 4b shows the properties of DirVAE and SBVAE from the perspective of the latent value collapsing, which SBVAE shows many near-zero average means and near-zero average variances, while DirVAE does not. The average Fisher kurtosis and average skewness of DirVAE are 5.76 and 2.03, respectively over the dataset, while SBVAE has 20.85 and 4.35, which states that the latent output distribution from SBVAE is more skewed than that of DirVAE. We found out that these near-zero latent values prevent learning on decoder weights, which we introduce as another type of collapsing problem, as latent value collapsing that is different from the decoder weight collapsing. These results mean that SBVAE distributes the non-near-zero latent values sparsely over a few dimensions while DirVAE samples relatively dense latent values. In other words, DirVAE utilizes the full spectrum of latent dimensions compared to SBVAE, and DirVAE has a better learning capability in the decoder network. Figure 3a supports the argument on the latent value collapsing by activating each and single latent dimension with a one-hot vector through the decoder. The non-changing latent dimension(a) Latent dimension-wise L2-norm of decoder weights of VAEs.
+
+![](images/72460a095d9e8d9acfbe0c553367190e22ea09a529f6e458e21046e43ab7da93.jpg)
+
+![](images/823b2ff3d8614b1ff525a2a06bdf1d89fed7be9c56062cc6a3e88d88fa55f397.jpg)  
+(b) Latent values of VAEs.   
+Figure 4: Sub-figure 4a shows GVAE and GVAE-Softmax have component collapsing issue, while SBVAE and DirVAE do not. Sub-figure 4b shows that SBVAE has many near-zero output values in the latent dimensions.
+
+wise images of SBVAE proves that there were no generation differences between the two differently activated one-hot latent values.
+
+# 4.3 APPLICATION 1. EXPERIMENTS OF (SEMI-)SUPERVISED CLASSIFICATION WITH VAES
+
+Semi-supervised classification task with VAEs. There is a previous work demonstrating that the SBVAE outperforms the GVAE in semi-supervised classification task (Nalisnick & Smyth, 2017). The overall model structure for this semi-supervised classification task uses a VAE with separate random variables of $\mathbf { z }$ and y, which is introduced as the M2 model in the original VAE work (Kingma et al., 2014b). The detailed settings of the semi-supervised classification tasks are enumerated in Appendix D.3. Fundamentally, we applied the same experimental settings to GVAE, SBVAE, and DirVAE in this experiment, as specified by the authors in Nalisnick & Smyth (2017).
+
+Table 2 enumerates the performances of the GVAE, the SBVAE, and the DirVAE, and the result shows that the error rate of classification result using $1 0 \%$ , $5 \%$ and $1 \%$ of labeled data for each dataset. In general, the experiment shows that the DirVAE has the best performance out of three alternative VAEs. Also, it should be noted that the performance of the DirVAE is more improved in the most complex task with the SVHN dataset.
+
+Table 2: The error rate of semi-supervised classification task using VAEs.   
+
+<table><tr><td></td><td colspan="3">MNIST(K=50)</td><td colspan="3">MNIST+rot (K = 50)</td><td colspan="3">SVHN (K= 50)</td></tr><tr><td></td><td>10%</td><td>5%</td><td>1%</td><td>10%</td><td>5%</td><td>1%</td><td>10%</td><td>5%</td><td>1%</td></tr><tr><td>GVAE(Nalisnick &amp; Smyth,2017)</td><td>3.95±0.15</td><td>4.74±0.43</td><td>11.55±2.28</td><td>21.78±0.73</td><td>27.72±0.69</td><td>38.13±0.95</td><td>36.08±1.49</td><td>48.75±1.47</td><td>69.58±1.64</td></tr><tr><td>SBVAE (Nalisnick &amp; Smyth,2017)</td><td>4.86±0.14</td><td>5.29±0.39</td><td>7.34±0.47</td><td>11.78±0.39</td><td>14.27±0.58</td><td>27.67±1.39</td><td>32.08±4.00</td><td>37.07±5.22</td><td>61.37±3.60</td></tr><tr><td>DirVAE</td><td>4.60±0.07</td><td>5.05±0.18</td><td>7.00±0.17</td><td>11.18±0.32</td><td>13.53±0.46</td><td>26.20±0.66</td><td>24.81±1.13</td><td>28.45±1.14</td><td>55.99±3.30</td></tr></table>
+
+Supervised classification task with latent values of VAEs. Also, we tested the performance of the supervised classification task with the learned latent representation from the VAEs. We applied the vanilla version of VAEs to the datasets, and we classified the latent representation of instances with $k$ -Nearest Neighbor $( k \mathrm { N N } )$ which is one of the simplest classification algorithms. Hence, this experiment can better distinguish the performance of the representation learning in the classification task. Further experimental details can be found in Appendix D.4.
+
+Table 3 enumerates the performances from the experimented VAEs in the datasets of MNIST and OMNIGLOT. Both datasets indicated that the DirVAE shows the best performance in reducing the classification error, which we conjecture that the performance is gathered from the better representation learning. It should be noted that, to our knowledge, this is the first reported comparison of latent representation learning on VAEs with $k \mathbf { N N }$ in the supervised classification using OMNIGLOT dataset. We identified that the classification with OMNIGLOT is difficult given that the $k \mathbf { N N }$ error rates with the raw original data are as high as $6 9 . 9 4 \%$ , $6 9 . 4 1 \%$ , and $7 0 . 1 0 \%$ . This high error rate mainly originates from the number of classification categories which is 50 categories in our test setting of OMNIGLOT, compared to 10 categories in MNIST.
+
+Table 3: The error rate of $k \mathbf { N N }$ with the latent representations of VAEs.   
+4.4 APPLICATION 2. EXPERIMENTS OF TOPIC MODEL AUGMENTATION WITH DIRVAE   
+
+<table><tr><td rowspan="2"></td><td colspan="3">MNIST (K = 50)</td><td colspan="3">OMNIGLOT(K= 100)</td></tr><tr><td>k=3</td><td>k=5</td><td>k=10</td><td>k=3</td><td>k=5</td><td>k=10</td></tr><tr><td>GVAE (Nalisnick et al.,2016)</td><td>28.40</td><td>20.96</td><td>15.33</td><td></td><td></td><td></td></tr><tr><td>SBVAE (Nalisnick et al.,2016)</td><td>9.34</td><td>8.65</td><td>8.90</td><td></td><td></td><td></td></tr><tr><td>DLGMM (Nalisnick et al., 2016)</td><td>9.14</td><td>8.38</td><td>8.42</td><td></td><td></td><td></td></tr><tr><td>GVAE</td><td>27.16±0.48</td><td>20.20±0.93</td><td>14.89±0.40</td><td>92.34±0.25</td><td>91.21±0.18</td><td>88.79±0.35</td></tr><tr><td>GVAE-Softmax</td><td>25.68±2.64</td><td>21.79±2.17</td><td>18.75±2.06</td><td>94.76±0.20</td><td>94.22±0.37</td><td>92.98±0.42</td></tr><tr><td>SBVAE</td><td>10.01±0.52</td><td>9.58±0.47</td><td>9.39±0.54</td><td>86.90±0.82</td><td>85.10±0.89</td><td>82.96±0.64</td></tr><tr><td>DirVAE</td><td>5.98±0.06</td><td>5.29±0.06</td><td>5.06±0.06</td><td>76.55±0.23</td><td>73.81±0.29</td><td>70.95±0.29</td></tr><tr><td>Raw Data</td><td>3.00</td><td>3.21</td><td>3.44</td><td>69.94</td><td>69.41</td><td>70.10</td></tr></table>
+
+One usefulness of the Dirichlet distribution is being a conjugate prior to the multinomial distribution, so it has been widely used in the field of topic modeling, such as Latent Dirichlet Allocation (LDA) (Blei et al., 2003). Recently, some neural variational topic (or document) models have been suggested, for example, ProdLDA (Srivastava & Sutton, 2017), NVDM (Miao et al., 2016), and GSM (Miao et al., 2017). NVDM used the GVAE, and the GSM used the GVAE-Softmax to make the sum-to-one positive topic vectors. Meanwhile, ProdLDA assume the prior distribution to be the Dirichlet distribution with the softmax Laplace approximation. To verify the usefulness of the DirVAE, we replace the probabilistic encoder part of the DirVAE to each model. Two popular performance measures in the topic model fields, which are perplexity and topic coherence via normalized pointwise mutual information (NPMI) (Lau et al., 2014), have been used with 20Newsgroups and RCV1-v2 datasets. Further details of the experiments can be found in Appendix D.5. Table 4 indicates that the augmentation of DirVAE improves the performance in general. Additionally, the best performers from the two measurements are always the experiment cell with DirVAE augmentation except for the perplexity of RCV1-v2, which still remains competent.
+
+Table 4: Topic modeling performances of perpexity and NPMI with DirVAE augmentations.   
+
+<table><tr><td rowspan="2" colspan="2"></td><td colspan="4">20Newsgroups (K= 50)</td><td colspan="4">RCV1-v2 (K= 100)</td></tr><tr><td>ProdLDA</td><td>NVDM</td><td>GSM</td><td>LDA (Gibbs)</td><td>ProdLDA</td><td>NVDM</td><td>GSM</td><td>LDA (Gibbs)</td></tr><tr><td rowspan="4">Perplexity</td><td>Reported</td><td>1172</td><td>837</td><td>822</td><td>、</td><td></td><td>=</td><td>=</td><td></td></tr><tr><td>Reproduced</td><td>1219±8.87</td><td>810±2.60</td><td>954±1.22</td><td>1314±18.50</td><td>1190±45.24</td><td>796±6.24</td><td>1386±21.06</td><td>1126±12.66</td></tr><tr><td>Add SBVAE</td><td>1164±2.55</td><td>878±14.21</td><td>980±13.50</td><td>=</td><td>1077±22.57</td><td>1050±12.19</td><td>1670±4.78</td><td></td></tr><tr><td>Add DirVAE</td><td>1114±2.30</td><td>752±12.17</td><td>916±1.64</td><td>■</td><td>992±2.19</td><td>809±12.60</td><td>1526±6.11</td><td>=</td></tr><tr><td rowspan="4">NPMI</td><td>Reported</td><td>0.240</td><td>0.186</td><td>0.121</td><td>-</td><td>-</td><td>-</td><td>-</td><td>·</td></tr><tr><td>Reproduced</td><td>0.273±0.019</td><td>0.119±0.003</td><td>0.199±0.006</td><td>0.225±0.002</td><td>0.194±0.005</td><td>0.023±0.002</td><td>0.267±0.019</td><td>0.266±0.006</td></tr><tr><td>Add SBVAE</td><td>0.247±0.015</td><td>0.162±0.007</td><td>0.162±0.006</td><td>·</td><td>0.190±0.006</td><td>0.116±0.016</td><td>0.207±0.004</td><td>=</td></tr><tr><td>Add DirVAE</td><td>0.359±0.026</td><td>0.247±0.010</td><td>0.201±0.003</td><td>·</td><td>0.193±0.004</td><td>0.131±0.015</td><td>0.308±0.005</td><td>=</td></tr></table>
+
+# 5 CONCLUSION
+
+Recent advances in VAEs have become one of the cornerstones in the field of DGMs. The VAEs infer the parameters of explicitly described latent variables, so the VAEs are easily included in the conventional PGMs. While this merit has motivated the diverse cases of merging the VAEs to the graphical models, we ask the fundamental quality of utilizing the GVAE where many models have latent values to be categorical probabilities. The softmax function cannot reproduce the multi-modal distribution that the Dirichlet distribution can. Recognizing this problem, there have been some previous works that approximated the Dirichlet distribution in the VAE settings by utilizing the Weibull distribution or the softmax Gaussian distribution, but the DirVAE with the inverse Gamma CDF shows the better learning performance in our experiments of the representation: the semi-supervised, the supervised classifications, and the topic models. Moreover, DirVAE shows no component collapsing and it leads to better latent representation and performance gain. The proposed DirVAE can be widely used if we recall the popularity of the conjugate relation between the multinomial and the Dirichlet distributions because the proposed DirVAE can be a brick to the construction of complex probabilistic models with neural networks.
+
+REFERENCES   
+D. M. Blei, A. Y. Ng, and M. I. Jordan. Latent dirichlet allocation. Journal of Machine Learning Research, 2003.   
+X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. International Conference on Artificial Intelligence and Statistics, 2010.   
+M. Hoffman and M. Johnson. Elbo surgery: yet another way to carve up the variational evidence lower bound. Neural Information Processing Systems Workshop on Advances in Approximate Bayesian Inference, 2016.   
+H. Ishwaran and L. F. James. Gibbs sampling methods for stick-breaking priors. Journal of the American Statistical Association, 2001.   
+E. Jang, S. Gu, and B. Poole. Categorical reparameterization with gumbel-softmax. International Conference on Learning Representations, 2017.   
+Z. Jiang, Y. Zheng, H. Tan, B. Tang, and H. Zhou. Variational deep embedding: An unsupervised and generative approach to clustering. International Joint Conference on Artificial Intelligence, 2017.   
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014a.   
+D. P. Kingma and M. Welling. Auto-encoding variational bayes. International Conference on Learning Representations, 2014c.   
+D. P. Kingma and M. Welling. Efficient gradient-based inference through transformations between bayes nets and neural nets. International Conference on Machine Learning, 2014d.   
+D. P. Kingma, S. Mohamed, D. J. Rezende, , and M. Welling. Semi-supervised learning with deep generative models. Neural Information Processing Systems, 2014b.   
+D. A. Knowles. Stochastic gradient variational bayes for gamma approximating distributions. arXiv preprint arXiv:1509.01631, 2015.   
+B. M. Lake, R. R. Salakhutdinov, and J. Tenenbaum. One-shot learning by inverting a compositional causal process. Neural Information Processing Systems, 2013.   
+J. H. Lau, D. Newman, and T. Baldwin. Machine reading tea leaves: Automatically evaluating topic coherence and topic model quality. European Chapter of the Association for Computational Linguistics, 2014.   
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the Institute of Electrical and Electronics Engineers, 1998.   
+L. V. D. Maaten and G. Hinton. Visualizing data using t-sne. Journal of machine learning research, 2008.   
+D. J. C. MacKay. Choice of basis for laplace approximation. Machine Learning, 1998.   
+C. J. Maddison, A. Mnih, and Y. W. Teh. The concrete distribution: A continuous relaxation of discrete random variables. International Conference on Learning Representations, 2017.   
+Y. Miao, L. Yu, and P. Blunsom. Neural variational inference for text processing. International Conference on Machine Learning, 2016.   
+Y. Miao, E. Grefenstette, and P. Blunsom. Discovering discrete latent topics with neural variational inference. International Conference on Machine Learning, 2017.   
+T. Minka. Estimating a dirichlet distribution. Technical report, M.I.T., 2000.   
+V. Nair and G. Hinton. Rectified linear units improve restricted boltzmann machines. International Conference on Machine Learning, 2010.   
+E. Nalisnick and P. Smyth. Stick-breaking variational autoencoders. International Conference on Learning Representations, 2017.   
+E. Nalisnick, L. Hertel, and P. Smyth. Approximate inference for deep latent gaussian mixtures. Neural Information Processing Systems Workshop on Bayesian Deep Learning, 2016.   
+J. Pitman. Combinatorial stochastic processes. Technical report, UC Berkeley, 2002.   
+D. J. Rezende and S. Mohamed. Variational inference with normalizing flows. International Conference on Machine Learning, 2015.   
+J. T. Rolfe. Discrete variational autoencoders. International Conference on Learning Representations, 2017.   
+A. Srivastava and C. Sutton. Autoencoding variational inference for topic models. International Conference on Learning Representations, 2017.   
+C. K. Snderby, T. Raiko, L. Maale, S. K. Snderby, and O. Winther. Ladder variational autoencoders. Neural Information Processing Systems, 2016.   
+H. Zhang, B. Chen, D. Guo, and M. Zhou. Whai: Weibull hybrid autoencoding inference for deep topic modeling. International Conference on Learning Representations, 2018.
+
+# APPENDIX
+
+This is an appendix for Dirichlet Variational Autoencoder. Here, we describe the derivations of key equations and experimental setting details which were used in the body of the paper. The detailed information such as model names, parameter names, or experiment assumptions is based on the main paper.
+
+# A MONTE-CARLO ESTIMATION ON THE MARGINAL LIKELIHOOD
+
+Proposition A.1. The marginal log-likelihood is approximated as $\begin{array} { r } { p ( \mathbf { x } ) \approx \sum _ { i } \frac { p ( \mathbf { x } | \mathbf { z } _ { i } ) p ( \mathbf { z } _ { i } ) } { q ( \mathbf { z } _ { i } ) } } \end{array}$ , where $q ( \mathbf { z } )$ is a posterior distribution of a prior distribution $p ( \mathbf { z } )$ .
+
+Proof.
+
+$$
+\begin{array} { l } { { \displaystyle p ( { \bf x } ) = \int _ { { \bf z } } p ( { \bf x } , { \bf z } ) d { \bf z } = \int _ { { \bf z } } p ( { \bf x } , { \bf z } ) \frac { q ( { \bf z } ) } { q ( { \bf z } ) } d { \bf z } } \ ~ } \\ { { \displaystyle ~ = \int _ { { \bf z } } p ( { \bf x } | { \bf z } ) p ( { \bf z } ) \frac { q ( { \bf z } ) } { q ( { \bf z } ) } d { \bf z } = \int _ { { \bf z } } \frac { p ( { \bf x } | { \bf z } ) p ( { \bf z } ) } { q ( { \bf z } ) } q ( { \bf z } ) d { \bf z } } \ ~ } \\ { { \displaystyle ~ \approx \sum _ { i } \frac { p ( { \bf x } | { \bf z } _ { i } ) p ( { \bf z } _ { i } ) } { q ( { \bf z } _ { i } ) } \mathrm { ~ w h e r e ~ } { \bf z } _ { i } \sim q ( { \bf z } ) } \ ~ } \end{array}
+$$
+
+# B KL DIVERGENCE OF TWO MULTI-GAMMA DISTRIBUTIONS
+
+Proposition B.1. Define $\mathbf { X } = ( X _ { 1 } , \cdots , X _ { K } ) \sim M u l t i G a m m a ( \alpha , \beta \cdot { \mathbf { 1 } } _ { K } )$ as a vector of $K$ independent Gamma random variables $X _ { k } \sim G a m m a ( \alpha _ { k } , \beta )$ where $\alpha _ { k } , \beta > 0$ for $k = 1 , \cdots , K$ . The $K L$ divergence between two MultiGamma distributions $P =$ MultiGamma $( { \pmb { \alpha } } , { \boldsymbol { \beta } } \cdot { \bf 1 } _ { K } )$ and $Q = M u l t i G a m m a ( \hat { \alpha } , \beta \cdot { \bf 1 } _ { K } )$ can be derived as the following:
+
+$$
+K L ( Q | | P ) = \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) + \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \psi ( \hat { \alpha } _ { k } ) ,
+$$
+
+where $\psi$ is a digamma function.
+
+Proof. Note that the derivative of a Gamma-like function $\frac { \Gamma ( \alpha ) } { \beta ^ { \alpha } }$ can be derived as follows:
+
+$$
+{ \frac { d } { d \alpha } } { \frac { \Gamma ( \alpha ) } { \beta ^ { \alpha } } } = \beta ^ { - \alpha } ( \Gamma ^ { \prime } ( \alpha ) - \Gamma ( \alpha ) \log \beta ) = \int _ { 0 } ^ { \infty } x ^ { \alpha - 1 } e ^ { - \beta x } \log x d x .
+$$
+
+Then, we have the following.
+
+$$
+\begin{array} { r l } & { \quad \mathrm { K L } ( Q | | P ) = \displaystyle \int _ { \nu } q ( \mathbf x ) \log \frac { q ( \mathbf x ) } { p ( \mathbf x ) } d \mathbf x } \\ & { = \displaystyle \int _ { 0 } ^ { \infty } \cdots \int _ { 0 } ^ { \infty } \prod \mathrm { G a m m a } ( \hat { \alpha } _ { k } , \beta ) \log \frac { \beta \sum \hat { \alpha } _ { k } | \prod ^ { \nu _ { 1 } } ( \hat { \alpha } _ { k } ) \mathrm { e } ^ { \beta \sum \nu _ { k } } \prod | \alpha _ { k } ^ { \hat { \alpha } _ { k } - 1 } } { \beta \sum \alpha _ { k } \prod ^ { \nu _ { 1 } - 1 } ( \exp \epsilon ^ { - \beta } \sum ^ { \nu _ { k } } \prod | \alpha _ { k } ^ { \hat { \alpha } _ { k } - 1 } } d \mathbf x } \\ & { = \displaystyle \int _ { 0 } ^ { \infty } \cdots \int _ { 0 } ^ { \infty } \prod \mathrm { G a m m a } ( \hat { \alpha } _ { k } , \beta ) } \\ & { \quad \quad \times \left[ \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \log \beta + \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) + \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \log \alpha _ { k } \right] d \mathbf x } \\ & { = \displaystyle \left[ \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \log \beta + \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) \right] } \\ & { \quad + \displaystyle \int _ { 0 } ^ { \infty } \cdots \int _ { 0 } ^ { \infty } \frac { \beta \hat { \alpha } _ { k } } { \prod \left( \hat { \alpha } _ { k } \right) } \mathrm { e } ^ { - \beta \sum \nu _ { k } } \prod \mathrm { x } _ { k } ^ { \hat { \alpha } _ { k } - 1 } \Big ( \sum _ { \alpha _ { k } } ^ { \hat { \alpha } _ { k } - 1 } ( \sum _ { \alpha _ { k } } ^ { \hat { \alpha } _ { k } } - \alpha _ { k } ) \log x _ { k } \Big ) d \mathbf x } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { = \Big [ \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \log \beta + \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) \Big ] } \\ & { \quad + \displaystyle \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \beta ^ { \hat { \alpha } _ { k } } \Gamma ^ { - 1 } ( \hat { \alpha } _ { k } ) \beta ^ { - \hat { \alpha } _ { k } } \big ( \Gamma ^ { \prime } ( \hat { \alpha } _ { k } ) - \Gamma ( \hat { \alpha } _ { k } ) \log \beta \big ) } \\ & { = \displaystyle \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \log \beta + \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) + \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) ( \psi ( \hat { \alpha } _ { k } ) - \log \beta ) } \\ & { = \displaystyle \sum \log \Gamma ( \alpha _ { k } ) - \sum \log \Gamma ( \hat { \alpha } _ { k } ) + \sum ( \hat { \alpha } _ { k } - \alpha _ { k } ) \psi ( \hat { \alpha } _ { k } ) } \end{array}
+$$
+
+# C HYPER-PARAMETER $\alpha$ LEARNING STRATEGY
+
+In this section, we introduce the method of moment estimator (MME) to update the Dirichlet prior parameter $_ { \pmb { \alpha } }$ . Suppose we have a set of sum-to-one proportions $\mathcal { D } = \{ { \bf p } _ { 1 } , \cdots , { \bf p } _ { N } \}$ sampled from Dirichle $( \alpha )$ , then the MME update rule is as the following:
+
+$$
+\alpha _ { k } \gets \frac { S } { N } \sum _ { n } p _ { n , k } \mathrm { w h e r e } S = \frac { 1 } { K } \sum _ { k } \frac { \tilde { \mu } _ { 1 , k } - \tilde { \mu } _ { 2 , k } } { \tilde { \mu } _ { 2 , k } - \tilde { \mu } _ { 1 , k } ^ { 2 } } \mathrm { f o r } \tilde { \mu } _ { j , k } = \frac { 1 } { N } \sum _ { n } p _ { n , k } ^ { j } \cdot
+$$
+
+After the burn-in period for stabilizing the neural network parameters, we use the MME for the hyper-parameter learning using the sampled latent values during training. We alternatively update the neural network parameters and hyper-parameter $_ \alpha$ . We choose this estimator because of its closed form nature and consistency (Minka, 2000). The usefulness of the hyper-parameter update can be found in Appendix D.2.
+
+Proposition C.1. Given a proportion set $\mathcal { D } = \{ { \bf p } _ { 1 } , \cdots , { \bf p } _ { N } \}$ sampled from Dirichle $\mathbf { \nabla } \cdot ( \alpha )$ , MME of the hyper-parameter $_ { \pmb { \alpha } }$ is as the following:
+
+$$
+\alpha _ { k } \gets \frac { S } { N } \sum _ { n } p _ { n , k } w h e r e ~ S = \frac { 1 } { K } \sum _ { k } \frac { \tilde { \mu } _ { 1 , k } - \tilde { \mu } _ { 2 , k } } { \tilde { \mu } _ { 2 , k } - \tilde { \mu } _ { 1 , k } ^ { 2 } } f o r ~ \tilde { \mu } _ { j , k } = \frac { 1 } { N } \sum _ { n } p _ { n , k } ^ { j } .
+$$
+
+Proof. Define $\mu _ { j , k } = \operatorname { \mathbb { E } } [ p _ { k } ^ { j } ]$ as the $j ^ { \mathrm { t h } }$ moment of the $k ^ { \mathrm { { t h } } }$ dimension of Dirichlet distribution with prior $_ { \pmb { \alpha } }$ . Then, by the law of large number, $\mu _ { j , k } \approx \tilde { \mu } _ { j , k }$ . It can be easily shown that $\textstyle \mu _ { 1 , k } = { \frac { \alpha _ { k } } { \sum _ { i } \alpha _ { i } } }$ $\begin{array} { r } { \mu _ { 2 , k } = \frac { \alpha _ { k } } { \sum _ { i } \alpha _ { i } } \frac { 1 + \alpha _ { k } } { 1 + \sum _ { i } \alpha _ { i } } = \mu _ { 1 , k } \frac { 1 + \alpha _ { k } } { 1 + \sum _ { i } \alpha _ { i } } } \end{array}$ so that
+
+$$
+\begin{array} { r } { \mathrm { n u m e r a t o r } \Big ( \frac { \mu _ { 1 , k } - \mu _ { 2 , k } } { \mu _ { 2 , k } - \mu _ { 1 , k } ^ { 2 } } \Big ) = \frac { \alpha _ { k } } { \sum _ { i } \alpha _ { i } } - \frac { \alpha _ { k } } { \sum _ { i } \alpha _ { i } } \frac { 1 + \alpha _ { k } } { 1 + \sum _ { i } \alpha _ { i } } } \\ { = \frac { \alpha _ { k } \left( \sum _ { i \neq k } \alpha _ { i } \right) } { \left( \sum _ { i } \alpha _ { i } \right) \left( 1 + \sum _ { i } \alpha _ { i } \right) } } \end{array}
+$$
+
+$$
+\begin{array} { l } { \displaystyle \mathrm { d e n o m i n a t o r } \Big ( \frac { \mu _ { 1 , k } - \mu _ { 2 , k } } { \mu _ { 2 , k } - \mu _ { 1 , k } ^ { 2 } } \Big ) = \frac { \alpha _ { k } } { \sum _ { i } \alpha _ { i } } \frac { 1 + \alpha _ { k } } { 1 + \sum _ { i } \alpha _ { i } } - \Big ( \frac { \alpha _ { k } } { \sum _ { i } \alpha _ { i } } \Big ) ^ { 2 } } \\ { \displaystyle = \frac { \alpha _ { k } \big ( \sum _ { i \neq k } \alpha _ { i } \big ) } { ( \sum _ { i } \alpha _ { i } ) ^ { 2 } ( 1 + \sum _ { i } \alpha _ { i } ) } } \end{array}
+$$
+
+holds for each $k = 1 , \cdots , K$ . Therefore,
+
+$$
+\sum _ { i } \alpha _ { i } = \frac { \mu _ { 1 , k } - \mu _ { 2 , k } } { \mu _ { 2 , k } - \mu _ { 1 , k } ^ { 2 } } \approx \frac { 1 } { K } \sum _ { k } \frac { \mu _ { 1 , k } - \mu _ { 2 , k } } { \mu _ { 2 , k } - \mu _ { 1 , k } ^ { 2 } } \approx \frac { 1 } { K } \sum _ { k } \frac { \tilde { \mu } _ { 1 , k } - \tilde { \mu } _ { 2 , k } } { \tilde { \mu } _ { 2 , k } - \tilde { \mu } _ { 1 , k } ^ { 2 } }
+$$
+
+and hence,
+
+$$
+\hat { \alpha } _ { k } = ( \sum _ { i } \alpha _ { i } ) \tilde { \mu } _ { 1 , k } = \frac { S } { N } \sum _ { n } p _ { n , k } .
+$$
+
+# D EXPERIMENTAL SETTINGS
+
+In this section, we support Section 4 in the original paper with more detailed experimental settings.   
+Our Tensorflow implementation is available at https://TO BE RELEASED.
+
+# D.1 DATASET DESCRIPTION
+
+We use the following benchmark datasets for the experiments in the original paper: 1) MNIST; 2) MNIST with rotations (MNIST+rot); 3) OMNIGLOT; and 4) SVHN with PCA transformation. MNIST (LeCun et al., 1998) is a hand-written digit image dataset of size $2 8 \times 2 8$ with 10 labels, consists of 60, 000 training data and 10, 000 testing data. MNIST+rot data is reproduced by the authors of Nalisnick & Smyth (2017) consists of MNIST and rotated MNIST1. OMNIGLOT2 (Lake et al., 2013; Snderby et al., 2016) is another hand-written image dataset of characters with $2 8 \times 2 8$ size and 50 labels, consists of 24, 345 training data and 8, 070 testing data. $\operatorname { S V H N } ^ { 3 }$ is a Street View House Numbers image dataset with the dimension-reduction by PCA into 500 dimensions (Nalisnick & Smyth, 2017).
+
+# D.2 REPRESENTATION LEARNING OF VAES
+
+We divided the datasets into {train,valid,test} as the following: $\begin{array}{c} \mathrm { { M N I S T } = \{ 4 5 , 0 0 0 \ : \ 5 , 0 0 0 } \end{array}$ $1 0 , 0 0 0 \}$ and $\mathrm { O M N I G L O T } = \{ 2 2 , 0 9 5 : 2 , 2 5 0 : 8 , 0 7 0 \}$ .
+
+For MNIST, we use 50-dimension latent variables with two hidden layers in the encoder and one hidden layer in the decoder of 500 dimensions. We set $\pmb { \alpha } = 0 . 9 8 \cdot \mathbf { 1 } _ { 5 0 }$ for the fair comparison to GVAEs using the Equation (5). The batch size was set to be 100. For OMNIGLOT, we use 100- dimension latent variables with two hidden layers in the encoder and one hidden layer in the decoder of 500 dimensions. We assume ${ \pmb { \alpha } } = 0 . 9 9 \cdot { \bf 1 } _ { 1 0 0 }$ for the fair comparison to the GVAEs using the Equation (5). The batch size was set to be 15.
+
+For both datasets, the gradient clipping is used; ReLU function (Nair & Hinton, 2010) is used as an activation function in hidden layers; Xavier initialization (Glorot & Bengio, 2010) is used for the neural network parameter initialization; and the Adam optimizer (Kingma & Ba, 2014a) is used as an optimizer with learning rate $5 \in - 4$ for all VAEs except $3 \in - 4$ for the SBVAEs. The prior assumptions for each VAE is the following: 1) $\mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ for the GVAE and the GVAE-Softmax; 2) GEM(5) for the SBVAEs; and 3) Dirichlet $\left( 0 . 9 8 \cdot \mathbf { 1 } _ { 5 0 } \right)$ (MNIST) and Dirichlet $\left( 0 . 9 9 \cdot { \bf 1 } _ { 1 0 0 } \right)$ (OMNIGLOT) for the DirVAE-Weibull. Finally, to compute the marginal log-likelihood, we used 100 samples for each 1, 000 randomly selected from the test data.
+
+We add the result of VAE with 20 normalizing flows (GVAE-NF20) (Rezende & Mohamed, 2015) as a baseline in Table 5. Also, latent dimension-wise decoder weight norm and t-SNE visualization on latent embeddings of MNIST is given in Figure 5a and 5b which correspond to Figure 4a and 3, respectively.
+
+Additionally, DirVAE-Learning use the same $_ { \pmb { \alpha } }$ for the initial value, but the DirVAE-Learning optimizes hyper-parameter $_ { \pmb { \alpha } }$ by the following stages through the learning iterations using the MME method in Appendix C: 1) the burn-in period for stabilizing the neural network parameters; 2) the alternative update period for the neural network parameters and $_ \alpha$ ; and 3) the update period for the neural network parameters with the fixed learned hyper-parameter $_ { \pmb { \alpha } }$ . Table 5 shows that there are improvements in the marginal log-likelihood, ELBO, and reconstruction loss with DirVAE-Learning in both datasets. We also give the learned hyper-parameter $_ \alpha$ in Figure 6.
+
+# D.3 SEMI-SUPERVISED CLASSIFICATION TASK WITH VAES
+
+The overall model structure for this semi-supervised classification task uses a VAE with a separate random variable of z and y, which is introduced as the $M 2$ model in the original VAE work (Kingma et al., 2014b). However, the same task with the SBVAE uses a different model modified to ignore (a) Latent dimension-wise L2-norm of decoder weights of GVAE-NF20.
+
+Table 5: Negative log-likelihood, negative ELBO, and reconstruction loss of the VAEs for MNIST and OMNIGLOT dataset. The lower values are the better for all measures.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">MNIST (K= 50)</td><td colspan="3">OMNIGLOT(K= 100)</td></tr><tr><td>Neg. LL</td><td>Neg. ELBO</td><td>Reconst. Loss</td><td>Neg.LL</td><td>Neg.ELBO</td><td>Reconst. Loss</td></tr><tr><td>GVAE(Nalisnick &amp; Smyth,2017)</td><td>96.80</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SBVAE-Kuma (Nalisnick &amp; Smyth,2017)</td><td>98.01</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SBVAE-Gamma (Nalisnick &amp; Smyth,2017)</td><td>100.74</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>GVAE</td><td>94.54±0.79</td><td>98.58±0.04</td><td>74.31±0.13</td><td>119.29±0.44</td><td>126.42±0.24</td><td>98.90±0.36</td></tr><tr><td>GVAE-Softmax</td><td>98.18±0.61</td><td>103.49±0.16</td><td>79.36±0.82</td><td>130.01±1.16</td><td>139.73±0.81</td><td>123.34±1.43</td></tr><tr><td>GVAE-NF20</td><td>95.87±0.64</td><td>113.14±0.47</td><td>90.09±1.19</td><td>113.51±1.29</td><td>129.82±0.64</td><td>108.96±1.19</td></tr><tr><td>SBVAE-Kuma</td><td>99.27±0.48</td><td>102.60±1.81</td><td>83.90±0.82</td><td>130.73±2.17</td><td>132.86±3.03</td><td>119.25±1.00</td></tr><tr><td>SBVAE-Gamma</td><td>102.14±0.69</td><td>135.30±0.24</td><td>113.89±0.25</td><td>128.82±1.82</td><td>149.30±0.82</td><td>136.36±1.53</td></tr><tr><td>DirVAE-Weibull</td><td>114.59±11.15</td><td>183.33±2.96</td><td>150.92±3.70</td><td>140.89±3.21</td><td>198.01±2.46</td><td>145.52±3.13</td></tr><tr><td>DirVAE</td><td>87.64±0.64</td><td>100.47±0.35</td><td>81.50±0.27</td><td>108.24±0.42</td><td>120.06±0.35</td><td>99.78±0.36</td></tr><tr><td>DirVAE-Learning</td><td>84.42±0.53</td><td>99.88±0.40</td><td>80.73±0.31</td><td>100.01±0.52</td><td>119.73±0.31</td><td>99.55±0.32</td></tr></table>
+
+![](images/6910e09004e7f8a0d2ed4affe7e69b92c8712ec63344ac9234eb0a44fa4c6dd1.jpg)  
+(b) GVAE-NF20 t-SNE visualization.
+
+![](images/5e386d0243f254f1bb98a26372b826a4d6ad7f7472a7827a9142f338d16fffe2.jpg)  
+Figure 5: Decoder weight collapsing and t-SNE latent embeddings visualization of GVAE-NF20 on MNIST.
+
+the relation between the class label variable $\mathbf { y }$ and the latent variable $\mathbf { z }$ , but they still share the same parent nodes: $q _ { \phi } ( { \bf z } , { \bf y } | { \bf x } ) = q _ { \phi } ( { \bf z } | { \bf x } ) q _ { \phi } ( { \bf y } | { \bf x } )$ where $q _ { \phi } ( \mathbf { y } | \mathbf { x } )$ is a discrimitive network for the unseen labels. We follow the structure of SBVAE. Finally, the below are the objective functions to optimize for the labeled and the unlabeled instances of the semi-supervised classification task, respectively:
+
+$$
+\begin{array} { r } { \log p ( \mathbf { x } , \mathbf { y } ) \geq \mathcal { L } _ { \mathrm { l a b e l e d } } ( \mathbf { x } , \mathbf { y } ) = \mathbb { E } _ { q _ { \phi ( \mathbf { z } | \mathbf { x } ) } } [ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } , \mathbf { y } ) ] - \mathrm { K L } ( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p _ { \theta } ( \mathbf { z } ) ) + \log q _ { \phi } ( \mathbf { y } | \mathbf { x } ) , } \end{array}
+$$
+
+$$
+\begin{array} { r } { \log p ( \mathbf { x } ) \geq \mathcal { L } _ { \mathrm { u n l a b e l e d } } ( \mathbf { x } ) = \mathbb { E } _ { q _ { \phi ( z , \mathbf { y } | \mathbf { x } ) } } [ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } , \mathbf { y } ) + \mathbb { H } ( q _ { \phi } ( \mathbf { y } | \mathbf { x } ) ) ] - \mathbf { K L } ( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p _ { \theta } ( \mathbf { z } ) ) ~ . } \end{array}
+$$
+
+In the above, $\mathbb { H }$ is an entropy function. The actual training on the semi-supervised learning optimizes the weighted sum of Equation (10) and (11) with a ratio hyper-parameter $0 < \lambda < 1$ .
+
+The datasets are divided into {train, valid, test} as the following: $\mathrm { { M N I S T } } = \{ 4 5 , 0 0 0 : 5 , 0 0 0 :$ $1 0 , 0 0 0 \}$ , $\mathbf { M N I S T + r o t } = \{ 7 0 , 0 0 0 : 1 0 , 0 0 0 : 2 0 , 0 0 0 \}$ , and $\mathrm { S V H N } = \{ 6 5 , 0 0 0 : 8 , 2 5 7 : 2 6 , 0 3 2 \}$ . For SVHN, dimension reduction into 500 dimensions by PCA is applied as preprocessing.
+
+Fundamentally, we applied the same experimental settings to GVAE, SBVAE and DirVAE in this experiment, as specified by the authors in Nalisnick & Smyth (2017).4,5 Specifically, the three VAEs used the same network structures of 1) a hidden layer of 500 dimension for MNIST; and 2) four hidden layers of 500 dimensions for MNIST+rot and SVHN with the residual network for the last three hidden layers. The latent variables have 50 dimensions for all settings. The ratio parameter $\lambda$ is set to be 0.375 for the MNISTs, and 0.45 for SVHN. ReLU function is used as an activation function in hidden layers, and the neural network parameters were initialized by sampling from $\mathcal { N } ( 0 , 0 . 0 0 1 )$ . The Adam optimizer is used with learning rate $3 \in - 4$ and the batch size was set to be 100. Finally, the DirVAE sets ${ \pmb { \alpha } } = 0 . 9 8 \cdot { \bf 1 } _ { 5 0 }$ by using Equation (5).
+
+![](images/1f5f74789d4e9aa4b4c0ff4eef5ef25eef6e4ae66da6f7133acc78bd1fcd9293.jpg)  
+Figure 6: The optimized dimension-wise $_ { \pmb { \alpha } }$ values from DirVAE-Learning with MNIST.
+
+# D.4 SUPERVISED CLASSIFICATION TASK WITH LATENT VALUES OF VAES
+
+For the supervised classification task on the latent representation of the VAEs, we used exactly the same experimental settings as in D.2. Since DLGMM is basically a Gaussian mixture model with the SBVAE, DLGMM is a more complex model than the VAE alternatives. We only report the authors’ result from Nalisnick et al. (2016) for the comparison purposes. Additionally, we omit the comparison with the VaDE (Jiang et al., 2017) because the VaDE is more customized to be a clustering model rather than the ordinary VAEs that we choose as baselines.
+
+Table 6: The error rate of $k \mathbf { N N }$ with the latent representations of VAEs.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">MNIST (K = 50)</td><td colspan="3">OMNIGLOT(K = 100)</td></tr><tr><td>k=3</td><td>k=5</td><td>k =10</td><td>k=3</td><td>k=5</td><td>k=10</td></tr><tr><td>GVAE (Nalisnick et al.,2016)</td><td>28.40</td><td>20.96</td><td>15.33</td><td>一</td><td></td><td>一</td></tr><tr><td>SBVAE (Nalisnick et al., 2016)</td><td>9.34</td><td>8.65</td><td>8.90</td><td></td><td></td><td></td></tr><tr><td>DLGMM (Nalisnick et al.,2016)</td><td>9.14</td><td>8.38</td><td>8.42</td><td>一</td><td></td><td>1</td></tr><tr><td>GVAE</td><td>27.16±0.48</td><td>20.20±0.93</td><td>14.89±0.40</td><td>92.34±0.25</td><td>91.21±0.18</td><td>88.79±0.35</td></tr><tr><td>GVAE-Softmax</td><td>25.68±2.64</td><td>21.79±2.17</td><td>18.75±2.06</td><td>94.76±0.20</td><td>94.22±0.37</td><td>92.98±0.42</td></tr><tr><td>GVAE-NF20</td><td>25.72±1.58</td><td>20.15±1.25</td><td>15.87±0.74</td><td>91.25±0.12</td><td>90.03±0.20</td><td>87.73±0.38</td></tr><tr><td>SBVAE</td><td>10.01±0.52</td><td>9.58±0.47</td><td>9.39±0.54</td><td>86.90±0.82</td><td>85.10±0.89</td><td>82.96±0.64</td></tr><tr><td>DirVAE</td><td>5.98±0.06</td><td>5.29±0.06</td><td>5.06±0.06</td><td>76.55±0.23</td><td>73.81±0.29</td><td>70.95±0.29</td></tr><tr><td>Raw Data</td><td>3.00</td><td>3.21</td><td>3.44</td><td>69.94</td><td>69.41</td><td>70.10</td></tr></table>
+
+# D.5 TOPIC MODEL AUGMENTATION WITH DIRVAE
+
+For the topic model augmentation experiment, two popular performance measures in the topic model fields, which are perplexity and topic coherence via normalized pointwise mutual information (NPMI) (Lau et al., 2014), have been used with 20Newsgroups6 and $R C V I - \nu 2 ^ { 7 }$ datasets. 20Newsgroups has 11, 258 train data and 7, 487 test data with vocabulary size 1, 995. For the RCV1-v2 dataset, due to the massive size of the whole data, we randomly sampled 20, 000 train data and 10, 000 test data with vocabulary size 10, 000. The lower is better for the perplexity, and the higher is better for the NPMI.
+
+The specific model structures can be found in the original papers, Srivastava & Sutton (2017); Miao et al. (2016; 2017). We replace the model prior to that of DirVAE to each model and search the hyper-parameter as Table 7 with 1, 000 randomly selected test data. We use 500-dimension hidden layers and 50 topics for 20Newsgroups, and 1, 000-dimension hidden layers and 100 topics for RCV1-v2.
+
+Table 8 shows top-10 high probability words per topic by activating single latent dimensions in the case of 20Newsgroups. Also, we visualized the latent embeddings of documents by t-SNE in Figure 7,8, and 9.
+
+Table 7: Hyper-parameter selections for DirVAE augmentations.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">20Newsgroups (K = 50)</td><td colspan="3">RCV1-v2 (K= 100)</td></tr><tr><td>ProdLDA</td><td>NVDM</td><td>GSM</td><td>ProdLDA</td><td>NVDM</td><td>GSM</td></tr><tr><td>Add DirVAE</td><td>0.98·150</td><td>0.95·150</td><td>0.20·150</td><td>0.99·1100</td><td>0.90·1100</td><td>0.01·1100</td></tr></table>
+
+Table 8: Sample of learned per topic top-10 high probability words from 20Newsgroups with DirVAE augmentation by activating single latent dimensions.   
+ProdLDA+DirVAE   
+
+<table><tr><td>Topic 1 Topic 2 Topic 3 Topic 4 Topic 5 Topic 6 Topic 7 Topic 8 Topic 9 Topic 10</td><td>turks turkish armenian genocide village armenia armenians muslims turkey greece doctrine jesus god faith christ scripture belief eternal holy bible season defensive puck playoff coach score flyers nhl team ice pitcher braves hitter coach pen defensive injury roger pitch player ide scsi scsus controller motherboard isa cache mb floppy ram toolkit widget workstation xlib jpeg xt vendor colormap interface pixel spacecraft satellite solar shuttle nasa mission professor lunar orbit rocket knife handgun assault homicide batf criminal gun firearm police apartment enforcement privacy encrypt encryption ripem wiretap rsa cipher cryptography escrow</td></tr></table>
+
+NVDM+DirVAE   
+
+<table><tr><td>Topic 1 Topic 2 Topic 3 Topic 4 Topic 5 Topic 6 Topic 7 Topic 8 Topic 9 Topic 10</td><td>armenian azerbaijan armenia genocide armenians turkish militia massacre village turks arab arabs israeli palestinian jews soldier turks nazi massacre jew resurrection bible christianity doctrine scripture eternal belief christian faith jesus hitter season braves pitcher baseball pitch game player defensive team directory file compile variable update ftp version site copy host performance speed faster mhz rate clock processor average twice fast windows microsoft driver dos nt graphic vga card virtual upgrade seat gear rear tire honda oil front mile wheel engine patient disease doctor treatment symptom medical health hospital pain medicine pt la det tor pit pp vs van cal nj (b) DirVAE augmentation to NVDM</td></tr></table>
+
+GSM+DirVAE   
+
+<table><tr><td>Topic 1 Topic 2 Topic 3 Topic 4 Topic 5 Topic 6 Topic 7 Topic 8 Topic 9</td><td>turkish armenian armenians people one turkey armenia turks greek history israel israeli jewsattack world jewish article arab peace land god jesus christian religion truth believe bible church christ belief team play game hockey nhl score first division go win drive video mac card port pc system modem memory speed image software file version server program system ftp package support space launch orbit earth nasa moon satellite mission project center law state gun government right rights case court police crime price sell new sale offer pay buy good condition money</td></tr></table>
+
+![](images/2757817bf53bb23267c3f04ca1dbbc58adc917663e6d215139afefd29eda825c.jpg)  
+Figure 7: 20Newsgroups latent document embedding visulaization with t-SNE by replacing the model prior to the Dirichlet. (Left) ProdLDA $^ +$ DirVAE, (Middle) NVDM $^ +$ DirVAE, (Right) GSM $^ +$ DirVAE.
+
+![](images/b5e00eef531a86c6add8ee91e18f0a48c741a3ea68c984b8557a7e298af9264c.jpg)  
+Figure 8: 20Newsgroups latent document embedding visulaization with t-SNE by replacing the model prior to the Stick-Breaking. (Left) ProdLDA $^ +$ SBVAE, (Middle) NVDM $^ +$ SBVAE, (Right) GSM $^ +$ SBVAE.
+
+![](images/16298de12d0d7e9fa8873a8b025765452fc7ad13b0bd62eaebb285f3c584852f.jpg)  
+Figure 9: 20Newsgroups latent document embedding visulaization with t-SNE of original models. (Left) ProdLDA, (Middle) NVDM, (Right) GSM.

parse/train/ryj0790hb/ryj0790hb.md

@@ -0,0 +1,225 @@
+# INCREMENTAL LEARNING THROUGH DEEP ADAPTA-TION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Given an existing trained neural network, it is often desirable to learn new capabilities without hindering performance of those already learned. Existing approaches either learn sub-optimal solutions, require joint training, or incur a substantial increment in the number of parameters for each added task, typically as many as the original network. We propose a method called Deep Adaptation Networks (DAN) that constrains newly learned filters to be linear combinations of existing ones. DANs preserve performance on the original task, require a fraction (typically $1 3 \%$ ) of the number of parameters compared to standard fine-tuning procedures and converge in less cycles of training to a comparable or better level of performance. When coupled with standard network quantization techniques, we further reduce the parameter cost to around $3 \%$ of the original with negligible or no loss in accuracy. The learned architecture can be controlled to switch between various learned representations, enabling a single network to solve a task from multiple different domains. We conduct extensive experiments showing the effectiveness of our method on a range of image classification tasks and explore different aspects of its behavior.
+
+# 1 INTRODUCTION
+
+While deep neural networks continue to show remarkable performance gains in various areas such as image classification (Krizhevsky et al. (2012)), semantic segmentation (Long et al. (2015)), object detection (Girshick et al. (2014)), speech recognition (Hannun et al. (2014))medical image analysis (Litjens et al. (2017)) - and many more - it is still the case that typically, a separate model needs to be trained for each new task. Given two tasks of a totally different modality or nature, such as predicting the next word in a sequence of words versus predicting the class of an object in an image, it stands to reason that each would require a different architecture or computation. However, for a set of related tasks such as classifying images from different domains it is natural to expect that solutions will (1) Utilize the same computational pipeline; (2) Require a modest increment in the number of required parameters for each added task; (3) Be learned without hindering performance of already learned tasks (a.k.a catastrophic forgetting) and (4) Be learned incrementally, dropping the requirement for joint training such as in cases where the training data for previously learned tasks is no longer available.
+
+Our goal is to enable a network to learn a set of related tasks one by one while adhering to the above requirements. We do so by augmenting a network learned for one task with controller modules which utilize already learned representations for another. The parameters of the controller modules are optimized to minimize a loss on a new task. The training data for the original task is not required at this stage. The network’s output on the original task data stays exactly as it was; any number of controller modules may be added to each layer so that a single network can simultaneously encode multiple distinct tasks, where the transition from one task to another can be done by setting a binary switching variable or controlled automatically. The resultant architecture is coined DAN, standing for Deep Adaptation Networks. We demonstrate the effectiveness of our method on the recently introduced Visual Decathlon Challenge (Rebuffi et al. (2017)) whose task is to produce a classifier to work well on ten different image classification datasets. Though adding only $13 \%$ of the number of original parameters for each newly learned task (the specific number depends on the network architecture), the average performance surpasses that of fine tuning all parameters - without the negative side effects of doubling the number of parameters and catastrophic forgetting. In this work, we focus on the task of image classification on various datasets, hence in our experiments the word “task” refers to a specific dataset.
+
+Our main contribution is the introduction of an improved alternative to transfer learning, which is as effective as fine-tuning all network parameters towards a new task, precisely preserves old task performance, requires a fraction (network dependent, typically $1 3 \%$ ) of the cost in terms of new weights and is able to switch between any number of learned tasks.
+
+We introduce two variants of the method, a fully-parametrized version, whose merits are described above and one with far fewer parameters, which significantly outperforms shallow transfer learning (i.e. feature extraction) for a comparable number of parameters. In the next section, we review some related work. Sec. 3 details the proposed method. In Sec. 4 we present various experiments, including comparison to related methods, as well as exploring various strategies on how to make our method more effective, followed by some discussion & concluding remarks.
+
+# 2 RELATED WORK
+
+Multi-task Learning. In multi-task learning, the goal is to train one network to perform several tasks simultaneously. This is usually done by jointly training on all tasks. Such training is advantageous in that a single representation is used for all tasks. In addition, multiple losses are said to act as an additional regularizer. Some examples include facial landmark localization (Zhu et al. (2015)), semantic segmentation (He et al. (2017)), 3D-reasoning (Eigen and Fergus (2015)), object and part detection (Bilen and Vedaldi (2016)) and others. While all of these learn to perform different tasks on the same dataset, the recent work of (Bilen and Vedaldi (2017)) explores the ability of a single network to perform tasks on various image classification datasets. We also aim to classify images from multiple datasets but we propose doing so in a manner which learns them one-by-one rather than jointly. Concurrent with our method is that of Rebuffi et al. (2017) which introduces dataset-specific additional residual units. We compare to this work in Sec 4. Our work bears some resemblance to Misra et al. (2016), where two networks are trained jointly, with additional “crossstitch” units, allowing each layer from one network to have as additional input linear combinations of outputs from a lower layer in another. However, our method does not require joint training and requires significantly fewer parameters.
+
+Incremental Learning. Adding a new ability to a neural net often results in so-called “catastrophic forgetting” (French (1999)), hindering the network’s ability to perform well on old tasks. The simplest way to overcome this is by fixing all parameters of the network and using its penultimate layer as a feature extractor, upon which a classifier may be trained (Donahue et al. (2014); Sharif Razavian et al. (2014)). While guaranteed to leave the old performance unaltered, it is observed to yield results which are substantially inferior to fine-tuning the entire architecture (Girshick et al. (2014)). The work of Li and Hoiem (2016) provides a succinct taxonomy of several variants of such methods. In addition, they propose a mechanism of fine-tuning the entire network while making sure to preserve old-task performance by incorporating a loss function which encourages the output of the old features to remain constant on newly introduced data. While their method adds a very small number of parameters for each new task, it does not guarantee that the model retains its full ability on the old task. In Rusu et al. (2016) new representations can be added alongside old ones while leaving the old task performance unaffected. However, this comes at a cost of duplicating the number of parameters of the original network for each added task. In Kirkpatrick et al. (2017) the learning rate of neurons is lowered if they are found to be important to the old task. Our method fully preserves the old representation while causing a modest increase in the number of parameters for each added task.
+
+Network Compression Multiple works have been published on reducing the number weights of a neural network as a means to represent it compactly (Han et al. (2015a;b)), gain speedups (Denton et al. (2014)) or avoid over-fitting (Hanson and Pratt (1988)), using combinations of coding, quantization, pruning and tensor decomposition. Such methods can be used in conjunction with ours to further improve results, as we show in Sec. 4.
+
+![](images/75f0ff6f40e26cd13c7fb664c6d897c50c301813121e50a2e099f11cb0f35143.jpg)  
+Figure 1: (a) Summary of proposed method. Each convolutional layer of a base network is modified 1/1 by re-combining its weights through a controller module. A set of controllers is added for each newly learned task. A binary switching vector $\alpha$ controls the output of the network by switching the controller modules on or off. $\alpha$ can be determined either manually or via a sub-network (“Dataset Decider”) which determines the source domain of the image, switching accordingly between different sets of control parameters. Other layers (e.g, non-linearities, batch-normalization, skip layers) not shown for presentation purposes. (b) Transferability of various datasets to each other $\scriptstyle { \mathcal { f } } t$ -last) fine tuning only the last layer $( f u l l )$ fine-tuning all layers (ft-full-bn-off ) fine tuning all layers while disallowing batch-normalization layers’ weights to be updated. Overall, networks tend to be more easily transferable to problems from related domain (e.g., natural / drawing). Zoom in to see numbers. It is recommended to view this figure in color on-line.
+
+# 3 APPROACH
+
+We begin with some notation. Let $T$ be some task to be learned. Specifically, we use a deep convolutional neural net (DCNN) in order to learn a classifier to solve $T$ , which is an image classification task. Most contemporary DCNN’s follow a common structure: for each input $x$ , the DCNN computes a representation of the input by passing it through a set of $l$ layers $\phi _ { i }$ , $i \in 1 \dots l$ interleaved with non-linearities. The initial (lower) layers of the network are computational blocks, e.g. convolutions with optional residual units in more recent architectures (He et al. (2016)). Our method applies equally to networks with or without residual connections. At least one fully connected layer $f _ { i }$ , $i \in { 1 \dots c }$ is attached to the output of the last convolutional layer. Let $\Phi _ { F _ { N } } = \sigma ( \phi _ { l } ) \circ . . . \sigma ( \phi _ { 2 } ) \circ \sigma ( \phi _ { 1 } )$ be the composition of all of the convolutional layers of the network $N$ , interleaved by non-linearities. We use an architecture where all non-linearities $\sigma$ are the same function, with no tunable parameters. Denote by $\Phi _ { F _ { N } } ( x )$ the feature part of $N$ . Similarly, denote by $\Phi _ { C _ { N } } = f _ { c } \circ . . . \sigma ( f _ { 2 } ) \circ \sigma ( f _ { 1 } )$ the classifier part of $N$ , i.e. the composition of all of the fully-connected layers of $N$ . The output of $N$ is then simply defined as:
+
+$$
+N ( x ) = \Phi _ { C _ { N } } \circ \Phi _ { F _ { N } } ( x )
+$$
+
+We do not specify batch-normalization layers in the above notation for brevity. It is also possible to drop the $\Phi _ { C _ { N } }$ term, if the network is fully convolutional, as in Long et al. (2015).
+
+# 3.1 ADAPTING REPRESENTATIONS
+
+Assume that we are given two tasks, $T _ { 1 }$ and $T _ { 2 }$ , to be learned, and that we have learned a base network $N$ to solve $T _ { 1 }$ . We assume that a good solution to $T _ { 2 }$ can be obtained by a network with the same architecture as $N$ but with different parameters. We augment $N$ so that it will be able to solve $T _ { 2 }$ as well by attaching a controller module to each of its convolutional layers. Each controller module uses the existing weights of the corresponding layer of $N$ to create new convolutional filters adapted to the new task $T _ { 2 }$ : for each convolutional layer $\phi _ { l }$ in $N$ , let $F _ { l } \in \mathcal { R } ^ { C _ { o } \times C _ { i } \times k \times k }$ be the set of filters for that layer, where $C _ { o }$ is the number of output features, $C _ { l }$ the number of inputs, and $k \times k$ the kernel size (assuming a square kernel). Denote by $b _ { l } \in \mathcal { R } ^ { C }$ the bias. Denote by $\tilde { F } _ { l } \in \mathcal { R } ^ { C _ { o } \times D }$ the matrix whose rows are flattened versions of the filters of $F _ { l }$ , where $D = C _ { i } \cdot k \cdot k$ ; let $f \in \mathcal { R } ^ { C _ { i } \times k \times k }$ be a filter from $F _ { l }$ whose values are $f ^ { 1 } = \left( \begin{array} { l l l } { { f _ { 1 1 } ^ { 1 } } } & { { \cdot \cdot \cdot } } & { { f _ { 1 k } ^ { 1 } } } \\ { { } } & { { \cdot \cdot } } & { { } } \\ { { } } & { { } } & { { f _ { k k } ^ { 1 } } } \end{array} \right) , \cdot \cdot \cdot , f ^ { i } = \left( \begin{array} { l l l } { { f _ { 1 1 } ^ { i } } } & { { \cdot \cdot } } & { { f _ { 1 k } ^ { i } } } \\ { { } } & { { \cdot } } & { { } } \\ { { } } & { { } } & { { f _ { k k } ^ { i } } } \end{array} \right) .$
+
+The flattened version of $f$ is a row vector $\tilde { f } = ( f _ { 1 1 } ^ { 1 } , \cdot \cdot \cdot , f _ { k k } ^ { 1 } , \cdot \cdot \cdot , \cdot \cdot f _ { 1 1 } ^ { i } , \cdot \cdot \cdot , f _ { k k } ^ { i } ) \in \mathcal { R } ^ { \mathcal { D } }$ . “Unflattening” a row vector $\tilde { f }$ reverts it to its tensor form $f \in \mathcal { R } ^ { C _ { i } \times k \times k }$ . This way, we can write
+
+$$
+\tilde { F _ { l } ^ { a } } = W _ { l } \cdot \tilde { F _ { l } }
+$$
+
+where $W _ { l } \in \mathcal { R } ^ { C _ { o } \times C _ { o } }$ is a weight matrix defining linear combinations of the flattened filters of $F _ { l }$ , resulting in $C _ { o }$ new filters. Unflattening $\tilde { F _ { l } ^ { a } }$ to its original shape results in $F _ { l } ^ { a } \in \mathcal { R } ^ { C _ { o } \times C _ { i } \times k \times k }$ , which we call the adapted filters of layer $\phi _ { l }$ . Using the symbol $X \otimes Y$ as shorthand for flatten $Y $ matrix multiply by $X $ unflatten, we can write:
+
+$$
+F _ { l } ^ { a } = W _ { l } \otimes F _ { l }
+$$
+
+If the convolution contains a bias, we instantiate a new weight vector $b _ { l } ^ { a }$ instead of the original $b _ { l }$ . The output of layer $\phi _ { l }$ is computed as follows: let $x _ { l }$ be the input of $\phi _ { l }$ in the adapted network. For a given switching parameter $\alpha \in \{ 0 , 1 \}$ , we set the output of the modified layer to be the application of the switched convolution parameters and biases:
+
+$$
+x _ { l + 1 } = [ \alpha ( W _ { l } \otimes F _ { l } ) + ( 1 - \alpha ) F _ { l } ] * x _ { l } + \alpha b _ { l } ^ { a } + ( 1 - \alpha ) b _ { l }
+$$
+
+A set of fully connected layers $f _ { i } ^ { a }$ are learned from scratch, attaching a new “head” to the network for each new task. Throughout training $\&$ testing, the weights of $F$ (the filters of $N$ ) are kept fixed and serve as basis functions for $F ^ { a }$ . The weights of the controller modules are learned via backpropagation given the loss function. Weights of any batch normalization (BN) layers are either kept fixed or learned anew. The batch-normalized output is switched between the values of the old and new BN layers, similarly to Eq. 4. A visualization of the resulting DAN can be seen in Fig. 1.
+
+Weaker parametrization A weaker variant of our method is one that forces the matrices $W _ { l }$ to be diagonal, e.g, only scaling the output of each filter of the original network. We call this variant “diagonal” (referring only to scaling coefficients, such as by a diagonal matrix) and the full variant of our method “linear” (referring to a linear combination of filters). The diagonal variant can be seen as a form of explicit regularization which limits the expressive power of the learned representation. While requiring significantly fewer parameters, it results in poorer classification accuracy, but as will be shown later, also outperforms regular feature-extraction for transfer learning, especially in network compression regimes.
+
+Multiple Controllers The above description mentions one base network and one controller network. However, any number of controller networks can be attached to a single base network, regardless of already attached ones. In this case $\alpha$ is extended to one-hot vector of values determined by another sub-network, allowing each controller network to be switched on or off as needed.
+
+In the following, we denote a network learned for a dataset/task $S$ as $N _ { S }$ . A controller learned using $N _ { S }$ as a base network will be denoted as $D A N _ { S }$ , where DAN stands for Deep Adaptation Network and $D A N _ { S  T }$ means using $D A N _ { S }$ for a specific task $T$ . While in this work we apply the method to classification tasks it is applicable to other tasks as well.
+
+Parameter Cost The number of new parameters added for each task depends on the number of filters in each layer and the number of parameters in the fully-connected layers. As the latter are not reused, their parameters are fully duplicated. Let $M = C _ { o } \times D$ be the filter dimensions for some conv. layer $\phi _ { l }$ where $D = C _ { i } \times k \times k$ . A controller module for $\phi _ { l }$ requires $C _ { o } ^ { 2 }$ coefficients for $F _ { l } ^ { a }$ and an additional $C _ { o }$ for $b _ { l } ^ { a }$ . Hence the ratio of new parameters w.r.t to the old for $\phi _ { l }$ is $\begin{array} { r } { \frac { C _ { o } \times ( \dot { C } _ { o } + 1 ) } { C _ { o } \times ( D + 1 ) } = \frac { C _ { o } + 1 } { D + 1 } \approx \frac { C _ { o } } { D } } \end{array}$ Co . Example: for $C _ { o } = C _ { i } = 2 5 6$ input and output units and a kernel size $k = 5$ this equals $\textstyle { \frac { 2 5 6 + 1 } { 2 5 6 \cdot 5 ^ { 2 } + 1 } } \approx 0 . 0 4$ . In the final architecture we use the total number of weights required to adapt the convolutional layers $\Phi _ { l }$ combined with a new fully-connected layer amounts to about $13 \%$ of the original parameters. For VGG-B, this is roughly $21 \%$ . For instance, constructing 10 classifiers using one base network and 9 controller networks requires $( 1 + 0 . 1 3 * 9 ) \cdot P \mathrm { = } 2 . 1 7 \cdot P$ parameters where $P$ is the number for the base network alone, compared to $1 0 \cdot P$ required to train each network independently. The cost is dependent on network architecture, for example it is higher
+
+<table><tr><td>Net</td><td>C-10</td><td>GTSR</td><td>SVHN</td><td>Caltech</td><td>Dped</td><td>Oglt</td><td>Plnk</td><td>Sketch</td><td>Perf.</td><td>#par</td></tr><tr><td>VGG-B(S)</td><td>92.5</td><td>98.2</td><td>96.2</td><td>88.2</td><td>92.9</td><td>86.9</td><td>74.5</td><td>69.2</td><td>87.32</td><td>8</td></tr><tr><td>VGG-B(P)</td><td>93.2</td><td>99.0</td><td>95.8</td><td>92.6</td><td>98.7</td><td>83.8</td><td>73.2</td><td>65.4</td><td>87.71</td><td>8</td></tr><tr><td>DANcaltech-256</td><td>77.9</td><td>93.6</td><td>91.8</td><td>88.2</td><td>93.8</td><td>81.0</td><td>63.6</td><td>49.4</td><td>79.91</td><td>2.54</td></tr><tr><td>DANsketch</td><td>77.9</td><td>93.3</td><td>93.2</td><td>86.9</td><td>94.0</td><td>85.4</td><td>69.6</td><td>69.2</td><td>83.7</td><td>2.54</td></tr><tr><td>DANnoise</td><td>68.1</td><td>90.9</td><td>90.4</td><td>84.6</td><td>91.3</td><td>80.6</td><td>61.7</td><td>42.7</td><td>76.29</td><td>1.76</td></tr><tr><td>DANimagenet</td><td>91.6</td><td>97.6</td><td>94.6</td><td>92.2</td><td>98.7</td><td>81.3</td><td>72.5</td><td>63.2</td><td>86.46</td><td>2.76</td></tr><tr><td>DANimagenet+sketch</td><td>91.6</td><td>97.6</td><td>94.6</td><td>92.2</td><td>98.7</td><td>85.4</td><td>72.5</td><td>69.2</td><td>87.76</td><td>3.32</td></tr></table>
+
+Table 1: Perf: top-1 accuracy $\%$ , higher is better) on various datasets and parameter cost (#par., lower is better) for a few baselines and several variants of our method. Rows 1,2: independent baseline performance. VGG-B: VGG (Simonyan and Zisserman (2014)) architecture B. (S) - trained from scratch. (P) - pre-trained on ImageNet. Rows 3-7: (ours) controller network performance; $D A N _ { s k e t c h }$ as a base network outperforms $D A N _ { c a l t e c h - 2 5 6 }$ on most datasets. A controller network based on random weights $( D A N _ { n o i s e } )$ works quite well given that its number of learned parameters is a fifth of the other methods. $D A N _ { i m a g e n e t }$ : controller networks initialized from VGG-B model pretrained on ImageNet. $D A N _ { i m a g e n e t + s k e t c h }$ : selective control network based on both VGG-B(P) & Sketch. We color code the first, second and third highest values in each column (lowest for #par). #par: amortized number of weights learned to achieve said performance for all tasks divided by number of tasks addressed (lower is better).
+
+when applied on the VGG-B architecture. While our method can be applied to any network with convolutional layers, if $C _ { o } \geq D$ , i.e., the number of output filters is greater than the dimension of each input filter, it would only increase the number of parameters.
+
+# 4 EXPERIMENTS
+
+We conduct several experiments to test our method and explore different aspects of its behavior. We use two different basic network architectures on two (somewhat overlapping) sets of classification benchmarks. The first is VGG-B (Simonyan and Zisserman (2014)) which we use for various analyses of our method. We begin by listing the datasets we used (4.0.1), followed by establishing baselines by training a separate model for each using a few initial networks. We proceed to test several variants of our proposed method (4.1) as well as testing different training schemes. Next, we discuss methods of predicting how well a network would fare as a base-network (4.2). We show how to discern the domain of an input image and output a proper classification (4.2.1) without manual choice of the control parameters $\alpha$ . In the second part of our experiments, we show results on the Visual Decathlon Challenge, using a different architecture. Before concluding we show some more useful properties of our method.
+
+# 4.0.1 DATASETS AND EVALUATION
+
+The first part of our evaluation protocol resembles that of Bilen and Vedaldi (2017): we test our method on the following datasets: Caltech-256 (Griffin et al. (2007)), CIFAR-10 (Krizhevsky and Hinton (2009)), Daimler (Munder and Gavrila (2006)) (DPed), GTSR (Stallkamp et al. (2012)), Omniglot (Mnih et al. (2015)), Plankton imagery data (Cowen et al. (2015)) (Plnk), Human Sketch dataset (Eitz et al. (2012)) and SVHN (Netzer et al. (2011)). All images are resized to 64 $\times 6 4$ pixels, duplicating gray-scale images so that they have 3 channels as do the RGB ones. We whiten all images by subtracting the mean pixel value and dividing by the variance per channel. This is done for each dataset separately. We select $80 \%$ for training and $20 \%$ for validation in datasets where no fixed split is provided. We use the B architecture described in Simonyan and Zisserman (2014), henceforth referred to as VGG-B. It performs quite well on the various datasets when trained from scratch (See Tab. 1). Kindly refer to Bilen and Vedaldi (2017) for a brief description of each dataset.
+
+As a baseline, we train networks independently on each of the 8 datasets. All experiments in this part are done with the Adam optimizer (Kingma and Ba (2014)), with an initial learning rate of 1e-3 or 1e-4, dependent on a few epochs of trial on each dataset. The learning rate is halved after each 10 epochs. Most networks converge within the first 10-20 epochs, with mostly negligible improvements afterwards. We chose Adam for this part due to its fast initial convergence with respect to nonadaptive optimization methods (e.g, SGD), at the cost of possibly lower final accuracy (Wilson et al. (2017)). The top-1 accuracy $( \% )$ is summarized in Tab. 1.
+
+# 4.1 CONTROLLER NETWORKS
+
+To test our method, we trained a network on each of the 8 datasets in turn to be used as a base network for all others. We compare this to the baseline of training on each dataset from scratch (VGGB(S)) or pretrained $\left( \mathbf { V } \mathbf { G } \mathbf { G } \mathbf { - } \mathbf { B } ( \mathbf { P } ) \right)$ networks. Tab. 1 summarizes performance on all datasets for two representative base nets: $D A N _ { c a l t e c h - 2 5 6 }$ $( 7 9 . 9 \% )$ and $D A N _ { s k e t c h }$ $( 8 3 . 7 \% )$ . Mean performance for other base nets are shown in Fig. 2 (a). The parameter cost (3.1) of each setting is reported in the last column of the table. This (similarly to Rebuffi et al. (2017)) is the total number of parameters required for a set of tasks normalized by that of a single fully-parametrized network. We also check how well a network can perform as a base-network after it has seen ample training examples: $D A N _ { i m a g e n e t }$ is based on VGG-B pretrained on ImageNet (Russakovsky et al. (2015)). This improves the average performance by a significant amount $( 8 3 . 7 \%$ to $8 6 . 5 \%$ ). On Caltech256 we see an improvement from $8 8 . 2 \%$ (training from scratch). However, for both Sketch and Omniglot the performance is in favor of $D A N _ { s k e t c h }$ . Note these are the only two domains of strictly unnatural images. Additionally, $D A N _ { i m a g e n e t }$ is still slightly inferior to the non-pretrained VGG-B(S) $8 6 . 5 \%$ vs $8 7 . 7 \%$ ), though the latter is more parameter costly.
+
+Multiple Base Networks A good base network should have features generic enough so that a controller network can use them for any target task. In practice this is not necessarily the case. To use two base-networks simultaneously, we implemented a dual-controlled network by using both $D A N _ { c a l t e c h - 2 5 6 }$ and $D A N _ { s k e t c h }$ and attaching to them controller networks. The outputs of the feature parts of the resulting sub-networks were concatenated before the fully-connected layer. This resulted in the exact same performance as $D A N _ { s k e t c h }$ alone. However, by using selected controllermodules per group of tasks, we can improve the results: for each dataset the maximally performing network (based on validation) is the basis for the control module, i.e., we used $D A N _ { i m a g e n e t }$ for all datasets except Omniglot and Sketch. For the latter two we use $D A N _ { s k e t c h }$ as a base net. We call this network $D A N _ { i m a g e n e t + s k e t c h }$ . At the cost of more parameters, it boosts the mean performance to $8 7 . 7 6 \%$ - better than using any single base net for controllers or training from scratch. Since it is utilized for 9 tasks (counting ImageNet), its parameter cost (2.76) is still quite good.
+
+Starting from a Randomly Initialized Base Network We tested how well our method can perform without any prior knowledge, e.g., building a controller network on a randomly initialized base network. The total number of parameters for this architecture is 12M. However, as 10M have been randomly initialized and only the controller modules and fully-connected layers have been learned, the effective number is actually 2M. Hence its parameter cost is determined to be 0.22. We summarize the results in Tab. 1. Notably, the results of this initialization worked surprisingly well; the mean top-1 precision attained by this network was $7 6 . 3 \%$ , slightly worse than of $D A N _ { c a l t e c h - 2 5 6 }$ $( 7 9 . 9 \% )$ . This is better than initializing with $D A N _ { d a i m l e r }$ , which resulted in a mean accuracy of $7 5 \%$ . This is possible the random values in the base network can still be linearly combined by our method to create ones that are useful for classification.
+
+# 4.1.1 INITIALIZATION
+
+One question which arises is how to initialize the weights $W$ of a control-module. We tested several options: (1) Setting $W$ to an identity matrix (diagonal). This is equivalent to the controller module starting with a state which effectively mimics the behavior of the base network (2) Setting $W$ to random noise (random) (3) Training an independent network for the new task from scratch, then set $W$ to best linearly approximate the new weights with the base weights (linear approx). To find the best initialization scheme, we trained $D A N _ { s k e t c h  c a l t e c h 2 5 6 }$ for one epoch with each and observed the loss. Each experiment was repeated 5 times and the results averaged. From Fig. 2(a), it is evident that the diagonal initialization is superior: perhaps counter-intuitively, there is no need to train a fully parametrized target network. Simply starting with the behavior of the base network and tuning it via the control modules results in faster convergence. Hence we train controller modules with the diagonal method. Interestingly, the residual adaptation unit in Rebuffi et al. (2017) is initially similar to the diagonal configuration. If all of the filters in their adapter unit are set to 1 (up to normalization), the output of the adapter will be initially the same as that of the controller unit initialized with the identity matrix.
+
+Table 2: Mean transfer learning performance. We show the mean top-1 accuracy $( \% )$ attained by fine-tuning a network from each domain to all domains. Out of the datasets above, starting with Caltech-256 proves most generic as a feature extractor $\mathcal { f } t$ -last). However, fine tuning is best when initially training on the Sketch dataset (ft-full).   
+
+<table><tr><td>Dataset</td><td>DPed</td><td>SVHN</td><td>GTSR</td><td>C-10</td><td>Oglt</td><td>Plnk</td><td>Sketch</td><td>Caltech</td></tr><tr><td>ft-full</td><td>60.1</td><td>60</td><td>65.8</td><td>70.9</td><td>80.4</td><td>81.6</td><td>84.2</td><td>82.3</td></tr><tr><td>ft-full-bn-off</td><td>61.8</td><td>64.6</td><td>66.2</td><td>72.5</td><td>78</td><td>80.2</td><td>82.5</td><td>81</td></tr><tr><td>ft-last</td><td>24.4</td><td>33.9</td><td>42.5</td><td>44</td><td>44.1</td><td>47</td><td>50.3</td><td>55.6</td></tr></table>
+
+# 4.2 TRANSFERABILITY
+
+How is one to choose a good network to serve as a base-network for others? As an indicator of the representative power of the features of each independently trained network $N$ , we test the performance on other datasets, using $N$ for fine tuning. We define the transferability of a source task $S$ w.r.t a target task $T$ as the top-1 accuracy attained by fine-tuning $N$ trained on $S$ to perform on $T$ . We test 3 different scenarios, as follows: (1) Fine-tuning only the last layer (a.k.a feature extraction) (ftlast); (2) Fine-tuning all layers of ${ \cal N } ( { \bf f t } { \bf - f u l l } )$ ; (3) same as ft-full, but freezing the parameters of the batch-normalization layers - this has proven beneficial in some cases - we call this option ft-full-bnoff. The results in Fig 1 (b) show some interesting phenomena. First, as expected, feature extraction (ft last) is inferior to fine-tuning the entire network. Second, usually training from scratch is the most beneficial option. Third, we see a distinction between natural images (Caltech-256, CIFAR10, SVHN, GTSR, Daimler) and unnatural ones (Sketch, Omniglot, Plankton); Plankton images are essentially natural but seem to exhibit different behavior than the rest. It is evident that features from the natural images are less beneficial for the unnatural images. Interestingly, the converse is not true: training a network starting from Sketch or Omniglot works quite well for most datasets, both natural and unnatural. This is further shown in Tab. 2 (a): we calculate the mean transferability of each dataset by the mean value of each rows of the transferability matrix from Fig. 1. $D A N _ { C a l t e c h - 2 5 6 }$ works best for feature extraction. However, for full fine-tuning using $D A N _ { P l a n k t o n }$ works as the best starting point, closely followed by $D A N _ { C a l t e c h - 2 5 6 }$ . For controller networks, the best mean accuracy attained for a single base net trained from scratch is attained using $D A N _ { s k e t c h }$ $( 8 3 . 7 \% )$ . This is close to the performance attained by full transfer learning from the same network $( 8 4 . 2 \%$ , see Tab. 2) at a fraction of the number of parameters. This is consistent with our transferability measure. To further test the correlation between the transferability and the performance given a specific base network, we used each dataset as a base for control networks for all others and measured the mean overall accuracy. The results can be seen in Fig. 2 (b).
+
+# 4.2.1 A UNIFIED NETWORK
+
+Finally, we test the possibility of a single network which can both determine the domain of an image and classify it. We train a classifier to predict from which dataset an image originates, using the training images from the 8 datasets. This is learned easily by the network (also VGG-B) which rapidly converges to $100 \%$ or near accuracy. With this “dataset-decider”, named $N _ { d c }$ we augment $D A N _ { s k e t c h }$ to set for each input image $I$ from any of the datasets $D _ { i }$ the controller scalar $\alpha _ { i }$ of $D A N _ { s k e t c h  D _ { i } }$ to 1 if and only if $N _ { d c }$ deemed $I$ to originate from $D _ { i }$ and to 0 otherwise. This produces a network which applies to each input image the correct controllers, classifying it within its own domain.
+
+# 4.3 VISUAL DECATHLON CHALLENGE
+
+We now show results on the recent Visual Decathlon Challenge of Rebuffi et al. (2017). The challenge introduces involves 10 different image classification datasets: ImageNet (Russakovsky et al. (2015)); Aircraft (Maji et al. (2013)); Cifar-100 (Krizhevsky and Hinton (2009)); Daimler Pedestrians (Munder and Gavrila (2006)); Dynamic Textures (Cimpoi et al. (2013)); GTSR (Stallkamp et al. (2012)); Flowers (Nilsback and Zisserman (2008)); Omniglot (Lake et al. (2015)); SVHN (Netzer et al. (2011)) and UCF-101 (Soomro et al. (2012)). The goal is to reach accurate classification on each dataset while retaining a small model size, using the train/val/test splits fixed by the authors. All images are resized so the smaller side of each image is 72 pixels. The classifier is expected to operate on images of 64x64 pixels. Each entry in the challenge is assigned a decathlon score, which is a function designed to highlight methods which do better than the baseline on all 10 datasets. Please refer to the challenge website for details about the scoring and datasets: http://www.robots.ox.ac.uk/˜vgg/decathlon/. Similarly to Rebuffi et al. (2017), we chose to use a wide residual network (Zagoruyko and Komodakis (2016)) with an overall depth of 28 and a widening factor of 4, with a stride of 2 in the convolution at the beginning of each basic block. In what follows we describe the challenge results, followed by some additional experiments showing the added value of our method in various settings. In this section we used the recent YellowFin optimizer (Zhang et al. (2017)) as it required less tuning than SGD. We use an initial learning rate factor of 0.1 and reduce it to 0.01 after 25 epochs. This is for all datasets with the exception of ImageNet which we train for 150 epochs with SGD with an initial learning rate of 0.1 which is reduced every 35 epochs by a factor of 10. This is the configuration we determined using the available validation data which was then used to train on the validation set as well (as did the authors of the challenge) and obtain results from the evaluation server. Here we trained on the reduced resolution ImageNet from scratch and used the resulting net as a base for all other tasks. Tab. 3 summarizes our results as well as baseline methods and the those of Rebuffi et al. (2017), all using a base architecture of similar capacity. By using a significantly stronger base architecture they obtained higher results (mean of $7 9 . 4 3 \%$ ) but with a parameter cost of 12. All of the rows are copied from Rebuffi et al. (2017), including their re-implementation of LWF, except the last which shows our results. The final column of the table shows the decathlon score. A score of 2500 reflects the baseline: finetuning from ImageNet for each dataset independently. For the same architecture, the best results obtained by the Residual Adapters method is slightly below ours in terms of decathlon score and slightly above them in terms of mean performance. However, unlike them, we avoid joint training over all of the datasets and using dataset-dependent weight decay.
+
+![](images/2b59dc95852fccffc83fac2b33654b7e1c0392a82ae29fe31f7c372051480c26.jpg)  
+Figure 2: (a) Controller initialization schemes. Mean loss averaged over 5 experiments for different ways of initializing controller modules, overlaid with minimal and maximal values. Random initialization performs the worst (random). Approximating the behavior of a fine-tuned network is slightly better (linear approx) and initializing by mimicking the base network (diagonal) performs the best $( b )$ Predictability of a control network’s overall accuracy average over all datasets, given its transferability measure. (c) Shifting Representations. Using a single base network $N _ { s k e t c h }$ , we check the method’s sensitivity to varying values of $\alpha$ by varying it in the range [0, 1]. Increasing $\alpha$ shifts the network away from the base representation and towards learned tasks - gradually lowering performance on the base task (diamonds) and improving on the learned ones (full circles). The relatively slow decrease of the performance on sketch (blue diamonds) and increase in that of Plankton (blue circles) indicates a similarity between the learned representations.
+
+# 4.4 COMPRESSION AND CONVERGENCE
+
+In this section, we highlight some additional useful properties of our method. All experiments in the following were done using the same architecture as in the last section but training was performed only on the training sets of the Visual Decathlon Challenge and tested on the validation sets. First, we check whether the effects of network compression are complementary to ours or can hinder them. Despite the recent trend of sophisticated network compression techniques (for example Han et al. (2015a)) we use only a simple method of compression as a proof-of-concept, noting that using recent compression methods will likely produce better results. We apply a simple linear quantization on the network weights, using either 4, 6, 8, 16 or 32 bits to represent each weight, where 32 means no quantization. We do not quantize batch-normalization coefficients. Fig. 3 (b) shows how accuracy is affected by quantizing the coefficients of each network. Using 8 bits results in only a marginal loss of accuracy. This effectively means our method can be used to learn new tasks with a cost of $3 . 2 5 \%$ of the original parameters. Many maintain performance even at 6 bits (DPed, Flowers, GTSR, Omniglot, SVHN. Next, we compare the effect of quantization on different transfer methods: feature extraction, fine-tuning and our method (both diagonal and linear variants). For each dataset we record the normalized (divided by the max.) accuracy for each method/quantization level (which is transformed into the percentage of required parameters). This is plotted in Fig. 4 (a). Our method requires significantly less parameters to reach the same accuracy as fine-tuning. If parameter usage is limited, the diagonal variant of our method significantly outperforms feature extraction. Finally, we show that the number of epochs until nearing the maximal performance is markedly lower for our method. This can be seen in Fig. 4 (b,c).
+
+Table 3: Results on Visual Decathlon Challenge. Scratch: training on each task independently. Feature: using a pre-trained network as a feature extractor. Finetune : vanilla fine tuning. Performs well but requires many parameters. Learning-without-forgetting (LWF, Li and Hoiem (2016)) slightly outperforms it but with a large parameter cost. Residual adapt. (Rebuffi et al. (2017)) significantly reduce the number of parameters. Results improve when training jointly on all task (Res.Adapt(Joint)). The proposed method (DAN) outperforms residual adapters despite adding each task independently of the others. S is the decathlon challenge score.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>#par</td><td rowspan=1 colspan=1>ImNet</td><td rowspan=1 colspan=1>Airc.</td><td rowspan=1 colspan=1>C100</td><td rowspan=1 colspan=1>DPed</td><td rowspan=1 colspan=1>DTD</td><td rowspan=1 colspan=1>GTSR</td><td rowspan=1 colspan=1>Flwr</td><td rowspan=1 colspan=1>Oglt</td><td rowspan=1 colspan=1>SVHN</td><td rowspan=1 colspan=1>UCF</td><td rowspan=1 colspan=1>mean</td><td rowspan=1 colspan=1>S</td></tr><tr><td rowspan=1 colspan=1>Scratch</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>59.87</td><td rowspan=1 colspan=1>57.1</td><td rowspan=1 colspan=1>75.73</td><td rowspan=1 colspan=1>91.2</td><td rowspan=1 colspan=1>37.77</td><td rowspan=1 colspan=1>96.55</td><td rowspan=1 colspan=1>56.3</td><td rowspan=1 colspan=1>88.74</td><td rowspan=1 colspan=1>96.63</td><td rowspan=1 colspan=1>43.27</td><td rowspan=1 colspan=1>70.32</td><td rowspan=1 colspan=1>1625</td></tr><tr><td rowspan=1 colspan=1>Feature</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>59.67</td><td rowspan=1 colspan=1>23.31</td><td rowspan=1 colspan=1>63.11</td><td rowspan=1 colspan=1>80.33</td><td rowspan=1 colspan=1>45.37</td><td rowspan=1 colspan=1>68.16</td><td rowspan=1 colspan=1>73.69</td><td rowspan=1 colspan=1>58.79</td><td rowspan=1 colspan=1>43.54</td><td rowspan=1 colspan=1>26.8</td><td rowspan=1 colspan=1>54.28</td><td rowspan=1 colspan=1>544</td></tr><tr><td rowspan=1 colspan=1>Finetune</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>59.87</td><td rowspan=1 colspan=1>60.34</td><td rowspan=1 colspan=1>82.12</td><td rowspan=1 colspan=1>92.82</td><td rowspan=1 colspan=1>55.53</td><td rowspan=1 colspan=1>97.53</td><td rowspan=1 colspan=1>81.41</td><td rowspan=1 colspan=1>87.69</td><td rowspan=1 colspan=1>96.55</td><td rowspan=1 colspan=1>51.2</td><td rowspan=1 colspan=1>76.51</td><td rowspan=1 colspan=1>2500</td></tr><tr><td rowspan=1 colspan=1>LWF</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>59.87</td><td rowspan=1 colspan=1>61.15</td><td rowspan=1 colspan=1>82.23</td><td rowspan=1 colspan=1>92.34</td><td rowspan=1 colspan=1>58.83</td><td rowspan=1 colspan=1>97.57</td><td rowspan=1 colspan=1>83.05</td><td rowspan=1 colspan=1>88.08</td><td rowspan=1 colspan=1>96.1</td><td rowspan=1 colspan=1>50.04</td><td rowspan=1 colspan=1>76.93</td><td rowspan=1 colspan=1>2515</td></tr><tr><td rowspan=1 colspan=1>Res. Adapt.</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>59.67</td><td rowspan=1 colspan=1>56.68</td><td rowspan=1 colspan=1>81.2</td><td rowspan=1 colspan=1>93.88</td><td rowspan=1 colspan=1>50.85</td><td rowspan=1 colspan=1>97.05</td><td rowspan=1 colspan=1>66.24</td><td rowspan=1 colspan=1>89.62</td><td rowspan=1 colspan=1>96.13</td><td rowspan=1 colspan=1>47.45</td><td rowspan=1 colspan=1>73.88</td><td rowspan=1 colspan=1>2118</td></tr><tr><td rowspan=1 colspan=1>Res. Adapt(Joint)</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>59.23</td><td rowspan=1 colspan=1>63.73</td><td rowspan=1 colspan=1>81.31</td><td rowspan=1 colspan=1>93.3</td><td rowspan=1 colspan=1>57.02</td><td rowspan=1 colspan=1>97.47</td><td rowspan=1 colspan=1>83.43</td><td rowspan=1 colspan=1>89.82</td><td rowspan=1 colspan=1>96.17</td><td rowspan=1 colspan=1>50.28</td><td rowspan=1 colspan=1>77.17</td><td rowspan=1 colspan=1>2643</td></tr><tr><td rowspan=1 colspan=1>DAN (Ours)</td><td rowspan=1 colspan=1>2.17</td><td rowspan=1 colspan=1>57.74</td><td rowspan=1 colspan=1>64.12</td><td rowspan=1 colspan=1>80.07</td><td rowspan=1 colspan=1>91.3</td><td rowspan=1 colspan=1>56.54</td><td rowspan=1 colspan=1>98.46</td><td rowspan=1 colspan=1>86.05</td><td rowspan=1 colspan=1>89.67</td><td rowspan=1 colspan=1>96.77</td><td rowspan=1 colspan=1>49.38</td><td rowspan=1 colspan=1>77.01</td><td rowspan=1 colspan=1>2851</td></tr></table>
+
+# 4.5 DISCUSSION
+
+We have observed that the proposed method converges to a a reasonably good solution faster than vanilla fine-tuning and eventually attains slightly better performance. This is despite the network’s expressive power, which is limited by our construction. We conjecture that constraining each layer to be expressed as a linear combination of the corresponding layer in the original network serves to regularize the space of solutions and is beneficial when the tasks are sufficiently related to each other. One could come up with simple examples where the proposed method would likely fail: if the required solutions to two tasks are disjoint. For example, one task requires counting of horizontal lines and the other requires counting of vertical ones, and such examples are all that appear in the training sets, then the proposed method will likely work far worse than vanilla fine-tuning or training from scratch. We leave the investigation of this issue, as well as finding ways between striking a balance between reusing features and learning new ones as future work.
+
+# 5 CONCLUSIONS
+
+We have presented a method for transfer learning thats adapts an existing network to new tasks while fully preserving the existing representation. Our method matches or outperforms vanilla finetuning, though requiring a fraction of the parameters, which when combined with net compression reaches $3 \%$ of the original parameters with no loss of accuracy. The method converges quickly to high accuracy while being on par or outperforming other methods with the same goal. Built into our method is the ability to easily switch the representation between the various learned tasks, enabling a single network to perform seamlessly on various domains. The control parameter $\alpha$ can be cast as a real-valued vector, allowing a smooth transition between representations of different tasks. An example of the effect of such a smooth transition can be seen in Fig. 2 (c) where $\alpha$ is used to linearly interpolate between the representation of differently learned tasks, allowing one to smoothly control transitions between different behaviors. Allowing each added task to use a convex combination of already existing controllers will potentially utilize controllers more efficiently and decouple the number of controllers from the number of tasks.
+
+![](images/628d8a338301be0b83e68224cd7a2e731fb014ffcc25b044243f72f3a2c21f86.jpg)  
+Figure 3: (a) Accuracy vs. learning method. Using only the last layer (feature extractor) performs worst. finetune: vanilla fine-tuning. Diagonal : our controller modules with a diagonal combination matrix. Linear: our full method. On average, our full method outperforms vanilla fine tuning. (b) Accuracy vs. quantization: with as low as 8 bits, we see no significant effect of network quantization on our method, showing they can be applied together.
+
+![](images/29448cb9c2c9e74e59c7ddafd34f4e7f5fcf82fc36a6d9f52eb551e4e3aee3e5.jpg)  
+Figure 4: (a) Mean classification accuracy (normalized, averaged over datasets) w.r.t no. parameters. Our method achieve better performance over baselines for a large range of parameter budgets. For very few parameters diagonal (ours) outperforms features extraction. To obtain maximal accuracy our full method requires far fewer parameters (see linear vs finetune). (b) Our method (linear) converges to a high accuracy faster than fine-tuning. The weaker variant of our method converges as fast as feature-extraction but reaches an overall higher accuracy (3 (a)). (c) zoom in on top-right of (b).
+
+# REFERENCES
+
+H. Bilen and A. Vedaldi. Integrated perception with recurrent multi-task neural networks. In Proceedings of Advances in Neural Information Processing Systems (NIPS), 2016. 2
+
+Hakan Bilen and Andrea Vedaldi. Universal representations:The missing link between faces, text, planktons, and cat breeds, 2017. 2, 4.0.1
+
+Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi. Describing Textures in the Wild. CoRR, abs/1311.3618, 2013. 4.3
+
+Robert K Cowen, S Sponaugle, K Robinson, and J Luo. Planktonset 1.0: Plankton imagery data collected from fg walton smith in straits of florida from 2014–06-03 to 2014–06-06 and used in the 2015 national data science bowl (ncei accession 0127422). Oregon State University; Hatfield Marine Science Center, 2015. 4.0.1
+
+Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In Advances in Neural Information Processing Systems, pages 1269–1277, 2014. 2
+
+Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. DeCAF: A Deep Convolutional Activation Feature for Generic Visual Recognition. In Icml, volume 32, pages 647–655, 2014. 2
+
+David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multi-scale convolutional architecture. In Proceedings of the IEEE International Conference on Computer Vision, pages 2650–2658, 2015. 2
+
+Mathias Eitz, James Hays, and Marc Alexa. How do humans sketch objects? ACM Trans. Graph., 31(4):44–1, 2012. 4.0.1
+
+Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3(4):128–135, 1999. 2
+
+Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 580–587, 2014. 1, 2
+
+Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007. 4.0.1
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015a. 2, 4.4
+
+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, pages 1135– 1143, 2015b. 2
+
+Awni Hannun, Carl Case, Jared Casper, Bryan Catanzaro, Greg Diamos, Erich Elsen, Ryan Prenger, Sanjeev Satheesh, Shubho Sengupta, Adam Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014. 1
+
+Stephen Jose Hanson and Lorien Y Pratt. Comparing biases for minimal network construction with ´ back-propagation. In Proceedings of the 1st International Conference on Neural Information Processing Systems, pages 177–185. MIT Press, 1988. 2
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016. 3
+
+Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask R-CNN. ´ arXiv preprint arXiv:1703.06870, 2017. 2
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 4.0.1
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, page 201611835, 2017. 2
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. 4.0.1, 4.3
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pages 1097–1105, 2012. 1
+
+Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. 4.3
+
+Zhizhong Li and Derek Hoiem. Learning without Forgetting. CoRR, abs/1606.09282, 2016. 2, 3
+
+Geert Litjens, Thijs Kooi, Babak Ehteshami Bejnordi, Arnaud Arindra Adiyoso Setio, Francesco Ciompi, Mohsen Ghafoorian, Jeroen AWM van der Laak, Bram van Ginneken, and Clara I Sanchez. A survey on deep learning in medical image analysis. ´ arXiv preprint arXiv:1702.05747, 2017. 1
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3431–3440, 2015. 1, 3
+
+Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew Blaschko, and Andrea Vedaldi. Fine-grained visual classification of aircraft. arXiv preprint arXiv:1306.5151, 2013. 4.3
+
+Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch Networks for Multi-task Learning. CoRR, abs/1604.03539, 2016. 2
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. 4.0.1
+
+Stefan Munder and Dariu M Gavrila. An experimental study on pedestrian classification. IEEE transactions on pattern analysis and machine intelligence, 28(11):1863–1868, 2006. 4.0.1, 4.3
+
+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, volume 2011, page 5, 2011. 4.0.1, 4.3
+
+Maria-Elena Nilsback and Andrew Zisserman. Automated Flower Classification over a Large Number of Classes. In ICVGIP, pages 722–729. IEEE, 2008. 4.3
+
+Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. Learning multiple visual domains with residual adapters. arXiv preprint arXiv:1705.08045, 2017. 1, 2, 4.1, 4.1.1, 4.3, 3
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. 4.1, 4.3
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. 2
+
+Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. CNN features off-the-shelf: an astounding baseline for recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 806–813, 2014. 2
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. 1, 4, 4.0.1
+
+Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild, 2012. 4.3
+
+Johannes Stallkamp, Marc Schlipsing, Jan Salmen, and Christian Igel. Man vs. computer: Benchmarking machine learning algorithms for traffic sign recognition. Neural networks, 32:323–332, 2012. 4.0.1, 4.3
+
+Ashia C. Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The Marginal Value of Adaptive Gradient Methods in Machine Learning. CoRR, abs/1705.08292, 2017. 4.0.1
+
+Sergey Zagoruyko and Nikos Komodakis. Wide Residual Networks. CoRR, abs/1605.07146, 2016. 4.3
+
+Jian Zhang, Ioannis Mitliagkas, and Christopher $\mathrm { R } \tilde { \mathrm { A } } \ @$ . Yellowfin and the art of momentum tuning. arXiv preprint arXiv:1706.03471, 2017. 4.3
+
+Shizhan Zhu, Cheng Li, Chen Change Loy, and Xiaoou Tang. Face alignment by coarse-to-fine shape searching. In CVPR, pages 4998–5006. IEEE Computer Society, 2015. ISBN 978-1-4673- 6964-0. 2

parse/train/ryj0790hb/ryj0790hb_content_list.json

@@ -0,0 +1,1288 @@
+[
+    {
+        "type": "text",
+        "text": "INCREMENTAL LEARNING THROUGH DEEP ADAPTA-TION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            145
+        ],
+        "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": "Given an existing trained neural network, it is often desirable to learn new capabilities without hindering performance of those already learned. Existing approaches either learn sub-optimal solutions, require joint training, or incur a substantial increment in the number of parameters for each added task, typically as many as the original network. We propose a method called Deep Adaptation Networks (DAN) that constrains newly learned filters to be linear combinations of existing ones. DANs preserve performance on the original task, require a fraction (typically $1 3 \\%$ ) of the number of parameters compared to standard fine-tuning procedures and converge in less cycles of training to a comparable or better level of performance. When coupled with standard network quantization techniques, we further reduce the parameter cost to around $3 \\%$ of the original with negligible or no loss in accuracy. The learned architecture can be controlled to switch between various learned representations, enabling a single network to solve a task from multiple different domains. We conduct extensive experiments showing the effectiveness of our method on a range of image classification tasks and explore different aspects of its behavior. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While deep neural networks continue to show remarkable performance gains in various areas such as image classification (Krizhevsky et al. (2012)), semantic segmentation (Long et al. (2015)), object detection (Girshick et al. (2014)), speech recognition (Hannun et al. (2014))medical image analysis (Litjens et al. (2017)) - and many more - it is still the case that typically, a separate model needs to be trained for each new task. Given two tasks of a totally different modality or nature, such as predicting the next word in a sequence of words versus predicting the class of an object in an image, it stands to reason that each would require a different architecture or computation. However, for a set of related tasks such as classifying images from different domains it is natural to expect that solutions will (1) Utilize the same computational pipeline; (2) Require a modest increment in the number of required parameters for each added task; (3) Be learned without hindering performance of already learned tasks (a.k.a catastrophic forgetting) and (4) Be learned incrementally, dropping the requirement for joint training such as in cases where the training data for previously learned tasks is no longer available. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            722
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to enable a network to learn a set of related tasks one by one while adhering to the above requirements. We do so by augmenting a network learned for one task with controller modules which utilize already learned representations for another. The parameters of the controller modules are optimized to minimize a loss on a new task. The training data for the original task is not required at this stage. The network’s output on the original task data stays exactly as it was; any number of controller modules may be added to each layer so that a single network can simultaneously encode multiple distinct tasks, where the transition from one task to another can be done by setting a binary switching variable or controlled automatically. The resultant architecture is coined DAN, standing for Deep Adaptation Networks. We demonstrate the effectiveness of our method on the recently introduced Visual Decathlon Challenge (Rebuffi et al. (2017)) whose task is to produce a classifier to work well on ten different image classification datasets. Though adding only $13 \\%$ of the number of original parameters for each newly learned task (the specific number depends on the network architecture), the average performance surpasses that of fine tuning all parameters - without the negative side effects of doubling the number of parameters and catastrophic forgetting. In this work, we focus on the task of image classification on various datasets, hence in our experiments the word “task” refers to a specific dataset. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contribution is the introduction of an improved alternative to transfer learning, which is as effective as fine-tuning all network parameters towards a new task, precisely preserves old task performance, requires a fraction (network dependent, typically $1 3 \\%$ ) of the cost in terms of new weights and is able to switch between any number of learned tasks. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            194
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We introduce two variants of the method, a fully-parametrized version, whose merits are described above and one with far fewer parameters, which significantly outperforms shallow transfer learning (i.e. feature extraction) for a comparable number of parameters. In the next section, we review some related work. Sec. 3 details the proposed method. In Sec. 4 we present various experiments, including comparison to related methods, as well as exploring various strategies on how to make our method more effective, followed by some discussion & concluding remarks. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            316,
+            343,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-task Learning. In multi-task learning, the goal is to train one network to perform several tasks simultaneously. This is usually done by jointly training on all tasks. Such training is advantageous in that a single representation is used for all tasks. In addition, multiple losses are said to act as an additional regularizer. Some examples include facial landmark localization (Zhu et al. (2015)), semantic segmentation (He et al. (2017)), 3D-reasoning (Eigen and Fergus (2015)), object and part detection (Bilen and Vedaldi (2016)) and others. While all of these learn to perform different tasks on the same dataset, the recent work of (Bilen and Vedaldi (2017)) explores the ability of a single network to perform tasks on various image classification datasets. We also aim to classify images from multiple datasets but we propose doing so in a manner which learns them one-by-one rather than jointly. Concurrent with our method is that of Rebuffi et al. (2017) which introduces dataset-specific additional residual units. We compare to this work in Sec 4. Our work bears some resemblance to Misra et al. (2016), where two networks are trained jointly, with additional “crossstitch” units, allowing each layer from one network to have as additional input linear combinations of outputs from a lower layer in another. However, our method does not require joint training and requires significantly fewer parameters. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Incremental Learning. Adding a new ability to a neural net often results in so-called “catastrophic forgetting” (French (1999)), hindering the network’s ability to perform well on old tasks. The simplest way to overcome this is by fixing all parameters of the network and using its penultimate layer as a feature extractor, upon which a classifier may be trained (Donahue et al. (2014); Sharif Razavian et al. (2014)). While guaranteed to leave the old performance unaltered, it is observed to yield results which are substantially inferior to fine-tuning the entire architecture (Girshick et al. (2014)). The work of Li and Hoiem (2016) provides a succinct taxonomy of several variants of such methods. In addition, they propose a mechanism of fine-tuning the entire network while making sure to preserve old-task performance by incorporating a loss function which encourages the output of the old features to remain constant on newly introduced data. While their method adds a very small number of parameters for each new task, it does not guarantee that the model retains its full ability on the old task. In Rusu et al. (2016) new representations can be added alongside old ones while leaving the old task performance unaffected. However, this comes at a cost of duplicating the number of parameters of the original network for each added task. In Kirkpatrick et al. (2017) the learning rate of neurons is lowered if they are found to be important to the old task. Our method fully preserves the old representation while causing a modest increase in the number of parameters for each added task. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Network Compression Multiple works have been published on reducing the number weights of a neural network as a means to represent it compactly (Han et al. (2015a;b)), gain speedups (Denton et al. (2014)) or avoid over-fitting (Hanson and Pratt (1988)), using combinations of coding, quantization, pruning and tensor decomposition. Such methods can be used in conjunction with ours to further improve results, as we show in Sec. 4. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/75f0ff6f40e26cd13c7fb664c6d897c50c301813121e50a2e099f11cb0f35143.jpg",
+        "image_caption": [
+            "Figure 1: (a) Summary of proposed method. Each convolutional layer of a base network is modified 1/1 by re-combining its weights through a controller module. A set of controllers is added for each newly learned task. A binary switching vector $\\alpha$ controls the output of the network by switching the controller modules on or off. $\\alpha$ can be determined either manually or via a sub-network (“Dataset Decider”) which determines the source domain of the image, switching accordingly between different sets of control parameters. Other layers (e.g, non-linearities, batch-normalization, skip layers) not shown for presentation purposes. (b) Transferability of various datasets to each other $\\scriptstyle { \\mathcal { f } } t$ -last) fine tuning only the last layer $( f u l l )$ fine-tuning all layers (ft-full-bn-off ) fine tuning all layers while disallowing batch-normalization layers’ weights to be updated. Overall, networks tend to be more easily transferable to problems from related domain (e.g., natural / drawing). Zoom in to see numbers. It is recommended to view this figure in color on-line. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            112,
+            799,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            297,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We begin with some notation. Let $T$ be some task to be learned. Specifically, we use a deep convolutional neural net (DCNN) in order to learn a classifier to solve $T$ , which is an image classification task. Most contemporary DCNN’s follow a common structure: for each input $x$ , the DCNN computes a representation of the input by passing it through a set of $l$ layers $\\phi _ { i }$ , $i \\in 1 \\dots l$ interleaved with non-linearities. The initial (lower) layers of the network are computational blocks, e.g. convolutions with optional residual units in more recent architectures (He et al. (2016)). Our method applies equally to networks with or without residual connections. At least one fully connected layer $f _ { i }$ , $i \\in { 1 \\dots c }$ is attached to the output of the last convolutional layer. Let $\\Phi _ { F _ { N } } = \\sigma ( \\phi _ { l } ) \\circ . . . \\sigma ( \\phi _ { 2 } ) \\circ \\sigma ( \\phi _ { 1 } )$ be the composition of all of the convolutional layers of the network $N$ , interleaved by non-linearities. We use an architecture where all non-linearities $\\sigma$ are the same function, with no tunable parameters. Denote by $\\Phi _ { F _ { N } } ( x )$ the feature part of $N$ . Similarly, denote by $\\Phi _ { C _ { N } } = f _ { c } \\circ . . . \\sigma ( f _ { 2 } ) \\circ \\sigma ( f _ { 1 } )$ the classifier part of $N$ , i.e. the composition of all of the fully-connected layers of $N$ . The output of $N$ is then simply defined as: ",
+        "bbox": [
+            173,
+            454,
+            825,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1fdbdbd3cf3c7191bf4aa44bcfcfb68f4b4048155191611264bc924ae078d016.jpg",
+        "text": "$$\nN ( x ) = \\Phi _ { C _ { N } } \\circ \\Phi _ { F _ { N } } ( x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            642,
+            581,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We do not specify batch-normalization layers in the above notation for brevity. It is also possible to drop the $\\Phi _ { C _ { N } }$ term, if the network is fully convolutional, as in Long et al. (2015). ",
+        "bbox": [
+            174,
+            674,
+            826,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ADAPTING REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            720,
+            426,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Assume that we are given two tasks, $T _ { 1 }$ and $T _ { 2 }$ , to be learned, and that we have learned a base network $N$ to solve $T _ { 1 }$ . We assume that a good solution to $T _ { 2 }$ can be obtained by a network with the same architecture as $N$ but with different parameters. We augment $N$ so that it will be able to solve $T _ { 2 }$ as well by attaching a controller module to each of its convolutional layers. Each controller module uses the existing weights of the corresponding layer of $N$ to create new convolutional filters adapted to the new task $T _ { 2 }$ : for each convolutional layer $\\phi _ { l }$ in $N$ , let $F _ { l } \\in \\mathcal { R } ^ { C _ { o } \\times C _ { i } \\times k \\times k }$ be the set of filters for that layer, where $C _ { o }$ is the number of output features, $C _ { l }$ the number of inputs, and $k \\times k$ the kernel size (assuming a square kernel). Denote by $b _ { l } \\in \\mathcal { R } ^ { C }$ the bias. Denote by $\\tilde { F } _ { l } \\in \\mathcal { R } ^ { C _ { o } \\times D }$ the matrix whose rows are flattened versions of the filters of $F _ { l }$ , where $D = C _ { i } \\cdot k \\cdot k$ ; let $f \\in \\mathcal { R } ^ { C _ { i } \\times k \\times k }$ be a filter from $F _ { l }$ whose values are $f ^ { 1 } = \\left( \\begin{array} { l l l } { { f _ { 1 1 } ^ { 1 } } } & { { \\cdot \\cdot \\cdot } } & { { f _ { 1 k } ^ { 1 } } } \\\\ { { } } & { { \\cdot \\cdot } } & { { } } \\\\ { { } } & { { } } & { { f _ { k k } ^ { 1 } } } \\end{array} \\right) , \\cdot \\cdot \\cdot , f ^ { i } = \\left( \\begin{array} { l l l } { { f _ { 1 1 } ^ { i } } } & { { \\cdot \\cdot } } & { { f _ { 1 k } ^ { i } } } \\\\ { { } } & { { \\cdot } } & { { } } \\\\ { { } } & { { } } & { { f _ { k k } ^ { i } } } \\end{array} \\right) .$ ",
+        "bbox": [
+            173,
+            746,
+            826,
+            873
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            872,
+            825,
+            929
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The flattened version of $f$ is a row vector $\\tilde { f } = ( f _ { 1 1 } ^ { 1 } , \\cdot \\cdot \\cdot , f _ { k k } ^ { 1 } , \\cdot \\cdot \\cdot , \\cdot \\cdot f _ { 1 1 } ^ { i } , \\cdot \\cdot \\cdot , f _ { k k } ^ { i } ) \\in \\mathcal { R } ^ { \\mathcal { D } }$ . “Unflattening” a row vector $\\tilde { f }$ reverts it to its tensor form $f \\in \\mathcal { R } ^ { C _ { i } \\times k \\times k }$ . This way, we can write ",
+        "bbox": [
+            171,
+            101,
+            823,
+            135
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5725e52f19026b507a4eb2068bda8af3c6566ce7ee9c8c96a26cf5df6e77808f.jpg",
+        "text": "$$\n\\tilde { F _ { l } ^ { a } } = W _ { l } \\cdot \\tilde { F _ { l } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            452,
+            152,
+            547,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { l } \\in \\mathcal { R } ^ { C _ { o } \\times C _ { o } }$ is a weight matrix defining linear combinations of the flattened filters of $F _ { l }$ , resulting in $C _ { o }$ new filters. Unflattening $\\tilde { F _ { l } ^ { a } }$ to its original shape results in $F _ { l } ^ { a } \\in \\mathcal { R } ^ { C _ { o } \\times C _ { i } \\times k \\times k }$ , which we call the adapted filters of layer $\\phi _ { l }$ . Using the symbol $X \\otimes Y$ as shorthand for flatten $Y $ matrix multiply by $X $ unflatten, we can write: ",
+        "bbox": [
+            174,
+            184,
+            825,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/843d24be84dcc71912b5fabd3e668ffad3edc966d8faa64a7f0adc0d6ffdaf4d.jpg",
+        "text": "$$\nF _ { l } ^ { a } = W _ { l } \\otimes F _ { l }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            447,
+            250,
+            550,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If the convolution contains a bias, we instantiate a new weight vector $b _ { l } ^ { a }$ instead of the original $b _ { l }$ . The output of layer $\\phi _ { l }$ is computed as follows: let $x _ { l }$ be the input of $\\phi _ { l }$ in the adapted network. For a given switching parameter $\\alpha \\in \\{ 0 , 1 \\}$ , we set the output of the modified layer to be the application of the switched convolution parameters and biases: ",
+        "bbox": [
+            174,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2b6e32b0a98cb84a3db250e4f36002c52fa63a792cd843db039d1a68d3c2d8f.jpg",
+        "text": "$$\nx _ { l + 1 } = [ \\alpha ( W _ { l } \\otimes F _ { l } ) + ( 1 - \\alpha ) F _ { l } ] * x _ { l } + \\alpha b _ { l } ^ { a } + ( 1 - \\alpha ) b _ { l }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            357,
+            694,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A set of fully connected layers $f _ { i } ^ { a }$ are learned from scratch, attaching a new “head” to the network for each new task. Throughout training $\\&$ testing, the weights of $F$ (the filters of $N$ ) are kept fixed and serve as basis functions for $F ^ { a }$ . The weights of the controller modules are learned via backpropagation given the loss function. Weights of any batch normalization (BN) layers are either kept fixed or learned anew. The batch-normalized output is switched between the values of the old and new BN layers, similarly to Eq. 4. A visualization of the resulting DAN can be seen in Fig. 1. ",
+        "bbox": [
+            173,
+            385,
+            825,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Weaker parametrization A weaker variant of our method is one that forces the matrices $W _ { l }$ to be diagonal, e.g, only scaling the output of each filter of the original network. We call this variant “diagonal” (referring only to scaling coefficients, such as by a diagonal matrix) and the full variant of our method “linear” (referring to a linear combination of filters). The diagonal variant can be seen as a form of explicit regularization which limits the expressive power of the learned representation. While requiring significantly fewer parameters, it results in poorer classification accuracy, but as will be shown later, also outperforms regular feature-extraction for transfer learning, especially in network compression regimes. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Multiple Controllers The above description mentions one base network and one controller network. However, any number of controller networks can be attached to a single base network, regardless of already attached ones. In this case $\\alpha$ is extended to one-hot vector of values determined by another sub-network, allowing each controller network to be switched on or off as needed. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following, we denote a network learned for a dataset/task $S$ as $N _ { S }$ . A controller learned using $N _ { S }$ as a base network will be denoted as $D A N _ { S }$ , where DAN stands for Deep Adaptation Network and $D A N _ { S  T }$ means using $D A N _ { S }$ for a specific task $T$ . While in this work we apply the method to classification tasks it is applicable to other tasks as well. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Parameter Cost The number of new parameters added for each task depends on the number of filters in each layer and the number of parameters in the fully-connected layers. As the latter are not reused, their parameters are fully duplicated. Let $M = C _ { o } \\times D$ be the filter dimensions for some conv. layer $\\phi _ { l }$ where $D = C _ { i } \\times k \\times k$ . A controller module for $\\phi _ { l }$ requires $C _ { o } ^ { 2 }$ coefficients for $F _ { l } ^ { a }$ and an additional $C _ { o }$ for $b _ { l } ^ { a }$ . Hence the ratio of new parameters w.r.t to the old for $\\phi _ { l }$ is $\\begin{array} { r } { \\frac { C _ { o } \\times ( \\dot { C } _ { o } + 1 ) } { C _ { o } \\times ( D + 1 ) } = \\frac { C _ { o } + 1 } { D + 1 } \\approx \\frac { C _ { o } } { D } } \\end{array}$ Co . Example: for $C _ { o } = C _ { i } = 2 5 6$ input and output units and a kernel size $k = 5$ this equals $\\textstyle { \\frac { 2 5 6 + 1 } { 2 5 6 \\cdot 5 ^ { 2 } + 1 } } \\approx 0 . 0 4$ . In the final architecture we use the total number of weights required to adapt the convolutional layers $\\Phi _ { l }$ combined with a new fully-connected layer amounts to about $13 \\%$ of the original parameters. For VGG-B, this is roughly $21 \\%$ . For instance, constructing 10 classifiers using one base network and 9 controller networks requires $( 1 + 0 . 1 3 * 9 ) \\cdot P \\mathrm { = } 2 . 1 7 \\cdot P$ parameters where $P$ is the number for the base network alone, compared to $1 0 \\cdot P$ required to train each network independently. The cost is dependent on network architecture, for example it is higher ",
+        "bbox": [
+            173,
+            747,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/5b181092538fb3d934c63dc6d5eadb4c95375ba14cc80682438ef0a93e962b3d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Net</td><td>C-10</td><td>GTSR</td><td>SVHN</td><td>Caltech</td><td>Dped</td><td>Oglt</td><td>Plnk</td><td>Sketch</td><td>Perf.</td><td>#par</td></tr><tr><td>VGG-B(S)</td><td>92.5</td><td>98.2</td><td>96.2</td><td>88.2</td><td>92.9</td><td>86.9</td><td>74.5</td><td>69.2</td><td>87.32</td><td>8</td></tr><tr><td>VGG-B(P)</td><td>93.2</td><td>99.0</td><td>95.8</td><td>92.6</td><td>98.7</td><td>83.8</td><td>73.2</td><td>65.4</td><td>87.71</td><td>8</td></tr><tr><td>DANcaltech-256</td><td>77.9</td><td>93.6</td><td>91.8</td><td>88.2</td><td>93.8</td><td>81.0</td><td>63.6</td><td>49.4</td><td>79.91</td><td>2.54</td></tr><tr><td>DANsketch</td><td>77.9</td><td>93.3</td><td>93.2</td><td>86.9</td><td>94.0</td><td>85.4</td><td>69.6</td><td>69.2</td><td>83.7</td><td>2.54</td></tr><tr><td>DANnoise</td><td>68.1</td><td>90.9</td><td>90.4</td><td>84.6</td><td>91.3</td><td>80.6</td><td>61.7</td><td>42.7</td><td>76.29</td><td>1.76</td></tr><tr><td>DANimagenet</td><td>91.6</td><td>97.6</td><td>94.6</td><td>92.2</td><td>98.7</td><td>81.3</td><td>72.5</td><td>63.2</td><td>86.46</td><td>2.76</td></tr><tr><td>DANimagenet+sketch</td><td>91.6</td><td>97.6</td><td>94.6</td><td>92.2</td><td>98.7</td><td>85.4</td><td>72.5</td><td>69.2</td><td>87.76</td><td>3.32</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            823,
+            207
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Perf: top-1 accuracy $\\%$ , higher is better) on various datasets and parameter cost (#par., lower is better) for a few baselines and several variants of our method. Rows 1,2: independent baseline performance. VGG-B: VGG (Simonyan and Zisserman (2014)) architecture B. (S) - trained from scratch. (P) - pre-trained on ImageNet. Rows 3-7: (ours) controller network performance; $D A N _ { s k e t c h }$ as a base network outperforms $D A N _ { c a l t e c h - 2 5 6 }$ on most datasets. A controller network based on random weights $( D A N _ { n o i s e } )$ works quite well given that its number of learned parameters is a fifth of the other methods. $D A N _ { i m a g e n e t }$ : controller networks initialized from VGG-B model pretrained on ImageNet. $D A N _ { i m a g e n e t + s k e t c h }$ : selective control network based on both VGG-B(P) & Sketch. We color code the first, second and third highest values in each column (lowest for #par). #par: amortized number of weights learned to achieve said performance for all tasks divided by number of tasks addressed (lower is better). ",
+        "bbox": [
+            173,
+            217,
+            825,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "when applied on the VGG-B architecture. While our method can be applied to any network with convolutional layers, if $C _ { o } \\geq D$ , i.e., the number of output filters is greater than the dimension of each input filter, it would only increase the number of parameters. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            443
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            326,
+            481
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conduct several experiments to test our method and explore different aspects of its behavior. We use two different basic network architectures on two (somewhat overlapping) sets of classification benchmarks. The first is VGG-B (Simonyan and Zisserman (2014)) which we use for various analyses of our method. We begin by listing the datasets we used (4.0.1), followed by establishing baselines by training a separate model for each using a few initial networks. We proceed to test several variants of our proposed method (4.1) as well as testing different training schemes. Next, we discuss methods of predicting how well a network would fare as a base-network (4.2). We show how to discern the domain of an input image and output a proper classification (4.2.1) without manual choice of the control parameters $\\alpha$ . In the second part of our experiments, we show results on the Visual Decathlon Challenge, using a different architecture. Before concluding we show some more useful properties of our method. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.0.1 DATASETS AND EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            669,
+            429,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The first part of our evaluation protocol resembles that of Bilen and Vedaldi (2017): we test our method on the following datasets: Caltech-256 (Griffin et al. (2007)), CIFAR-10 (Krizhevsky and Hinton (2009)), Daimler (Munder and Gavrila (2006)) (DPed), GTSR (Stallkamp et al. (2012)), Omniglot (Mnih et al. (2015)), Plankton imagery data (Cowen et al. (2015)) (Plnk), Human Sketch dataset (Eitz et al. (2012)) and SVHN (Netzer et al. (2011)). All images are resized to 64 $\\times 6 4$ pixels, duplicating gray-scale images so that they have 3 channels as do the RGB ones. We whiten all images by subtracting the mean pixel value and dividing by the variance per channel. This is done for each dataset separately. We select $80 \\%$ for training and $20 \\%$ for validation in datasets where no fixed split is provided. We use the B architecture described in Simonyan and Zisserman (2014), henceforth referred to as VGG-B. It performs quite well on the various datasets when trained from scratch (See Tab. 1). Kindly refer to Bilen and Vedaldi (2017) for a brief description of each dataset. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As a baseline, we train networks independently on each of the 8 datasets. All experiments in this part are done with the Adam optimizer (Kingma and Ba (2014)), with an initial learning rate of 1e-3 or 1e-4, dependent on a few epochs of trial on each dataset. The learning rate is halved after each 10 epochs. Most networks converge within the first 10-20 epochs, with mostly negligible improvements afterwards. We chose Adam for this part due to its fast initial convergence with respect to nonadaptive optimization methods (e.g, SGD), at the cost of possibly lower final accuracy (Wilson et al. (2017)). The top-1 accuracy $( \\% )$ is summarized in Tab. 1. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 CONTROLLER NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            162,
+            395,
+            176
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To test our method, we trained a network on each of the 8 datasets in turn to be used as a base network for all others. We compare this to the baseline of training on each dataset from scratch (VGGB(S)) or pretrained $\\left( \\mathbf { V } \\mathbf { G } \\mathbf { G } \\mathbf { - } \\mathbf { B } ( \\mathbf { P } ) \\right)$ networks. Tab. 1 summarizes performance on all datasets for two representative base nets: $D A N _ { c a l t e c h - 2 5 6 }$ $( 7 9 . 9 \\% )$ and $D A N _ { s k e t c h }$ $( 8 3 . 7 \\% )$ . Mean performance for other base nets are shown in Fig. 2 (a). The parameter cost (3.1) of each setting is reported in the last column of the table. This (similarly to Rebuffi et al. (2017)) is the total number of parameters required for a set of tasks normalized by that of a single fully-parametrized network. We also check how well a network can perform as a base-network after it has seen ample training examples: $D A N _ { i m a g e n e t }$ is based on VGG-B pretrained on ImageNet (Russakovsky et al. (2015)). This improves the average performance by a significant amount $( 8 3 . 7 \\%$ to $8 6 . 5 \\%$ ). On Caltech256 we see an improvement from $8 8 . 2 \\%$ (training from scratch). However, for both Sketch and Omniglot the performance is in favor of $D A N _ { s k e t c h }$ . Note these are the only two domains of strictly unnatural images. Additionally, $D A N _ { i m a g e n e t }$ is still slightly inferior to the non-pretrained VGG-B(S) $8 6 . 5 \\%$ vs $8 7 . 7 \\%$ ), though the latter is more parameter costly. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Multiple Base Networks A good base network should have features generic enough so that a controller network can use them for any target task. In practice this is not necessarily the case. To use two base-networks simultaneously, we implemented a dual-controlled network by using both $D A N _ { c a l t e c h - 2 5 6 }$ and $D A N _ { s k e t c h }$ and attaching to them controller networks. The outputs of the feature parts of the resulting sub-networks were concatenated before the fully-connected layer. This resulted in the exact same performance as $D A N _ { s k e t c h }$ alone. However, by using selected controllermodules per group of tasks, we can improve the results: for each dataset the maximally performing network (based on validation) is the basis for the control module, i.e., we used $D A N _ { i m a g e n e t }$ for all datasets except Omniglot and Sketch. For the latter two we use $D A N _ { s k e t c h }$ as a base net. We call this network $D A N _ { i m a g e n e t + s k e t c h }$ . At the cost of more parameters, it boosts the mean performance to $8 7 . 7 6 \\%$ - better than using any single base net for controllers or training from scratch. Since it is utilized for 9 tasks (counting ImageNet), its parameter cost (2.76) is still quite good. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Starting from a Randomly Initialized Base Network We tested how well our method can perform without any prior knowledge, e.g., building a controller network on a randomly initialized base network. The total number of parameters for this architecture is 12M. However, as 10M have been randomly initialized and only the controller modules and fully-connected layers have been learned, the effective number is actually 2M. Hence its parameter cost is determined to be 0.22. We summarize the results in Tab. 1. Notably, the results of this initialization worked surprisingly well; the mean top-1 precision attained by this network was $7 6 . 3 \\%$ , slightly worse than of $D A N _ { c a l t e c h - 2 5 6 }$ $( 7 9 . 9 \\% )$ . This is better than initializing with $D A N _ { d a i m l e r }$ , which resulted in a mean accuracy of $7 5 \\%$ . This is possible the random values in the base network can still be linearly combined by our method to create ones that are useful for classification. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            718
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 INITIALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            339,
+            747
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One question which arises is how to initialize the weights $W$ of a control-module. We tested several options: (1) Setting $W$ to an identity matrix (diagonal). This is equivalent to the controller module starting with a state which effectively mimics the behavior of the base network (2) Setting $W$ to random noise (random) (3) Training an independent network for the new task from scratch, then set $W$ to best linearly approximate the new weights with the base weights (linear approx). To find the best initialization scheme, we trained $D A N _ { s k e t c h  c a l t e c h 2 5 6 }$ for one epoch with each and observed the loss. Each experiment was repeated 5 times and the results averaged. From Fig. 2(a), it is evident that the diagonal initialization is superior: perhaps counter-intuitively, there is no need to train a fully parametrized target network. Simply starting with the behavior of the base network and tuning it via the control modules results in faster convergence. Hence we train controller modules with the diagonal method. Interestingly, the residual adaptation unit in Rebuffi et al. (2017) is initially similar to the diagonal configuration. If all of the filters in their adapter unit are set to 1 (up to normalization), the output of the adapter will be initially the same as that of the controller unit initialized with the identity matrix. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3c895e9e13b9ad4757019611593f9331485e766b637ad0641f1d511f517b6ba4.jpg",
+        "table_caption": [
+            "Table 2: Mean transfer learning performance. We show the mean top-1 accuracy $( \\% )$ attained by fine-tuning a network from each domain to all domains. Out of the datasets above, starting with Caltech-256 proves most generic as a feature extractor $\\mathcal { f } t$ -last). However, fine tuning is best when initially training on the Sketch dataset (ft-full). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>DPed</td><td>SVHN</td><td>GTSR</td><td>C-10</td><td>Oglt</td><td>Plnk</td><td>Sketch</td><td>Caltech</td></tr><tr><td>ft-full</td><td>60.1</td><td>60</td><td>65.8</td><td>70.9</td><td>80.4</td><td>81.6</td><td>84.2</td><td>82.3</td></tr><tr><td>ft-full-bn-off</td><td>61.8</td><td>64.6</td><td>66.2</td><td>72.5</td><td>78</td><td>80.2</td><td>82.5</td><td>81</td></tr><tr><td>ft-last</td><td>24.4</td><td>33.9</td><td>42.5</td><td>44</td><td>44.1</td><td>47</td><td>50.3</td><td>55.6</td></tr></table>",
+        "bbox": [
+            215,
+            99,
+            781,
+            181
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            276,
+            823,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 TRANSFERABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            323,
+            346,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "How is one to choose a good network to serve as a base-network for others? As an indicator of the representative power of the features of each independently trained network $N$ , we test the performance on other datasets, using $N$ for fine tuning. We define the transferability of a source task $S$ w.r.t a target task $T$ as the top-1 accuracy attained by fine-tuning $N$ trained on $S$ to perform on $T$ . We test 3 different scenarios, as follows: (1) Fine-tuning only the last layer (a.k.a feature extraction) (ftlast); (2) Fine-tuning all layers of ${ \\cal N } ( { \\bf f t } { \\bf - f u l l } )$ ; (3) same as ft-full, but freezing the parameters of the batch-normalization layers - this has proven beneficial in some cases - we call this option ft-full-bnoff. The results in Fig 1 (b) show some interesting phenomena. First, as expected, feature extraction (ft last) is inferior to fine-tuning the entire network. Second, usually training from scratch is the most beneficial option. Third, we see a distinction between natural images (Caltech-256, CIFAR10, SVHN, GTSR, Daimler) and unnatural ones (Sketch, Omniglot, Plankton); Plankton images are essentially natural but seem to exhibit different behavior than the rest. It is evident that features from the natural images are less beneficial for the unnatural images. Interestingly, the converse is not true: training a network starting from Sketch or Omniglot works quite well for most datasets, both natural and unnatural. This is further shown in Tab. 2 (a): we calculate the mean transferability of each dataset by the mean value of each rows of the transferability matrix from Fig. 1. $D A N _ { C a l t e c h - 2 5 6 }$ works best for feature extraction. However, for full fine-tuning using $D A N _ { P l a n k t o n }$ works as the best starting point, closely followed by $D A N _ { C a l t e c h - 2 5 6 }$ . For controller networks, the best mean accuracy attained for a single base net trained from scratch is attained using $D A N _ { s k e t c h }$ $( 8 3 . 7 \\% )$ . This is close to the performance attained by full transfer learning from the same network $( 8 4 . 2 \\%$ , see Tab. 2) at a fraction of the number of parameters. This is consistent with our transferability measure. To further test the correlation between the transferability and the performance given a specific base network, we used each dataset as a base for control networks for all others and measured the mean overall accuracy. The results can be seen in Fig. 2 (b). ",
+        "bbox": [
+            173,
+            349,
+            825,
+            683
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 A UNIFIED NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            699,
+            382,
+            713
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we test the possibility of a single network which can both determine the domain of an image and classify it. We train a classifier to predict from which dataset an image originates, using the training images from the 8 datasets. This is learned easily by the network (also VGG-B) which rapidly converges to $100 \\%$ or near accuracy. With this “dataset-decider”, named $N _ { d c }$ we augment $D A N _ { s k e t c h }$ to set for each input image $I$ from any of the datasets $D _ { i }$ the controller scalar $\\alpha _ { i }$ of $D A N _ { s k e t c h  D _ { i } }$ to 1 if and only if $N _ { d c }$ deemed $I$ to originate from $D _ { i }$ and to 0 otherwise. This produces a network which applies to each input image the correct controllers, classifying it within its own domain. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 VISUAL DECATHLON CHALLENGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            450,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now show results on the recent Visual Decathlon Challenge of Rebuffi et al. (2017). The challenge introduces involves 10 different image classification datasets: ImageNet (Russakovsky et al. (2015)); Aircraft (Maji et al. (2013)); Cifar-100 (Krizhevsky and Hinton (2009)); Daimler Pedestrians (Munder and Gavrila (2006)); Dynamic Textures (Cimpoi et al. (2013)); GTSR (Stallkamp et al. (2012)); Flowers (Nilsback and Zisserman (2008)); Omniglot (Lake et al. (2015)); SVHN (Netzer et al. (2011)) and UCF-101 (Soomro et al. (2012)). The goal is to reach accurate classification on each dataset while retaining a small model size, using the train/val/test splits fixed by the authors. All images are resized so the smaller side of each image is 72 pixels. The classifier is expected to operate on images of 64x64 pixels. Each entry in the challenge is assigned a decathlon score, which is a function designed to highlight methods which do better than the baseline on all 10 datasets. Please refer to the challenge website for details about the scoring and datasets: http://www.robots.ox.ac.uk/˜vgg/decathlon/. Similarly to Rebuffi et al. (2017), we chose to use a wide residual network (Zagoruyko and Komodakis (2016)) with an overall depth of 28 and a widening factor of 4, with a stride of 2 in the convolution at the beginning of each basic block. In what follows we describe the challenge results, followed by some additional experiments showing the added value of our method in various settings. In this section we used the recent YellowFin optimizer (Zhang et al. (2017)) as it required less tuning than SGD. We use an initial learning rate factor of 0.1 and reduce it to 0.01 after 25 epochs. This is for all datasets with the exception of ImageNet which we train for 150 epochs with SGD with an initial learning rate of 0.1 which is reduced every 35 epochs by a factor of 10. This is the configuration we determined using the available validation data which was then used to train on the validation set as well (as did the authors of the challenge) and obtain results from the evaluation server. Here we trained on the reduced resolution ImageNet from scratch and used the resulting net as a base for all other tasks. Tab. 3 summarizes our results as well as baseline methods and the those of Rebuffi et al. (2017), all using a base architecture of similar capacity. By using a significantly stronger base architecture they obtained higher results (mean of $7 9 . 4 3 \\%$ ) but with a parameter cost of 12. All of the rows are copied from Rebuffi et al. (2017), including their re-implementation of LWF, except the last which shows our results. The final column of the table shows the decathlon score. A score of 2500 reflects the baseline: finetuning from ImageNet for each dataset independently. For the same architecture, the best results obtained by the Residual Adapters method is slightly below ours in terms of decathlon score and slightly above them in terms of mean performance. However, unlike them, we avoid joint training over all of the datasets and using dataset-dependent weight decay. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b59dc95852fccffc83fac2b33654b7e1c0392a82ae29fe31f7c372051480c26.jpg",
+        "image_caption": [
+            "Figure 2: (a) Controller initialization schemes. Mean loss averaged over 5 experiments for different ways of initializing controller modules, overlaid with minimal and maximal values. Random initialization performs the worst (random). Approximating the behavior of a fine-tuned network is slightly better (linear approx) and initializing by mimicking the base network (diagonal) performs the best $( b )$ Predictability of a control network’s overall accuracy average over all datasets, given its transferability measure. (c) Shifting Representations. Using a single base network $N _ { s k e t c h }$ , we check the method’s sensitivity to varying values of $\\alpha$ by varying it in the range [0, 1]. Increasing $\\alpha$ shifts the network away from the base representation and towards learned tasks - gradually lowering performance on the base task (diamonds) and improving on the learned ones (full circles). The relatively slow decrease of the performance on sketch (blue diamonds) and increase in that of Plankton (blue circles) indicates a similarity between the learned representations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            111,
+            805,
+            238
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            433,
+            825,
+            834
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 COMPRESSION AND CONVERGENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            462,
+            868
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we highlight some additional useful properties of our method. All experiments in the following were done using the same architecture as in the last section but training was performed only on the training sets of the Visual Decathlon Challenge and tested on the validation sets. First, we check whether the effects of network compression are complementary to ours or can hinder them. Despite the recent trend of sophisticated network compression techniques (for example Han et al. (2015a)) we use only a simple method of compression as a proof-of-concept, noting that using recent compression methods will likely produce better results. We apply a simple linear quantization on the network weights, using either 4, 6, 8, 16 or 32 bits to represent each weight, where 32 means no quantization. We do not quantize batch-normalization coefficients. Fig. 3 (b) shows how accuracy is affected by quantizing the coefficients of each network. Using 8 bits results in only a marginal loss of accuracy. This effectively means our method can be used to learn new tasks with a cost of $3 . 2 5 \\%$ of the original parameters. Many maintain performance even at 6 bits (DPed, Flowers, GTSR, Omniglot, SVHN. Next, we compare the effect of quantization on different transfer methods: feature extraction, fine-tuning and our method (both diagonal and linear variants). For each dataset we record the normalized (divided by the max.) accuracy for each method/quantization level (which is transformed into the percentage of required parameters). This is plotted in Fig. 4 (a). Our method requires significantly less parameters to reach the same accuracy as fine-tuning. If parameter usage is limited, the diagonal variant of our method significantly outperforms feature extraction. Finally, we show that the number of epochs until nearing the maximal performance is markedly lower for our method. This can be seen in Fig. 4 (b,c). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f89d19947fc80ffdd89a2ddcca52471c19f50d7bdcd4da86b9d4943dae6e267a.jpg",
+        "table_caption": [
+            "Table 3: Results on Visual Decathlon Challenge. Scratch: training on each task independently. Feature: using a pre-trained network as a feature extractor. Finetune : vanilla fine tuning. Performs well but requires many parameters. Learning-without-forgetting (LWF, Li and Hoiem (2016)) slightly outperforms it but with a large parameter cost. Residual adapt. (Rebuffi et al. (2017)) significantly reduce the number of parameters. Results improve when training jointly on all task (Res.Adapt(Joint)). The proposed method (DAN) outperforms residual adapters despite adding each task independently of the others. S is the decathlon challenge score. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>#par</td><td rowspan=1 colspan=1>ImNet</td><td rowspan=1 colspan=1>Airc.</td><td rowspan=1 colspan=1>C100</td><td rowspan=1 colspan=1>DPed</td><td rowspan=1 colspan=1>DTD</td><td rowspan=1 colspan=1>GTSR</td><td rowspan=1 colspan=1>Flwr</td><td rowspan=1 colspan=1>Oglt</td><td rowspan=1 colspan=1>SVHN</td><td rowspan=1 colspan=1>UCF</td><td rowspan=1 colspan=1>mean</td><td rowspan=1 colspan=1>S</td></tr><tr><td rowspan=1 colspan=1>Scratch</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>59.87</td><td rowspan=1 colspan=1>57.1</td><td rowspan=1 colspan=1>75.73</td><td rowspan=1 colspan=1>91.2</td><td rowspan=1 colspan=1>37.77</td><td rowspan=1 colspan=1>96.55</td><td rowspan=1 colspan=1>56.3</td><td rowspan=1 colspan=1>88.74</td><td rowspan=1 colspan=1>96.63</td><td rowspan=1 colspan=1>43.27</td><td rowspan=1 colspan=1>70.32</td><td rowspan=1 colspan=1>1625</td></tr><tr><td rowspan=1 colspan=1>Feature</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>59.67</td><td rowspan=1 colspan=1>23.31</td><td rowspan=1 colspan=1>63.11</td><td rowspan=1 colspan=1>80.33</td><td rowspan=1 colspan=1>45.37</td><td rowspan=1 colspan=1>68.16</td><td rowspan=1 colspan=1>73.69</td><td rowspan=1 colspan=1>58.79</td><td rowspan=1 colspan=1>43.54</td><td rowspan=1 colspan=1>26.8</td><td rowspan=1 colspan=1>54.28</td><td rowspan=1 colspan=1>544</td></tr><tr><td rowspan=1 colspan=1>Finetune</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>59.87</td><td rowspan=1 colspan=1>60.34</td><td rowspan=1 colspan=1>82.12</td><td rowspan=1 colspan=1>92.82</td><td rowspan=1 colspan=1>55.53</td><td rowspan=1 colspan=1>97.53</td><td rowspan=1 colspan=1>81.41</td><td rowspan=1 colspan=1>87.69</td><td rowspan=1 colspan=1>96.55</td><td rowspan=1 colspan=1>51.2</td><td rowspan=1 colspan=1>76.51</td><td rowspan=1 colspan=1>2500</td></tr><tr><td rowspan=1 colspan=1>LWF</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>59.87</td><td rowspan=1 colspan=1>61.15</td><td rowspan=1 colspan=1>82.23</td><td rowspan=1 colspan=1>92.34</td><td rowspan=1 colspan=1>58.83</td><td rowspan=1 colspan=1>97.57</td><td rowspan=1 colspan=1>83.05</td><td rowspan=1 colspan=1>88.08</td><td rowspan=1 colspan=1>96.1</td><td rowspan=1 colspan=1>50.04</td><td rowspan=1 colspan=1>76.93</td><td rowspan=1 colspan=1>2515</td></tr><tr><td rowspan=1 colspan=1>Res. Adapt.</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>59.67</td><td rowspan=1 colspan=1>56.68</td><td rowspan=1 colspan=1>81.2</td><td rowspan=1 colspan=1>93.88</td><td rowspan=1 colspan=1>50.85</td><td rowspan=1 colspan=1>97.05</td><td rowspan=1 colspan=1>66.24</td><td rowspan=1 colspan=1>89.62</td><td rowspan=1 colspan=1>96.13</td><td rowspan=1 colspan=1>47.45</td><td rowspan=1 colspan=1>73.88</td><td rowspan=1 colspan=1>2118</td></tr><tr><td rowspan=1 colspan=1>Res. Adapt(Joint)</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>59.23</td><td rowspan=1 colspan=1>63.73</td><td rowspan=1 colspan=1>81.31</td><td rowspan=1 colspan=1>93.3</td><td rowspan=1 colspan=1>57.02</td><td rowspan=1 colspan=1>97.47</td><td rowspan=1 colspan=1>83.43</td><td rowspan=1 colspan=1>89.82</td><td rowspan=1 colspan=1>96.17</td><td rowspan=1 colspan=1>50.28</td><td rowspan=1 colspan=1>77.17</td><td rowspan=1 colspan=1>2643</td></tr><tr><td rowspan=1 colspan=1>DAN (Ours)</td><td rowspan=1 colspan=1>2.17</td><td rowspan=1 colspan=1>57.74</td><td rowspan=1 colspan=1>64.12</td><td rowspan=1 colspan=1>80.07</td><td rowspan=1 colspan=1>91.3</td><td rowspan=1 colspan=1>56.54</td><td rowspan=1 colspan=1>98.46</td><td rowspan=1 colspan=1>86.05</td><td rowspan=1 colspan=1>89.67</td><td rowspan=1 colspan=1>96.77</td><td rowspan=1 colspan=1>49.38</td><td rowspan=1 colspan=1>77.01</td><td rowspan=1 colspan=1>2851</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            825,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            339,
+            825,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            594,
+            302,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have observed that the proposed method converges to a a reasonably good solution faster than vanilla fine-tuning and eventually attains slightly better performance. This is despite the network’s expressive power, which is limited by our construction. We conjecture that constraining each layer to be expressed as a linear combination of the corresponding layer in the original network serves to regularize the space of solutions and is beneficial when the tasks are sufficiently related to each other. One could come up with simple examples where the proposed method would likely fail: if the required solutions to two tasks are disjoint. For example, one task requires counting of horizontal lines and the other requires counting of vertical ones, and such examples are all that appear in the training sets, then the proposed method will likely work far worse than vanilla fine-tuning or training from scratch. We leave the investigation of this issue, as well as finding ways between striking a balance between reusing features and learning new ones as future work. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            328,
+            866
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have presented a method for transfer learning thats adapts an existing network to new tasks while fully preserving the existing representation. Our method matches or outperforms vanilla finetuning, though requiring a fraction of the parameters, which when combined with net compression reaches $3 \\%$ of the original parameters with no loss of accuracy. The method converges quickly to high accuracy while being on par or outperforming other methods with the same goal. Built into our method is the ability to easily switch the representation between the various learned tasks, enabling a single network to perform seamlessly on various domains. The control parameter $\\alpha$ can be cast as a real-valued vector, allowing a smooth transition between representations of different tasks. An example of the effect of such a smooth transition can be seen in Fig. 2 (c) where $\\alpha$ is used to linearly interpolate between the representation of differently learned tasks, allowing one to smoothly control transitions between different behaviors. Allowing each added task to use a convex combination of already existing controllers will potentially utilize controllers more efficiently and decouple the number of controllers from the number of tasks. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/628d8a338301be0b83e68224cd7a2e731fb014ffcc25b044243f72f3a2c21f86.jpg",
+        "image_caption": [
+            "Figure 3: (a) Accuracy vs. learning method. Using only the last layer (feature extractor) performs worst. finetune: vanilla fine-tuning. Diagonal : our controller modules with a diagonal combination matrix. Linear: our full method. On average, our full method outperforms vanilla fine tuning. (b) Accuracy vs. quantization: with as low as 8 bits, we see no significant effect of network quantization on our method, showing they can be applied together. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            190,
+            779,
+            362
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/29448cb9c2c9e74e59c7ddafd34f4e7f5fcf82fc36a6d9f52eb551e4e3aee3e5.jpg",
+        "image_caption": [
+            "Figure 4: (a) Mean classification accuracy (normalized, averaged over datasets) w.r.t no. parameters. Our method achieve better performance over baselines for a large range of parameter budgets. For very few parameters diagonal (ours) outperforms features extraction. To obtain maximal accuracy our full method requires far fewer parameters (see linear vs finetune). (b) Our method (linear) converges to a high accuracy faster than fine-tuning. The weaker variant of our method converges as fast as feature-extraction but reaches an overall higher accuracy (3 (a)). (c) zoom in on top-right of (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            606,
+            843,
+            743
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            104,
+            825,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            285,
+            279
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H. Bilen and A. Vedaldi. Integrated perception with recurrent multi-task neural networks. In Proceedings of Advances in Neural Information Processing Systems (NIPS), 2016. 2 ",
+        "bbox": [
+            176,
+            287,
+            820,
+            316
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hakan Bilen and Andrea Vedaldi. Universal representations:The missing link between faces, text, planktons, and cat breeds, 2017. 2, 4.0.1 ",
+        "bbox": [
+            174,
+            325,
+            821,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi. Describing Textures in the Wild. CoRR, abs/1311.3618, 2013. 4.3 ",
+        "bbox": [
+            171,
+            363,
+            823,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert K Cowen, S Sponaugle, K Robinson, and J Luo. Planktonset 1.0: Plankton imagery data collected from fg walton smith in straits of florida from 2014–06-03 to 2014–06-06 and used in the 2015 national data science bowl (ncei accession 0127422). Oregon State University; Hatfield Marine Science Center, 2015. 4.0.1 ",
+        "bbox": [
+            178,
+            401,
+            823,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In Advances in Neural Information Processing Systems, pages 1269–1277, 2014. 2 ",
+        "bbox": [
+            171,
+            468,
+            821,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. DeCAF: A Deep Convolutional Activation Feature for Generic Visual Recognition. In Icml, volume 32, pages 647–655, 2014. 2 ",
+        "bbox": [
+            176,
+            520,
+            821,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multi-scale convolutional architecture. In Proceedings of the IEEE International Conference on Computer Vision, pages 2650–2658, 2015. 2 ",
+        "bbox": [
+            173,
+            571,
+            821,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mathias Eitz, James Hays, and Marc Alexa. How do humans sketch objects? ACM Trans. Graph., 31(4):44–1, 2012. 4.0.1 ",
+        "bbox": [
+            173,
+            625,
+            823,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3(4):128–135, 1999. 2 ",
+        "bbox": [
+            173,
+            662,
+            823,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 580–587, 2014. 1, 2 ",
+        "bbox": [
+            174,
+            700,
+            821,
+            744
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007. 4.0.1 ",
+        "bbox": [
+            171,
+            752,
+            813,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015a. 2, 4.4 ",
+        "bbox": [
+            173,
+            776,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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, pages 1135– 1143, 2015b. 2 ",
+        "bbox": [
+            173,
+            829,
+            823,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Awni Hannun, Carl Case, Jared Casper, Bryan Catanzaro, Greg Diamos, Erich Elsen, Ryan Prenger, Sanjeev Satheesh, Shubho Sengupta, Adam Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014. 1 ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephen Jose Hanson and Lorien Y Pratt. Comparing biases for minimal network construction with ´ back-propagation. In Proceedings of the 1st International Conference on Neural Information Processing Systems, pages 177–185. MIT Press, 1988. 2 ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016. 3 ",
+        "bbox": [
+            174,
+            156,
+            825,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask R-CNN. ´ arXiv preprint arXiv:1703.06870, 2017. 2 ",
+        "bbox": [
+            173,
+            209,
+            823,
+            238
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 4.0.1 ",
+        "bbox": [
+            173,
+            248,
+            823,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, page 201611835, 2017. 2 ",
+        "bbox": [
+            174,
+            287,
+            825,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. 4.0.1, 4.3 ",
+        "bbox": [
+            171,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pages 1097–1105, 2012. 1 ",
+        "bbox": [
+            174,
+            393,
+            825,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. 4.3 ",
+        "bbox": [
+            173,
+            446,
+            820,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhizhong Li and Derek Hoiem. Learning without Forgetting. CoRR, abs/1606.09282, 2016. 2, 3 ",
+        "bbox": [
+            173,
+            486,
+            807,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geert Litjens, Thijs Kooi, Babak Ehteshami Bejnordi, Arnaud Arindra Adiyoso Setio, Francesco Ciompi, Mohsen Ghafoorian, Jeroen AWM van der Laak, Bram van Ginneken, and Clara I Sanchez. A survey on deep learning in medical image analysis. ´ arXiv preprint arXiv:1702.05747, 2017. 1 ",
+        "bbox": [
+            174,
+            512,
+            825,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3431–3440, 2015. 1, 3 ",
+        "bbox": [
+            173,
+            578,
+            823,
+            622
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew Blaschko, and Andrea Vedaldi. Fine-grained visual classification of aircraft. arXiv preprint arXiv:1306.5151, 2013. 4.3 ",
+        "bbox": [
+            173,
+            632,
+            823,
+            661
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch Networks for Multi-task Learning. CoRR, abs/1604.03539, 2016. 2 ",
+        "bbox": [
+            173,
+            671,
+            823,
+            700
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. 4.0.1 ",
+        "bbox": [
+            173,
+            710,
+            825,
+            753
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stefan Munder and Dariu M Gavrila. An experimental study on pedestrian classification. IEEE transactions on pattern analysis and machine intelligence, 28(11):1863–1868, 2006. 4.0.1, 4.3 ",
+        "bbox": [
+            171,
+            763,
+            825,
+            792
+        ],
+        "page_idx": 11
+    },
+    {
+        "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, volume 2011, page 5, 2011. 4.0.1, 4.3 ",
+        "bbox": [
+            176,
+            803,
+            825,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Maria-Elena Nilsback and Andrew Zisserman. Automated Flower Classification over a Large Number of Classes. In ICVGIP, pages 722–729. IEEE, 2008. 4.3 ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. Learning multiple visual domains with residual adapters. arXiv preprint arXiv:1705.08045, 2017. 1, 2, 4.1, 4.1.1, 4.3, 3 ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. 4.1, 4.3 ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. 2 ",
+        "bbox": [
+            174,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. CNN features off-the-shelf: an astounding baseline for recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 806–813, 2014. 2 ",
+        "bbox": [
+            174,
+            207,
+            820,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. 1, 4, 4.0.1 ",
+        "bbox": [
+            176,
+            257,
+            820,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild, 2012. 4.3 ",
+        "bbox": [
+            174,
+            295,
+            821,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Johannes Stallkamp, Marc Schlipsing, Jan Salmen, and Christian Igel. Man vs. computer: Benchmarking machine learning algorithms for traffic sign recognition. Neural networks, 32:323–332, 2012. 4.0.1, 4.3 ",
+        "bbox": [
+            173,
+            333,
+            826,
+            376
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ashia C. Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The Marginal Value of Adaptive Gradient Methods in Machine Learning. CoRR, abs/1705.08292, 2017. 4.0.1 ",
+        "bbox": [
+            174,
+            385,
+            825,
+            428
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide Residual Networks. CoRR, abs/1605.07146, 2016. 4.3 ",
+        "bbox": [
+            173,
+            436,
+            823,
+            465
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jian Zhang, Ioannis Mitliagkas, and Christopher $\\mathrm { R } \\tilde { \\mathrm { A } } \\ @$ . Yellowfin and the art of momentum tuning. arXiv preprint arXiv:1706.03471, 2017. 4.3 ",
+        "bbox": [
+            173,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shizhan Zhu, Cheng Li, Chen Change Loy, and Xiaoou Tang. Face alignment by coarse-to-fine shape searching. In CVPR, pages 4998–5006. IEEE Computer Society, 2015. ISBN 978-1-4673- 6964-0. 2 ",
+        "bbox": [
+            174,
+            512,
+            825,
+            554
+        ],
+        "page_idx": 12
+    }
+]