Add files using upload-large-folder tool

parse/train/-_FVMKvxVCQo1/-_FVMKvxVCQo1.md

@@ -0,0 +1,359 @@
+# The return of ADABOOST.MH: multi-class Hamming trees
+
+# Balazs K ´ egl ´
+
+BALAZS.KEGL $@$ GMAIL.COM
+
+LAL/LRI, University of Paris-Sud, CNRS, 91898 Orsay, France
+
+# Abstract
+
+Within the framework of ADABOOST.MH, we propose to train vector-valued decision trees to optimize the multi-class edge without reducing the multi-class problem to $K$ binary one-againstall classifications. The key element of the method is a vector-valued decision stump, factorized into an input-independent vector of length $K$ and label-independent scalar classifier. At inner tree nodes, the label-dependent vector is discarded and the binary classifier can be used for partitioning the input space into two regions. The algorithm retains the conceptual elegance, power, and computational efficiency of binary ADABOOST. In experiments it is on par with support vector machines and with the best existing multi-class boosting algorithm AOSOLOGITBOOST, and it is significantly better than other known implementations of ADABOOST.MH.
+
+and Singer’s seminal paper (Schapire & Singer, 1999), which proposed, among other interesting extensions, ADABOOST.MH. The main idea of the this approach is to use vector-valued base classifiers to build a multi-class discriminant function of $K$ outputs (for $K$ -class classification). The weight vector, which plays a crucial role in binary ADABOOST, is replaced by a weight matrix over instances and labels. The simplest implementation of the concept is to use $K$ independent one-against-all classifiers in which base classifiers are only loosely connected through the common normalization of the weight matrix. This setup works well with single decision stumps, but in most of the practical problems, boosting stumps is suboptimal compared to boosting more complex base classifiers such as trees. Technically, it is possible to build $K$ one-against-all binary decision trees in each iteration, but this approach, for one reason or another, has not produced state-of-the-art results. As a consequence, several recent papers concentrate on replacing the boosting objective and the engine that optimizes this objective (Li, 2009a;b; Zhu et al., 2009; Sun et al., 2012; Mukherjee & Schapire, 2013).
+
+# 1. Introduction
+
+ADABOOST (Freund & Schapire, 1997) is one of the most influential supervised learning algorithms of the last twenty years. It has inspired learning theoretical developments and also provided a simple and easily interpretable modeling tool that proved to be successful in many applications (Caruana & Niculescu-Mizil, 2006). It is especially the method of choice when any-time solutions are required on large data sets, so it has been one of the most successful techniques in recent large-scale classification and ranking challenges (Dror et al., 2009; Chapelle et al., 2011).
+
+The original ADABOOST paper of Freund and Schapire (Freund & Schapire, 1997), besides defining binary ADABOOST, also described two multi-class extensions, ADABOOST.M1 and ADABOOST.M2. Both required a quite strong performance from the base learners, partly defeating the purpose of boosting, and saw limited practical success. The breakthrough came with Schapire
+
+The main misconception that comes back in several papers is that ADABOOST.MH has to train $K$ parallel oneagainst-all classifiers in each iteration. It turns out that the original setup is more general. For example, staying within the classical ADABOOST.MH framework, Kegl & ´ Busa-Fekete (2009) trained products of simple classifiers and obtained state-of-the-art results on several data sets. In this paper, we describe multi-class Hamming trees, another base learner that optimizes the multi-class edge without reducing the problem to $K$ binary classifications. The key idea is to factorize general vector-valued classifiers into an input-independent vector of length $K$ , and labelindependent scalar classifier. It turns out that optimizing such base classifiers using decision stumps as the scalar component is almost as simple as optimizing simple binary stumps on binary data. The technique can be intuitively understood as optimizing a binary cut and an output code at the same time. The main consequence of the setup is that now it is easy to build trees of these classifiers by simply discarding the label-dependent vector and using the binary classifier for partitioning the input space into two regions.
+
+The algorithm retains the conceptual elegance, power, and computational efficiency of binary ADABOOST. Algorithmically it cannot fail (the edge is always positive) and in practice it almost never overfits. Inheriting the flexibility of ADABOOST.MH, it can be applied directly (without any modification) to multi-label and multi-task classification. In experiments (carried out using an open source package of Benbouzid et al. (2012) for reproducibility) we found that ADABOOST.MH with Hamming trees performs on par with the best existing multiclass boosting algorithm AOSOLOGITBOOST (Sun et al., 2012) and with support vector machines (SVMs; Boser et al. 1992). It is also significantly better than other known implementations of ADABOOST.MH (Zhu et al., 2009; Mukherjee & Schapire, 2013).
+
+The paper is organized as follows. In Section 2 we give the formal multi-class setup used in the paper and ADABOOST.MH, and show how to train factorized base learners in general. The algorithm to build Hamming trees is described in Section 3. Experiments are described in Section 4 before a brief conclusion in Section 5.
+
+# 2. ADABOOST.MH
+
+In this section we first introduce the general multiclass learning setup (Section 2.1), then we describe ADABOOST.MH in detail (Section 2.2). We proceed by explaining the general requirements for base learning in ADABOOST.MH, and introduce the notion of the factorized vector-valued base learner (Section 2.3). Finally, we explain the general objective for factorized base learners and the algorithmic setup to optimize that objective. (Section 2.4).
+
+# 2.1. The multi-class setup: single-label and multi-label/multi-task
+
+For the formal description of ADABOOST.MH, let the training data be $\mathcal { D } \ = \ \big \{ ( \mathbf { x } _ { 1 } , \mathbf { y } _ { 1 } ) , \dotsc , ( \mathbf { x } _ { n } , \mathbf { y } _ { n } ) \big \} _ { . }$ , where $\mathbf { x } _ { i } \in \mathbb { R } ^ { d }$ are observation vectors, and $\mathbf { y } _ { i } \in \{ \pm 1 \} ^ { \mathrm { \tilde { K } } }$ are label vectors. Sometimes we will use the notion of an $n \times d$ observation matrix of $\mathbf { X } = \left( \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } \right)$ and an $n \times K$ label matrix $\mathbf { Y } = ( \mathbf { y } _ { 1 } , \ldots , \mathbf { y } _ { n } )$ instead of the set of pairs $\mathcal { D }$ .1 In multi-class classification, the single label $\ell ( \mathbf { x } )$ of the observation $\mathbf { x }$ comes from a finite set. Without loss of generality, we will suppose that $\ell \in \mathcal { L } = \{ 1 , \ldots , K \}$ . The label vector $\mathbf { y }$ is a one-hot representation of the correct class: the $\ell ( { \mathbf { x } } ) { \mathrm { t h } }$ element of $\mathbf { y }$ will be 1 and all the other elements will be $- 1$ . Besides expressing faithfully the architecture of a multi-class neural network or multi-class ADABOOST, this representation has the advantage to be generalizable to multi-label or multi-task learning when an observation x can belong to several classes. To avoid confusion, from now on we will call $\mathbf { y }$ and $\ell$ the label and the label index of x, respectively. For emphasizing the distinction between multi-class and multi-label classification, we will use the term single-label for the classical multi-class setup, and reserve multi-class to situations when we talk about the three setups in general.
+
+The goal of learning is to infer a vector-valued multi-class discriminant function f $: \mathcal { X }  \mathbb { R } ^ { K }$ . 2 The single-label output of the algorithm is then $\ell _ { \mathbf { f } } ( \mathbf { x } ) = \arg \operatorname* { m a x } _ { \ell } f _ { \ell } ( \mathbf { x } )$ . The classical measure of the performance of the multiclass discriminant function f is the single-label one-loss $L _ { \mathbb { I } } ( \mathbf { f } , ( \mathbf { x } , \boldsymbol { \ell } ) ) = \mathbb { I } \left\{ \boldsymbol { \ell } \neq \ell _ { \mathbf { f } } ( \mathbf { x } _ { i } ) \right\}$ , which defines the singlelabel training error
+
+$$
+{ \widehat { R } } _ { \mathbb { I } } ( \mathbf { f } ) = { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } \mathbb { I } \left\{ \ell ( \mathbf { x } _ { i } ) \neq \ell _ { \mathbf { f } } ( \mathbf { x } _ { i } ) \right\} . ^ { 3 }
+$$
+
+Another, perhaps more comprehensive, way to measure the perfloss $\mathbf { f }$   
+$L _ { \mathrm { H } } \big ( \mathbf { f } , ( \mathbf { x } , \mathbf { y } ) , \mathbf { w } \big ) ^ { * } \ = \ \dot { \sum _ { \ell = 1 } ^ { K } } \overline { { { w _ { \ell } } } } \mathbb { I } \left\{ \mathrm { s i g n } \big ( f _ { \ell } ( \mathbf { x } ) \big ) \neq y _ { \ell } \right\}$ where $\mathbf { w } = \left[ w _ { \ell } \right]$ is an $\mathbb { R } ^ { K }$ -valued “user-defined” weight vector over labels. The corresponding empirical risk (training error) is
+
+$$
+\widehat { R } _ { \mathrm { H } } ( \mathbf { f } , \mathbf { W } ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \sum _ { \ell = 1 } ^ { K } w _ { i , \ell } \mathbb { I } \left\{ \mathrm { s i g n } \big ( f _ { \ell } ( \mathbf { x } _ { i } ) \big ) \neq y _ { i , \ell } \right\} ,
+$$
+
+where $\mathbf { W } = \left[ w _ { i , \ell } \right]$ is an $n \times k$ weight matrix over data points and labels.
+
+In the multi-label/multi-task setup, when, for example, it is equally important to predict that a song is “folk” as predicting that it is sung by a woman, the Hamming loss with uniform weights $w _ { \ell } = 1 / K , \ \ell = 1 , \dots , K$ is a natural measure of performance: it represents the uniform error rate of missing any class sign $y _ { \ell }$ of a given observation $\mathbf { x }$ . In single-label classification, w is usually set asymmetrically to
+
+$$
+w _ { \ell } = { \left\{ \begin{array} { l l } { { \frac { 1 } { 2 } } } & { { \mathrm { ~ i f ~ } } \ell = \ell ( \mathbf { x } ) { \mathrm { ~ } } ( { \mathrm { i . e . , ~ i f ~ } } y _ { \ell } = 1 ) , } \\ { { \frac { 1 } { 2 ( K - 1 ) } } } & { { \mathrm { ~ o t h e r w i s e ~ } } ( { \mathrm { i . e . , ~ i f ~ } } y _ { \ell } = - 1 ) . } \end{array} \right. }
+$$
+
+The idea behind this scheme is that it will create $K$ wellbalanced one-against-all binary classification problems: if we start with a balanced single-label multi-class problem, that is, if each of the $K$ classes have $n / K$ examples in $\mathcal { D }$ , then for each class $\ell$ , the sum of the weights of the positive examples in the column $\mathbf { w } _ { \cdot , \ell }$ of the weight matrix W will be equal to the sum of the weights of the negative examples. Note that both schemes boil down to the classical uniform weighting in binary classification.
+
+# 2.2. ADABOOST.MH
+
+The goal of the ADABOOST.MH algorithm (Schapire & Singer 1999; Figure 1) is to return a vector-valued discriminant function $\bar { \bf f } ^ { ( T ) } : \mathbb { R } ^ { d }  \mathbb { R } ^ { K }$ with a small Hamming loss $\widehat { R } _ { \mathrm { H } } ( \mathbf { f } , \mathbf { W } )$ (2) by minimizing the weighted multi-class exponential margin-based error
+
+$$
+\widehat { R } _ { \mathrm { E X P } } \big ( \mathbf { f } ^ { ( T ) } , \mathbf { W } \big ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \sum _ { \ell = 1 } ^ { K } w _ { i , \ell } \exp \big ( { - f _ { \ell } ^ { ( T ) } ( \mathbf { x } _ { i } ) y _ { i , \ell } } \big ) .
+$$
+
+Since $\exp ( - \rho ) \geq \mathbb { I } \{ \rho < 0 \}$ , (4) upper bounds the Hamming loss final discr $\widehat { R } _ { \mathrm { H } } \big ( \mathbf { f } ^ { ( T ) } , \mathbf { W } \big )$ (2on $\begin{array} { r } { \mathbf { f } ^ { ( T ) } ( \mathbf { x } ) = \sum _ { t = 1 } ^ { T } \mathbf { h } ^ { ( t ) } ( \mathbf { x } ) } \end{array}$ s theas a sum of base classifiers $\mathbf { h } ^ { ( t ) } : \mathcal { X }  \mathbb { R } ^ { K }$ 1 returned by a base learner algorithm $\mathbf { B } \operatorname { A S E } \left( \mathbf { X } , \mathbf { Y } , \mathbf { W } ^ { ( t ) } \right)$ in each iteration $t$ .
+
+$$
+\boxed { \mathrm { A D A B O O S T . M H ( X , Y , W , B A S E ( \cdot , \cdot , \cdot ) , } T ) }
+$$
+
+$$
+\mathbf { W } ^ { ( 1 ) }  \frac { 1 } { n } \mathbf { W }
+$$
+
+$$
+\begin{array} { r l } & { \left( \boldsymbol { \alpha } ^ { ( t ) } , \mathbf { v } ^ { ( t ) } , \varphi ^ { ( t ) } ( \cdot ) \right) \gets \mathbf { B A S E } \big ( \mathbf { X } , \mathbf { Y } , \mathbf { W } ^ { ( t ) } \big ) } \\ & { \mathbf { h } ^ { ( t ) } ( \cdot ) \gets \boldsymbol { \alpha } ^ { ( t ) } \mathbf { v } ^ { ( t ) } \varphi ^ { ( t ) } ( \cdot ) } \end{array}
+$$
+
+$$
+w _ { i , \ell } ^ { ( t + 1 ) } \gets w _ { i , \ell } ^ { ( t ) } \frac { e ^ { - h _ { \ell } ^ { ( t ) } ( \mathbf { x } _ { i } ) y _ { i , \ell } } } { \displaystyle \sum _ { i ^ { \prime } = 1 } ^ { n } \sum _ { \ell ^ { \prime } = 1 } ^ { K } w _ { i ^ { \prime } , \ell ^ { \prime } } ^ { ( t ) } e ^ { - h _ { \ell ^ { \prime } } ^ { ( t ) } ( \mathbf { x } _ { i ^ { \prime } } ) y _ { i ^ { \prime } , \ell ^ { \prime } } } }
+$$
+
+# 2.3. Base learning for ADABOOST.MH
+
+The goal of multi-class base learning is to minimize the base objective
+
+$$
+Z ^ { ( t ) } = \operatorname* { m i n } _ { \mathbf { h } } Z \bigl ( \mathbf { h } , \mathbf { W } ^ { ( t ) } \bigr ) = \sum _ { i = 1 } ^ { n } \sum _ { \ell = 1 } ^ { K } w _ { i , \ell } ^ { ( t ) } e ^ { - h _ { \ell } ( \mathbf { x } _ { i } ) y _ { i , \ell } } .
+$$
+
+It is easy to show (Schapire & Singer, 1999) that i) the oneerror $\widetilde { R _ { \mathbb { I } } } ( \mathbf { f } ^ { ( T ) } )$ (1) is upper bounded by $\textstyle \prod _ { t = 1 } ^ { T } Z ^ { ( t ) }$ , and so ii) if the standard weak-learning condition ${ \hat { Z } } ^ { ( t ) } \leq 1 - \delta$ holds, $\widehat { R } _ { \mathbb { I } } ( \mathbf { f } )$ becomes zero in $T \sim O ( \log n )$ iterations.
+
+In general, any vector-valued multi-class learning algorithm can be used to minimize (5). Although this goal is clearly defined in (Schapire & Singer, 1999), efficient base learning algorithms have never been described in detail. In most recent papers (Zhu et al., 2009; Mukherjee & Schapire, 2013) where ADABOOST.MH is used as baseline, the base learner is a classical single-label decision tree which has to be grown rather large to satisfy the weaklearning condition, and, when boosted, yields suboptimal results (Section 4). The reason why methods for learning multi-class $\{ \pm 1 \} ^ { K }$ -valued base classifiers had not been developed before is because they have to be boosted: since they do not select a single label, they cannot be used as stand-alone multi-class classifiers.
+
+Although it is not described in detail, it seems that the base classifier used in the original paper of Schapire & Singer (1999) is a vector of $K$ independent decision stumps $\mathbf { h } ( \mathbf { x } ) \ = \ \left( h _ { 1 } ( \mathbf { x } ) , \ldots , h _ { K } ( \mathbf { x } ) \right)$ . These stumps cannot be used as node classifiers to grow decision trees since they do not define a single cut that depends only on the input (see Section 3 for a more detailed discussion). To overcome this problem, we propose base learning algorithms that factorize $\mathbf { h } ( \mathbf { x } )$ into
+
+$$
+\mathbf { h } ( \mathbf { x } ) = \alpha \mathbf { v } \varphi ( \mathbf { x } ) ,
+$$
+
+where $\alpha \in \mathbb { R } ^ { + }$ is a positive real valued base coefficient, $\mathbf { v }$ is an input-independent vote vector of length $K$ , and $\varphi ( \mathbf { x } )$ is a label-independent scalar classifier. In discrete ADABOOST.MH, both components are binary, that is, ${ \textbf { v } } \in$ $\{ \pm 1 \} ^ { K }$ and $\varphi ( \mathbf { x } ) : \mathbb { R } ^ { d }  \{ \pm 1 \}$ . The setup can be extended to real-valued classifiers $\varphi ( \mathbf { x } ) \ : \ \mathbb { R } ^ { d } \  \ \mathbb { R }$ , also known as confidence-rated classifiers, and it is also easy to make the vote vector $\mathbf { v }$ real-valued (in which case, without the loss of generality, $\alpha$ would be set to 1). Both variants are known under the name of real ADABOOST.MH. Although there might be slight differences in the practical performance of real and discrete ADABOOST.MH, here we decided to stick to the discrete case for the sake of simplicity.
+
+# 2.4. Casting the votes
+
+To start, we show how to set $\alpha$ and $\mathbf { v }$ in general if the scalar base classifier $\varphi$ is given. The intuitive semantics of (6) is the following. The binary classifier $\varphi ( \mathbf { x } )$ cuts the input space into a positive and a negative region. In binary classification this is the end of the story: we need $\varphi ( \mathbf { x } )$ to be well-correlated with the binary class labels $y$ . In multiclass classification it is possible that $\varphi ( \mathbf { x } )$ correlates with some of the class labels $y _ { \ell }$ and anti-correlates with others. This free choice is expressed by the binary “votes” $v _ { \ell } \in \{ \pm 1 \}$ . We say that $\varphi ( \mathbf { x } )$ votes for class $\ell$ if $v _ { \ell } = + 1$ and it votes against class $\ell$ if $v _ { \ell } = - 1$ . As in binary classification, $\alpha$ expresses the overall quality of the classifier $\mathbf { v } \varphi ( \mathbf { x } )$ : $\alpha$ is monotonically decreasing with respect to the weighted error of $\mathbf { v } \varphi ( \mathbf { x } )$ .
+
+The advantage of the setup is that, given the binary classifier $\varphi ( \mathbf { x } )$ , the optimal vote vector $\mathbf { v }$ and the coefficient $\alpha$ can be set in an efficient way. To see this, first let us define the weighted per-class error rate
+
+$$
+\mu _ { \ell - } = \sum _ { i = 1 } ^ { n } w _ { i , \ell } \mathbb { I } \left\{ \varphi ( \mathbf { x } _ { i } ) \neq y _ { i , \ell } \right\} ,
+$$
+
+and the weighted per-class correct classification rate
+
+$$
+\mu _ { \ell + } = \sum _ { i = 1 } ^ { n } w _ { i , \ell } \mathbb { I } \left\{ \varphi ( \mathbf { x } _ { i } ) = y _ { i , \ell } \right\}
+$$
+
+for each class $\ell = 1 , \ldots , K$ . With this notation, $Z ( \mathbf { h } , \mathbf { W } )$ simplifies to (see Appendix A)
+
+$$
+Z ( \mathbf { h } , \mathbf { W } ) = { \frac { e ^ { \alpha } + e ^ { - \alpha } } { 2 } } - { \frac { e ^ { \alpha } - e ^ { - \alpha } } { 2 } } \sum _ { \ell = 1 } ^ { K } v _ { \ell } { \big ( } \mu _ { \ell + } - \mu _ { \ell - } { \big ) } .
+$$
+
+The quantity
+
+$$
+\gamma _ { \ell } = v _ { \ell } \bigl ( \mu _ { \ell + } - \mu _ { \ell - } \bigr ) = \sum _ { i = 1 } ^ { n } w _ { i , \ell } v _ { \ell } \varphi ( \mathbf { x } _ { i } ) y _ { i , \ell }
+$$
+
+is called the classwise edge of $\mathbf { h } ( \mathbf { x } )$ . The full multi-class edge of the classifier is then
+
+$$
+\begin{array} { l } { { \displaystyle \gamma = \gamma ( \mathbf { v } , \varphi , \mathbf { W } ) = \sum _ { \ell = 1 } ^ { K } \gamma _ { \ell } = \sum _ { \ell = 1 } ^ { K } v _ { \ell } \big ( \mu _ { \ell + } - \mu _ { \ell - } \big ) } } \\ { { \displaystyle \ = \sum _ { i = 1 } ^ { n } \sum _ { \ell = 1 } ^ { K } w _ { i , \ell } v _ { \ell } \varphi ( \mathbf { x } _ { i } ) y _ { i , \ell } } . } \end{array}
+$$
+
+With this notation, the classical (Freund & Schapire, 1997) binary coefficient $\alpha$ is recovered: it is easy to see that (9) is minimized when
+
+$$
+\alpha = \frac { 1 } { 2 } \log \frac { 1 + \gamma } { 1 - \gamma } .
+$$
+
+With this optimal coefficient, (9) becomes $Z ( \mathbf { h } , \mathbf { W } ) \ =$ $\sqrt { 1 - \gamma ^ { 2 } }$ , so $Z ( \mathbf { h } , \mathbf { W } )$ is minimized when $\gamma$ is maximized. From (11) it then follows that $Z ( \mathbf { h } , \mathbf { W } )$ is minimized if $v _ { \ell }$ agrees with the sign of $\left( \mu _ { \ell + } - \mu _ { \ell - } \right)$ , that is,
+
+$$
+v _ { \ell } = { \left\{ \begin{array} { l l } { 1 } & { { \mathrm { ~ i f ~ } } \mu _ { \ell + } > \mu _ { \ell - } } \\ { - 1 } & { { \mathrm { ~ o t h e r w i s e } } } \end{array} \right. }
+$$
+
+for all classes $\ell = 1 , \ldots , K$
+
+The setup of factorized base classification (6) has another important consequence: the preservation of the weaklearning condition. Indeed, if $\varphi ( \mathbf { x } )$ is slightly better then a coin toss, $\gamma$ will be positive. Another way to look at it is to say that if a $( \varphi , \mathbf { v } )$ combination has a negative edge $\gamma < 0$ , then the edge of its complement (either $( - \varphi , \mathbf { v } )$ or $( \varphi , - \mathbf { v } ) )$ will be $- \gamma > 0$ . To understand the significance of this, consider a classical single-label base classifier $h \ : \ \mathcal { X } \ \to \ \mathcal { L } \ = \ \{ 1 , . . . , K \}$ , required by ADABOOST.M1. Now if $h ( \mathbf { x } )$ is slightly better than a coin toss, all one can hope for is an error rate slightly lower than $\textstyle { \frac { K - 1 } { K } }$ (which is equivalent to a. To achieve the error of edge slightly higher than(zero edge), required for $\textstyle { \frac { 2 - K } { K } } )$ $\frac { 1 } { 2 }$ continuing boosting, one has to come up with a base learner which is significantly better than a coin toss.
+
+There is a long line of research on output codes similar in spirit to our setup. The boosting engine in these works is usually slightly different from ADABOOST.MH since it attempts to optimize the multi-class hinge loss, but the factorization of the multi-class base classifier is similar to (6). Formally, the vote vector v in this framework is one column in an output code matrix. In the simplest setup this matrix is fixed beforehand by maximizing the error correcting capacity of the matrix (Dietterich & Bakiri, 1995; Allwein et al., 2001). A slightly better solution (Schapire, 1997; Guruswami & Sahai, 1999; Sun et al., 2005) is to wait until the given iteration to pick $\mathbf { v }$ by maximizing
+
+$$
+\mathbf { v } ^ { * } = \underset { \mathbf { v } } { \arg \operatorname* { m a x } } \sum _ { i = 1 } ^ { n } \sum _ { \ell = 1 } ^ { K } w _ { i , \ell } \mathbb { I } \left\{ v _ { \ell } \neq v _ { \ell ( \mathbf { x } _ { i } ) } \right\} ,
+$$
+
+and then to choose the optimal binary classifier $\varphi$ with this fixed vote (or code) vector $\mathbf { v } ^ { * }$ (although in practice it seems to be better to fix $\mathbf { v }$ to a random binary vector; Sun et al. 2005). The state of the art in this line of research is to iterate between optimizing $\varphi$ with a fixed $\mathbf { v }$ and then picking the best v with a fixed $\varphi$ (Li, 2006; Kegl & Busa-Fekete ´ , 2009; Gao & Koller, 2011).
+
+It turns out that if $\varphi$ is a decision stump, exhaustive search for both the best binary cut (threshold) and the best vote vector can be carried out using one single sweep in $\Theta ( n K )$ time. The algorithm is a simple extension of the classical binary decision stump learner; for the sake of completeness, we provide the pseudocode in Appendix B. The computational efficiency of this learning algorithm combined with the factorized form (6) of the classifier allows us to build multiclass Hamming trees in an efficient manner, circumventing the problem of global maximization of the edge with respect to $\varphi$ and $\mathbf { v }$ .
+
+# 3. Hamming trees
+
+Classification trees (Quinlan, 1986) have been widely used for multivariate classification since the 80s. They are especially efficient when used as base learners in ADABOOST (Caruana & Niculescu-Mizil, 2006; Quinlan, 1996). Their main disadvantage is their variance with respect to the training data, but when averaged over $T$ different runs, this problem largely disappears. The most commonly used tree learner is C4.5 of Quinlan (1993). Whereas this tree implementation is a perfect choice for binary ADABOOST, it is suboptimal for ADABOOST.MH since it outputs a single-label classifier with no guarantee of a positive multi-class edge (11). Although this problem can be solved in practice by building large trees, it seems that using these large single-class trees is suboptimal (Section 4).
+
+The main technical difficulty of building trees out of generic $\{ \pm 1 \} ^ { K }$ -valued multi-class classifiers $\mathbf { h } ( \mathbf { x } )$ is that they do not necessarily implement a binary cut ${ \bf x } \mapsto \{ \pm 1 \}$ , and partitioning the data into all the possibly $2 ^ { K }$ children at a tree node leads to rapid overfitting. Factorizing the multiclass classifier $\mathbf { h } ( \mathbf { x } )$ into an input-independent vote vector $\mathbf { v }$ and a label-independent binary classifier $\varphi ( x )$ as in (6) solves this problem. Base classifiers are trained as usual at each new tree leaf. In case this leaf remains a leaf, the full classifier $\mathbf { h } ( \mathbf { x } )$ is used for instances $\mathbf { x }$ that arrive to this leaf. If it becomes an inner node, the vote vector $\mathbf { v }$ is discarded, and the partitioning of the data set is based on solely the binary classifier $\varphi ( x )$ . An advantage of this formalization is that we can use any multi-class base classifier of the form (6) for the tree cuts, so the Hamming tree algorithm can be considered as a “meta learner” which can be used on the top of any factorized base learner.
+
+Formally, a binary classification tree with $N$ inner nodes $( N + 1$ leaves) consists of a list of $N$ base classifiers $\pmb { 5 } = ( \mathbf { h } _ { 1 } , \ldots , \mathbf { h } _ { N } )$ of the form $\mathbf { h } _ { j } ( \mathbf { x } ) = \alpha _ { j } \mathbf { v } _ { j } \varphi _ { j } ( \mathbf { x } )$ and two index lists ${ \sf I } = \left( { \sf I } _ { 1 } , \ldots , { \sf I } _ { N } \right)$ and ${ \mathfrak { r } } = ( \mathfrak { r } _ { 1 } , \ldots , \mathfrak { r } _ { N } )$ with $\mathfrak { l } , \mathfrak { r } \in \mathsf { \Gamma } ( \mathbb { N } \cup \{ \mathrm { N U L L } \} ) ^ { N }$ . $\mathfrak { l } _ { j }$ and $\mathfrak { r } _ { j }$ represent the indices of the left and right children of the $j$ th node of the tree, respectively. The node classifier in the $j$ th node is defined
+
+recursively as
+
+$$
+\mathfrak { h } _ { j } ( \mathbf { x } ) = \left\{ \begin{array} { l l } { - \mathbf { v } _ { j } } & { \mathrm { i f } \varphi _ { j } ( \mathbf { x } ) = - 1 \wedge \mathrm { I } _ { j } = \mathrm { N U L } } \\ & { \mathrm { ( l e f t ~ l e f ) } , } \\ { \mathbf { v } _ { j } } & { \mathrm { i f } \varphi _ { j } ( \mathbf { x } ) = + 1 \wedge \mathbf { r } _ { j } = \mathrm { N U L } } \\ & { \mathrm { ( r i g h t ~ l e a f ) } , } \\ { \mathfrak { h } _ { \mathrm { I } _ { j } } ( \mathbf { x } ) } & { \mathrm { i f } \varphi _ { j } ( \mathbf { x } ) = - 1 \wedge \mathrm { I } _ { j } \neq \mathrm { N U L } } \\ & { \mathrm { ( l e f t ~ i n e r n o d e ) } , } \\ { \mathfrak { h } _ { \mathrm { r } _ { j } } ( \mathbf { x } ) } & { \mathrm { i f } \varphi _ { j } ( \mathbf { x } ) = + 1 \wedge \mathbf { r } _ { j } \neq \mathrm { N U L } } \\ & { \mathrm { ( r i g h t ~ i n e r n o d e ) } . } \end{array} \right.
+$$
+
+The final tree classifier $\mathbf { h } _ { \mathfrak { H } , \mathfrak { t } , \mathfrak { r } } ( \mathbf { x } ) = \alpha \mathfrak { h } _ { 1 } ( \mathbf { x } )$ itself is not a factorized classifier (6).4 In particular, $\mathbf { h } _ { \mathcal { S } , \mathfrak { l } , \mathfrak { r } } ( \mathbf { x } )$ uses the local vote vectors $\mathbf { v } _ { j }$ determined by each leaf instead of a global vote vector. On the other hand, the coefficient $\alpha$ is unique, and it is determined in the standard way
+
+$$
+\alpha = \frac { 1 } { 2 } \log \frac { 1 + \gamma ( \mathfrak { h } _ { 1 } , \mathbf { W } ) } { 1 - \gamma ( \mathfrak { h } _ { 1 } , \mathbf { W } ) }
+$$
+
+based on the edge of the tree classifier ${ \mathfrak { h } } _ { 1 }$ . The local coefficients $\alpha _ { j }$ returned by the base learners are discarded (along with the vote vectors in the inner nodes).
+
+Finding the optimal $N$ -inner-node tree is a difficult combinatorial problem. Most tree-building algorithms are therefore sub-optimal by construction. For ADABOOST this is not a problem: we can continue boosting as long as the edge is positive. Classification trees are usually built in a greedy manner: at each stage we try to cut all the current leaves $j$ by calling the base learner of the data points reaching the $j$ th leaf, then select the best node to cut, convert the old leaf into an inner node, and add two new leaves. The difference between the different algorithms is in the way the best node is selected. Usually, we select the node that improves a gain function the most. In ADABOOST.MH the natural gain is the edge (11) of the base classifier. Since the data set $( \mathbf { X } , \mathbf { Y } )$ is different at each node, we include it explicitly in the argument of the full multi-class edge
+
+$$
+\gamma ( \mathbf { v } , \varphi , \mathbf { X } , \mathbf { Y } , \mathbf { W } ) = \sum _ { i = 1 } ^ { n } \sum _ { \ell = 1 } ^ { K } \mathbb { I } \left\{ x _ { i } \in \mathbf { X } \right\} w _ { i , \ell } v _ { \ell } \varphi ( \mathbf { x } _ { i } ) y _ { i , \ell } .
+$$
+
+Note that in this definition we do not require that the weights of the selected points add up to 1. Also note that this gain function is additive on subsets of the original data set, so the local edges in the leaves add up to the edge of the full tree. This means that any improvement in the local edge directly translates to an improvement of the tree edge. This is a crucial property: it assures that the edge of the tree is always positive as long as the local edges in the inner nodes are positive, so any weak binary classifier $\phi ( \mathbf { x } )$ can be used to define the inner cuts and the leaves.
+
+The basic operation when adding a tree node with a scalar binary classifier (cut) $\varphi$ is to separate the data matrices $\mathbf { X }$ , $\mathbf { Y }$ , and W according to the sign of classification $\varphi ( \mathbf { x } _ { i } )$ for all $\mathbf { x } _ { i } \in \mathbf { X }$ . The pseudocode is straightforward, but for the sake of completeness, we include it in the supplementary (Appendix C, Figure 5).
+
+Building a tree is usually described in a recursive way but we find the iterative procedure easier to explain, so our pseudocode in Figure 2 contains this version. The main idea is to maintain a priority queue, a data structure that allows inserting objects with numerical keys into a set, and extracting the object with the maximum key (Cormen et al., 2009). The key will represent the improvement of the edge when cutting a leaf. We first call the base learner on the full data set (line 1) and insert it into the priority queue with its edge $\gamma ( \mathbf { v } , \varphi , \mathbf { X } , \mathbf { Y } , \mathbf { W } )$ (line 3) as the key. Then in each iteration, we extract the leaf that would provide the best edge improvement among all the leaves in the priority queue (line 7), we partition the data set (line 11), call the base learners on the two new leaves (line 12), and insert them into the priority queue using the difference between the old edge on the partitioned data sets and the new edges of the base classifiers in the two new leaves (line 13). When inserting a leaf into the queue, we also save the sign of the cut (left or right child) and the index of the parent, so the index vectors l and $\mathfrak { r }$ can be set properly in line 8.
+
+When the priority queue is implemented as a heap, both the insertion and the extraction of the maximum takes ${ \cal O } ( \log N )$ time (Cormen et al., 2009), so the total running time of the procedure is $O \big ( N ( T _ { \mathrm { B a s E } } + n + \log N ) \big )$ , where $T _ { \mathrm { B A S E } }$ is the running time of the base learner. Since $N$ cannot be more than $n$ , the running time is $O \big ( N ( T _ { \mathrm { B a S E } } + n ) \big )$ . If the base learners cutting the leaves are decision stumps, the total running time is $O ( n K d N )$ . In the procedure we have no explicit control over the shape of the tree, but if it happens to be balanced, the running time can further be improved to $O ( n K d \log N )$ .
+
+# 4. Experiments
+
+Full reproducibility was one of the key motivations when we designed our experimental setup. All experiments were done using the open source multiboost software of Benbouzid et al. (2012), version 1.2. In addition, we will make public all the configuration files, train/test/validation cuts, and the scripts that we used to set up the hyperparameter validation.
+
+We carried out experiments on five mid-sized (isolet, letter, optdigits, pendigits, and USPS) and nine small (balance, blood, wdbc, breast, ecoli, iris, pima, sonar, and wine) data sets from the UCI repository. The five sets were chosen to overlap with the selections of most of the recent multi-class boosting papers (Kegl & ´ Busa-Fekete, 2009; Li, 2009a;b; Zhu et al., 2009; Sun et al., 2012; Mukherjee & Schapire, 2013), The small data sets were selected for comparing ADABOOST.MH with SVMs using Gaussian kernels, taking the results of a recent paper (Duch et al., 2012) whose experimental setup we adopted. All numerical results (multi-class test errors $\widehat { R } _ { \mathbb { I } } ( \mathbf { f } )$ (1) and test learning curves) are available at https://www.lri.fr/˜kegl/research/ multiboostResults.pdf, one experiment per page for clarity. Tables 1 and 2 contain summaries of the results.
+
+Table 2. Test error percentages on small benchmark data sets.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>AB.MH</td><td rowspan=1 colspan=1>SVM</td></tr><tr><td rowspan=1 colspan=1>balance</td><td rowspan=1 colspan=1>6.0±4.0</td><td rowspan=1 colspan=1>10.0±2.0</td></tr><tr><td rowspan=1 colspan=1>blood</td><td rowspan=1 colspan=1>22.0±4.0</td><td rowspan=1 colspan=1>21.0± 5.0</td></tr><tr><td rowspan=1 colspan=1>wdbc</td><td rowspan=1 colspan=1>3.0± 2.0</td><td rowspan=1 colspan=1>2.0±3.0</td></tr><tr><td rowspan=1 colspan=1>breast</td><td rowspan=1 colspan=1>34.0 ±13.0</td><td rowspan=1 colspan=1>37.0±8.0</td></tr><tr><td rowspan=1 colspan=1>ecoli</td><td rowspan=1 colspan=1>15.0±6.0</td><td rowspan=1 colspan=1>16.0±6.0</td></tr><tr><td rowspan=1 colspan=1>iris</td><td rowspan=1 colspan=1>7.0±6.0</td><td rowspan=1 colspan=1>5.0±6.0</td></tr><tr><td rowspan=1 colspan=1>pima</td><td rowspan=1 colspan=1>24.0±5.0</td><td rowspan=1 colspan=1>24.0±4.0</td></tr><tr><td rowspan=1 colspan=1>sonar</td><td rowspan=1 colspan=1>13.0±10.0</td><td rowspan=1 colspan=1>14.0±8.0</td></tr><tr><td rowspan=1 colspan=1>wine</td><td rowspan=1 colspan=1>2.0±3.0</td><td rowspan=1 colspan=1>3.0±4.0</td></tr></table>
+
+Hyperparameter optimization is largely swept under the rug in papers describing alternative multi-class boosting methods. Some report results with fixed hyperparameters (Zhu et al., 2009; Sun et al., 2012) and others give the full table of test errors for a grid of hyperparameters (Kegl & Busa- ´ Fekete, 2009; Li, ${ 2 0 0 9 \mathrm { a } ; \mathrm { b } }$ ; Mukherjee & Schapire, 2013). Although the following procedure is rather old, we feel the need to detail it for promoting a more scrupulous comparison across papers.
+
+For the small data sets we ran $1 0 \times 1 0$ cross-validation (CV) to optimize the hyperparameters and the estimate the generalization error. For the number of inner nodes we do a grid search (we also considered using the “one sigma” rule for biasing the selection towards smaller trees, but the simple minimization proved to be better). For robustly estimating the optimal stopping time we use a smoothed test error. For the formal description, let $\widehat { R } ^ { ( t ) }$ be the average test error (1) of the ten validation runs after $t$ iterations. We run ADABOOST.MH for $T _ { \mathrm { m a x } }$ iterations, and compute the optimal stopping time using the minimum of the smoothed test error using a linearly growing sliding window, that is,
+
+$$
+T ^ { * } = \operatorname * { a r g m i n } _ { T : T _ { \mathrm { m i n } } < T \leq T _ { \mathrm { m a x } } } \frac { 1 } { T - \lfloor 0 . 8 T \rfloor } \sum _ { t = \lfloor 0 . 8 T \rfloor } ^ { T } \widehat { R } ^ { ( t ) } ,
+$$
+
+where $T _ { \mathrm { m i n } }$ was set to a constant 50 to avoid stopping too early due to fluctuations. For selecting the best number of inner nodes $N$ , we simply minimized the smoothed test
+
+1 $( \alpha , \mathbf { v } , \varphi ( \cdot ) ) \gets \mathrm { B A S E } ( \mathbf { X } , \mathbf { Y } , \mathbf { W } )$ 2 S ← PRIORITYQUEUE $\triangleright O ( \log N )$ insertion and extraction of maximum key   
+3 $\begin{array} { r l } & { \mathrm { I N S E R T } \left( S , \left( \mathbf { v } , \varphi ( \cdot ) , \mathbf { X } , \mathbf { Y } , \mathrm { N U L L } , 0 \right) , \gamma ( \mathbf { v } , \varphi , \mathbf { X } , \mathbf { Y } , \mathbf { W } ) \right) \quad \textrm { \textrm { s } } k e y = e d g e \gamma } \\ & { \textit { \textbf { c } } , } \end{array}$   
+4 H ← () . initialize classifier list   
+5 for $j  1$ to $N$   
+6 $[ \boldsymbol { \mathbf { \rho } } _ { j } \gets \boldsymbol { \mathbf { \tau } } _ { j } \gets \mathrm { N U L L }$ . initialize child indices   
+7 $( \mathbf { v } _ { j } , \varphi _ { j } ( \cdot ) , \mathbf { X } _ { j } , \mathbf { Y } _ { j } , \bullet , j _ { \mathrm { p } } )  \mathrm { E X T R A C T M A X } ( S )$ . best node in the priority queue   
+8 if $\bullet = -$ then ${ \mathfrak { l } } _ { j _ { \mathrm { p } } } \gets j$ else if ${ \bullet } = +$ then ${ \mathfrak { r } } _ { j _ { \mathrm { p } } } \gets j$ . child index of parent   
+9 $\begin{array} { r l } { \mathfrak { H }  \mathrm { A P P E N D } \big ( \mathfrak { H } , \mathbf { v } _ { j } \varphi _ { j } ( \cdot ) \big ) } & { { } \triangleright a d d i n g \mathbf { h } _ { j } ( \cdot ) = \mathbf { v } _ { j } \varphi _ { j } ( \cdot ) t o \tilde { \mathfrak { H } } } \end{array}$   
+10 $( \mathbf { X } _ { - } , \mathbf { Y } _ { - } , \mathbf { W } _ { - } , \mathbf { X } _ { + } , \mathbf { Y } _ { + } , \mathbf { W } _ { + } ) \xleftarrow - \mathrm { C U T D A T A S E T } \big ( \mathbf { X } _ { j } , \mathbf { Y } _ { j } , \mathbf { W } , \varphi _ { j } ( \cdot ) \big )$   
+11 f $\mathbf { \dot { o } r } \bullet \in \{ - , + \}$ . insert children into priority queue   
+12 $( \alpha _ { \bullet } , \mathbf { v _ { \bullet } } , \varphi _ { \bullet } ( \cdot ) )  \mathrm { B A S E } ( \mathbf { X _ { \bullet } } , \mathbf { Y _ { \bullet } } , \mathbf { W _ { \bullet } } )$   
+13 $\mathrm { I N S E R T } \big ( S , \big ( \mathbf { v _ { * } } , \varphi _ { \bullet } ( \cdot ) , \mathbf { X _ { \bullet } } , \mathbf { Y _ { \bullet } } , \bullet , j \big ) , \gamma ( \mathbf { v _ { * } } , \varphi _ { \bullet } , \mathbf { X _ { \bullet } } , \mathbf { Y _ { \bullet } } , \mathbf { W _ { \bullet } } ) - \gamma ( \mathbf { v } _ { j } , \varphi _ { j } , \mathbf { X _ { \bullet } } , \mathbf { Y _ { \bullet } } , \mathbf { W _ { \bullet } } ) \big )$ . key = edge improvement over parent edge 1 1 + γ(h1, W)   
+14 α = 2 log 1 − γ(h1, W) . standard coefficient of the full tree classifier ${ \mathfrak { h } } _ { 1 }$ (14) 2   
+15 return α, H, l, r

+
+Figure 2. The pseudocode of the Hamming tree base learner. $N$ is the number of inner nodes. The algorithm returns a list of base classifiers ${ \mathfrak H }$ , two index lists l and $\mathfrak { r }$ , and the base coefficient $\alpha$ . The tree classifier is then defined by (14).   
+Table 1. Test error percentages on mid-sized benchmark data sets.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>isolet</td><td rowspan=1 colspan=1>letter</td><td rowspan=1 colspan=1>optdigits</td><td rowspan=1 colspan=1>pendigits</td><td rowspan=1 colspan=1>USPS</td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MH w Hamming trees</td><td rowspan=1 colspan=1>3.5±0.5</td><td rowspan=1 colspan=1>2.1±0.2</td><td rowspan=1 colspan=1>2.0±0.3</td><td rowspan=1 colspan=1>2.1±0.3</td><td rowspan=1 colspan=1>4.5±0.5</td></tr><tr><td rowspan=1 colspan=1> ADABoosT.MH w Hamming prod. (Kégl &amp; Busa-Fekete, 2009)</td><td rowspan=1 colspan=1>4.2±0.5</td><td rowspan=1 colspan=1>2.5±0.2</td><td rowspan=1 colspan=1>2.1 ± 0.4</td><td rowspan=1 colspan=1>2.1±0.2</td><td rowspan=1 colspan=1>4.4±0.5</td></tr><tr><td rowspan=1 colspan=1>AOSOLOGITBoOST J= 20,v = 0.1 (Sun et al.,2012)</td><td rowspan=1 colspan=1>3.5 ± 0.5</td><td rowspan=1 colspan=1>2.3±0.2</td><td rowspan=1 colspan=1>2.1 ± 0.3</td><td rowspan=1 colspan=1>2.4± 0.3</td><td rowspan=1 colspan=1>4.9±0.5</td></tr><tr><td rowspan=1 colspan=1>ABCLOGITB0OSTJ= 20,v= 0.1 (Li,2009b)</td><td rowspan=1 colspan=1>4.2±0.5</td><td rowspan=1 colspan=1>2.2±0.2</td><td rowspan=1 colspan=1>3.1± 0.4</td><td rowspan=1 colspan=1>2.9±0.3</td><td rowspan=1 colspan=1>4.9±0.5</td></tr><tr><td rowspan=1 colspan=1>ABCMARTJ= 20,v=0.1(Li,2009a)</td><td rowspan=1 colspan=1>5.0±0.6</td><td rowspan=1 colspan=1>2.5±0.2</td><td rowspan=1 colspan=1>2.6±0.4</td><td rowspan=1 colspan=1>3.0± 0.3</td><td rowspan=1 colspan=1>5.2±0.5</td></tr><tr><td rowspan=1 colspan=1>LOGITB0OST J= 20,v = 0.1 (Li,2009b)</td><td rowspan=1 colspan=1>4.7± 0.5</td><td rowspan=1 colspan=1>2.8±0.3</td><td rowspan=1 colspan=1>3.6±0.4</td><td rowspan=1 colspan=1>3.1± 0.3</td><td rowspan=1 colspan=1>5.8±0.5</td></tr><tr><td rowspan=1 colspan=1>SAMME w single-label trees (Zhu etal., 2009)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.3±0.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.5 ± 0.3</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MH w single-label trees (Zhu et al., 2009)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.6± 0.3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.8±0.3</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MM (Mukherjee &amp; Schapire,2013)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.5± 0.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.7 ± 0.3</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MH w single-label trees (Mukherjee &amp; Schapire,2013)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9.0±0.5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>7.0± 0.4</td><td rowspan=1 colspan=1></td></tr></table>
+
+error over a predefined grid
+
+$$
+N ^ { * } = \operatorname* { m i n } _ { N \in \mathcal { N } } \widehat { R } ^ { ( T _ { N } ^ { * } ) } ( N )
+$$
+
+where $T _ { N } ^ { * }$ and $\widehat { R } ^ { ( t ) } ( N )$ are the optimal stopping time (15) and the test error, respectively, in the run with $N$ inner nodes, and $\mathcal { N }$ is the set of inner nodes participating in the grid search. Then we re-run ADABOOST.MH on the joined training/validation set using the selected hyperparameters $N ^ { * }$ and $T _ { N ^ { * } } ^ { * }$ . The error $\widetilde { R _ { i } }$ in the ith training/test fold is then computed on the held-out test set. In the tables we report the mean error and the standard deviation. On the medium-size data sets we ran $1 \times 5$ CV (using the designated test sets where available) following the same procedure. In this case the report the binomial standard deviation $\sqrt { \widehat { R } ( 1 - \widehat { R } ) / n }$ . Further details and the description and explanation of some slight variations of this experimental setup are available at https://www.lri.fr/˜kegl/ research/multiboostResults.pdf.
+
+On the small data sets, Duch et al. (2012) used the exact same protocol, so, although the folds are not the same, the results are directly comparable. The error bars represent the standard deviation of the test errors over the ten test folds not divided by $\sqrt { 1 0 }$ , contrary to common practice, since the training set of the folds are highly correlated. The large error bars are the consequence of the small size and the noisiness of these sets. They make it difficult to establish any significant trends. We can safely state that ADABOOST.MH is on par with SVM (it is certainly not worse, “winning” on six of the nine sets), widely considered one of the the best classification methods for small data sets.
+
+Even though on the mid-sized data sets there are dedicated test sets used by most of the experimenters, comparing ADABOOST.MH to alternative multi-class boosting techniques is somewhat more difficult since none of the papers do proper hyperparameter tuning. Most of the papers report results with a table of errors given for a set of hyperparameter choices, without specifying which hyperparameter choice would be picked by proper validation. For methods that are non-competitive with ADABOOST.MH (SAMME of Zhu et al. (2009) and ADABOOST.MM of Mukherjee & Schapire (2013)) we report the post-validated best error which may be significantly lower than the error corresponding to the hyperparameter choice selected by proper validation. For methods where this choice would unfairly bias the comparison (AOSOLOGITBOOST (Sun et al., 2012), ABCLOGITBOOST, LOGITBOOST, and ABCMART (Li, 2009a;b)), we chose the best overall hyperparameter $\textit { J } = \ 2 0$ and $\nu ~ = ~ 0 . 1$ , suggested by the Li $( 2 0 0 9 \mathrm { a } ; \mathrm { b } )$ . At https://www.lri.fr/˜kegl/ research/multiboostResults.pdf (but not in Table 1) we give both errors for some of the methods. Proper hyperparameter-validation should put the correct test error estimates between those two limits. Since ADABOOST.MH with decision products (Kegl & Busa- ´ Fekete, 2009) is also implemented in multiboost (Benbouzid et al., 2012), for this method we re-ran experiments with the protocol described above.
+
+The overall conclusion is that AOSOLOGITBOOST (Sun et al., 2012) and ADABOOST.MH with Hamming trees are the best algorithms (ADABOOST.MH winning on all the five data sets but within one standard deviation). ADABOOST.MH with decision products (Kegl & Busa- ´ Fekete, 2009) and ABCLOGITBOOST are slightly weaker, as also noted by (Sun et al., 2012). SAMME (Zhu et al., 2009) and ADABOOST.MM (Mukherjee & Schapire, 2013) perform below the rest of the methods on the two data sets shared among all the papers (even though we give post-validated results). Another important conclusion is that ADABOOST.MH with Hamming trees is significantly better then other implementations of ADABOOST.MH in (Zhu et al., 2009; Mukherjee & Schapire, 2013), assumably implemented using single-label trees (the errors reported by Mukherjee & Schapire (2013) are especially conspicuous).
+
+ADABOOST.MH with Hamming trees also achieves good results on image recognition problems. On MNIST, boosting trees of stumps over pixels with eight inner nodes and about 50000 iterations has a test error of $1 . 2 5 \%$ , making it one of the best no-domain-knowledge “shallow” classifiers. Using stumps over Haar filters (Viola & Jones, 2004), boosted trees with four inner nodes and 10000 iterations achieves a test error of $0 . 8 5 \%$ , comparable to classical convolutional nets (LeCun et al., 1998).
+
+ADABOOST.MH with Hamming trees, usually combined with calibration (Platt, 2000; Niculescu-Mizil & Caruana, 2005) and model averaging, has been also successful in recent data challenges. On the Kaggle emotions data challenge, although not competitive with deep learning techniques, out-of-the-box ADABOOST.MH with Hamming trees over Haar filters finished 17th place with a test error of $5 7 \%$ . In the Yahoo! Learning-to-Rank Challenge (Chapelle et al., 2011) it achieved top ten performances with results not significantly different from the winning scores. Finally, in the recent INTERSPEECH Challenge it won the Emotion sub-challenge and it was runner up in the Social Signals sub-challenge.
+
+# 5. Conclusion
+
+In this paper we introduced Hamming trees that optimize the multi-class edge prescribed by ADABOOST.MH without reducing the multi-class problem to $K$ binary oneagainst-all classifications. We showed that without this restriction, often considered mandatory, ADABOOST.MH is one of the best off-the-shelf multi-class classification algorithms. The algorithm retains the conceptual elegance, power, and computational efficiency of binary ADABOOST.
+
+Using decision stumps at the inner nodes and at the leaves of the tree is a natural choice due to the efficiency of the learning algorithm, nevertheless, the general setup described in this paper allows for using any binary classifier. One of the avenues investigated for future work is to try stronger classifiers, such as SVMs, as binary cuts. The formal setup described in Section 2.1 does not restrict the algorithm to single-label problems; another direction for future work is to benchmark it on standard multi-label and sequence-to-sequence classification problems (Dietterich et al., 2008).
+
+# References
+
+Allwein, E. L., Schapire, R. E., and Singer, Y. Reducing multiclass to binary: a unifying approach for margin classifiers. Journal of Machine Learning Research, 1: 113–141, 2001.   
+Benbouzid, D., Busa-Fekete, R., Casagrande, N., Collin, F.-D., and Kegl, B. MultiBoost: a multi-purpose boost- ´ ing package. Journal of Machine Learning Research, 13: 549–553, 2012.   
+Boser, B., Guyon, I., and Vapnik, V. A training algorithm for optimal margin classifiers. In Fifth Annual Workshop on Computational Learning Theory, pp. 144–152, 1992.   
+Caruana, R. and Niculescu-Mizil, A. An empirical comparison of supervised learning algorithms. In Proceedings
+
+of the 23rd International Conference on Machine Learning, pp. 161–168, 2006.
+
+Chapelle, O., Chang, Y., and Liu, T.Y. (eds.). Yahoo! Learning-to-Rank Challenge, volume 14 of JMLR W&CP, 2011.
+
+Cormen, T., Leiserson, C., and Rivest, R. Introduction to Algorithms. MIT Press, 2009.
+
+Dietterich, T. G. and Bakiri, G. Solving multiclass learning problems via error-correcting output codes. Journal of Artificial Intelligence Research, 2:263–286, 1995.
+
+Dietterich, T. G., Hao, Guohua, and Ashenfelter, A. Gradient tree boosting for training conditional random fields. Journal of Machine Learning Research, 9:2113–2139, 2008.
+
+Dror, G., Boulle, M., Guyon, I., Lemaire, V., and Vogel, D. ´ (eds.). Proceedings of KDD-Cup 2009 competition, volume 7 of JMLR Workshop and Conference Proceedings, 2009.
+
+Duch, W., Jankowski, N., and Maszczyk, T. Make it cheap: Learning with $O ( n d )$ complexity. In International Joint Conference on Neural Networks (IJCNN), pp. 1–4, 2012.
+
+Freund, Y. and Schapire, R. E. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of Computer and System Sciences, 55:119– 139, 1997.
+
+Gao, T. and Koller, D. Multiclass boosting with hinge loss based on output coding. In International Conference on Machine Learning, 2011.
+
+Guruswami, V. and Sahai, A. Multiclass learning, boosting, and error-correcting codes. In Conference on Computational Learning Theory, 1999.
+
+Kegl, B. and Busa-Fekete, R. Boosting products of base ´ classifiers. In International Conference on Machine Learning, volume 26, pp. 497–504, Montreal, Canada, 2009.
+
+LeCun, Y., Bottou, L., Bengio, Y., and Haffner, P. Gradientbased learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Li, Ling. Multiclass boosting with repartitioning. In International Conference on Machine Learning, 2006.
+
+Li, P. ABC-Boost: Adaptive base class boost for multiclass classification. In International Conference on Machine Learning, 2009a.
+
+Li, P. ABC-LogitBoost for multi-class classification. Technical Report arXiv:0908.4144, Arxiv preprint, 2009b.
+
+Mukherjee, I. and Schapire, R. E. A theory of multiclass boosting. Journal of Machine Learning Research, 14: 437–497, 2013.
+
+Niculescu-Mizil, A. and Caruana, R. Obtaining calibrated probabilities from boosting. In Proceedings of the 21st International Conference on Uncertainty in Artificial Intelligence, pp. 413–420, 2005.
+
+Platt, J. Probabilistic outputs for support vector machines and comparison to regularized likelihood methods. In Smola, A.J., Bartlett, P., Schoelkopf, B., and Schuurmans, D. (eds.), Advances in Large Margin Classifiers, pp. 61–74. MIT Press, 2000.
+
+Quinlan, J. Induction of decision trees. Machine Learning, 1(1):81–106, 1986.
+
+Quinlan, J. C4.5: Programs for Machine Learning. Morgan Kaufmann, 1993.
+
+Quinlan, J. Bagging, boosting and C4.5. In Proceedings of the 13th National Conference on Artificial Intelligence, pp. 725–730, 1996.
+
+Schapire, R. E. Using output codes to boost multiclass learing problems. In International Conference on Machine Learning, 1997.
+
+Schapire, R. E. and Singer, Y. Improved boosting algorithms using confidence-rated predictions. Machine Learning, 37(3):297–336, 1999.
+
+Sun, P., Reid, M. D., and Zhou, J. AOSO-LogitBoost: Adaptive one-vs-one LogitBoost for multi-class problem. In International Conference on Machine Learning (ICML), 2012.
+
+Sun, Y., Todorovic, S., Li, J., and Wu, D. Unifying the error-correcting and output-code AdaBoost within the margin framework. In International Conference on Machine Learning, 2005.
+
+Viola, P. and Jones, M. Robust real-time face detection. International Journal of Computer Vision, 57:137–154, 2004.
+
+Zhu, J., Zou, H., Rosset, S., and Hastie, T. Multi-class AdaBoost. Statistics and its Interface, 2:349–360, 2009.
+
+A. Showing (9)
+
+$$
+\begin{array} { r l } { Z _ { 1 } \mathbf { h } _ { N } \boldsymbol { u } } & { = \underbrace { \frac { 1 } { \sqrt { 2 } } \frac { \epsilon _ { \mathrm { N } } } { \epsilon _ { \mathrm { N } } } \boldsymbol { u } _ { 1 } \cdot \boldsymbol { u } _ { N } ^ { \mathrm { o r } } \{ \alpha \mathbf { h } _ { \mathrm { o l d } } ^ { \mathrm { o p } } ( x , y ) \boldsymbol { \Lambda } _ { 1 } ^ { \mathrm { o r } } \geq \frac { \epsilon _ { \mathrm { N } } ^ { \mathrm { o r } } \gamma _ { 1 } } { \omega _ { 1 } ^ { 2 } } , \alpha \epsilon _ { \mathrm { N } } \gamma _ { 1 } ^ { \mathrm { o r } } \{ \alpha \mathbf { h } _ { \mathrm { o l d } } ^ { \mathrm { o p } } ( x , y ) \boldsymbol { \Lambda } _ { 1 } ^ { \mathrm { o r } } \} , } \\ & { = \quad \sum _ { i = 1 } ^ { \infty } \Bigg \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \} ,   \Bigg . } \\ & { = \quad \frac { 1 } { \sqrt { 2 } } \omega _ { 1 } } ( \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) - \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \} ,  } \\ & { \quad  - \sum _ { i = 1 } ^ { \infty } \{ \beta _ { 1 } ^ { \mathrm { o p } } \boldsymbol { u } _ { i } ^ { \mathrm { o p } } ( x , y ) + \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \{ \alpha \mathbf { h } _ { i } ^ { \mathrm { o r } } ( x , y ) \} ,  } \\ &  = \quad \sum _ { i = 1 } ^ { \infty } \{ \alpha _ { i } ^  \end{array}
+$$
+
+(16) comes from the definition (6) of $\mathbf { h }$ and (17) follows from the definitions (7) and (8) of $\mu _ { \ell - }$ and $\mu _ { \ell + }$ . In the final step (18) we used the fact that
+
+$$
+\sum _ { \ell = 1 } ^ { K } \left( \mu _ { \ell + } + \mu _ { \ell - } \right) = \sum _ { i = 1 } ^ { n } \sum _ { \ell = 1 } ^ { K } w _ { i , \ell } = 1 .
+$$
+
+# B. Multi-class decision stumps
+
+The simplest scalar base learner used in practice on numerical features is the decision stump, a one-decision two-leaf decision tree of the form
+
+$$
+\varphi _ { j , b } ( \mathbf { x } ) = \left\{ { \begin{array} { r l } { 1 } & { { } { \mathrm { ~ i f ~ } } x ^ { ( j ) } \geq b , } \\ { - 1 } & { { } { \mathrm { ~ o t h e r w i s e } } , } \end{array} } \right.
+$$
+
+where $j$ is the index of the selected feature and $b$ is the decision threshold. If the feature values $\big ( x _ { 1 } ^ { ( j ) } , \dots , x _ { n } ^ { ( j ) } \big )$ are preordered before the first boosting iteration, a decision stump maximizing the edge (11) (or minimizing the energy $( 1 6 ) ^ { 5 }$ ) can be found very efficiently in $\Theta ( n d K )$ time.
+
+The pseudocode of the algorithm is given in Figure 3. STUMPBASE first calculates the edge vector $\gamma ^ { ( 0 ) }$ of the constant classifier ${ \bf h } ^ { ( 0 ) } ( { \bf x } ) \equiv { \bf 1 }$ which will serve as the initial edge vector for each featurewise edge-maximizer. Then it loops over the features, calls BESTSTUMP to return the best featurewise stump, and then selects the best of the best by minimizing the energy (16). BESTSTUMP loops over all (sorted) feature values $s _ { 1 } , \ldots , s _ { n - 1 }$ . It considers all thresholds $b$ halfway between two non-identical feature values $s _ { i } \neq s _ { i + 1 }$ . The main trick (and, at the same time, the bottleneck of the algorithm) is the update of the classwise edges in lines 4-5: when the threshold moves from $\begin{array} { r } { b = \frac { s _ { i - 1 } + s _ { i } } { 2 } } \end{array}$ to $\textstyle b = { \frac { s _ { i } + s _ { i + 1 } } { 2 } }$ , the classwise edge $\gamma _ { \ell }$ of ${ \bf 1 } \varphi ( { \bf x } )$ (that is, $\mathbf { v } \varphi ( \mathbf { x } )$ with $\mathbf { v } = \mathbf { 1 } $ ) can only change by $\pm w _ { i , \ell }$ , depending on the sign $y _ { i , \ell }$ (Figure 4). The total edge of $\mathbf { v } \varphi ( \mathbf { x } )$ with optimal votes (13) is then the sum of the absolute values of the classwise edges of ${ \bf 1 } \varphi ( { \bf x } )$ (line 7).
+
+<table><tr><td>STUMPBASE(X, Y,W)</td><td></td></tr><tr><td>1 forl←1 to K&gt;for all classes n &gt; 2 20</td><td>↑ Wi,lyi,l&gt; classwise edges (1O) of constant classifier h(O)(x) = 1</td></tr><tr><td>3 for j←1 to d</td><td>i=1 D all (numerical) features</td></tr><tr><td>4</td><td>s ← SORT(𝑥x(),..,x)） sort the jth column of X</td></tr><tr><td>5</td><td>(vj,bj,γj) ← BEsTSTUMP(s,Y,W,γ(0))D best stump per feature</td></tr><tr><td>6 αj←</td><td>1+Yj log base coefficient (12) 2 1-Yj</td></tr><tr><td>7</td><td> j* ← arg min Z(αjVjj,b,W)&gt; best stump across features</td></tr><tr><td>J return (αj*,Vj*,j*,b*(·))</td><td></td></tr><tr><td>BESTSTUMP(s,Y,W, γ(0))</td><td></td></tr><tr><td></td><td></td></tr><tr><td>1</td><td>γ*← γ(0）best edge vector</td></tr><tr><td>2</td><td>γ ← γ(o）initial edge vector</td></tr><tr><td>3</td><td>for i← 1to n-1 &gt;for all points in order s1 ≤...≤ sn-1</td></tr><tr><td>4</td><td>for l ← 1 to K&gt;for all classes</td></tr><tr><td>5</td><td></td></tr><tr><td></td><td>Ye ← Ye - 2wi,lyi,l &gt; update classwise edges of stump with v = 1</td></tr><tr><td>6</td><td>if si  Si+1 then&gt; no threshold if identical coordinates Si = Si+1</td></tr><tr><td>7</td><td>if∑=1 lel &gt;∑ε-1l|thenfound beter stump</td></tr><tr><td>8</td><td>γ* ←γupdate best edge vector</td></tr><tr><td></td><td></td></tr><tr><td>9</td><td>6*←Si+si+1 update best threshold 2</td></tr><tr><td>10</td><td>forl ←1 to Kfor all classes</td></tr><tr><td>11</td><td>U ← sign(γe) D set vote vector according to (13)</td></tr><tr><td></td><td></td></tr><tr><td>12</td><td>ifγ*=γ(0） did not beat the constant classifier</td></tr><tr><td>13</td><td>return (v*,-O,llγ*lli）D constant classifier with optimal votes</td></tr><tr><td></td><td></td></tr><tr><td>14</td><td>else</td></tr><tr><td></td><td></td></tr><tr><td>15</td><td></td></tr><tr><td></td><td>return (v*,b*,llγ*ll1）)&gt;best stump</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr></table>
+
+# C. Cutting the data set
+
+The basic operation when adding a tree node with a scalar binary classifier (cut) $\varphi$ is to separate the data matrices X, Y, and W according to the sign of the classification $\varphi ( \mathbf { x } _ { i } )$ for all $\mathbf { x } _ { i } \in \mathbf { X }$ . Figure 5 contains the pseudocode of this simple operation.
+
+![](images/6f525edd3d65aa159a624c63bf871c52a5c96d6c549bf8d437780aec0c6d7dd8.jpg)  
+Figure 4. Updating the edge $\gamma _ { \ell }$ in line 5 of BESTSTUMP. If $y _ { i , \ell } = 1$ , then $\gamma _ { \ell }$ decreases by $2 w _ { i , \ell }$ , and if $y _ { i } = - 1$ , then $\gamma _ { \ell }$ increases by 2wi,\`.
+
+![](images/e8b070048778b8e7c5b3a8494b7eecdc749148db839d4bed3eb669c61546ed7a.jpg)  
+Figure 5. The basic operation when adding a tree node is to separate the data matrices X, $\mathbf { Y }$ , and W according to the sign of classification $\varphi ( \mathbf { x } _ { i } )$ for all $\mathbf { x } _ { i } \in \mathbf { X }$ .

parse/train/-_FVMKvxVCQo1/-_FVMKvxVCQo1_content_list.json

@@ -0,0 +1,1719 @@
+[
+    {
+        "type": "text",
+        "text": "The return of ADABOOST.MH: multi-class Hamming trees ",
+        "text_level": 1,
+        "bbox": [
+            186,
+            109,
+            782,
+            131
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Balazs K ´ egl ´",
+        "text_level": 1,
+        "bbox": [
+            89,
+            176,
+            173,
+            190
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "BALAZS.KEGL $@$ GMAIL.COM ",
+        "bbox": [
+            674,
+            178,
+            872,
+            190
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "LAL/LRI, University of Paris-Sud, CNRS, 91898 Orsay, France ",
+        "bbox": [
+            88,
+            194,
+            506,
+            208
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            245,
+            244,
+            316,
+            261
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Within the framework of ADABOOST.MH, we propose to train vector-valued decision trees to optimize the multi-class edge without reducing the multi-class problem to $K$ binary one-againstall classifications. The key element of the method is a vector-valued decision stump, factorized into an input-independent vector of length $K$ and label-independent scalar classifier. At inner tree nodes, the label-dependent vector is discarded and the binary classifier can be used for partitioning the input space into two regions. The algorithm retains the conceptual elegance, power, and computational efficiency of binary ADABOOST. In experiments it is on par with support vector machines and with the best existing multi-class boosting algorithm AOSOLOGITBOOST, and it is significantly better than other known implementations of ADABOOST.MH. ",
+        "bbox": [
+            120,
+            271,
+            441,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "and Singer’s seminal paper (Schapire & Singer, 1999), which proposed, among other interesting extensions, ADABOOST.MH. The main idea of the this approach is to use vector-valued base classifiers to build a multi-class discriminant function of $K$ outputs (for $K$ -class classification). The weight vector, which plays a crucial role in binary ADABOOST, is replaced by a weight matrix over instances and labels. The simplest implementation of the concept is to use $K$ independent one-against-all classifiers in which base classifiers are only loosely connected through the common normalization of the weight matrix. This setup works well with single decision stumps, but in most of the practical problems, boosting stumps is suboptimal compared to boosting more complex base classifiers such as trees. Technically, it is possible to build $K$ one-against-all binary decision trees in each iteration, but this approach, for one reason or another, has not produced state-of-the-art results. As a consequence, several recent papers concentrate on replacing the boosting objective and the engine that optimizes this objective (Li, 2009a;b; Zhu et al., 2009; Sun et al., 2012; Mukherjee & Schapire, 2013). ",
+        "bbox": [
+            501,
+            247,
+            883,
+            577
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. Introduction ",
+        "text_level": 1,
+        "bbox": [
+            89,
+            585,
+            215,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ADABOOST (Freund & Schapire, 1997) is one of the most influential supervised learning algorithms of the last twenty years. It has inspired learning theoretical developments and also provided a simple and easily interpretable modeling tool that proved to be successful in many applications (Caruana & Niculescu-Mizil, 2006). It is especially the method of choice when any-time solutions are required on large data sets, so it has been one of the most successful techniques in recent large-scale classification and ranking challenges (Dror et al., 2009; Chapelle et al., 2011). ",
+        "bbox": [
+            89,
+            613,
+            472,
+            762
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The original ADABOOST paper of Freund and Schapire (Freund & Schapire, 1997), besides defining binary ADABOOST, also described two multi-class extensions, ADABOOST.M1 and ADABOOST.M2. Both required a quite strong performance from the base learners, partly defeating the purpose of boosting, and saw limited practical success. The breakthrough came with Schapire ",
+        "bbox": [
+            89,
+            771,
+            472,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The main misconception that comes back in several papers is that ADABOOST.MH has to train $K$ parallel oneagainst-all classifiers in each iteration. It turns out that the original setup is more general. For example, staying within the classical ADABOOST.MH framework, Kegl & ´ Busa-Fekete (2009) trained products of simple classifiers and obtained state-of-the-art results on several data sets. In this paper, we describe multi-class Hamming trees, another base learner that optimizes the multi-class edge without reducing the problem to $K$ binary classifications. The key idea is to factorize general vector-valued classifiers into an input-independent vector of length $K$ , and labelindependent scalar classifier. It turns out that optimizing such base classifiers using decision stumps as the scalar component is almost as simple as optimizing simple binary stumps on binary data. The technique can be intuitively understood as optimizing a binary cut and an output code at the same time. The main consequence of the setup is that now it is easy to build trees of these classifiers by simply discarding the label-dependent vector and using the binary classifier for partitioning the input space into two regions. ",
+        "bbox": [
+            501,
+            585,
+            883,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The algorithm retains the conceptual elegance, power, and computational efficiency of binary ADABOOST. Algorithmically it cannot fail (the edge is always positive) and in practice it almost never overfits. Inheriting the flexibility of ADABOOST.MH, it can be applied directly (without any modification) to multi-label and multi-task classification. In experiments (carried out using an open source package of Benbouzid et al. (2012) for reproducibility) we found that ADABOOST.MH with Hamming trees performs on par with the best existing multiclass boosting algorithm AOSOLOGITBOOST (Sun et al., 2012) and with support vector machines (SVMs; Boser et al. 1992). It is also significantly better than other known implementations of ADABOOST.MH (Zhu et al., 2009; Mukherjee & Schapire, 2013). ",
+        "bbox": [
+            89,
+            85,
+            472,
+            310
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The paper is organized as follows. In Section 2 we give the formal multi-class setup used in the paper and ADABOOST.MH, and show how to train factorized base learners in general. The algorithm to build Hamming trees is described in Section 3. Experiments are described in Section 4 before a brief conclusion in Section 5. ",
+        "bbox": [
+            88,
+            319,
+            472,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. ADABOOST.MH ",
+        "text_level": 1,
+        "bbox": [
+            89,
+            428,
+            250,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we first introduce the general multiclass learning setup (Section 2.1), then we describe ADABOOST.MH in detail (Section 2.2). We proceed by explaining the general requirements for base learning in ADABOOST.MH, and introduce the notion of the factorized vector-valued base learner (Section 2.3). Finally, we explain the general objective for factorized base learners and the algorithmic setup to optimize that objective. (Section 2.4). ",
+        "bbox": [
+            89,
+            455,
+            472,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1. The multi-class setup: single-label and multi-label/multi-task ",
+        "text_level": 1,
+        "bbox": [
+            88,
+            607,
+            385,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the formal description of ADABOOST.MH, let the training data be $\\mathcal { D } \\ = \\ \\big \\{ ( \\mathbf { x } _ { 1 } , \\mathbf { y } _ { 1 } ) , \\dotsc , ( \\mathbf { x } _ { n } , \\mathbf { y } _ { n } ) \\big \\} _ { . }$ , where $\\mathbf { x } _ { i } \\in \\mathbb { R } ^ { d }$ are observation vectors, and $\\mathbf { y } _ { i } \\in \\{ \\pm 1 \\} ^ { \\mathrm { \\tilde { K } } }$ are label vectors. Sometimes we will use the notion of an $n \\times d$ observation matrix of $\\mathbf { X } = \\left( \\mathbf { x } _ { 1 } , \\ldots , \\mathbf { x } _ { n } \\right)$ and an $n \\times K$ label matrix $\\mathbf { Y } = ( \\mathbf { y } _ { 1 } , \\ldots , \\mathbf { y } _ { n } )$ instead of the set of pairs $\\mathcal { D }$ .1 In multi-class classification, the single label $\\ell ( \\mathbf { x } )$ of the observation $\\mathbf { x }$ comes from a finite set. Without loss of generality, we will suppose that $\\ell \\in \\mathcal { L } = \\{ 1 , \\ldots , K \\}$ . The label vector $\\mathbf { y }$ is a one-hot representation of the correct class: the $\\ell ( { \\mathbf { x } } ) { \\mathrm { t h } }$ element of $\\mathbf { y }$ will be 1 and all the other elements will be $- 1$ . Besides expressing faithfully the architecture of a multi-class neural network or multi-class ADABOOST, this representation has the advantage to be generalizable to multi-label or multi-task learning when an observation x can belong to several classes. To avoid confusion, from now on we will call $\\mathbf { y }$ and $\\ell$ the label and the label index of x, respectively. For emphasizing the distinction between multi-class and multi-label classification, we will use the term single-label for the classical multi-class setup, and reserve multi-class to situations when we talk about the three setups in general. ",
+        "bbox": [
+            88,
+            645,
+            472,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            500,
+            85,
+            885,
+            220
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal of learning is to infer a vector-valued multi-class discriminant function f $: \\mathcal { X }  \\mathbb { R } ^ { K }$ . 2 The single-label output of the algorithm is then $\\ell _ { \\mathbf { f } } ( \\mathbf { x } ) = \\arg \\operatorname* { m a x } _ { \\ell } f _ { \\ell } ( \\mathbf { x } )$ . The classical measure of the performance of the multiclass discriminant function f is the single-label one-loss $L _ { \\mathbb { I } } ( \\mathbf { f } , ( \\mathbf { x } , \\boldsymbol { \\ell } ) ) = \\mathbb { I } \\left\\{ \\boldsymbol { \\ell } \\neq \\ell _ { \\mathbf { f } } ( \\mathbf { x } _ { i } ) \\right\\}$ , which defines the singlelabel training error ",
+        "bbox": [
+            500,
+            228,
+            885,
+            334
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b973b60b2036b622fa1cfa5740c23c5abd090cb38286d3d8fdae95ee1a25a7ef.jpg",
+        "text": "$$\n{ \\widehat { R } } _ { \\mathbb { I } } ( \\mathbf { f } ) = { \\frac { 1 } { n } } \\sum _ { i = 1 } ^ { n } \\mathbb { I } \\left\\{ \\ell ( \\mathbf { x } _ { i } ) \\neq \\ell _ { \\mathbf { f } } ( \\mathbf { x } _ { i } ) \\right\\} . ^ { 3 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            571,
+            343,
+            810,
+            386
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another, perhaps more comprehensive, way to measure the perfloss $\\mathbf { f }$   \n$L _ { \\mathrm { H } } \\big ( \\mathbf { f } , ( \\mathbf { x } , \\mathbf { y } ) , \\mathbf { w } \\big ) ^ { * } \\ = \\ \\dot { \\sum _ { \\ell = 1 } ^ { K } } \\overline { { { w _ { \\ell } } } } \\mathbb { I } \\left\\{ \\mathrm { s i g n } \\big ( f _ { \\ell } ( \\mathbf { x } ) \\big ) \\neq y _ { \\ell } \\right\\}$ where $\\mathbf { w } = \\left[ w _ { \\ell } \\right]$ is an $\\mathbb { R } ^ { K }$ -valued “user-defined” weight vector over labels. The corresponding empirical risk (training error) is ",
+        "bbox": [
+            501,
+            395,
+            883,
+            487
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71e1df98c353e536f8d54d5bce489eddbc152398c090b1b74bfa35ff3d33dc5c.jpg",
+        "text": "$$\n\\widehat { R } _ { \\mathrm { H } } ( \\mathbf { f } , \\mathbf { W } ) = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\sum _ { \\ell = 1 } ^ { K } w _ { i , \\ell } \\mathbb { I } \\left\\{ \\mathrm { s i g n } \\big ( f _ { \\ell } ( \\mathbf { x } _ { i } ) \\big ) \\neq y _ { i , \\ell } \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            506,
+            497,
+            857,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W } = \\left[ w _ { i , \\ell } \\right]$ is an $n \\times k$ weight matrix over data points and labels. ",
+        "bbox": [
+            500,
+            553,
+            885,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the multi-label/multi-task setup, when, for example, it is equally important to predict that a song is “folk” as predicting that it is sung by a woman, the Hamming loss with uniform weights $w _ { \\ell } = 1 / K , \\ \\ell = 1 , \\dots , K$ is a natural measure of performance: it represents the uniform error rate of missing any class sign $y _ { \\ell }$ of a given observation $\\mathbf { x }$ . In single-label classification, w is usually set asymmetrically to ",
+        "bbox": [
+            500,
+            590,
+            885,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/314721567f9b4b64c68b227818f287561f05ad4631cab00ec2ac0715d85a18c4.jpg",
+        "text": "$$\nw _ { \\ell } = { \\left\\{ \\begin{array} { l l } { { \\frac { 1 } { 2 } } } & { { \\mathrm { ~ i f ~ } } \\ell = \\ell ( \\mathbf { x } ) { \\mathrm { ~ } } ( { \\mathrm { i . e . , ~ i f ~ } } y _ { \\ell } = 1 ) , } \\\\ { { \\frac { 1 } { 2 ( K - 1 ) } } } & { { \\mathrm { ~ o t h e r w i s e ~ } } ( { \\mathrm { i . e . , ~ i f ~ } } y _ { \\ell } = - 1 ) . } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            535,
+            722,
+            846,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The idea behind this scheme is that it will create $K$ wellbalanced one-against-all binary classification problems: if we start with a balanced single-label multi-class problem, that is, if each of the $K$ classes have $n / K$ examples in $\\mathcal { D }$ , then for each class $\\ell$ , the sum of the weights of the positive examples in the column $\\mathbf { w } _ { \\cdot , \\ell }$ of the weight matrix W will be equal to the sum of the weights of the negative examples. Note that both schemes boil down to the classical uniform weighting in binary classification. ",
+        "bbox": [
+            500,
+            775,
+            885,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            89,
+            84,
+            473,
+            190
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2. ADABOOST.MH ",
+        "text_level": 1,
+        "bbox": [
+            88,
+            207,
+            235,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal of the ADABOOST.MH algorithm (Schapire & Singer 1999; Figure 1) is to return a vector-valued discriminant function $\\bar { \\bf f } ^ { ( T ) } : \\mathbb { R } ^ { d }  \\mathbb { R } ^ { K }$ with a small Hamming loss $\\widehat { R } _ { \\mathrm { H } } ( \\mathbf { f } , \\mathbf { W } )$ (2) by minimizing the weighted multi-class exponential margin-based error ",
+        "bbox": [
+            89,
+            231,
+            472,
+            306
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb2a5d3ee3fc33cd12a826b88d534d7ea3be47797f12b5a901f45df4e368a245.jpg",
+        "text": "$$\n\\widehat { R } _ { \\mathrm { E X P } } \\big ( \\mathbf { f } ^ { ( T ) } , \\mathbf { W } \\big ) = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\sum _ { \\ell = 1 } ^ { K } w _ { i , \\ell } \\exp \\big ( { - f _ { \\ell } ^ { ( T ) } ( \\mathbf { x } _ { i } ) y _ { i , \\ell } } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            98,
+            332,
+            462,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since $\\exp ( - \\rho ) \\geq \\mathbb { I } \\{ \\rho < 0 \\}$ , (4) upper bounds the Hamming loss final discr $\\widehat { R } _ { \\mathrm { H } } \\big ( \\mathbf { f } ^ { ( T ) } , \\mathbf { W } \\big )$ (2on $\\begin{array} { r } { \\mathbf { f } ^ { ( T ) } ( \\mathbf { x } ) = \\sum _ { t = 1 } ^ { T } \\mathbf { h } ^ { ( t ) } ( \\mathbf { x } ) } \\end{array}$ s theas a sum of base classifiers $\\mathbf { h } ^ { ( t ) } : \\mathcal { X }  \\mathbb { R } ^ { K }$ 1 returned by a base learner algorithm $\\mathbf { B } \\operatorname { A S E } \\left( \\mathbf { X } , \\mathbf { Y } , \\mathbf { W } ^ { ( t ) } \\right)$ in each iteration $t$ . ",
+        "bbox": [
+            88,
+            388,
+            472,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/971e5375f524ee84ee5bd6c39296b885af9bdd1b3369d37326f04adaa95d88fc.jpg",
+        "text": "$$\n\\boxed { \\mathrm { A D A B O O S T . M H ( X , Y , W , B A S E ( \\cdot , \\cdot , \\cdot ) , } T ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            83,
+            512,
+            383,
+            530
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ad880d3dcf30aa0183551cf00f5cc68d365ab5ca7b4f5ce1d661d9863c09d62.jpg",
+        "text": "$$\n\\mathbf { W } ^ { ( 1 ) }  \\frac { 1 } { n } \\mathbf { W }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            140,
+            536,
+            238,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4e772bad1a5b417e3546b703a0a72cf678ceaafa92d753160f8779fc6108e59.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\left( \\boldsymbol { \\alpha } ^ { ( t ) } , \\mathbf { v } ^ { ( t ) } , \\varphi ^ { ( t ) } ( \\cdot ) \\right) \\gets \\mathbf { B A S E } \\big ( \\mathbf { X } , \\mathbf { Y } , \\mathbf { W } ^ { ( t ) } \\big ) } \\\\ & { \\mathbf { h } ^ { ( t ) } ( \\cdot ) \\gets \\boldsymbol { \\alpha } ^ { ( t ) } \\mathbf { v } ^ { ( t ) } \\varphi ^ { ( t ) } ( \\cdot ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            158,
+            571,
+            446,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7628e79879e07b9696e1e8a2c10b2033a8bf4a8fcc28e767f55ff2259e0725a4.jpg",
+        "text": "$$\nw _ { i , \\ell } ^ { ( t + 1 ) } \\gets w _ { i , \\ell } ^ { ( t ) } \\frac { e ^ { - h _ { \\ell } ^ { ( t ) } ( \\mathbf { x } _ { i } ) y _ { i , \\ell } } } { \\displaystyle \\sum _ { i ^ { \\prime } = 1 } ^ { n } \\sum _ { \\ell ^ { \\prime } = 1 } ^ { K } w _ { i ^ { \\prime } , \\ell ^ { \\prime } } ^ { ( t ) } e ^ { - h _ { \\ell ^ { \\prime } } ^ { ( t ) } ( \\mathbf { x } _ { i ^ { \\prime } } ) y _ { i ^ { \\prime } , \\ell ^ { \\prime } } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            626,
+            473,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3. Base learning for ADABOOST.MH ",
+        "text_level": 1,
+        "bbox": [
+            501,
+            84,
+            769,
+            99
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal of multi-class base learning is to minimize the base objective ",
+        "bbox": [
+            500,
+            108,
+            885,
+            138
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bedf9cc7adf9f8d6de0f051f0b6015ac424dcf66818d851c9f70e5fadef486b.jpg",
+        "text": "$$\nZ ^ { ( t ) } = \\operatorname* { m i n } _ { \\mathbf { h } } Z \\bigl ( \\mathbf { h } , \\mathbf { W } ^ { ( t ) } \\bigr ) = \\sum _ { i = 1 } ^ { n } \\sum _ { \\ell = 1 } ^ { K } w _ { i , \\ell } ^ { ( t ) } e ^ { - h _ { \\ell } ( \\mathbf { x } _ { i } ) y _ { i , \\ell } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            509,
+            155,
+            856,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is easy to show (Schapire & Singer, 1999) that i) the oneerror $\\widetilde { R _ { \\mathbb { I } } } ( \\mathbf { f } ^ { ( T ) } )$ (1) is upper bounded by $\\textstyle \\prod _ { t = 1 } ^ { T } Z ^ { ( t ) }$ , and so ii) if the standard weak-learning condition ${ \\hat { Z } } ^ { ( t ) } \\leq 1 - \\delta$ holds, $\\widehat { R } _ { \\mathbb { I } } ( \\mathbf { f } )$ becomes zero in $T \\sim O ( \\log n )$ iterations. ",
+        "bbox": [
+            500,
+            215,
+            885,
+            275
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In general, any vector-valued multi-class learning algorithm can be used to minimize (5). Although this goal is clearly defined in (Schapire & Singer, 1999), efficient base learning algorithms have never been described in detail. In most recent papers (Zhu et al., 2009; Mukherjee & Schapire, 2013) where ADABOOST.MH is used as baseline, the base learner is a classical single-label decision tree which has to be grown rather large to satisfy the weaklearning condition, and, when boosted, yields suboptimal results (Section 4). The reason why methods for learning multi-class $\\{ \\pm 1 \\} ^ { K }$ -valued base classifiers had not been developed before is because they have to be boosted: since they do not select a single label, they cannot be used as stand-alone multi-class classifiers. ",
+        "bbox": [
+            501,
+            284,
+            885,
+            493
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although it is not described in detail, it seems that the base classifier used in the original paper of Schapire & Singer (1999) is a vector of $K$ independent decision stumps $\\mathbf { h } ( \\mathbf { x } ) \\ = \\ \\left( h _ { 1 } ( \\mathbf { x } ) , \\ldots , h _ { K } ( \\mathbf { x } ) \\right)$ . These stumps cannot be used as node classifiers to grow decision trees since they do not define a single cut that depends only on the input (see Section 3 for a more detailed discussion). To overcome this problem, we propose base learning algorithms that factorize $\\mathbf { h } ( \\mathbf { x } )$ into ",
+        "bbox": [
+            500,
+            502,
+            885,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e40c55211aa4b35c9932c4b1019a3f2f87663aad86250151dc4e81e48e9a73c3.jpg",
+        "text": "$$\n\\mathbf { h } ( \\mathbf { x } ) = \\alpha \\mathbf { v } \\varphi ( \\mathbf { x } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            632,
+            656,
+            750,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha \\in \\mathbb { R } ^ { + }$ is a positive real valued base coefficient, $\\mathbf { v }$ is an input-independent vote vector of length $K$ , and $\\varphi ( \\mathbf { x } )$ is a label-independent scalar classifier. In discrete ADABOOST.MH, both components are binary, that is, ${ \\textbf { v } } \\in$ $\\{ \\pm 1 \\} ^ { K }$ and $\\varphi ( \\mathbf { x } ) : \\mathbb { R } ^ { d }  \\{ \\pm 1 \\}$ . The setup can be extended to real-valued classifiers $\\varphi ( \\mathbf { x } ) \\ : \\ \\mathbb { R } ^ { d } \\  \\ \\mathbb { R }$ , also known as confidence-rated classifiers, and it is also easy to make the vote vector $\\mathbf { v }$ real-valued (in which case, without the loss of generality, $\\alpha$ would be set to 1). Both variants are known under the name of real ADABOOST.MH. Although there might be slight differences in the practical performance of real and discrete ADABOOST.MH, here we decided to stick to the discrete case for the sake of simplicity. ",
+        "bbox": [
+            500,
+            690,
+            885,
+            901
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4. Casting the votes ",
+        "text_level": 1,
+        "bbox": [
+            88,
+            85,
+            236,
+            99
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To start, we show how to set $\\alpha$ and $\\mathbf { v }$ in general if the scalar base classifier $\\varphi$ is given. The intuitive semantics of (6) is the following. The binary classifier $\\varphi ( \\mathbf { x } )$ cuts the input space into a positive and a negative region. In binary classification this is the end of the story: we need $\\varphi ( \\mathbf { x } )$ to be well-correlated with the binary class labels $y$ . In multiclass classification it is possible that $\\varphi ( \\mathbf { x } )$ correlates with some of the class labels $y _ { \\ell }$ and anti-correlates with others. This free choice is expressed by the binary “votes” $v _ { \\ell } \\in \\{ \\pm 1 \\}$ . We say that $\\varphi ( \\mathbf { x } )$ votes for class $\\ell$ if $v _ { \\ell } = + 1$ and it votes against class $\\ell$ if $v _ { \\ell } = - 1$ . As in binary classification, $\\alpha$ expresses the overall quality of the classifier $\\mathbf { v } \\varphi ( \\mathbf { x } )$ : $\\alpha$ is monotonically decreasing with respect to the weighted error of $\\mathbf { v } \\varphi ( \\mathbf { x } )$ . ",
+        "bbox": [
+            88,
+            108,
+            472,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The advantage of the setup is that, given the binary classifier $\\varphi ( \\mathbf { x } )$ , the optimal vote vector $\\mathbf { v }$ and the coefficient $\\alpha$ can be set in an efficient way. To see this, first let us define the weighted per-class error rate ",
+        "bbox": [
+            88,
+            327,
+            473,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bbd8c1f44044fd745356ab187d882a63a4b468f2e24b4071c76c094a2e6e8d09.jpg",
+        "text": "$$\n\\mu _ { \\ell - } = \\sum _ { i = 1 } ^ { n } w _ { i , \\ell } \\mathbb { I } \\left\\{ \\varphi ( \\mathbf { x } _ { i } ) \\neq y _ { i , \\ell } \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            396,
+            388,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and the weighted per-class correct classification rate ",
+        "bbox": [
+            88,
+            445,
+            436,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3444c65b60e624987b2884bf31ba1baba263b40af689327939b5e73c4e18982a.jpg",
+        "text": "$$\n\\mu _ { \\ell + } = \\sum _ { i = 1 } ^ { n } w _ { i , \\ell } \\mathbb { I } \\left\\{ \\varphi ( \\mathbf { x } _ { i } ) = y _ { i , \\ell } \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            469,
+            387,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for each class $\\ell = 1 , \\ldots , K$ . With this notation, $Z ( \\mathbf { h } , \\mathbf { W } )$ simplifies to (see Appendix A) ",
+        "bbox": [
+            88,
+            521,
+            472,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d25cb1108e6d08f11eee579d184f8a7a5fde79e3aa76dfd15e72991ce7f9db46.jpg",
+        "text": "$$\nZ ( \\mathbf { h } , \\mathbf { W } ) = { \\frac { e ^ { \\alpha } + e ^ { - \\alpha } } { 2 } } - { \\frac { e ^ { \\alpha } - e ^ { - \\alpha } } { 2 } } \\sum _ { \\ell = 1 } ^ { K } v _ { \\ell } { \\big ( } \\mu _ { \\ell + } - \\mu _ { \\ell - } { \\big ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            91,
+            560,
+            470,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The quantity ",
+        "bbox": [
+            88,
+            616,
+            173,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7310cfe6e5f30cddb542bc24167d75ae3a0173737707038f3ac7c543f425fb65.jpg",
+        "text": "$$\n\\gamma _ { \\ell } = v _ { \\ell } \\bigl ( \\mu _ { \\ell + } - \\mu _ { \\ell - } \\bigr ) = \\sum _ { i = 1 } ^ { n } w _ { i , \\ell } v _ { \\ell } \\varphi ( \\mathbf { x } _ { i } ) y _ { i , \\ell }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            120,
+            640,
+            413,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "is called the classwise edge of $\\mathbf { h } ( \\mathbf { x } )$ . The full multi-class edge of the classifier is then ",
+        "bbox": [
+            86,
+            690,
+            472,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ddbff5ed176fe6c144c817d1749c36443bd920698609c485f54289bafc8c6450.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\gamma = \\gamma ( \\mathbf { v } , \\varphi , \\mathbf { W } ) = \\sum _ { \\ell = 1 } ^ { K } \\gamma _ { \\ell } = \\sum _ { \\ell = 1 } ^ { K } v _ { \\ell } \\big ( \\mu _ { \\ell + } - \\mu _ { \\ell - } \\big ) } } \\\\ { { \\displaystyle \\ = \\sum _ { i = 1 } ^ { n } \\sum _ { \\ell = 1 } ^ { K } w _ { i , \\ell } v _ { \\ell } \\varphi ( \\mathbf { x } _ { i } ) y _ { i , \\ell } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            102,
+            728,
+            428,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With this notation, the classical (Freund & Schapire, 1997) binary coefficient $\\alpha$ is recovered: it is easy to see that (9) is minimized when ",
+        "bbox": [
+            88,
+            827,
+            473,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe05a16d39699acdf8c48c1d4b9b91f6f817e255c58393d12c4b7e69f19eccd5.jpg",
+        "text": "$$\n\\alpha = \\frac { 1 } { 2 } \\log \\frac { 1 + \\gamma } { 1 - \\gamma } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            877,
+            341,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With this optimal coefficient, (9) becomes $Z ( \\mathbf { h } , \\mathbf { W } ) \\ =$ $\\sqrt { 1 - \\gamma ^ { 2 } }$ , so $Z ( \\mathbf { h } , \\mathbf { W } )$ is minimized when $\\gamma$ is maximized. From (11) it then follows that $Z ( \\mathbf { h } , \\mathbf { W } )$ is minimized if $v _ { \\ell }$ agrees with the sign of $\\left( \\mu _ { \\ell + } - \\mu _ { \\ell - } \\right)$ , that is, ",
+        "bbox": [
+            500,
+            84,
+            885,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b7e93401adf003e34752ad21c63c263af98efa75b492268bd44cc53c8cafa39c.jpg",
+        "text": "$$\nv _ { \\ell } = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { ~ i f ~ } } \\mu _ { \\ell + } > \\mu _ { \\ell - } } \\\\ { - 1 } & { { \\mathrm { ~ o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            599,
+            155,
+            784,
+            198
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for all classes $\\ell = 1 , \\ldots , K$ ",
+        "bbox": [
+            501,
+            205,
+            686,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The setup of factorized base classification (6) has another important consequence: the preservation of the weaklearning condition. Indeed, if $\\varphi ( \\mathbf { x } )$ is slightly better then a coin toss, $\\gamma$ will be positive. Another way to look at it is to say that if a $( \\varphi , \\mathbf { v } )$ combination has a negative edge $\\gamma < 0$ , then the edge of its complement (either $( - \\varphi , \\mathbf { v } )$ or $( \\varphi , - \\mathbf { v } ) )$ will be $- \\gamma > 0$ . To understand the significance of this, consider a classical single-label base classifier $h \\ : \\ \\mathcal { X } \\ \\to \\ \\mathcal { L } \\ = \\ \\{ 1 , . . . , K \\}$ , required by ADABOOST.M1. Now if $h ( \\mathbf { x } )$ is slightly better than a coin toss, all one can hope for is an error rate slightly lower than $\\textstyle { \\frac { K - 1 } { K } }$ (which is equivalent to a. To achieve the error of edge slightly higher than(zero edge), required for $\\textstyle { \\frac { 2 - K } { K } } )$ $\\frac { 1 } { 2 }$ continuing boosting, one has to come up with a base learner which is significantly better than a coin toss. ",
+        "bbox": [
+            500,
+            227,
+            885,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There is a long line of research on output codes similar in spirit to our setup. The boosting engine in these works is usually slightly different from ADABOOST.MH since it attempts to optimize the multi-class hinge loss, but the factorization of the multi-class base classifier is similar to (6). Formally, the vote vector v in this framework is one column in an output code matrix. In the simplest setup this matrix is fixed beforehand by maximizing the error correcting capacity of the matrix (Dietterich & Bakiri, 1995; Allwein et al., 2001). A slightly better solution (Schapire, 1997; Guruswami & Sahai, 1999; Sun et al., 2005) is to wait until the given iteration to pick $\\mathbf { v }$ by maximizing ",
+        "bbox": [
+            500,
+            462,
+            885,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d26af1d5ff7ef05698b2350d6e4c660b784bcd48e67d28f1a2b95413dc228ed4.jpg",
+        "text": "$$\n\\mathbf { v } ^ { * } = \\underset { \\mathbf { v } } { \\arg \\operatorname* { m a x } } \\sum _ { i = 1 } ^ { n } \\sum _ { \\ell = 1 } ^ { K } w _ { i , \\ell } \\mathbb { I } \\left\\{ v _ { \\ell } \\neq v _ { \\ell ( \\mathbf { x } _ { i } ) } \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            547,
+            651,
+            834,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and then to choose the optimal binary classifier $\\varphi$ with this fixed vote (or code) vector $\\mathbf { v } ^ { * }$ (although in practice it seems to be better to fix $\\mathbf { v }$ to a random binary vector; Sun et al. 2005). The state of the art in this line of research is to iterate between optimizing $\\varphi$ with a fixed $\\mathbf { v }$ and then picking the best v with a fixed $\\varphi$ (Li, 2006; Kegl & Busa-Fekete ´ , 2009; Gao & Koller, 2011). ",
+        "bbox": [
+            500,
+            702,
+            885,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It turns out that if $\\varphi$ is a decision stump, exhaustive search for both the best binary cut (threshold) and the best vote vector can be carried out using one single sweep in $\\Theta ( n K )$ time. The algorithm is a simple extension of the classical binary decision stump learner; for the sake of completeness, we provide the pseudocode in Appendix B. The computational efficiency of this learning algorithm combined with the factorized form (6) of the classifier allows us to build multiclass Hamming trees in an efficient manner, circumventing the problem of global maximization of the edge with respect to $\\varphi$ and $\\mathbf { v }$ . ",
+        "bbox": [
+            500,
+            814,
+            885,
+            905
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            89,
+            85,
+            473,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3. Hamming trees ",
+        "text_level": 1,
+        "bbox": [
+            88,
+            179,
+            238,
+            196
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Classification trees (Quinlan, 1986) have been widely used for multivariate classification since the 80s. They are especially efficient when used as base learners in ADABOOST (Caruana & Niculescu-Mizil, 2006; Quinlan, 1996). Their main disadvantage is their variance with respect to the training data, but when averaged over $T$ different runs, this problem largely disappears. The most commonly used tree learner is C4.5 of Quinlan (1993). Whereas this tree implementation is a perfect choice for binary ADABOOST, it is suboptimal for ADABOOST.MH since it outputs a single-label classifier with no guarantee of a positive multi-class edge (11). Although this problem can be solved in practice by building large trees, it seems that using these large single-class trees is suboptimal (Section 4). ",
+        "bbox": [
+            88,
+            205,
+            472,
+            431
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The main technical difficulty of building trees out of generic $\\{ \\pm 1 \\} ^ { K }$ -valued multi-class classifiers $\\mathbf { h } ( \\mathbf { x } )$ is that they do not necessarily implement a binary cut ${ \\bf x } \\mapsto \\{ \\pm 1 \\}$ , and partitioning the data into all the possibly $2 ^ { K }$ children at a tree node leads to rapid overfitting. Factorizing the multiclass classifier $\\mathbf { h } ( \\mathbf { x } )$ into an input-independent vote vector $\\mathbf { v }$ and a label-independent binary classifier $\\varphi ( x )$ as in (6) solves this problem. Base classifiers are trained as usual at each new tree leaf. In case this leaf remains a leaf, the full classifier $\\mathbf { h } ( \\mathbf { x } )$ is used for instances $\\mathbf { x }$ that arrive to this leaf. If it becomes an inner node, the vote vector $\\mathbf { v }$ is discarded, and the partitioning of the data set is based on solely the binary classifier $\\varphi ( x )$ . An advantage of this formalization is that we can use any multi-class base classifier of the form (6) for the tree cuts, so the Hamming tree algorithm can be considered as a “meta learner” which can be used on the top of any factorized base learner. ",
+        "bbox": [
+            88,
+            439,
+            472,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formally, a binary classification tree with $N$ inner nodes $( N + 1$ leaves) consists of a list of $N$ base classifiers $\\pmb { 5 } = ( \\mathbf { h } _ { 1 } , \\ldots , \\mathbf { h } _ { N } )$ of the form $\\mathbf { h } _ { j } ( \\mathbf { x } ) = \\alpha _ { j } \\mathbf { v } _ { j } \\varphi _ { j } ( \\mathbf { x } )$ and two index lists ${ \\sf I } = \\left( { \\sf I } _ { 1 } , \\ldots , { \\sf I } _ { N } \\right)$ and ${ \\mathfrak { r } } = ( \\mathfrak { r } _ { 1 } , \\ldots , \\mathfrak { r } _ { N } )$ with $\\mathfrak { l } , \\mathfrak { r } \\in \\mathsf { \\Gamma } ( \\mathbb { N } \\cup \\{ \\mathrm { N U L L } \\} ) ^ { N }$ . $\\mathfrak { l } _ { j }$ and $\\mathfrak { r } _ { j }$ represent the indices of the left and right children of the $j$ th node of the tree, respectively. The node classifier in the $j$ th node is defined ",
+        "bbox": [
+            88,
+            704,
+            473,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "recursively as ",
+        "bbox": [
+            500,
+            85,
+            591,
+            99
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6e31cb8f67421fbce48a777c197763cbeb88b3ec74357a66f28c1d4bcf74b69.jpg",
+        "text": "$$\n\\mathfrak { h } _ { j } ( \\mathbf { x } ) = \\left\\{ \\begin{array} { l l } { - \\mathbf { v } _ { j } } & { \\mathrm { i f } \\varphi _ { j } ( \\mathbf { x } ) = - 1 \\wedge \\mathrm { I } _ { j } = \\mathrm { N U L } } \\\\ & { \\mathrm { ( l e f t ~ l e f ) } , } \\\\ { \\mathbf { v } _ { j } } & { \\mathrm { i f } \\varphi _ { j } ( \\mathbf { x } ) = + 1 \\wedge \\mathbf { r } _ { j } = \\mathrm { N U L } } \\\\ & { \\mathrm { ( r i g h t ~ l e a f ) } , } \\\\ { \\mathfrak { h } _ { \\mathrm { I } _ { j } } ( \\mathbf { x } ) } & { \\mathrm { i f } \\varphi _ { j } ( \\mathbf { x } ) = - 1 \\wedge \\mathrm { I } _ { j } \\neq \\mathrm { N U L } } \\\\ & { \\mathrm { ( l e f t ~ i n e r n o d e ) } , } \\\\ { \\mathfrak { h } _ { \\mathrm { r } _ { j } } ( \\mathbf { x } ) } & { \\mathrm { i f } \\varphi _ { j } ( \\mathbf { x } ) = + 1 \\wedge \\mathbf { r } _ { j } \\neq \\mathrm { N U L } } \\\\ & { \\mathrm { ( r i g h t ~ i n e r n o d e ) } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            511,
+            111,
+            844,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The final tree classifier $\\mathbf { h } _ { \\mathfrak { H } , \\mathfrak { t } , \\mathfrak { r } } ( \\mathbf { x } ) = \\alpha \\mathfrak { h } _ { 1 } ( \\mathbf { x } )$ itself is not a factorized classifier (6).4 In particular, $\\mathbf { h } _ { \\mathcal { S } , \\mathfrak { l } , \\mathfrak { r } } ( \\mathbf { x } )$ uses the local vote vectors $\\mathbf { v } _ { j }$ determined by each leaf instead of a global vote vector. On the other hand, the coefficient $\\alpha$ is unique, and it is determined in the standard way ",
+        "bbox": [
+            500,
+            272,
+            885,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0039d787afa472fe250acb36bc8a76221aaf84f41220305a809f2cb53839e9f.jpg",
+        "text": "$$\n\\alpha = \\frac { 1 } { 2 } \\log \\frac { 1 + \\gamma ( \\mathfrak { h } _ { 1 } , \\mathbf { W } ) } { 1 - \\gamma ( \\mathfrak { h } _ { 1 } , \\mathbf { W } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            606,
+            358,
+            779,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "based on the edge of the tree classifier ${ \\mathfrak { h } } _ { 1 }$ . The local coefficients $\\alpha _ { j }$ returned by the base learners are discarded (along with the vote vectors in the inner nodes). ",
+        "bbox": [
+            500,
+            404,
+            885,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finding the optimal $N$ -inner-node tree is a difficult combinatorial problem. Most tree-building algorithms are therefore sub-optimal by construction. For ADABOOST this is not a problem: we can continue boosting as long as the edge is positive. Classification trees are usually built in a greedy manner: at each stage we try to cut all the current leaves $j$ by calling the base learner of the data points reaching the $j$ th leaf, then select the best node to cut, convert the old leaf into an inner node, and add two new leaves. The difference between the different algorithms is in the way the best node is selected. Usually, we select the node that improves a gain function the most. In ADABOOST.MH the natural gain is the edge (11) of the base classifier. Since the data set $( \\mathbf { X } , \\mathbf { Y } )$ is different at each node, we include it explicitly in the argument of the full multi-class edge ",
+        "bbox": [
+            501,
+            457,
+            885,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4be1759aeb131b39ae7d4209eedba8bd51d57cbf366037b0d941f0769edc0a74.jpg",
+        "text": "$$\n\\gamma ( \\mathbf { v } , \\varphi , \\mathbf { X } , \\mathbf { Y } , \\mathbf { W } ) = \\sum _ { i = 1 } ^ { n } \\sum _ { \\ell = 1 } ^ { K } \\mathbb { I } \\left\\{ x _ { i } \\in \\mathbf { X } \\right\\} w _ { i , \\ell } v _ { \\ell } \\varphi ( \\mathbf { x } _ { i } ) y _ { i , \\ell } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            501,
+            693,
+            882,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that in this definition we do not require that the weights of the selected points add up to 1. Also note that this gain function is additive on subsets of the original data set, so the local edges in the leaves add up to the edge of the full tree. This means that any improvement in the local edge directly translates to an improvement of the tree edge. This is a crucial property: it assures that the edge of the tree is always positive as long as the local edges in the inner nodes are positive, so any weak binary classifier $\\phi ( \\mathbf { x } )$ can be used to define the inner cuts and the leaves. ",
+        "bbox": [
+            501,
+            747,
+            885,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            88,
+            85,
+            472,
+            114
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The basic operation when adding a tree node with a scalar binary classifier (cut) $\\varphi$ is to separate the data matrices $\\mathbf { X }$ , $\\mathbf { Y }$ , and W according to the sign of classification $\\varphi ( \\mathbf { x } _ { i } )$ for all $\\mathbf { x } _ { i } \\in \\mathbf { X }$ . The pseudocode is straightforward, but for the sake of completeness, we include it in the supplementary (Appendix C, Figure 5). ",
+        "bbox": [
+            88,
+            122,
+            472,
+            213
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Building a tree is usually described in a recursive way but we find the iterative procedure easier to explain, so our pseudocode in Figure 2 contains this version. The main idea is to maintain a priority queue, a data structure that allows inserting objects with numerical keys into a set, and extracting the object with the maximum key (Cormen et al., 2009). The key will represent the improvement of the edge when cutting a leaf. We first call the base learner on the full data set (line 1) and insert it into the priority queue with its edge $\\gamma ( \\mathbf { v } , \\varphi , \\mathbf { X } , \\mathbf { Y } , \\mathbf { W } )$ (line 3) as the key. Then in each iteration, we extract the leaf that would provide the best edge improvement among all the leaves in the priority queue (line 7), we partition the data set (line 11), call the base learners on the two new leaves (line 12), and insert them into the priority queue using the difference between the old edge on the partitioned data sets and the new edges of the base classifiers in the two new leaves (line 13). When inserting a leaf into the queue, we also save the sign of the cut (left or right child) and the index of the parent, so the index vectors l and $\\mathfrak { r }$ can be set properly in line 8. ",
+        "bbox": [
+            88,
+            219,
+            472,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When the priority queue is implemented as a heap, both the insertion and the extraction of the maximum takes ${ \\cal O } ( \\log N )$ time (Cormen et al., 2009), so the total running time of the procedure is $O \\big ( N ( T _ { \\mathrm { B a s E } } + n + \\log N ) \\big )$ , where $T _ { \\mathrm { B A S E } }$ is the running time of the base learner. Since $N$ cannot be more than $n$ , the running time is $O \\big ( N ( T _ { \\mathrm { B a S E } } + n ) \\big )$ . If the base learners cutting the leaves are decision stumps, the total running time is $O ( n K d N )$ . In the procedure we have no explicit control over the shape of the tree, but if it happens to be balanced, the running time can further be improved to $O ( n K d \\log N )$ . ",
+        "bbox": [
+            88,
+            530,
+            472,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4. Experiments ",
+        "text_level": 1,
+        "bbox": [
+            89,
+            715,
+            215,
+            732
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Full reproducibility was one of the key motivations when we designed our experimental setup. All experiments were done using the open source multiboost software of Benbouzid et al. (2012), version 1.2. In addition, we will make public all the configuration files, train/test/validation cuts, and the scripts that we used to set up the hyperparameter validation. ",
+        "bbox": [
+            89,
+            741,
+            472,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We carried out experiments on five mid-sized (isolet, letter, optdigits, pendigits, and USPS) and nine small (balance, blood, wdbc, breast, ecoli, iris, pima, sonar, and wine) data sets from the UCI repository. The five sets were chosen to overlap with the selections of most of the recent multi-class boosting papers (Kegl & ´ Busa-Fekete, 2009; Li, 2009a;b; Zhu et al., 2009; Sun et al., 2012; Mukherjee & Schapire, 2013), The small data sets were selected for comparing ADABOOST.MH with SVMs using Gaussian kernels, taking the results of a recent paper (Duch et al., 2012) whose experimental setup we adopted. All numerical results (multi-class test errors $\\widehat { R } _ { \\mathbb { I } } ( \\mathbf { f } )$ (1) and test learning curves) are available at https://www.lri.fr/˜kegl/research/ multiboostResults.pdf, one experiment per page for clarity. Tables 1 and 2 contain summaries of the results. ",
+        "bbox": [
+            88,
+            854,
+            472,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            501,
+            85,
+            883,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/6c320c18c62cb527aa52b7174e1c627728143aa9d5cf94cbe968cb791b3259ae.jpg",
+        "table_caption": [
+            "Table 2. Test error percentages on small benchmark data sets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>AB.MH</td><td rowspan=1 colspan=1>SVM</td></tr><tr><td rowspan=1 colspan=1>balance</td><td rowspan=1 colspan=1>6.0±4.0</td><td rowspan=1 colspan=1>10.0±2.0</td></tr><tr><td rowspan=1 colspan=1>blood</td><td rowspan=1 colspan=1>22.0±4.0</td><td rowspan=1 colspan=1>21.0± 5.0</td></tr><tr><td rowspan=1 colspan=1>wdbc</td><td rowspan=1 colspan=1>3.0± 2.0</td><td rowspan=1 colspan=1>2.0±3.0</td></tr><tr><td rowspan=1 colspan=1>breast</td><td rowspan=1 colspan=1>34.0 ±13.0</td><td rowspan=1 colspan=1>37.0±8.0</td></tr><tr><td rowspan=1 colspan=1>ecoli</td><td rowspan=1 colspan=1>15.0±6.0</td><td rowspan=1 colspan=1>16.0±6.0</td></tr><tr><td rowspan=1 colspan=1>iris</td><td rowspan=1 colspan=1>7.0±6.0</td><td rowspan=1 colspan=1>5.0±6.0</td></tr><tr><td rowspan=1 colspan=1>pima</td><td rowspan=1 colspan=1>24.0±5.0</td><td rowspan=1 colspan=1>24.0±4.0</td></tr><tr><td rowspan=1 colspan=1>sonar</td><td rowspan=1 colspan=1>13.0±10.0</td><td rowspan=1 colspan=1>14.0±8.0</td></tr><tr><td rowspan=1 colspan=1>wine</td><td rowspan=1 colspan=1>2.0±3.0</td><td rowspan=1 colspan=1>3.0±4.0</td></tr></table>",
+        "bbox": [
+            570,
+            295,
+            813,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter optimization is largely swept under the rug in papers describing alternative multi-class boosting methods. Some report results with fixed hyperparameters (Zhu et al., 2009; Sun et al., 2012) and others give the full table of test errors for a grid of hyperparameters (Kegl & Busa- ´ Fekete, 2009; Li, ${ 2 0 0 9 \\mathrm { a } ; \\mathrm { b } }$ ; Mukherjee & Schapire, 2013). Although the following procedure is rather old, we feel the need to detail it for promoting a more scrupulous comparison across papers. ",
+        "bbox": [
+            501,
+            465,
+            883,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the small data sets we ran $1 0 \\times 1 0$ cross-validation (CV) to optimize the hyperparameters and the estimate the generalization error. For the number of inner nodes we do a grid search (we also considered using the “one sigma” rule for biasing the selection towards smaller trees, but the simple minimization proved to be better). For robustly estimating the optimal stopping time we use a smoothed test error. For the formal description, let $\\widehat { R } ^ { ( t ) }$ be the average test error (1) of the ten validation runs after $t$ iterations. We run ADABOOST.MH for $T _ { \\mathrm { m a x } }$ iterations, and compute the optimal stopping time using the minimum of the smoothed test error using a linearly growing sliding window, that is, ",
+        "bbox": [
+            501,
+            609,
+            885,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/562d41023d6bb36672a40809eea86f872f135f21bc0cade503027d368602d153.jpg",
+        "text": "$$\nT ^ { * } = \\operatorname * { a r g m i n } _ { T : T _ { \\mathrm { m i n } } < T \\leq T _ { \\mathrm { m a x } } } \\frac { 1 } { T - \\lfloor 0 . 8 T \\rfloor } \\sum _ { t = \\lfloor 0 . 8 T \\rfloor } ^ { T } \\widehat { R } ^ { ( t ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            517,
+            801,
+            839,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $T _ { \\mathrm { m i n } }$ was set to a constant 50 to avoid stopping too early due to fluctuations. For selecting the best number of inner nodes $N$ , we simply minimized the smoothed test ",
+        "bbox": [
+            500,
+            861,
+            885,
+            905
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1 $( \\alpha , \\mathbf { v } , \\varphi ( \\cdot ) ) \\gets \\mathrm { B A S E } ( \\mathbf { X } , \\mathbf { Y } , \\mathbf { W } )$ 2 S ← PRIORITYQUEUE $\\triangleright O ( \\log N )$ insertion and extraction of maximum key   \n3 $\\begin{array} { r l } & { \\mathrm { I N S E R T } \\left( S , \\left( \\mathbf { v } , \\varphi ( \\cdot ) , \\mathbf { X } , \\mathbf { Y } , \\mathrm { N U L L } , 0 \\right) , \\gamma ( \\mathbf { v } , \\varphi , \\mathbf { X } , \\mathbf { Y } , \\mathbf { W } ) \\right) \\quad \\textrm { \\textrm { s } } k e y = e d g e \\gamma } \\\\ & { \\textit { \\textbf { c } } , } \\end{array}$   \n4 H ← () . initialize classifier list   \n5 for $j  1$ to $N$   \n6 $[ \\boldsymbol { \\mathbf { \\rho } } _ { j } \\gets \\boldsymbol { \\mathbf { \\tau } } _ { j } \\gets \\mathrm { N U L L }$ . initialize child indices   \n7 $( \\mathbf { v } _ { j } , \\varphi _ { j } ( \\cdot ) , \\mathbf { X } _ { j } , \\mathbf { Y } _ { j } , \\bullet , j _ { \\mathrm { p } } )  \\mathrm { E X T R A C T M A X } ( S )$ . best node in the priority queue   \n8 if $\\bullet = -$ then ${ \\mathfrak { l } } _ { j _ { \\mathrm { p } } } \\gets j$ else if ${ \\bullet } = +$ then ${ \\mathfrak { r } } _ { j _ { \\mathrm { p } } } \\gets j$ . child index of parent   \n9 $\\begin{array} { r l } { \\mathfrak { H }  \\mathrm { A P P E N D } \\big ( \\mathfrak { H } , \\mathbf { v } _ { j } \\varphi _ { j } ( \\cdot ) \\big ) } & { { } \\triangleright a d d i n g \\mathbf { h } _ { j } ( \\cdot ) = \\mathbf { v } _ { j } \\varphi _ { j } ( \\cdot ) t o \\tilde { \\mathfrak { H } } } \\end{array}$   \n10 $( \\mathbf { X } _ { - } , \\mathbf { Y } _ { - } , \\mathbf { W } _ { - } , \\mathbf { X } _ { + } , \\mathbf { Y } _ { + } , \\mathbf { W } _ { + } ) \\xleftarrow - \\mathrm { C U T D A T A S E T } \\big ( \\mathbf { X } _ { j } , \\mathbf { Y } _ { j } , \\mathbf { W } , \\varphi _ { j } ( \\cdot ) \\big )$   \n11 f $\\mathbf { \\dot { o } r } \\bullet \\in \\{ - , + \\}$ . insert children into priority queue   \n12 $( \\alpha _ { \\bullet } , \\mathbf { v _ { \\bullet } } , \\varphi _ { \\bullet } ( \\cdot ) )  \\mathrm { B A S E } ( \\mathbf { X _ { \\bullet } } , \\mathbf { Y _ { \\bullet } } , \\mathbf { W _ { \\bullet } } )$   \n13 $\\mathrm { I N S E R T } \\big ( S , \\big ( \\mathbf { v _ { * } } , \\varphi _ { \\bullet } ( \\cdot ) , \\mathbf { X _ { \\bullet } } , \\mathbf { Y _ { \\bullet } } , \\bullet , j \\big ) , \\gamma ( \\mathbf { v _ { * } } , \\varphi _ { \\bullet } , \\mathbf { X _ { \\bullet } } , \\mathbf { Y _ { \\bullet } } , \\mathbf { W _ { \\bullet } } ) - \\gamma ( \\mathbf { v } _ { j } , \\varphi _ { j } , \\mathbf { X _ { \\bullet } } , \\mathbf { Y _ { \\bullet } } , \\mathbf { W _ { \\bullet } } ) \\big )$ . key = edge improvement over parent edge 1 1 + γ(h1, W)   \n14 α = 2 log 1 − γ(h1, W) . standard coefficient of the full tree classifier ${ \\mathfrak { h } } _ { 1 }$ (14) 2   \n15 return \u0000α, H, l, r\u0001 ",
+        "bbox": [
+            89,
+            104,
+            745,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b2605a0500719a817c760fece751ea1bfbd28f4775fca649517681ca01ce2278.jpg",
+        "table_caption": [
+            "Figure 2. The pseudocode of the Hamming tree base learner. $N$ is the number of inner nodes. The algorithm returns a list of base classifiers ${ \\mathfrak H }$ , two index lists l and $\\mathfrak { r }$ , and the base coefficient $\\alpha$ . The tree classifier is then defined by (14). ",
+            "Table 1. Test error percentages on mid-sized benchmark data sets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>isolet</td><td rowspan=1 colspan=1>letter</td><td rowspan=1 colspan=1>optdigits</td><td rowspan=1 colspan=1>pendigits</td><td rowspan=1 colspan=1>USPS</td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MH w Hamming trees</td><td rowspan=1 colspan=1>3.5±0.5</td><td rowspan=1 colspan=1>2.1±0.2</td><td rowspan=1 colspan=1>2.0±0.3</td><td rowspan=1 colspan=1>2.1±0.3</td><td rowspan=1 colspan=1>4.5±0.5</td></tr><tr><td rowspan=1 colspan=1> ADABoosT.MH w Hamming prod. (Kégl &amp; Busa-Fekete, 2009)</td><td rowspan=1 colspan=1>4.2±0.5</td><td rowspan=1 colspan=1>2.5±0.2</td><td rowspan=1 colspan=1>2.1 ± 0.4</td><td rowspan=1 colspan=1>2.1±0.2</td><td rowspan=1 colspan=1>4.4±0.5</td></tr><tr><td rowspan=1 colspan=1>AOSOLOGITBoOST J= 20,v = 0.1 (Sun et al.,2012)</td><td rowspan=1 colspan=1>3.5 ± 0.5</td><td rowspan=1 colspan=1>2.3±0.2</td><td rowspan=1 colspan=1>2.1 ± 0.3</td><td rowspan=1 colspan=1>2.4± 0.3</td><td rowspan=1 colspan=1>4.9±0.5</td></tr><tr><td rowspan=1 colspan=1>ABCLOGITB0OSTJ= 20,v= 0.1 (Li,2009b)</td><td rowspan=1 colspan=1>4.2±0.5</td><td rowspan=1 colspan=1>2.2±0.2</td><td rowspan=1 colspan=1>3.1± 0.4</td><td rowspan=1 colspan=1>2.9±0.3</td><td rowspan=1 colspan=1>4.9±0.5</td></tr><tr><td rowspan=1 colspan=1>ABCMARTJ= 20,v=0.1(Li,2009a)</td><td rowspan=1 colspan=1>5.0±0.6</td><td rowspan=1 colspan=1>2.5±0.2</td><td rowspan=1 colspan=1>2.6±0.4</td><td rowspan=1 colspan=1>3.0± 0.3</td><td rowspan=1 colspan=1>5.2±0.5</td></tr><tr><td rowspan=1 colspan=1>LOGITB0OST J= 20,v = 0.1 (Li,2009b)</td><td rowspan=1 colspan=1>4.7± 0.5</td><td rowspan=1 colspan=1>2.8±0.3</td><td rowspan=1 colspan=1>3.6±0.4</td><td rowspan=1 colspan=1>3.1± 0.3</td><td rowspan=1 colspan=1>5.8±0.5</td></tr><tr><td rowspan=1 colspan=1>SAMME w single-label trees (Zhu etal., 2009)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.3±0.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.5 ± 0.3</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MH w single-label trees (Zhu et al., 2009)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.6± 0.3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.8±0.3</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MM (Mukherjee &amp; Schapire,2013)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.5± 0.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.7 ± 0.3</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>ADABoosT.MH w single-label trees (Mukherjee &amp; Schapire,2013)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9.0±0.5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>7.0± 0.4</td><td rowspan=1 colspan=1></td></tr></table>",
+        "bbox": [
+            88,
+            458,
+            893,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "error over a predefined grid ",
+        "bbox": [
+            88,
+            655,
+            269,
+            669
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3021175b108f1d0092cdde2dcb99eb301de4d842fee80598f218bf1c4e15165c.jpg",
+        "text": "$$\nN ^ { * } = \\operatorname* { m i n } _ { N \\in \\mathcal { N } } \\widehat { R } ^ { ( T _ { N } ^ { * } ) } ( N )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            204,
+            678,
+            356,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $T _ { N } ^ { * }$ and $\\widehat { R } ^ { ( t ) } ( N )$ are the optimal stopping time (15) and the test error, respectively, in the run with $N$ inner nodes, and $\\mathcal { N }$ is the set of inner nodes participating in the grid search. Then we re-run ADABOOST.MH on the joined training/validation set using the selected hyperparameters $N ^ { * }$ and $T _ { N ^ { * } } ^ { * }$ . The error $\\widetilde { R _ { i } }$ in the ith training/test fold is then computed on the held-out test set. In the tables we report the mean error and the standard deviation. On the medium-size data sets we ran $1 \\times 5$ CV (using the designated test sets where available) following the same procedure. In this case the report the binomial standard deviation $\\sqrt { \\widehat { R } ( 1 - \\widehat { R } ) / n }$ . Further details and the description and explanation of some slight variations of this experimental setup are available at https://www.lri.fr/˜kegl/ research/multiboostResults.pdf. ",
+        "bbox": [
+            89,
+            717,
+            472,
+            906
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            500,
+            655,
+            883,
+            699
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the small data sets, Duch et al. (2012) used the exact same protocol, so, although the folds are not the same, the results are directly comparable. The error bars represent the standard deviation of the test errors over the ten test folds not divided by $\\sqrt { 1 0 }$ , contrary to common practice, since the training set of the folds are highly correlated. The large error bars are the consequence of the small size and the noisiness of these sets. They make it difficult to establish any significant trends. We can safely state that ADABOOST.MH is on par with SVM (it is certainly not worse, “winning” on six of the nine sets), widely considered one of the the best classification methods for small data sets. ",
+        "bbox": [
+            501,
+            708,
+            885,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Even though on the mid-sized data sets there are dedicated test sets used by most of the experimenters, comparing ADABOOST.MH to alternative multi-class boosting techniques is somewhat more difficult since none of the papers do proper hyperparameter tuning. Most of the papers report results with a table of errors given for a set of hyperparameter choices, without specifying which hyperparameter choice would be picked by proper validation. For methods that are non-competitive with ADABOOST.MH (SAMME of Zhu et al. (2009) and ADABOOST.MM of Mukherjee & Schapire (2013)) we report the post-validated best error which may be significantly lower than the error corresponding to the hyperparameter choice selected by proper validation. For methods where this choice would unfairly bias the comparison (AOSOLOGITBOOST (Sun et al., 2012), ABCLOGITBOOST, LOGITBOOST, and ABCMART (Li, 2009a;b)), we chose the best overall hyperparameter $\\textit { J } = \\ 2 0$ and $\\nu ~ = ~ 0 . 1$ , suggested by the Li $( 2 0 0 9 \\mathrm { a } ; \\mathrm { b } )$ . At https://www.lri.fr/˜kegl/ research/multiboostResults.pdf (but not in Table 1) we give both errors for some of the methods. Proper hyperparameter-validation should put the correct test error estimates between those two limits. Since ADABOOST.MH with decision products (Kegl & Busa- ´ Fekete, 2009) is also implemented in multiboost (Benbouzid et al., 2012), for this method we re-ran experiments with the protocol described above. ",
+        "bbox": [
+            89,
+            87,
+            472,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The overall conclusion is that AOSOLOGITBOOST (Sun et al., 2012) and ADABOOST.MH with Hamming trees are the best algorithms (ADABOOST.MH winning on all the five data sets but within one standard deviation). ADABOOST.MH with decision products (Kegl & Busa- ´ Fekete, 2009) and ABCLOGITBOOST are slightly weaker, as also noted by (Sun et al., 2012). SAMME (Zhu et al., 2009) and ADABOOST.MM (Mukherjee & Schapire, 2013) perform below the rest of the methods on the two data sets shared among all the papers (even though we give post-validated results). Another important conclusion is that ADABOOST.MH with Hamming trees is significantly better then other implementations of ADABOOST.MH in (Zhu et al., 2009; Mukherjee & Schapire, 2013), assumably implemented using single-label trees (the errors reported by Mukherjee & Schapire (2013) are especially conspicuous). ",
+        "bbox": [
+            89,
+            501,
+            472,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ADABOOST.MH with Hamming trees also achieves good results on image recognition problems. On MNIST, boosting trees of stumps over pixels with eight inner nodes and about 50000 iterations has a test error of $1 . 2 5 \\%$ , making it one of the best no-domain-knowledge “shallow” classifiers. Using stumps over Haar filters (Viola & Jones, 2004), boosted trees with four inner nodes and 10000 iterations achieves a test error of $0 . 8 5 \\%$ , comparable to classical convolutional nets (LeCun et al., 1998). ",
+        "bbox": [
+            89,
+            763,
+            472,
+            898
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ADABOOST.MH with Hamming trees, usually combined with calibration (Platt, 2000; Niculescu-Mizil & Caruana, 2005) and model averaging, has been also successful in recent data challenges. On the Kaggle emotions data challenge, although not competitive with deep learning techniques, out-of-the-box ADABOOST.MH with Hamming trees over Haar filters finished 17th place with a test error of $5 7 \\%$ . In the Yahoo! Learning-to-Rank Challenge (Chapelle et al., 2011) it achieved top ten performances with results not significantly different from the winning scores. Finally, in the recent INTERSPEECH Challenge it won the Emotion sub-challenge and it was runner up in the Social Signals sub-challenge. ",
+        "bbox": [
+            501,
+            85,
+            883,
+            280
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5. Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            500,
+            300,
+            614,
+            318
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper we introduced Hamming trees that optimize the multi-class edge prescribed by ADABOOST.MH without reducing the multi-class problem to $K$ binary oneagainst-all classifications. We showed that without this restriction, often considered mandatory, ADABOOST.MH is one of the best off-the-shelf multi-class classification algorithms. The algorithm retains the conceptual elegance, power, and computational efficiency of binary ADABOOST. ",
+        "bbox": [
+            501,
+            327,
+            883,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using decision stumps at the inner nodes and at the leaves of the tree is a natural choice due to the efficiency of the learning algorithm, nevertheless, the general setup described in this paper allows for using any binary classifier. One of the avenues investigated for future work is to try stronger classifiers, such as SVMs, as binary cuts. The formal setup described in Section 2.1 does not restrict the algorithm to single-label problems; another direction for future work is to benchmark it on standard multi-label and sequence-to-sequence classification problems (Dietterich et al., 2008). ",
+        "bbox": [
+            501,
+            470,
+            883,
+            635
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            501,
+            656,
+            593,
+            671
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Allwein, E. L., Schapire, R. E., and Singer, Y. Reducing multiclass to binary: a unifying approach for margin classifiers. Journal of Machine Learning Research, 1: 113–141, 2001.   \nBenbouzid, D., Busa-Fekete, R., Casagrande, N., Collin, F.-D., and Kegl, B. MultiBoost: a multi-purpose boost- ´ ing package. Journal of Machine Learning Research, 13: 549–553, 2012.   \nBoser, B., Guyon, I., and Vapnik, V. A training algorithm for optimal margin classifiers. In Fifth Annual Workshop on Computational Learning Theory, pp. 144–152, 1992.   \nCaruana, R. and Niculescu-Mizil, A. An empirical comparison of supervised learning algorithms. In Proceedings ",
+        "bbox": [
+            500,
+            680,
+            885,
+            905
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "of the 23rd International Conference on Machine Learning, pp. 161–168, 2006. ",
+        "bbox": [
+            102,
+            85,
+            472,
+            114
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chapelle, O., Chang, Y., and Liu, T.Y. (eds.). Yahoo! Learning-to-Rank Challenge, volume 14 of JMLR W&CP, 2011. ",
+        "bbox": [
+            88,
+            125,
+            473,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cormen, T., Leiserson, C., and Rivest, R. Introduction to Algorithms. MIT Press, 2009. ",
+        "bbox": [
+            88,
+            180,
+            472,
+            210
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dietterich, T. G. and Bakiri, G. Solving multiclass learning problems via error-correcting output codes. Journal of Artificial Intelligence Research, 2:263–286, 1995. ",
+        "bbox": [
+            88,
+            220,
+            475,
+            266
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dietterich, T. G., Hao, Guohua, and Ashenfelter, A. Gradient tree boosting for training conditional random fields. Journal of Machine Learning Research, 9:2113–2139, 2008. ",
+        "bbox": [
+            86,
+            276,
+            473,
+            335
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dror, G., Boulle, M., Guyon, I., Lemaire, V., and Vogel, D. ´ (eds.). Proceedings of KDD-Cup 2009 competition, volume 7 of JMLR Workshop and Conference Proceedings, 2009. ",
+        "bbox": [
+            86,
+            347,
+            473,
+            406
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Duch, W., Jankowski, N., and Maszczyk, T. Make it cheap: Learning with $O ( n d )$ complexity. In International Joint Conference on Neural Networks (IJCNN), pp. 1–4, 2012. ",
+        "bbox": [
+            88,
+            417,
+            473,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Freund, Y. and Schapire, R. E. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of Computer and System Sciences, 55:119– 139, 1997. ",
+        "bbox": [
+            86,
+            473,
+            473,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao, T. and Koller, D. Multiclass boosting with hinge loss based on output coding. In International Conference on Machine Learning, 2011. ",
+        "bbox": [
+            88,
+            542,
+            473,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Guruswami, V. and Sahai, A. Multiclass learning, boosting, and error-correcting codes. In Conference on Computational Learning Theory, 1999. ",
+        "bbox": [
+            88,
+            598,
+            473,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kegl, B. and Busa-Fekete, R. Boosting products of base ´ classifiers. In International Conference on Machine Learning, volume 26, pp. 497–504, Montreal, Canada, 2009. ",
+        "bbox": [
+            86,
+            654,
+            473,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "LeCun, Y., Bottou, L., Bengio, Y., and Haffner, P. Gradientbased learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            88,
+            724,
+            472,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Li, Ling. Multiclass boosting with repartitioning. In International Conference on Machine Learning, 2006. ",
+        "bbox": [
+            86,
+            780,
+            472,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Li, P. ABC-Boost: Adaptive base class boost for multiclass classification. In International Conference on Machine Learning, 2009a. ",
+        "bbox": [
+            86,
+            820,
+            473,
+            866
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Li, P. ABC-LogitBoost for multi-class classification. Technical Report arXiv:0908.4144, Arxiv preprint, 2009b. ",
+        "bbox": [
+            88,
+            876,
+            472,
+            905
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mukherjee, I. and Schapire, R. E. A theory of multiclass boosting. Journal of Machine Learning Research, 14: 437–497, 2013. ",
+        "bbox": [
+            498,
+            85,
+            883,
+            128
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Niculescu-Mizil, A. and Caruana, R. Obtaining calibrated probabilities from boosting. In Proceedings of the 21st International Conference on Uncertainty in Artificial Intelligence, pp. 413–420, 2005. ",
+        "bbox": [
+            498,
+            140,
+            883,
+            200
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Platt, J. Probabilistic outputs for support vector machines and comparison to regularized likelihood methods. In Smola, A.J., Bartlett, P., Schoelkopf, B., and Schuurmans, D. (eds.), Advances in Large Margin Classifiers, pp. 61–74. MIT Press, 2000. ",
+        "bbox": [
+            500,
+            210,
+            885,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Quinlan, J. Induction of decision trees. Machine Learning, 1(1):81–106, 1986. ",
+        "bbox": [
+            500,
+            296,
+            883,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Quinlan, J. C4.5: Programs for Machine Learning. Morgan Kaufmann, 1993. ",
+        "bbox": [
+            498,
+            337,
+            883,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Quinlan, J. Bagging, boosting and C4.5. In Proceedings of the 13th National Conference on Artificial Intelligence, pp. 725–730, 1996. ",
+        "bbox": [
+            498,
+            377,
+            885,
+            421
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Schapire, R. E. Using output codes to boost multiclass learing problems. In International Conference on Machine Learning, 1997. ",
+        "bbox": [
+            500,
+            433,
+            883,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Schapire, R. E. and Singer, Y. Improved boosting algorithms using confidence-rated predictions. Machine Learning, 37(3):297–336, 1999. ",
+        "bbox": [
+            500,
+            488,
+            883,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sun, P., Reid, M. D., and Zhou, J. AOSO-LogitBoost: Adaptive one-vs-one LogitBoost for multi-class problem. In International Conference on Machine Learning (ICML), 2012. ",
+        "bbox": [
+            498,
+            542,
+            883,
+            603
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sun, Y., Todorovic, S., Li, J., and Wu, D. Unifying the error-correcting and output-code AdaBoost within the margin framework. In International Conference on Machine Learning, 2005. ",
+        "bbox": [
+            498,
+            613,
+            883,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Viola, P. and Jones, M. Robust real-time face detection. International Journal of Computer Vision, 57:137–154, 2004. ",
+        "bbox": [
+            500,
+            684,
+            885,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhu, J., Zou, H., Rosset, S., and Hastie, T. Multi-class AdaBoost. Statistics and its Interface, 2:349–360, 2009. ",
+        "bbox": [
+            500,
+            739,
+            885,
+            768
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Showing (9) ",
+        "bbox": [
+            88,
+            83,
+            215,
+            101
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a47054a0d130dcbcae99dc68ca9dd789192e2afd3b0714c261c91560c134de60.jpg",
+        "text": "$$\n\\begin{array} { r l } { Z _ { 1 } \\mathbf { h } _ { N } \\boldsymbol { u } } & { = \\underbrace { \\frac { 1 } { \\sqrt { 2 } } \\frac { \\epsilon _ { \\mathrm { N } } } { \\epsilon _ { \\mathrm { N } } } \\boldsymbol { u } _ { 1 } \\cdot \\boldsymbol { u } _ { N } ^ { \\mathrm { o r } } \\{ \\alpha \\mathbf { h } _ { \\mathrm { o l d } } ^ { \\mathrm { o p } } ( x , y ) \\boldsymbol { \\Lambda } _ { 1 } ^ { \\mathrm { o r } } \\geq \\frac { \\epsilon _ { \\mathrm { N } } ^ { \\mathrm { o r } } \\gamma _ { 1 } } { \\omega _ { 1 } ^ { 2 } } , \\alpha \\epsilon _ { \\mathrm { N } } \\gamma _ { 1 } ^ { \\mathrm { o r } } \\{ \\alpha \\mathbf { h } _ { \\mathrm { o l d } } ^ { \\mathrm { o p } } ( x , y ) \\boldsymbol { \\Lambda } _ { 1 } ^ { \\mathrm { o r } } \\} , } \\\\ & { = \\quad \\sum _ { i = 1 } ^ { \\infty } \\Bigg \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\} ,   \\Bigg . } \\\\ & { = \\quad \\frac { 1 } { \\sqrt { 2 } } \\omega _ { 1 } } ( \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) - \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\} ,  } \\\\ & { \\quad  - \\sum _ { i = 1 } ^ { \\infty } \\{ \\beta _ { 1 } ^ { \\mathrm { o p } } \\boldsymbol { u } _ { i } ^ { \\mathrm { o p } } ( x , y ) + \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\{ \\alpha \\mathbf { h } _ { i } ^ { \\mathrm { o r } } ( x , y ) \\} ,  } \\\\ &  = \\quad \\sum _ { i = 1 } ^ { \\infty } \\{ \\alpha _ { i } ^  \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            132,
+            784,
+            493
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(16) comes from the definition (6) of $\\mathbf { h }$ and (17) follows from the definitions (7) and (8) of $\\mu _ { \\ell - }$ and $\\mu _ { \\ell + }$ . In the final step (18) we used the fact that ",
+        "bbox": [
+            88,
+            493,
+            883,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ab4138ff2abc6cae8a014285a97e71c3ddf6f125dac894db89eac0726ac511e.jpg",
+        "text": "$$\n\\sum _ { \\ell = 1 } ^ { K } \\left( \\mu _ { \\ell + } + \\mu _ { \\ell - } \\right) = \\sum _ { i = 1 } ^ { n } \\sum _ { \\ell = 1 } ^ { K } w _ { i , \\ell } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            520,
+            612,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B. Multi-class decision stumps ",
+        "text_level": 1,
+        "bbox": [
+            89,
+            580,
+            343,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The simplest scalar base learner used in practice on numerical features is the decision stump, a one-decision two-leaf decision tree of the form ",
+        "bbox": [
+            93,
+            606,
+            883,
+            635
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33c7ae9b34dc3cab52430ca81bc175baacd8b78ede3aec78206d1ca1158dc3ef.jpg",
+        "text": "$$\n\\varphi _ { j , b } ( \\mathbf { x } ) = \\left\\{ { \\begin{array} { r l } { 1 } & { { } { \\mathrm { ~ i f ~ } } x ^ { ( j ) } \\geq b , } \\\\ { - 1 } & { { } { \\mathrm { ~ o t h e r w i s e } } , } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            631,
+            586,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "where $j$ is the index of the selected feature and $b$ is the decision threshold. If the feature values $\\big ( x _ { 1 } ^ { ( j ) } , \\dots , x _ { n } ^ { ( j ) } \\big )$ are preordered before the first boosting iteration, a decision stump maximizing the edge (11) (or minimizing the energy $( 1 6 ) ^ { 5 }$ ) can be found very efficiently in $\\Theta ( n d K )$ time. ",
+        "bbox": [
+            88,
+            681,
+            887,
+            728
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The pseudocode of the algorithm is given in Figure 3. STUMPBASE first calculates the edge vector $\\gamma ^ { ( 0 ) }$ of the constant classifier ${ \\bf h } ^ { ( 0 ) } ( { \\bf x } ) \\equiv { \\bf 1 }$ which will serve as the initial edge vector for each featurewise edge-maximizer. Then it loops over the features, calls BESTSTUMP to return the best featurewise stump, and then selects the best of the best by minimizing the energy (16). BESTSTUMP loops over all (sorted) feature values $s _ { 1 } , \\ldots , s _ { n - 1 }$ . It considers all thresholds $b$ halfway between two non-identical feature values $s _ { i } \\neq s _ { i + 1 }$ . The main trick (and, at the same time, the bottleneck of the algorithm) is the update of the classwise edges in lines 4-5: when the threshold moves from $\\begin{array} { r } { b = \\frac { s _ { i - 1 } + s _ { i } } { 2 } } \\end{array}$ to $\\textstyle b = { \\frac { s _ { i } + s _ { i + 1 } } { 2 } }$ , the classwise edge $\\gamma _ { \\ell }$ of ${ \\bf 1 } \\varphi ( { \\bf x } )$ (that is, $\\mathbf { v } \\varphi ( \\mathbf { x } )$ with $\\mathbf { v } = \\mathbf { 1 } $ ) can only change by $\\pm w _ { i , \\ell }$ , depending on the sign $y _ { i , \\ell }$ (Figure 4). The total edge of $\\mathbf { v } \\varphi ( \\mathbf { x } )$ with optimal votes (13) is then the sum of the absolute values of the classwise edges of ${ \\bf 1 } \\varphi ( { \\bf x } )$ (line 7). ",
+        "bbox": [
+            88,
+            734,
+            887,
+            856
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/4fdbf0476a3f87db4f5145cd2b9edc560c0afae7a3baad23f8c113d97b827bfb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>STUMPBASE(X, Y,W)</td><td></td></tr><tr><td>1 forl←1 to K&gt;for all classes n &gt; 2 20</td><td>↑ Wi,lyi,l&gt; classwise edges (1O) of constant classifier h(O)(x) = 1</td></tr><tr><td>3 for j←1 to d</td><td>i=1 D all (numerical) features</td></tr><tr><td>4</td><td>s ← SORT(𝑥x(),..,x)） sort the jth column of X</td></tr><tr><td>5</td><td>(vj,bj,γj) ← BEsTSTUMP(s,Y,W,γ(0))D best stump per feature</td></tr><tr><td>6 αj←</td><td>1+Yj log base coefficient (12) 2 1-Yj</td></tr><tr><td>7</td><td> j* ← arg min Z(αjVjj,b,W)&gt; best stump across features</td></tr><tr><td>J return (αj*,Vj*,j*,b*(·))</td><td></td></tr><tr><td>BESTSTUMP(s,Y,W, γ(0))</td><td></td></tr><tr><td></td><td></td></tr><tr><td>1</td><td>γ*← γ(0）best edge vector</td></tr><tr><td>2</td><td>γ ← γ(o）initial edge vector</td></tr><tr><td>3</td><td>for i← 1to n-1 &gt;for all points in order s1 ≤...≤ sn-1</td></tr><tr><td>4</td><td>for l ← 1 to K&gt;for all classes</td></tr><tr><td>5</td><td></td></tr><tr><td></td><td>Ye ← Ye - 2wi,lyi,l &gt; update classwise edges of stump with v = 1</td></tr><tr><td>6</td><td>if si  Si+1 then&gt; no threshold if identical coordinates Si = Si+1</td></tr><tr><td>7</td><td>if∑=1 lel &gt;∑ε-1l|thenfound beter stump</td></tr><tr><td>8</td><td>γ* ←γupdate best edge vector</td></tr><tr><td></td><td></td></tr><tr><td>9</td><td>6*←Si+si+1 update best threshold 2</td></tr><tr><td>10</td><td>forl ←1 to Kfor all classes</td></tr><tr><td>11</td><td>U ← sign(γe) D set vote vector according to (13)</td></tr><tr><td></td><td></td></tr><tr><td>12</td><td>ifγ*=γ(0） did not beat the constant classifier</td></tr><tr><td>13</td><td>return (v*,-O,llγ*lli）D constant classifier with optimal votes</td></tr><tr><td></td><td></td></tr><tr><td>14</td><td>else</td></tr><tr><td></td><td></td></tr><tr><td>15</td><td></td></tr><tr><td></td><td>return (v*,b*,llγ*ll1）)&gt;best stump</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            81,
+            82,
+            890,
+            607
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C. Cutting the data set ",
+        "text_level": 1,
+        "bbox": [
+            89,
+            763,
+            279,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The basic operation when adding a tree node with a scalar binary classifier (cut) $\\varphi$ is to separate the data matrices X, Y, and W according to the sign of the classification $\\varphi ( \\mathbf { x } _ { i } )$ for all $\\mathbf { x } _ { i } \\in \\mathbf { X }$ . Figure 5 contains the pseudocode of this simple operation. ",
+        "bbox": [
+            88,
+            790,
+            887,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f525edd3d65aa159a624c63bf871c52a5c96d6c549bf8d437780aec0c6d7dd8.jpg",
+        "image_caption": [
+            "Figure 4. Updating the edge $\\gamma _ { \\ell }$ in line 5 of BESTSTUMP. If $y _ { i , \\ell } = 1$ , then $\\gamma _ { \\ell }$ decreases by $2 w _ { i , \\ell }$ , and if $y _ { i } = - 1$ , then $\\gamma _ { \\ell }$ increases by 2wi,\\`. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            147,
+            728,
+            373
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8b070048778b8e7c5b3a8494b7eecdc749148db839d4bed3eb669c61546ed7a.jpg",
+        "image_caption": [
+            "Figure 5. The basic operation when adding a tree node is to separate the data matrices X, $\\mathbf { Y }$ , and W according to the sign of classification $\\varphi ( \\mathbf { x } _ { i } )$ for all $\\mathbf { x } _ { i } \\in \\mathbf { X }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            86,
+            558,
+            870,
+            799
+        ],
+        "page_idx": 11
+    }
+]

parse/train/Bkeuz20cYm/Bkeuz20cYm.md

@@ -0,0 +1,491 @@
+# DOUBLE NEURAL COUNTERFACTUAL REGRET MINIMIZATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Counterfactual Regret Minimization (CRF) is a fundamental and effective technique for solving Imperfect Information Games (IIG). However, the original CRF algorithm only works for discrete state and action spaces, and the resulting strategy is maintained as a tabular representation. Such tabular representation limits the method from being directly applied to large games and continuing to improve from a poor strategy profile. In this paper, we propose a double neural representation for the imperfect information games, where one neural network represents the cumulative regret, and the other represents the average strategy. Furthermore, we adopt the counterfactual regret minimization algorithm to optimize this double neural representation. To make neural learning efficient, we also developed several novel techniques including a robust sampling method, mini-batch Monte Carlo Counterfactual Regret Minimization (MCCFR) and Monte Carlo Counterfactual Regret Minimization Plus $( \mathrm { M C C F R + } )$ ) which may be of independent interests. Experimentally, we demonstrate that the proposed double neural algorithm converges significantly better than the reinforcement learning counterpart.
+
+# 1 INTRODUCTION
+
+In Imperfect Information Games (IIG), a player only has partial access to the knowledge of her opponents before making a decision. This is similar to real-world scenarios, such as trading, traffic routing, and public auction. Thus designing methods for solving IIG is of great economic and societal benefits. Due to the hidden information, a player has to reason under the uncertainty about her opponents’ information, and she also needs to act so as to take advantage of her opponents’ uncertainty about her own information.
+
+Nash equilibrium is a typical solution concept for a two-player extensive-form game. Many algorithms have been designed over years to approximately find Nash equilibrium for large games. One of the most effective approaches is CFR (Zinkevich et al., 2007). In this algorithm, the authors proposed to minimize overall counterfactual regret and prove that the average of the strategies in all iterations would converge to a Nash equilibrium. However, the original CFR only works for discrete state and action spaces, and the resulting strategy is maintained as a tabular representation. Such tabular representation limits the method from being directly applied to large games and continuing to improve if starting from a poor strategy profile.
+
+To alleviate CFR’s large memory requirement in large games such as heads-up no-limit Texas Hold’em, Moravcik et al. (2017) proposed a seminal approach called DeepStack which uses fully connected neural networks to represent players counterfactual values and obtain a strategy online as requested. However, the strategy is still represented as a tabular form and the quality of this solution depends a lot on the initial quality of the counterfactual network. Furthermore, the counterfactual network is estimated separately, and it is not easy to continue improving both counterfactual network and the tabular strategy profile in an end-to-end optimization framework.
+
+Heinrich et al. (2015); Heinrich & Silver (2016) proposed end-to-end fictitious self-play approaches (XFP and NFSP respectively) to learn the approximate Nash equilibrium with deep reinforcement learning. In a fictitious play model, strategies are represented as neural networks and the strategies are updated by selecting the best responses to their opponents’ average strategies. This approach is advantageous in the sense that the approach does not rely on abstracting the game, and in theory, the strategy should continually improve as the algorithm iterates more steps. However, these methods do not explicitly take into account the hidden information in a game, because they are optimized based on the transition memory and the reward of the intermediate node is the utility of the game rather than the counterfactual value which consider the distribution of hidden variables (opponent’s private information). In experiments for games such as Leduc Hold’em, these methods converge slower than tabular based counterfactual regret minimization algorithms. Waugh et al. (2015) used handcraft features of the information sets to estimates the counterfactual regret. However, it need traverse the full game tree which is infeasible in large games.
+
+Thus it remains an open question whether the purely neural-based end-to-end approach can achieve comparable performance to tabular based CFR approach. In the paper, we partially resolve this open question by designing a double neural counterfactual regret minimization algorithm which can match the performance of tabular based counterfactual regret minimization algorithm. We employed two neural networks, one for the cumulative regret, and the other for the average strategy. We show that careful algorithm design allows these two networks to track the cumulative regret and average strategy respectively, resulting in a converging neural strategy. Furthermore, in order to improve the convergence of the neural algorithm, we also developed a new sampling technique which has lower variance than the outcome sampling, while being more memory efficient than the external sampling. In experiments with One-card poker and a large Leduc Hold’em containing more than $1 0 ^ { 7 }$ nodes, we showed that the proposed double neural algorithm has a strong generalization and compression ability even though only a small proportion of nodes are visited in each iteration. In addition, this method can converge to comparable results produced by its tabular counterpart while performing much better than deep reinforcement learning method. The current results open up the possibility for a purely neural approach to directly solve large IIG.
+
+# 2 BACKGROUND
+
+In this section, we will introduce some background on IIG and existing approaches to solve them.
+
+# 2.1 REPRESENTATION OF EXTENSIVE-FORM GAME
+
+We define the components of an extensive-form game following Osborne & Ariel (1994) (page $2 0 0 \sim 2 0 1$ ). A finite set $N = \{ 0 , 1 , . . . , n - 1 \}$ of players. Define $h _ { i } ^ { v }$ as the hidden variable of player $i$ in IIG, e.g., in poker game $h _ { i } ^ { v }$ refers to the private cards of player $i$ . $H$ refers to a finite set of histories. Each member $h \ = \ ( h _ { i } ^ { v } ) _ { i = 0 , 1 , \ldots , n - 1 } ( a _ { l } ) _ { l = 0 , \ldots , L - 1 } \ = \ h _ { 0 } ^ { v } h _ { 1 } ^ { v } . . . h _ { n - 1 } ^ { v } a _ { 0 } a _ { 1 } . . . a _ { L - 1 }$ of $H$ denotes a possible history (or state), which consists of each player’s hidden variable and $L$ actions taken by players including chance. For player $i , h$ also can be denoted as $h _ { i } ^ { v } h _ { - i } ^ { v } a _ { 0 } a _ { 1 } . . . a _ { L - 1 } .$ , where $h _ { - i } ^ { v }$ refers to the opponent’s hidden variables. The empty sequence $\varnothing$ is a member of $H$ . $h _ { j } \subseteq h$ denotes $h _ { j }$ is a prefix of $h$ , where $h _ { j } = ( h _ { i } ^ { v } ) _ { i = 0 , 1 , \ldots , n - 1 } ( a _ { l } ) _ { l = 1 , \ldots , L ^ { \prime } - 1 }$ and $0 < L ^ { \prime } < L$ . ${ \dot { Z } } \subseteq H$ denotes the terminal histories and any member $z \in Z$ is not a prefix of any other sequences. $A ( h ) = \{ a : h a \in H \}$ is the set of available actions after non-terminal history $h \in H \backslash Z$ . A player function $P$ assigns a member of $N \cup \{ c \}$ to each non-terminal history, where $c$ denotes the chance player id, which usually is -1. $P ( h )$ is the player who takes an action after history $h$ . $\mathcal { T } _ { i }$ of a history $\mathbf { \bar { \{ } }  h \mathbf { \bar { \Psi } } \in H : P ( h ) = i \}$ is an information partition of player $i$ . A set $I _ { i } \in \mathcal { T } _ { i }$ is an information set of player $i$ and $I _ { i } ( h )$ refers to information set $I _ { i }$ at state $h$ . Generally, $I _ { i }$ could only remember the information observed by player $i$ including player $i ^ { \prime } s$ hidden variable and public actions. Therefore $I _ { i }$ indicates a sequence in IIG, i.e., $h _ { i } ^ { v } a _ { 0 } a _ { 2 } . . . a _ { L - 1 }$ . For $I _ { i } \in \mathcal { I } _ { i }$ we denote by $A ( I _ { i } )$ the set $A ( h )$ and by $P ( I _ { i } )$ the player $P ( h )$ for any $h \in I _ { i }$ . For each player $i \in N$ a utility function $u _ { i } ( z )$ define the payoff of the terminal state $z$ . A more detailed explanation of these notations and definitions is presented in section B.
+
+# 2.2 STRATEGY AND NASH EQUILIBRIUM
+
+A strategy profile $\sigma = \{ \sigma _ { i } | \sigma _ { i } \in \Sigma _ { i } , i \in N \}$ is a collection of strategies for all players, where $\Sigma _ { i }$ is the set of all possible strategies for player $i$ . $\sigma _ { - i }$ refers to strategy of all players other than player $i$ . For play $i \in N$ the strategy $\sigma _ { i } ( I _ { i } )$ is a function, which assigns an action distribution over $A ( I _ { i } )$ to information set $I _ { i }$ . $\sigma _ { i } ( a | h )$ denotes the probability of action $a$ taken by player $i \in N \cup \{ c \}$ at state $h$ . In IIG, $\forall h _ { 1 } , h _ { 2 } \ \in \ I _ { i }$ , we have $I _ { i } \stackrel { \cdot } { = } I _ { i } ( h _ { 1 } ) \stackrel { \cdot } { = } I _ { i } ( h _ { 2 } )$ , $\sigma _ { i } ( I _ { i } ) = \sigma _ { i } ( h _ { 1 } ) = \sigma _ { i } ( \tilde { h _ { 2 } } )$ , $\sigma _ { i } ( a | I _ { i } ) = \sigma _ { i } ( a | h _ { 1 } ) = \sigma _ { i } ( a | h _ { 2 } )$ . For iterative method such as CFR, $\sigma ^ { t }$ refers to the strategy profile at $t$ -th iteration. The state reach probability of history $h$ is denoted by $\pi ^ { \sigma } ( h )$ if players take actions according to $\sigma$ . For an empty sequence $\pi ^ { \sigma } ( \emptyset ) = 1$ . The reach probability can be decomposed into $\begin{array} { r } { \pi ^ { \sigma } ( h ) = \dot { \prod } _ { i \in N \cup \{ c \} } \pi _ { i } ^ { \sigma } ( h ) \dot { = } \pi _ { i } ^ { \sigma } \bar { ( h ) } \pi _ { - i } ^ { \sigma } ( h ) } \end{array}$ according to each player’s contribution, where $\pi _ { i } ^ { \sigma } ( h ) =$ $\scriptstyle \prod _ { h ^ { \prime } a \subseteq h , P ( h ^ { \prime } ) = P ( h ) } \sigma _ { i } ( a | h ^ { \prime } )$ and $\begin{array} { r } { \pi _ { - i } ^ { \sigma } ( h ) \ = \ \prod _ { h ^ { \prime } a \subseteq h , P ( h ^ { \prime } ) \neq P ( h ) } \sigma _ { - i } ( a | h ^ { \prime } ) } \end{array}$ . The information set reach probability of $I _ { i }$ is defined as $\begin{array} { r } { \pi ^ { \sigma } ( I _ { i } ) = \sum _ { h \in I _ { i } } \pi ^ { \sigma } ( h ) } \end{array}$ . If $h ^ { \prime } \subseteq h$ , the interval state reach probability from state $h ^ { \prime }$ to $h$ is defined as $\pi ^ { \sigma } ( h ^ { \prime } , h )$ , then we have $\pi ^ { \sigma } ( h ^ { \prime } , h ) = \pi ^ { \sigma } ( h ) / \pi ^ { \sigma } ( h ^ { \prime } )$ $\pi _ { i } ^ { \sigma } ( I _ { i } )$ , $\pi _ { - i } ^ { \sigma } ( I _ { i } )$ , $\pi _ { i } ^ { \sigma } ( h ^ { \prime } , h )$ , and $\pi _ { - i } ^ { \sigma } ( h ^ { \prime } , h )$ are defined similarly.
+
+# 2.3 COUNTERFACTUAL REGRET MINIMIZATION
+
+In large and zero-sum IIG, CFR is proved to be an efficient method to compute Nash equilibrium (Zinkevich et al., 2007; Brown & Sandholm, 2017). We present some key ideas of this method as follows.
+
+Lemma 1: The state reach probability of one player is proportional to posterior probability of the opponent’s hidden variable, $i . e . , p ( h _ { - i } ^ { v } | I _ { i } ) \propto \pi _ { - i } ^ { \sigma } ( h )$ , where $h _ { i } ^ { v }$ and $I _ { i }$ indicate a particular $h$ . (see the proof in section G.1)
+
+For player $i$ and strategy profile $\sigma$ , the counterfactual value (CFV) $v _ { i } ^ { \sigma } ( h )$ at state $h$ is define as
+
+$$
+v _ { i } ^ { \sigma } ( h ) = \sum _ { h \subseteq z , z \in Z } \pi _ { - i } ^ { \sigma } ( h ) \pi ^ { \sigma } ( h , z ) u _ { i } ( z ) = \sum _ { h \subseteq z , z \in Z } \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ^ { \prime } ( z ) .
+$$
+
+where $u _ { i } ^ { \prime } ( z ) = \pi _ { - i } ^ { \sigma } ( z ) u _ { i } ( z )$ is the expected reward of player $i$ with respective to the approximated posterior distribution of the opponent’s hidden variable. The action counterfactual value of taking action $a$ is $v _ { i } ^ { \sigma } ( a | h ) = v _ { i } ^ { \sigma } ( h a )$ and the regret of taking this action is $r _ { i } ^ { \sigma } ( a | h ) = v _ { i } ^ { \sigma } ( a | h ) - v _ { i } ^ { \sigma } ( h )$ . Similarly, the CFV of information set $I _ { i }$ is $\begin{array} { r } { v _ { i } ^ { \sigma } ( I _ { i } ) \stackrel {  } { = } \sum _ { h \in I _ { i } } v _ { i } ^ { \sigma } ( h ) } \end{array}$ and the regret is $r _ { i } ^ { \sigma } ( a | I _ { i } ) =$ $\begin{array} { r l } & { \sum _ { z \in Z , h a \subseteq z , h \in I _ { i } } \pi _ { i } ^ { \sigma } ( h a , z ) u _ { i } ^ { \prime } ( z ) - \sum _ { z \in Z , h \subseteq z , h \in I _ { i } } \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ^ { \prime } ( z ) } \end{array}$ . Then the cumulative regret of action $a$ after $T$ iterations is
+
+$$
+R _ { i } ^ { T } ( a | I _ { i } ) = \sum _ { t = 1 } ^ { T } ( v _ { i } ^ { \sigma ^ { t } } ( a | I _ { i } ) - v _ { i } ^ { \sigma ^ { t } } ( I _ { i } ) ) = R _ { i } ^ { T - 1 } ( a | I _ { i } ) + r _ { i } ^ { \sigma ^ { T } } ( a | I _ { i } ) .
+$$
+
+where $R _ { i } ^ { 0 } ( a | I _ { i } ) = 0$ . Define $R _ { i } ^ { T , + } ( a | I _ { i } ) = \operatorname* { m a x } ( R _ { i } ^ { T } ( a | I _ { i } ) , 0 )$ , the current strategy (or behavior strategy) at $T + 1$ iteration will be updated by
+
+$$
+\sigma _ { i } ^ { T + 1 } ( a | I _ { i } ) = \left\{ \begin{array} { l l } { \frac { R _ { i } ^ { T , + } ( a | I _ { i } ) } { \sum _ { a \in A ( I _ { i } ) } R _ { i } ^ { T , + } ( a | I _ { i } ) } } & { \mathrm { i f } \sum _ { a \in A ( I _ { i } ) } R _ { i } ^ { T , + } ( a | I _ { i } ) > 0 } \\ { \frac { 1 } { | A ( I _ { i } ) | } } & { \mathrm { o t h e r w i s e } . } \end{array} \right.
+$$
+
+The average strategy $\bar { \sigma _ { i } } ^ { T }$ from iteration 1 to $T$ is defined as:
+
+$$
+\bar { \sigma _ { i } } ^ { T } ( a | I _ { i } ) = \frac { \sum _ { t = 1 } ^ { T } \pi _ { i } ^ { \sigma ^ { t } } ( I _ { i } ) \sigma _ { i } ^ { t } ( a | I _ { i } ) } { \sum _ { t = 1 } ^ { T } \pi _ { i } ^ { \sigma ^ { t } } ( I _ { i } ) } .
+$$
+
+where $\pi _ { i } ^ { \sigma ^ { t } } ( I _ { i } )$ denotes the information set reach probability of $I _ { i }$ at $t$ -th iteration and is used to weight the corresponding current strategy $\sigma _ { i } ^ { t } ( a | I _ { i } )$ . Define $s _ { i } ^ { t } ( a | I _ { i } ) ~ = ~ \pi _ { i } ^ { \sigma ^ { t } } ( I _ { i } ) \sigma _ { i } ^ { t } ( a | I _ { i } )$ as the additional numerator in iteration $t$ , then the cumulative numerator can be defined as
+
+$$
+\boldsymbol { S } ^ { T } ( \boldsymbol { a } | I _ { i } ) = \sum _ { t = 1 } ^ { T } \pi _ { i } ^ { \sigma ^ { t } } ( I _ { i } ) \boldsymbol { \sigma } _ { i } ^ { t } ( \boldsymbol { a } | I _ { i } ) = \boldsymbol { S } ^ { T - 1 } ( \boldsymbol { a } | I _ { i } ) + \boldsymbol { s } _ { i } ^ { T } ( \boldsymbol { a } | I _ { i } ) .
+$$
+
+where $S ^ { 0 } ( a | I _ { i } ) = 0$ .
+
+# 2.4 MONTE CARLO CFR
+
+When solving a game, CFR needs to traverse the entire game tree in each iteration, which will prevent it from handling large games with limited memory. To address this challenge, Lanctot et al. (2009) proposed a Monte Carlo CFR to minimize counterfactual regret. Their method can compute an unbiased estimation of counterfactual value and avoid traversing the entire game tree. Since only subsets of all information sets are visited in each iteration, this approach requires less memory than standard CFR.
+
+Define $\mathcal { Q } = \{ Q _ { 1 } , Q _ { 2 } , . . . , Q _ { m } \}$ , where $Q _ { j } \in Z$ is a block of sampling terminal histories in each iteration, such that $\mathcal { Q } _ { j }$ spans the set $Z$ . Generally, different $Q _ { j }$ may have an overlap according to the specify sampling schema. Specifically, in the external sampling and outcome sampling, each block $\textstyle \sum _ { j = 1 } ^ { m } q _ { Q _ { j } } = 1$ $Q _ { j } \in \mathcal { Q }$ . Define is a partition of $\begin{array} { r } { q ( z ) = \sum _ { j : z \in Q _ { j } } q _ { Q _ { j } } } \end{array}$ $Z$ . Define $q _ { Q _ { j } }$ j  as the probability of considering a particular terminal as the probability of considering block $Q _ { j }$ , where history $z$ . Specifically, vanilla CFR is a special case of MCCFR, where $\mathcal { Q } = \{ Z \}$ only contain one block and $q _ { Q _ { 1 } } = 1$ . In outcome sampling, only one trajectory will be sampled, such that $\forall Q _ { j } \in \mathcal { Q }$ , $| Q _ { j } | = 1$ and $| \mathcal { Q } _ { j } | = | Z |$ . For information set $I _ { i }$ , a sample estimate of counterfactual value is $\begin{array} { r } { \tilde { v } _ { i } ^ { \sigma } ( I _ { i } | Q _ { j } ) = \sum _ { h \in I _ { i } , z \in Q _ { j } , h \subseteq z } \frac { 1 } { q ( z ) } \pi _ { - i } ^ { \sigma } ( z ) \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ( z ) . } \end{array}$
+
+Lemma 2: The sampling counterfactual value in MCCFR is the unbiased estimation of actual counterfactual value in CFR. $E _ { j \sim q _ { Q _ { j } } } [ \tilde { v } _ { i } ^ { \sigma } ( I _ { i } | Q _ { j } ) ] = v _ { i } ^ { \sigma } ( I _ { i } )$ (Lemma 1, Lanctot et al. (2009).)
+
+Define $\sigma ^ { r s }$ as sampling strategy profile, where $\sigma _ { i } ^ { r s }$ is the sampling strategy for player $i$ and $\boldsymbol { \sigma } _ { - i } ^ { r s }$ are the sampling strategies for players expect $i$ . Particularly, for both external sampling and outcome sampling proposed by (Lanctot et al., 2009), $\sigma _ { - i } ^ { r s } = \sigma _ { - i }$ . The regret of the sampled action $a \in A ( I _ { i } )$ is defined as
+
+$$
+\tilde { r } _ { i } ^ { \sigma } ( ( a | I _ { i } ) | Q _ { j } ) = \sum _ { \substack { z \in Q _ { j } , h a \subseteq z , h \in I _ { i } } } \pi _ { i } ^ { \sigma } ( h a , z ) u _ { i } ^ { r s } ( z ) - \sum _ { \substack { z \in Q _ { j } , h \subseteq z , h \in I _ { i } } } \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ^ { r s } ( z ) \quad \quad ,
+$$
+
+where $\begin{array} { r } { u _ { i } ^ { r s } ( z ) = \frac { u _ { i } ( z ) } { \pi _ { i } ^ { \sigma ^ { r s } } ( z ) } } \end{array}$ is a new utility weighted by $\frac { 1 } { \pi _ { i } ^ { \sigma ^ { r s } } ( z ) }$ . The sample estimate for cumulative regret of action $a$ after $T$ iterations is $\tilde { R } _ { i } ^ { T } ( ( a | I _ { i } ) | Q _ { j } ) = \tilde { R } _ { i } ^ { T - 1 } ( ( a | I _ { i } ) | Q _ { j } ) + \tilde { r } _ { i } ^ { \sigma ^ { T } } ( ( a | I _ { i } ) | Q _ { j } )$ with $\tilde { R } _ { i } ^ { 0 } ( ( a | I _ { i } ) | Q _ { j } ) = 0 .$ .
+
+# 3 DOUBLE NEURAL COUNTERFACTUAL REGRET MINIMIZATION
+
+![](images/64147e383af628fd9db0c831bbea06a83794a2efc56494a24ebbd190b9053504.jpg)  
+Figure 1: (A) tabular based CRF and (B) our double neural based CRF framework.
+
+In this section, we will explain our double neural CFR algorithm, where we employ two neural networks, one for the cumulative regret, and the other for the average strategy. As shown in Figure 1 (A), standard CFR-family methods such as CFR (Zinkevich et al., 2007), outcome-sampling MCCFR, external sampling MCCFR (Lanctot et al., 2009), and $\mathrm { C F R + }$ (Tammelin, 2014) need to use two large tabular-based memories $\mathcal { M } _ { R }$ and $\mathcal { M } _ { S }$ to record the cumulative regret and average strategy for all information sets. Such tabular representation makes these methods difficult to apply to large extensive-form games with limited time and space (Burch, 2017).
+
+In contrast, we will use two deep neural networks to compute approximate Nash equilibrium of IIG as shown in Figure 1 (B). Different from NFSP, our method is based on the theory of CFR, where the first network is used to learn the cumulative regret and the other is to learn the cumulative numerator of the average strategy profile. With the help of these two networks, we do not need to use two large tabular-based memories; instead, we rely on the generalization ability of the compact neural network to produce the cumulative regret and the average strategy. In practice, the proposed double neural method can achieve a lower exploitability with fewer iterations than NFSP. In addition, we present experimentally that our double neural CFR can also continually improve after initialization from a poor tabular strategy.
+
+# 3.1 OVERALL FRAMEWORK
+
+The iterative updates of the CFR algorithm maintain two strategies: the current strategy $\sigma _ { i } ^ { t } ( a | I _ { i } )$ , and the average strategy $\bar { \sigma } _ { i } ^ { t } ( a | I _ { i } )$ for $\forall i \in N , \forall I _ { i } \in \mathbb { Z } _ { i } , \forall a \in A ( \bar { I } _ { i } ) , \forall t \in \{ 1 , \dots , T \}$ . Thus, our two neural networks are designed to maintain these two strategies in iterative fashion. More specifically, • Current strategy. According to Eq. (3), current strategy $\sigma ^ { t + 1 } ( a | I _ { i } )$ is computed by the cumulative regret $R ^ { t } ( a | I _ { i } )$ . We only need to track the numerator in Eq. (3) since the normalization in the denominator can easily be computed when the strategy is used. Given information set $I _ { i }$ and action $a$ , we design a neural network RegretSumNetwork(RSN) $\mathcal { R } ( a , I _ { i } | \theta _ { \mathcal { R } } ^ { t } )$ to learn $R ^ { t } ( a | I _ { i } )$ , where $\theta _ { \mathcal { R } } ^ { t }$ is the parameter in the network at $t$ -th iteration. As shown Figure 1 (b), define memory $\mathcal { M } _ { R } ~ = ~ \{ ( I _ { i } , \tilde { r } _ { i } ^ { \sigma ^ { t } } ( ( a | I _ { i } ) | Q _ { j } ) ) | \forall i ~ \in ~ N , \forall a ~ \in ~$ $A ( I _ { i } ) , h \in I _ { i } , h \subseteq z , z \in Q _ { j } \}$ . Each member of $\mathcal { M } _ { R }$ is the visited information set $I _ { i }$ and the corresponding regret $\tilde { r } _ { i } ^ { \sigma ^ { t } } ( ( a | I _ { i } ) | Q _ { j } )$ , where $Q _ { j }$ is the sampled block in $t$ -th iteration. According to Eq. (2), we can estimate $\mathcal { R } ( a , I _ { i } | \theta _ { \mathcal { R } } ^ { t + 1 } )$ using the following optimization:
+
+$$
+\theta _ { \mathcal { R } } ^ { t + 1 }  \underset { \theta _ { \mathcal { R } } ^ { t + 1 } } { \mathrm { a r g m i n } } \sum _ { \substack { ( I _ { i } , \tilde { r } _ { i } ^ { \sigma ^ { t } } ( ( a | I _ { i } ) | Q _ { j } ) ) \in \mathcal { M } _ { R } } } ( \mathcal { R } ( a , I _ { i } | \theta _ { \mathcal { R } } ^ { t } ) + \tilde { r } _ { i } ^ { \sigma ^ { t } } ( ( a | I _ { i } ) | Q _ { j } ) - \mathcal { R } ( a , I _ { i } | \theta _ { \mathcal { R } } ^ { t + 1 } ) ) ^ { 2 } .
+$$
+
+• Average Strategy. According to Eq. (4), the approximate Nash equilibrium is the weighted average of all previous strategies over $T$ iterations. Similar to the cumulative regret, we employ another deep neural network AvgStrategyNetwork(ASN) to learn the numerator of the average strategy. Define $\mathcal { M } _ { S } = \{ ( I _ { i } , \pi _ { i } ^ { \sigma ^ { t } } ( I _ { i } ) \sigma _ { i } ^ { t } ( a | I _ { i } ) ) | \forall i \in N , \forall a \in A ( I _ { i } ) , h \in$ $I _ { i } , h \subseteq z , z \in Q _ { j } \}$ . Each member of $\mathcal { M } _ { S }$ is the visited information set $I _ { i }$ and the value of $\pi _ { i } ^ { \sigma ^ { t } } ( I _ { i } ) \sigma _ { i } ^ { t } ( a | I _ { i } )$ , where $Q _ { j }$ is the sampled block in $t$ -th iteration. Then the parameter $\theta _ { S } ^ { t + 1 }$ can estimated by the following optimization:
+
+$$
+\theta _ { \mathcal { S } } ^ { t + 1 }  \underset { \theta _ { \mathcal { S } } ^ { t + 1 } } { \mathrm { a r g m i n } } \sum _ { \substack { ( I _ { i } , s _ { i } ^ { t } ( a | I _ { i } ) ) \in \mathcal { M } _ { \mathcal { S } } } } ( \mathcal { S } ( a , I _ { i } | \theta _ { \mathcal { S } } ^ { t } ) + s _ { i } ^ { t } ( a | I _ { i } ) - \mathcal { S } ( a , I _ { i } | \theta _ { \mathcal { S } } ^ { t + 1 } ) ) ^ { 2 } .
+$$
+
+Remark 1: In each iteration, only a small subset of information sets are sampled, which may lead to the neural networks forgetting values for those unobserved information sets. To address this problem, we will use the neural network parameters from the previous iteration as the initialization, which gives an online learning/adaptation flavor to the updates. Furthermore, due to the generalization ability of the neural networks, even samples from a small number of information sets are used to update the new neural networks, the newly updated neural networks can produce very good value for the cumulative regret and the average strategy.
+
+Remark 2: As we increase the number of iterations $t$ , the value of $R _ { i } ^ { t } ( a | I _ { i } )$ will become increasingly large, which may make neural network difficult to learn. To address this problem,√ we will normalize the cumulative regret by a factor of $\sqrt { t }$ to make its range more stable. This can be understood from the regret bound of online learning. More specifically, let $\Delta \ =$ $\begin{array} { r } { \operatorname* { m a x } _ { I _ { i } , a , t } | R ^ { t } ( a | I _ { i } ) - R ^ { t - 1 } ( a | I _ { i } ) | , \forall \bar { I _ { i } } \ \in \ \mathcal { Z } , a \ \in \ A ( I _ { i } ) , t \ \in \ \{ 1 , \cdots , T \} } \end{array}$ . We have $\begin{array} { r } { \mathrm { ~ \dot { ~ } ~ } R _ { i } ^ { t } ( a | I _ { i } ) \ \le \ } \end{array}$ $\Delta \sqrt { | A | t }$ according to the Theorem 6 in (Burch, 2017), where $\vert A \vert = \operatorname* { m a x } _ { I _ { i } \in { \mathcal { T } } } \left. A ( I _ { i } ) \right.$ . In practice, we can use the neural network to track $\hat { R } _ { i } ^ { t } ( a | I _ { i } ) = R _ { i } ^ { t } ( a | I _ { i } ) / \sqrt { t }$ , and update it by
+
+$$
+\hat { R } _ { i } ^ { t } ( a | I _ { i } ) = \frac { \sqrt { t - 1 } \hat { R } _ { i } ^ { t - 1 } ( a | I _ { i } ) } { \sqrt { t } } + \frac { r _ { i } ^ { \sigma ^ { t } } ( a | I _ { i } ) } { \sqrt { t } } , \mathrm { ~ w h e r e ~ } \hat { R } _ { i } ^ { 0 } ( a | I _ { i } ) = 0 .
+$$
+
+Remark 3: The optimization problem for the double neural networks is different from that in DQN (Mnih et al., 2015). In DQN, the Q-value for the greedy action is used in the update, while in our setting, we do not use greedy actions. Algorithm E gives further details on how to optimize the objectives in Eq. (7) and Eq. (8).
+
+Relation between CFR, MCCFR and our double neural method. As shown in Figure 1, these three methods are based on the CFR framework. The CFR computes counterfactual value and regret by traversing the entire tree in each iteration, which makes it computationally intensive to be applied to large games directly. MCCFR samples a subset of information sets and will need less computation than CFR in each iteration. However, both CFR and MCCFR need two large tabular memories to save the cumulative regrets and the numerators of the average strategy for all information sets, which prevents these two methods to be used in large games directly. The proposed neural method keeps the benefit of MCCFR yet without the need for two large tabular memories.
+
+# 3.2 RECURRENT NEURAL NETWORK REPRESENTATION FOR INFORMATION SET
+
+In order to define our $\mathcal { R }$ and $s$ network, we need to represent the information set $I _ { i } ~ \in ~ \mathcal { T }$ in extensive-form games. In such games, players take action in alternating fashion and each player makes a decision according to the observed history. Because the action sequences vary in length, in this paper, we model them with a recurrent neural network and each action in the sequence corresponds to a cell in RNN. This architecture is different from the one in DeepStack (Moravcik et al., 2017), which used a fully connected deep neural network to estimate counterfactual value. Figure 2 (A) provides an illustration of the proposed deep sequential neural network representation for information sets. Besides the vanilla RNN, there are several variants of more expressive RNNs, such as the GRU (Cho et al., 2014) and LSTM (Hochreiter & Schmidhuber, 1997). In our later experiments, we will compare these different neural architectures as well as a fully connected network representation.
+
+![](images/a87aa39619199022149e3da013cad7ccf70e7a8294277e6ea9144e66d377597e.jpg)  
+Figure 2: (A) the key architecture of the sequential neural networks. (B) an overview of the novel double neural counterfactual regret minimization method.
+
+Furthermore, different position in the sequence may contribute differently to the decision making, we will add an attention mechanism (Desimone & Duncan, 1995; Cho et al., 2015) to the RNN architecture to enhance the representation. For example, the player may need to take a more aggressive strategy after beneficial public cards are revealed. Thus the information, after the public cards are revealed may be more important. In practice, we find that the attention mechanism can help the double neural CFR obtain a better convergence rate. In section D, we will provide more details on neural network architectures.
+
+# 3.3 CONTINUAL IMPROVEMENT
+
+With the proposed framework of double neural CFR, it is easy to initialize the neural networks from an existing strategy profile based on the tabular representation or neural representation. For information set $I _ { i }$ and action $a$ , in an existing strategy profile, define $R _ { i } ^ { \prime } ( a | I _ { i } )$ as the cumulative regret and $\boldsymbol { S } ^ { ' } ( \boldsymbol { a } | I _ { i } )$ as the cumulative numerator of average strategy. We can clone the cumulative regret for all information sets and actions by optimizing
+
+$$
+\theta _ { \mathcal { R } } ^ { * }  \underset { \theta _ { \mathcal { R } } } {  } \underset { i \in N , I _ { i } \in \mathcal { T } _ { i } , a \in A ( I _ { i } ) } { \sum } \Bigg ( \mathcal { R } ( a , I _ { i } | \theta _ { \mathcal { R } } ) - R ^ { ' } ( a | I _ { i } ) \Bigg ) ^ { 2 } .
+$$
+
+Similarly, the parameters $\theta _ { S } ^ { * }$ for cloning the cumulative numerator of average strategy can be optimized in the same way. Based on the learned $\theta _ { \mathcal { R } } ^ { * }$ and $\theta _ { S } ^ { * }$ , we can warm start the double neural networks and continually improve beyond the tabular strategy profile.
+
+Remark: In the large extensive game, the initial strategy is obtained from an abstracted game which has a manageable number of information sets. The abstracted game is generated by domain knowledge, such as clustering similar hand strength cards into the same buckets. Once the strategy of this abstract game is solved, it can be clone according to Eq. (10) and improved continuously using our double neural CFR framework.
+
+# 3.4 OVERALL ALGORITHM
+
+Algorithm 1 provides a summary of the proposed double neural counterfactual regret minimization algorithm. In the first iteration, if the system warm starts from tabular based CFR or MCCFR methods, the techniques in section 3.3 will be used to clone the cumulative regrets and strategy. If there is no warm start initialization, we can start our algorithm by randomly initializing the parameters in RSN and ASN at iteration $ { \boldsymbol { t } } \ = \ 1$ . Then sampling methods will return the counterfactual regret and the numerator of average strategy for the sampled information sets in this iteration, and they will be saved in memories $\mathcal { M } _ { \mathcal { R } }$ and $\mathcal { M } _ { \mathcal { S } }$ respectively. Then these samples will be used by the NeuralAgent algorithm from Algorithm 2 to optimize RSN and ASN. Further details for the sampling methods and the NeuralAgent fitting algorithm will be discussed in the next section.
+
+# Algorithm 1: Counterfactual Regret Minimization with Two Deep Neural Networks
+
+1 Function Agent $( T , b )$ :   
+2 For $t = 1$ to $T$ do   
+3 if $t = 1$ and using warm starting then   
+4 initialize $\theta _ { \mathcal { R } } ^ { t }$ and $\theta _ { S } ^ { t }$ from an existing checkpoint   
+5 $t \gets t + 1$ . skip cold starting   
+6 else   
+7 initialize $\theta _ { \mathcal { R } } ^ { t }$ and $\theta _ { S } ^ { t }$ randomly.   
+8 $\dot { \mathcal { M } } _ { \mathcal { R } } , \mathcal { M } _ { S } \gets$ sampling methods for CFV and average strategy. . such as Algorithm3   
+9 sum aggregate the value in $\mathcal { M } _ { R }$ by information set. . according to the Lemma 5 and Equation 12   
+10 remove duplicated records in $\mathcal { M } _ { S }$ .   
+11 $\theta _ { \mathcal { R } } ^ { t } \gets \mathrm { N e u r a l A g e n t } ( \mathcal { R } ( \cdot | \theta _ { \mathcal { R } } ^ { t - 1 } ) , \mathcal { M } _ { R } , \theta _ { \mathcal { R } } ^ { t - 1 } , \beta _ { \mathcal { R } } ^ { * } )$ . update $\boldsymbol { \theta } _ { \mathcal { R } } ^ { t }$ using Algorithm2   
+12 $\mathsf { \Pi } _ { \mathsf { C } } \theta _ { S } ^ { t } \gets \mathrm { N e u r a l A g e n t } ( S ( \cdot | \theta _ { S } ^ { t - 1 } ) , \mathcal { M } _ { S } , \theta _ { S } ^ { t - 1 } , \beta _ { S } ^ { * } )$ . update $\theta _ { S } ^ { t }$ using Algorithm2   
+13 return θtR, θtS
+
+# 4 EFFICIENT TRAINING
+
+In this section, we will propose two techniques to improve the efficiency of the double neural method. These techniques can also be used separately in other CFR-based methods.
+
+# 4.1 ROBUST SAMPLING TECHNIQUES
+
+In this paper, we proposed a new robust sampling technique which has lower variance than outcome sampling, while being more memory efficient than the external sampling. In this robust sampling method, the sampling profile is defined as $\sigma ^ { r s ( k ) } = ( \sigma _ { i } ^ { r s ( k ) } , \sigma _ { - i } )$ , where player $i$ will randomly select player actions according to sampling strategy will randomly select one action according $\sigma _ { i } ^ { r s ( k ) } ( I _ { i } )$ y each information set . $I _ { i }$ and other $\sigma _ { - i }$
+
+Specifically, if player $i$ randomly selects $m i n ( k , | A ( I _ { i } ) | )$ actions according to discrete uniform distribution uni $f ( 0 , \left| A ( I _ { i } ) \right| )$ at information set $I _ { i }$ , i.e., $\begin{array} { r } { \sigma _ { i } ^ { r s ( k ) } ( a | I _ { i } ) = \frac { m i n ( k , | A ( I _ { i } ) | ) } { | A ( I _ { i } ) | } } \end{array}$ min(k,|A(Ii)|) , then
+
+$$
+\pi _ { i } ^ { \sigma ^ { r s ( k ) } } ( I _ { i } ) = \prod _ { \substack { h \in I _ { i } , h ^ { \prime } \subseteq h , h ^ { \prime } a \subseteq h , h ^ { \prime } \in I _ { i } ^ { \prime } } } \frac { m i n ( k , | A ( I _ { i } ^ { \prime } ) | ) } { | A ( I _ { i } ^ { \prime } ) | }
+$$
+
+and the weighted utility $u _ { i } ^ { r s ( k ) } ( z )$ will be a constant number in each iteration, which has a low variance. In addition, because the weighted utility no longer requires explicit knowledge of the opponent’s strategy, we can use this sampling method for online regret minimization. For simplicity, $k = m a x$ refers to $k = m a x _ { I _ { i } \in \mathcal { T } } | A ( I _ { i } ) |$ in the following sections.
+
+Lemma 3: If $k = m a x$ and $\forall i \in N , \forall I _ { i } \in \mathbb { Z } _ { i } , \forall a \in A ( I _ { i } ) , \sigma _ { i } ^ { r s ( k ) } ( a | I _ { i } ) \sim u n i f ( 0 , | A ( I _ { i } ) | ) .$ , then robust sampling is the same as external sampling.
+
+Lemma 4: If $k = 1$ and $\sigma _ { i } ^ { r s ( k ) } = \sigma _ { i }$ , then robust sampling is the same as outcome sampling.
+
+Lemma 3 and Lemma 4 provide the relationship between outcome sampling, external sampling, and the proposed robust sampling algorithm. The detailed theoretical analysis are presented in Appendix G.2.
+
+# 4.2 MINI-BATCH TECHNIQUES
+
+Mini-batch MCCFR: Traditional outcome sampling and external sampling only sample one block in an iteration and provide an unbiased estimator of origin CFV according to Lemma 2. In this paper, we present a mini-batch Monte Carlo technique and randomly sample $b$ blocks in one iteration. Let $Q ^ { j }$ denote a block of terminals sampled according to the scheme in section 4.1 at $j$ −th time, then mini-batch CFV with $b$ mini-batches for information set $I _ { i }$ can be defined as
+
+$$
+\tilde { v } _ { i } ^ { \sigma } ( I _ { i } | b ) = \frac { 1 } { b } \sum _ { j = 1 } ^ { b } \left( \sum _ { h \in I _ { i } , z \in Q ^ { j } , h \subseteq z } \frac { \pi _ { - i } ^ { \sigma } ( z ) \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ( z ) } { q ( z ) } \right) = \sum _ { j = 1 } ^ { b } \frac { \tilde { v } _ { i } ^ { \sigma } ( I _ { i } | Q ^ { j } ) } { b } .
+$$
+
+Furthermore, we can show that $\tilde { v } _ { i } ^ { \sigma } ( I _ { i } | b )$ is an unbiased estimator of the counterfactual value of $I _ { i }$ : Lemma 5: $E _ { Q ^ { j } \sim \mathrm { R o b u s t \ : S a m p l i n g } } [ \tilde { v } _ { i } ^ { \sigma } ( I _ { i } | b ) ] = v _ { i } ^ { \sigma } ( I _ { i } )$ . (see the proof in section G.3) Similarly, the cumulative mini-batch regret of action $a$ is
+
+$$
+\tilde { R } _ { i } ^ { T } ( ( a | I _ { i } ) | b ) = \tilde { R } _ { i } ^ { T - 1 } ( ( a | I _ { i } ) | b ) + \tilde { v } _ { i } ^ { \sigma ^ { T } } ( ( a | I _ { i } ) | b ) - \tilde { v } _ { i } ^ { \sigma ^ { T } } ( I _ { i } | b )
+$$
+
+where $\tilde { R } _ { i } ^ { 0 } ( ( a | I _ { i } ) | b ) = 0$ . In practice, mini-batch technique can sample $b$ blocks in parallel and help MCCFR to converge faster.
+
+Mini-Batch $\mathbf { M C C F R + }$ : When optimizing counterfactual regret, $\mathrm { C F R + }$ (Tammelin, 2014) substitutes the regret-matching algorithm (Hart & Mas-Colell, 2000) with regret-matching $^ +$ and can converge faster than CFR. However, Burch (2017) showed that ${ \mathrm { M C C F R } } +$ actually converge slower than MCCFR when mini-batch is not used. In our paper, we derive mini-batch version of MCCFR $^ +$ which updates cumulative mini-batch regret $\tilde { R } ^ { T , + } ( ( a | I _ { i } ) | b )$ up to iteration $T$ by
+
+$$
+\begin{array} { r } { \tilde { R } ^ { T , + } ( ( a | I _ { i } ) | b ) = \left\{ \begin{array} { l l } { \big ( \tilde { v } _ { i } ^ { \sigma ^ { T } } ( ( a | I _ { i } ) | b ) - \tilde { v } _ { i } ^ { \sigma ^ { T } } ( I _ { i } | b ) \big ) ^ { + } } & { \mathrm { i f } T = 0 } \\ { \big ( \tilde { R } _ { i } ^ { T - 1 , + } ( ( a | I _ { i } ) | b ) + \tilde { v } _ { i } ^ { \sigma ^ { T } } ( ( a | I _ { i } ) | b ) - \tilde { v } _ { i } ^ { \sigma ^ { T } } ( I _ { i } | b ) \big ) ^ { + } } & { \mathrm { i f } T > 0 } \end{array} \right. , } \end{array}
+$$
+
+where $( x ) ^ { + } = m a x ( x , 0 )$ . In practice, we find that mini-batch ${ \mathrm { M C C F R } } +$ converges faster than mini-batch MCCFR when specifying a suitable mini-batch size.
+
+# 5 EXPERIMENT
+
+The proposed double neural CFR algorithm will be evaluated in the One-Card-Poker game with 5 cards and a large No-Limit Leduc Hold’em (NLLH) with stack size 5, 10, and 15. The largest NLLH in our experiment has over $2 \times 1 0 ^ { 7 }$ states and $3 . 7 \times 1 0 ^ { 6 }$ information sets. We will compare it with tabular CFR and deep reinforcement learning based method such as NFSP. The experiments show that the proposed double neural algorithm can converge to comparable results produced by its tabular counterpart while performing much better than deep reinforcement learning method. With the help of neural networks, our method has a strong generalization ability to converge to an approximate Nash equilibrium by using fewer parameters than the number of information sets. The current results open up the possibility for a purely neural approach to directly solve large IIG. Due to space limit, we present experimental results for One-Card-Poker and the analysis in section C. The hyperparameters and setting about the neural networks can be found in section E.
+
+Settings. To simplify the expression, the abbreviations of different methods are defined as follows. XFP refers to the full-width extensive-form fictitious play method. NFSP refers to the reinforcement learning based fictitious self-play method. RS-MCCFR refers to the proposed robust sampling MCCFR. This method with regret matching+ acceleration technique is denoted by $\mathbf { R S - M C C F R + }$ . These methods only containing one neural network are denoted by $\mathbf { R S - M C C F R + - R S N }$ and RS-MCCFR $^ +$ -ASN respectively. RS-MCCFR $^ +$ -RSN-ASN refers to the proposed double neural MCCFR. According to Lemma 3, if $k = m a x$ , ES-MCCFR is the same with RS-MCCFR. More specifically, we investigated the following questions.
+
+Is mini-batch sampling helpful? Figure 3(A) presents the convergence curves of the proposed robust sampling method with $k = m a x$ under different mini-batch sizes $\scriptstyle \mathbf { b } = 1$ , 1000, 5000, 10000 respectively). The experimental results show that larger batch sizes generally lead to better strategy profiles. Furthermore, the convergence for $b = 5 0 0 0$ is as good as $b = 1 0 0 0 0$ . Thus in the later experiments, we set the mini-batch size equal to 5000.
+
+Is robust sampling helpful? Figure 3 (B) and (C) presents convergence curves for outcome sampling, external sampling $ { k } = \ m a x ,$ ) and the proposed robust sampling method under the different number of sampled actions. The outcome sampling cannot converge to a low exploitability smaller than 0.1 after 1000 iterations The proposed robust sampling algorithm with $k = 1$ , which only samples one trajectory like the outcome sampling, can achieve a better strategy profile after the same number of iterations. With an increasing $k$ , the robust sampling method achieves an even better convergence rate. Experiment results show $k = 3$ and 5 have a similar trend with $k = m a x$ , which demonstrates that the proposed robust sampling achieves similar strategy profile but requires less memory than the external sampling. We choose $k = 3$ for the later experiments in Leduc Hold’em Poker. Figure 3 (C) presents the results in a different way and displays the relation between exploitability and the cumulative number of touched nodes. The robust sampling with small $k$ is just as good as the external sampling while being more memory efficient on the condition that each algorithm touches the same number of nodes.
+
+![](images/4045b089d201f5e8d882ec7c4c42356a8678b0d4fa0cb084a0de16dc2556e69d.jpg)  
+Figure 3: Comparison of different CFR-family methods in Leduc Hold’em. (A) Performance of robust sampling with different batch size. (B) Performance of robust sampling with different parameter $k$ by iteration. (C) Performance by the number of touched node.
+
+![](images/ecb77d608bb71a775aaa8e16fe9b03508cfe43ba39750e4fc2967e6a14d3bcaa.jpg)  
+Figure 4: Performance of different methods in Leduc Hold’em. (A) comparison of NSFP, XFP and the proposed double neural method. (B) each contribution of RSN and ASN. (C) continue improvement from tabular based CFR and ${ \mathrm { R S - M C C F R + } }$ .
+
+How does double neural CRF compare to the tabular counterpart, XFP, and NFSP? To obtain an approximation of Nash equilibrium, Figure 4(A) demonstrates that NFSP needs $1 0 ^ { 6 }$ iterations to reach a 0.06-Nash equilibrium, and requires $2 \times 1 0 ^ { 5 }$ state-action pair samples and $2 \times 1 0 ^ { 6 }$ samples for supervised learning respectively. The XFP needs $1 0 ^ { 3 }$ iterations to obtain the same exploitability, however, this method is the precursor of NFSP and updated by a tabular based full-width fictitious play. Our proposed neural method only needs 200 iterations to achieve the same performance which shows that the proposed double neural algorithm converges significantly better than the reinforcement learning counterpart. In practice, our double neural method can achieve an exploitability of 0.02 after 1000 iterations, which is similar to the tabular method.
+
+What is the individual effect of RSN and ASN? Figure 4(B) presents ablation study of the effects of RSN and ASN network respectively. Both MCCFR $^ +$ -RSN and $\mathbf { M C C F R + - A }$ SN, which only employ one neural network, perform only slightly better than the double neural method. All the proposed neural methods can match the performance of the tabular based method.
+
+How well does continual improvement work? In practice, we usually want to continually improve our strategy profile from an existing checkpoint (Brown & Sandholm, 2016). In the framework of the proposed neural counterfactual regret minimization algorithm, warm starting is easy and friendly. Firstly, we employ two neural networks to clone the existing tabular based cumulative regret and the numerator of average strategy by optimizing Eq. (10). Then the double neural methods can continually improve the tabular based methods. As shown in Figure 4(C), warm start from either full-width based or sampling based CFR the existing can lead to continual improvements. Specifically, the first 10 iterations are learned by tabular based CFR and ${ \mathrm { R S - M C C F R + } }$ . The remaining iterations are continually improved by the double neural method, where $b = 5 0 0 0 , k =$ max.
+
+![](images/bcf24e34580fd0c6453d666790442ef51eae0b02c9104594e383c44c0dcbf075.jpg)  
+Figure 5: Performance analysis from different perspectives: (A) Generalization: by observed nodes. (B) Compression: by embedding size. (C) Large Game: by game size. (D) Architecture: by attention or not.
+
+Do the neural networks generalize to unseen information sets? To investigate the generalization ability, we perform the neural CFR with small mini-batch sizes $( \mathtt { b } \mathtt { = } 5 0$ , 100, 500), where only $3 . 0 8 \%$ , $5 . 5 9 \%$ , and $1 3 . 0 6 \%$ information sets are observed in each iteration. In all these settings, the double neural can still converge and arrive at exploitability less than 0.1 within only 1000 iterations (Figure 5(A)).
+
+Do the neural networks just memorize but not generalize? One indication that the neural networks are generalizing is that they use much fewer parameters than their tabular counterparts. We experimented with LSTM plus attention networks, and embedding size of 8 and 16 respectively. These architectures contain 1048 and 2608 parameters respectively in NLLH(5), both of which are much less than the tabular memory (more than $1 0 ^ { 4 }$ number here). Note that both these two embedding sizes still leads to a converging strategy profile as shown in Figure 5(B).
+
+Does neural method converge in the larger game? Figure 5(C) presents the log-log convergence curve of NLLH with different stack size (5, 10 and 15 respectively). The largest game size contains over $2 \times 1 0 ^ { 7 }$ states and $3 . 7 \times 1 0 ^ { 6 }$ information sets. Let mini-batch size be 500, there are $1 3 . 0 6 \%$ , $2 . 3 9 \%$ and $0 . 5 3 \%$ information sets that are observed respectively in each iteration. Even though only a small subset of nodes are sampled, the double neural method can still converge.
+
+Is attention in the neural architecture helpful? Figure 5(D) presents the convergence curves of several different deep neural architectures, such as a fully connected deep neural network(FC), LSTM, LSTM plus attention, original RNN plus attention, and GRU plus attention. The recurrent neural network plus attention helps us obtain better strategies rate than other architectures after hundreds of iterations.
+
+# 6 CONCLUSION AND FUTURE WORK
+
+In this paper, we present a novel double neural counterfactual regret minimization method to solve large imperfect information game, which has a strong generalization and compression ability and can match the performance of tabular based CFR approach. We also developed a new sampling technique which has lower variance than the outcome sampling, while being more memory efficient than the external sampling. In the future, we plan to explore much more flexible methods and apply the double neural method to larger games, such as No-Limit Texas Hold’em.
+
+# REFERENCES
+
+Noam Brown and Tuomas Sandholm. Strategy-based warm starting for regret minimization in games. pp. 432–438. AAAI, 2016.
+
+Noam Brown and Tuomas Sandholm. Superhuman ai for heads-up no-limit poker: Libratus beats top professionals. Science, pp. eaao1733, 2017.
+
+Neil Burch. Time and space: Why imperfect information games are hard. PhD thesis, 2017.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, ¨ Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
+
+Kyunghyun Cho, Aaron Courville, and Yoshua Bengio. Describing multimedia content using attention-based encoderdecoder networks. arXiv preprint arXiv:1507.01053, 2015.
+
+Robert Desimone and John Duncan. Neural mechanisms of selective visual attention. Number 18, pp. 193–222. Annual review of neuroscience, 1995.
+
+Geoffrey J. Gordon. No-regret algorithms for structured prediction problems. Number CMU-CALD-05-112. CARNEGIE-MELLON UNIV PITTSBURGH PA SCHOOL OF COMPUTER SCIENCE, 2005.
+
+David Harris and Sarah Harris. Digital design and computer architecture (2nd ed.), volume ISBN 978-0-12-394424-5. San Francisco, Calif.: Morgan Kaufmann.
+
+Sergiu Hart and Andreu Mas-Colell. A simple adaptive procedure leading to correlated equilibrium. Econometrica, (65(5)):1127–1150, 2000.
+
+Johannes Heinrich and David Silver. Deep reinforcement learning from self-play in imperfect-information games. arXiv preprint arXiv:1603.01121, 2016.
+
+Johannes Heinrich, Marc Lanctot, and David Silver. Fictitious self-play in extensive-form games. pp. 805–813. International Conference on Machine Learning, 2015.
+
+Sepp Hochreiter and Jrgen Schmidhuber. Long short-term memory. Number 8, pp. 1735–1780. Neural computation, 1997.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Marc Lanctot, Waugh Kevin, Zinkevich Martin, and Michael Bowling. Monte carlo sampling for regret minimization in extensive games. In Advances in neural information processing systems, 2009.
+
+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, 2015.
+
+Matej Moravcik, Schmid Martin, Burch Neil, Lis Viliam, Dustin Morrill, Nolan Bard, Trevor Davis, Kevin Waugh, Michael Johanson, and Michael Bowling. Deepstack: Expert-level artificial intelligence in heads-up no-limit poker. Science, (6337):508–513, 2017.
+
+Martin J. Osborne and Rubinstein Ariel. A course in game theory, volume 1. MIT Press, 1994.
+
+Sebastian Ruder. An overview of gradient descent optimization algorithms. arXiv preprint arXiv:1609.04747, 2017.
+
+Finnegan Southey, Michael P. Bowling, Bryce Larson, Carmelo Piccione, Neil Burch, Darse Billings, and Chris Rayner. Bayes’ bluff: Opponent modelling in poker. arXiv preprint arXiv:1207.1411, 2012.
+
+Oskari Tammelin. Solving large imperfect information games using cfr+. arXiv preprint, 2014.
+
+Kevin Waugh, Dustin Morrill, James Andrew Bagnell, and Michael Bowling. Solving games with functional regret estimation. In AAAI, volume 15, pp. 2138–2144, 2015.
+
+Martin Zinkevich, Johanson Michael, Bowling Michael, and Carmelo Piccione. Regret minimization in games with incomplete information. Advances in neural information processing systems, 2007.
+
+# APPENDIX A GAME RULES
+
+Leduc Hold’em a two-players IIG of poker, which was first introduced in (Southey et al., 2012). In Leduc Hold’em, there is a deck of 6 cards comprising two suits of three ranks. The cards are often denoted by king, queen, and jack. In No-Limit Leduc Hold’em(NLLH), the player may wager any amount of chips up to a maximum of that player’s remaining stack. There is also no limit on the number of raises or bets in each betting round. There are two rounds. In the first betting round, each player is dealt one card from a deck of 6 cards. In the second betting round, a community (or public) card is revealed from a deck of the remaining 4 cards. In this paper, we use NLLH(x) refer to the No-Limit Leduc Hold’em, whose stack size is $x$ .
+
+One-Card Poker is a two-players IIG of poker described by (Gordon, 2005). The game rules are defined as follows. Each player is dealt one card from a deck of $X$ cards. The first player can pass or bet, If the first player bet, the second player can call or fold. If the first player pass, the second player can pass or bet. If second player bet, the first player can fold or call. The game ends with two pass, call, fold. The fold player will lose 1 chips. If the game ended with two passes, the player with higher card win 1 chips, If the game end with call, the player with higher card win 2 chips.
+
+![](images/2ba244e9a04f20f8b13b20832920481e8e0cf6e582642b16a83b4de8740b66a5.jpg)  
+APPENDIX B DEFINITION OF EXTENSIVE-FORM GAMES   
+Figure 6: Illustration of extensive-form game. The left and right denote two different kinds of dealt private cards. We use same color other than gray for each state in the same information set. F, C, P, B refer to fold, call, pass, bet respectively.
+
+# B.1 ADDITIONAL DEFINITIONS
+
+For player $i$ , the expected game utility $\begin{array} { r } { u _ { i } ^ { \sigma } = \sum _ { z \in Z } \pi ^ { \sigma } ( z ) u _ { i } ( z ) } \end{array}$ of $\sigma$ is the expected payoff of all possible terminal nodes. Given a fixed strategy profile $\sigma _ { - i }$ , any strategy $\sigma _ { i } ^ { * } = \operatorname* { m a x } _ { \sigma _ { i } ^ { \prime } \in \Sigma _ { i } } u _ { i } ^ { ( \sigma _ { i } ^ { \prime } , \sigma _ { - i } ) }$ of player that achieves maximize payoff against $\pi _ { - i } ^ { \sigma }$ is a best response. For two players’ extensive-form games, a Nash equilibrium is a strategy profile $\sigma ^ { * } ~ = ~ ( \sigma _ { 0 } ^ { * } , \sigma _ { 1 } ^ { * } )$ such that each player’s strategy is a best response to the opponent. An $\epsilon$ -Nash equilibrium is an approximation of a Nash equilibrium, whose strategy profile $\sigma ^ { * }$ satisfies: $\forall i \in N$ , $\begin{array} { r } { \bar { u } _ { i } ^ { \sigma _ { i } ^ { * } } + \epsilon \geq \operatorname* { m a x } _ { \sigma _ { i } ^ { \prime } \in \Sigma _ { i } } u _ { i } ^ { ( \sigma _ { i } ^ { \prime } , \sigma _ { - i } ) } } \end{array}$ . Exploitability of a strategy $\sigma _ { i }$ is defined as $\epsilon _ { i } ( \sigma _ { i } ) = u _ { i } ^ { \sigma ^ { * } } - u _ { i } ^ { ( \sigma _ { i } , \sigma _ { - i } ^ { * } ) }$ u(σi,σ∗−i)i . A strategy is unexploitable if $\epsilon _ { i } ( \sigma _ { i } ) = 0$ . In large two player zero-sum games such poker, $u _ { i } ^ { \sigma ^ { * } }$ is intractable to compute. However, if the players alternate their positions, the value of a pair of games is zeros, i.e., $u _ { 0 } ^ { \sigma ^ { * } } + u _ { 1 } ^ { \sigma ^ { * } } = 0$ . We define the exploitability of strategy profile $\sigma$ as $\epsilon ( \bar { \sigma } ) = ( \bar { u _ { 1 } ^ { ( \sigma _ { 0 } , \sigma _ { 1 } ^ { * } ) } } + u _ { 0 } ^ { ( \sigma _ { 0 } ^ { * } , \sigma _ { 1 } ) } ) / 2$
+
+# B.2 EXPLANATION BY EXAMPLE
+
+To provide a more detailed explanation, Figure 6 presents an illustration of a partial game tree in One-Card Poker. In the first tree, two players are dealt (queen, jack) as shown in the left subtree and (queen, king) as shown in the right subtree. $z _ { i }$ denotes terminal node and $h _ { i }$ denotes non-terminal node. There are 19 distinct nodes, corresponding 9 non-terminal nodes including chance $h _ { 0 }$ and 10 terminal nodes in the left tree. The trajectory from the root to each node is a history of actions. In an extensive-form game, $h _ { i }$ refers to this history. For example, $h _ { 3 }$ consists of actions 0:Q, 1:J and P.
+
+$h _ { 7 }$ consists of actions 0:Q, 1:J, P and B. $h _ { 8 }$ consists of actions 0:Q, 1:K, P and B. We have $h _ { 3 } \subseteq h _ { 7 }$ , $A ( h _ { 7 } ) = \{ { \bf P } , { \bf B } \}$ and $P ( h _ { 3 } ) = 1$
+
+In IIG, the private card of player 1 is invisible to player 0, therefore $h _ { 7 }$ and $h _ { 8 }$ are actually the same for player 0. We use information set to denote the set of these undistinguished states. Similarly, $h _ { 1 }$ and $h _ { 2 }$ are in the same information set. For the right tree of Figure 6, $h _ { 3 } ^ { \prime }$ and $h _ { 5 } ^ { \prime }$ are in the same information set. $h _ { 4 } ^ { \prime }$ and $h _ { 6 } ^ { \prime }$ are in the same information set.
+
+Generally, any $I _ { i } \in \mathcal { Z }$ could only remember the information observed by player $i$ including player $i ^ { \prime } s$ hidden variable and public actions. For example, the information set of $h _ { 7 }$ and $h _ { 8 }$ indicates a sequence of 0:Q, P, and B. Because $h _ { 7 }$ and $h _ { 8 }$ are undistinguished by player 0 in IIG, all the states have a same strategy. For example, $I _ { 0 }$ is the information set of $h _ { 7 }$ and $h _ { 8 }$ , we have $I _ { 0 } = I _ { 0 } ( h _ { 7 } ) =$ $I _ { 0 } ( h _ { 8 } ) , \sigma _ { 0 } ( I _ { 0 } ) = \sigma _ { 0 } ( h _ { 7 } ) = \sigma _ { 0 } ( h _ { 8 } )$ , $\sigma _ { 0 } ( a | I _ { 0 } ) = \sigma _ { 0 } ( a | h _ { 7 } ) = \sigma _ { 0 } ( a | h _ { 8 } )$ .
+
+# APPENDIX C ADDITIONAL EXPERIMENT DETAILS
+
+# C.1 FEATURE ENCODING OF POKER GAMES
+
+The feature is encoded as following. As shown in the figure 2 (A), for a history $h$ and player $P ( h )$ , we use one-hot encoding (Harris & Harris) to represent the observed actions including chance player. For example, the input feature $x _ { l }$ for $l$ -th cell is the concatenation of three one-hot features including the given private cards, the revealed public cards and current action $a$ . Both the private cards and public cards are encoded by one-hot technique, where the value in the existing position is 1 and the others are 0. If there are no public cards, the respective position will be filled with 0. Because the action taking by chance is also a cell in the proposed sequential model. Thus in a No-Limit poker, such as Leduc Hold’em, action $a$ could be any element in $\{$ {fold, cumulative spent $\}$ {public cards} , where cumulative spent denotes the total chips after making a call or raise. The length of the encoding vector of action $a$ is the quantities of public cards plus 2, where cumulative spent is normalized by the stack size.
+
+# C.2 ADDITIONAL EXPERIMENT RESULTS
+
+![](images/9f2ed4259ee6c4db9d142fe13cb8344830768ceecd8e45cdf80e7e70412d94ac.jpg)  
+Figure 7: Comparison of different CFR-family methods and neural network methods in One-Card-Poker. (A) Comparison of the robust sampling with different mini-batch size. (B) Comparison of the outcome sampling and the robust sampling with different sample actions k. (C) Comparison of tabular based RS-MCCFR $^ +$ and the double neural method.
+
+Figure 7 (A) presents the convergence rate for the proposed robust sampling method of different mini-batch size $b = ( 1 , 1 0 0 , 5 0 0 ^ { - } , 1 0 0 0 )$ . The experimental results are similar to Leduc Hold’em poker, larger mini-batch size indicates a better exploitability.
+
+Figure 7 (B) demonstrates that the convergence rate for different sampling methods including outcome sampling and robust sampling under $k \ = \ 1 , 2$ . The conclusion is that RS-MCCFR $^ +$ converges significantly faster than ${ \mathrm { O S - M C C F R + } }$ after touching the same number of nodes. Experiment results show that $k = 1$ has a similar trend with $k = 2$ (external sampling). Because only one trajectory is sampled, the proposed RS-MCCFR $^ +$ will require less memory than the external sampling.
+
+Figure 7 (C) compares the performance between the tabular method and the double neural method. Experimental results demonstrate that RS-MCCFR $+ \cdot$ -RSN-ASN can achieve an exploitability of less than 0.0004 in One-Card Poker, which matches the performance of the tabular method. For RSN and ASN, we set neural batch size 4, hidden size 32 and learning rate 0.001.
+
+# APPENDIX D DETAILS OF RECURRENT NEURAL NETWORK
+
+In order to define our $\mathcal { R }$ and $s$ network, we need to represent the information set $I _ { i } ~ \in ~ \mathcal { T }$ in extensive-form games. In such games, players take action in alternating fashion and each player makes a decision according to the observed history. In this paper, we model the behavior sequence as a recurrent neural network and each action in the sequence corresponds to a cell in RNN. Figure 2 (A) provides an illustration of the proposed deep sequential neural network representation for information sets.
+
+In standard RNN, the recurrent cell will have a very simple structure, such as a single tanh or sigmoid layer. Hochreiter & Schmidhuber (1997) proposed a long short-term memory method (LSTM) with the gating mechanism, which outperforms the standard version and is capable of learning long-term dependencies. Thus we will use LSTM for the representation. Furthermore, different position in the sequence may contribute differently to the decision making, we will add an attention mechanism (Desimone & Duncan, 1995; Cho et al., 2015) to the LSTM architecture to enhance the representation. For example, the player may need to take a more aggressive strategy after beneficial public cards are revealed. Thus the information, after the public cards are revealed may be more important.
+
+More specifically, for $l$ -th cell, define $x _ { l }$ as the input vector (which can be either player or chance actions), $e _ { l }$ as the hidden layer embedding, $\phi _ { * }$ as a general nonlinear function. Each action is represented by a LSTM cell, which has the ability to remove or add information to the cell state with three different gates. Define the notation $\cdot$ as element-wise product. The first forgetting gate layer is defined as $\bar { g _ { l } ^ { f } } = \phi _ { f } ( w ^ { f } [ x _ { l } , e _ { l - 1 } ] )$ , where $[ x _ { l } , e _ { l - 1 } ]$ denotes the concatenation of $x _ { l }$ and $e _ { l - 1 }$ . The second input gate layer decides which values to update and is defined as $g _ { l } ^ { i } = \phi _ { i } ( w ^ { i } [ x _ { l } , e _ { l - 1 } ] )$ . A nonlinear layer output a vector of new candidate values $\tilde { C } _ { l } = \phi _ { c } ( w ^ { l } [ x _ { l } , e _ { l - 1 } ] )$ to decide what can be added to the state. After the forgetting gate and the input gate, the new cell state is updated by $C _ { l } = g _ { l } ^ { f } \cdot C _ { l - 1 } + g _ { l } ^ { i } \cdot \tilde { C } _ { l }$ . The third output gate is defined as $g _ { l } ^ { o } = \phi _ { o } ( w ^ { o } [ x _ { l } , e _ { l - 1 } ] )$ . Finally, the updated hidden embedding is $e _ { l } = g _ { l } ^ { o } \cdot \phi _ { e } ( C _ { l } )$ . As shown in Figure 2 (A), for each LSTM cell $j$ , the vector of attention weight is learned by an attention network. Each member in this vector is a scalar $\alpha _ { j } = \phi _ { a } ( w ^ { a } e _ { j } )$ . The attention embedding of $l$ -th cell is then defined as $\begin{array} { r } { e _ { l } ^ { a } = \sum _ { j = 1 } ^ { l } \alpha _ { j } \cdot e _ { j } } \end{array}$ , which is the summation of the hidden embedding $e _ { j }$ and the learned attention weight $\alpha _ { j }$ . The final output of the network is predicted by a value network, which is defined as
+
+$$
+\widetilde { y } _ { l } : = f ( a , I _ { i } | \theta ) = w ^ { y } \phi _ { v } ( e _ { l } ^ { a } ) = w ^ { y } \phi _ { v } \left( \sum _ { j = 1 } ^ { l } \phi _ { a } ( w ^ { a } e _ { j } ) \cdot e _ { j } \right) ,
+$$
+
+where $\theta$ is the parameters in the defined sequential neural networks. Specifically, $\phi _ { f } , \phi _ { i } , \phi _ { o }$ are sigmoid functions. $\phi _ { c }$ and $\phi _ { e }$ are hyperbolic tangent functions. $\phi _ { a }$ and $\phi _ { v }$ are rectified linear functions. The proposed RSN and ASN share the same neural architecture, but use different parameters. That is $\mathcal { R } ( a , I _ { i } \vert \theta _ { \mathcal { R } } ^ { t } ) = f ( a , I _ { i } \vert \theta _ { \mathcal { R } } ^ { t } )$ and ${ \cal S } ( a , I _ { i } \vert \theta _ { S } ^ { t } ) = f ( a , I _ { i } \vert \theta _ { S } ^ { t } )$ . $\mathcal { R } ( \cdot , I _ { i } | \theta _ { \mathcal { R } } ^ { t } )$ and $\bar { \boldsymbol { S } } ( \cdot , I _ { i } | \theta _ { S } ^ { t } )$ denote two vectors of inference value for all $a \in A ( I _ { i } )$ .
+
+# APPENDIX E NEURAL AGENT FOR OPTIMIZING NEURAL REPRESENTATION
+
+Define $\beta _ { e p o c h }$ as training epoch, $\beta _ { l r }$ as learning rate, $\beta _ { l o s s }$ as the criteria for early stopping, $\beta _ { r e }$ as the upper bound for the number of iterations from getting the minimal loss last time, $\theta ^ { t - 1 }$ as the parameter to optimize, $f ( \cdot | \theta ^ { t - 1 } )$ as the neural network, $\mathcal { M }$ as the training sample consisting information set and the corresponding target. To simplify notations, we use $\beta ^ { * }$ to denote the set of hyperparameters in the proposed deep neural networks. $\beta _ { \mathcal { R } } ^ { * }$ and $\beta _ { S } ^ { * }$ refer to the
+
+# Algorithm 2: Optimization of Deep Neural Network
+
+Function NeuralAgent(f (·|θT −1), M, θT −1, β∗):
+
+2 initialize optimizer, scheduler . gradient descent optimizer and learning rate scheduler   
+3 θT ← θT −1, lbest ← ∞, tbest ← 0 . warm starting from the checkpoint of the last iteration   
+4 For $t = 1$ to βepoch do   
+5 $l o s s \gets [ ]$ . initialize loss as an empty list   
+6 For each training epoch do   
+7 $\{ x ^ { ( i ) } , y ^ { ( i ) } \} _ { i = 1 } ^ { m ^ { - } } \sim \mathcal { M }$ $\begin{array} { r } { b a t c h . l o s s \gets \frac { 1 } { m } \sum _ { i = 1 } ^ { m } ( f ( x ^ { ( i ) } | \theta ^ { T - 1 } ) + y ^ { ( i ) } - f ( x ^ { ( i ) } | \theta ^ { T } ) ) ^ { 2 } } \end{array}$ sampling a mini-batch from $\mathcal { M }$   
+9 back propagation batch loss with learning rate $l r$   
+10 clip gradient of $\theta ^ { T }$ to $[ - \epsilon , \epsilon ] ^ { d }$ . $d$ is the dimension of $\theta ^ { T }$   
+11 optimizer(batch loss)   
+12 $\mathit { l o s s . a p p e n d } ( \mathit { b a t c h \_ l o s s } )$   
+13 $l r \gets s h e d u l e r ( l r )$ . reduce learning rate adaptively when loss has stopped improving   
+14 15 if $a v g ( l o s s ) < \beta _ { l o s s }$ $\theta _ { b e s t } ^ { T }  \theta ^ { T }$ theny stopping. . if loss is small enough, using early stopping mechanism.   
+16 else if $\ddot { a v g } ( l o s s ) < l _ { b e s t }$ then   
+17 $l _ { b e s t } = a v g ( l o s s ) , t _ { b e s t }  t , \theta _ { b e s t } ^ { T }  \theta ^ { T }$   
+18 if $t - t _ { b e s t } > \beta _ { r e }$ then   
+19 lr ← βlr . reset learning rate to escape from potential saddle point or local minima.   
+20 return θT
+
+sets of hyperparameters in RSN and ASN respectively. According to our experiments, we find a carefully designed optimization method can help us obtain a relatively higher convergence rate of exploitability. Algorithm 2 presents the details of how to optimize the proposed neural networks.
+
+Both $\mathcal { R } ( a , I _ { i } | \theta _ { \mathcal { R } } ^ { t + 1 } )$ and ${ \cal { S } } ( a , I _ { i } | \theta _ { S } ^ { t } )$ are optimized by mini-batch stochastic gradient descent method. In this paper, we use Adam optimizer (Kingma & Ba, 2014) with both momentum and adaptive learning rate. Some other optimizers such as Nadam, RMSprop, Nadam from (Ruder, 2017) are also tried in our experiments, however, they do not achieve better experimental results. In practice, existing optimizers may not return a relatively low enough loss because of potential saddle point or local minima. To obtain a relatively higher accuracy and lower optimization loss, we use a carefully designed scheduler to reduce the learning rate when the loss has stopped decrease. Specifically, the scheduler reads a metrics quantity, e.g, mean squared error, and if no improvement is seen for a number of epochs, the learning rate is reduced by a factor. In addition, we will reset the learning rate in both optimizer and scheduler once loss stops decrease in $\beta _ { r e }$ epochs. Gradient clipping mechanism is used to limit the magnitude of the parameter gradient and make optimizer behave better in the vicinity of steep cliffs. After each epoch, the best parameter will be updated. Early stopping mechanism is used once the lowest loss is less than the specified criteria $\beta _ { l o s s }$ .
+
+In experiments, we set the network hyperparameters as follow. For RSN, we set the hyperparameters as follows: neural batch size is 256 and learning rate $\beta _ { l r } = 0 . 0 0 1$ . A scheduler, who will reduce the learning rate based on the number of epochs and the convergence rate of loss, help the neural agent to obtain a high accuracy. The learning rate will be reduced by 0.5 when loss has stopped improving after 10 epochs. The lower bound on the learning rate of all parameters in this scheduler is $1 \bar { 0 } ^ { - 6 }$ . To avoid the algorithm converging to potential local minima or saddle point, we will reset the learning rate to 0.001 and help the optimizer to learn a better performance. $\theta _ { b e s t } ^ { T }$ is the best parameters to achieve the lowest loss after $T$ epochs. If average loss for epoch $t$ is less than the specified criteria $\beta _ { l o s s } { = } 1 0 ^ { - 4 }$ , we will early stop the optimizer. We set $\beta _ { e p o c h } = 2 0 0 0$ and update the optimizer 2000 maximum epochs. For ASN, we set the loss of early stopping criteria as $1 0 ^ { - 5 }$ . The learning rate will be reduced by 0.7 when loss has stopped improving after 15 epochs. Other hyperparameters in ASN are similar to RSN.
+
+# APPENDIX F OPTIMIZE COUNTERFACTUAL REGRET MINIMIZATION WITH TWO DEEP NEURAL NETWORKS
+
+# Algorithm 3: Mini-Batch RS-MCCFR with Double Neural Networks
+
+1 Function Mini-Batch-MCCFR-NN(t):   
+2 $\mathcal { M } _ { \mathcal { R } }  \emptyset$ , $\mathcal { M } _ { \mathcal { S } }  \emptyset$   
+3 For all $i = 1$ to $b$ do in parallel then   
+4 $\mathbf { M C C F R - N N } ( t , \emptyset , 0 , 1 , 1 )$   
+5 $\mathbf { M C C F R - N N } ( t , \emptyset , 1 , 1 , 1 )$   
+6 return $\mathcal { M } _ { \mathcal { R } } , \mathcal { M } _ { \mathcal { S } }$   
+7   
+8 Function MCCFR-NN(t, h, i, πi, i πrs(k)):   
+9 $I _ { i } \gets I _ { i } ( h )$ . information set at state h   
+10 if $h \in Z$ then   
+11 return $\frac { u _ { i } ( h ) } { \pi _ { i } ^ { r s ( k ) } }$ . return game payoff   
+12 else if $P ( h ) = - 1$ then   
+13 $a \sim \sigma _ { - i } ( I _ { i } )$ . Sample an action from $\sigma _ { - i } ( h )$   
+14 $\mathbf { r e t u r n ~ M C C F R - N N } ( t , h a , i , \pi _ { i } , \pi _ { i } ^ { r s ( k ) } )$   
+15 else if $P ( h ) = i$ then   
+16 $\hat { R } _ { i } ( \cdot | I _ { i } ) \gets \mathcal { R } ( \cdot , I _ { i } | \theta _ { \mathcal { R } } ^ { t } )$ if $t > 1$ else $\vec { 0 }$ . inference the vector of cumulative regret $\forall a \in A ( I _ { i } )$   
+17 $\sigma _ { i } ( I _ { i } ) \gets$ CalculateStrategy $( \hat { R } _ { i } ( \cdot | I _ { i } ) , I _ { i } )$ . calculate current strategy   
+18 $v _ { i } ( h )  0 , r _ { i } ( \cdot | I _ { i } )  \vec { 0 } , s _ { i } ( \cdot | I _ { i } )  \vec { 0 }$ . $r _ { i } ( \cdot | I _ { i } )$ and $\phantom { } _ { i } ( \cdot | I _ { i } )$ are two vectors over $A ( I _ { i } )$   
+19 $A ^ { r s ( k ) } ( I _ { i } ) $ sampling $k$ different actions according to $\boldsymbol { \sigma } _ { i } ^ { r s ( k ) }$   
+20 For $a \in A ^ { r s ( k ) } ( I _ { i } )$ do   
+21 $\begin{array} { r l } & { v _ { i } ( a | h ) \xleftarrow { } \mathbf { M C C F R - N N } ( t , h a , i , \pi _ { i } \sigma _ { i } ( a | I _ { i } ) , \pi _ { i } ^ { r s } \sigma _ { i } ^ { r s ( k ) } ( a | I _ { i } ) ) } \\ & { v _ { i } ( h ) \xleftarrow { } v _ { i } ( h ) + v _ { i } ( a | h ) \sigma _ { i } ( a | I _ { i } ) } \end{array}$   
+22 . update counterfactual value   
+23 For $a \in A ^ { r s ( k ) } ( I _ { i } )$ do   
+24 $r _ { i } ( a | I _ { i } )  v _ { i } ( a | h ) - v _ { i } ( h )$ . update cumulative regret   
+25 $s _ { i } ( a | I _ { i } ) \gets \pi _ { i } ^ { \sigma } ( I _ { i } ) \sigma _ { i } ( a | I _ { i } )$ . update average strategy numerator   
+26 Store updated cumulative regret tuple $\left( I _ { i } , r _ { i } ( \cdot | I _ { i } ) \right)$ in $\mathcal { M } _ { \mathcal { R } }$   
+27 Store updated current strategy dictionary $\left( I _ { i } , s _ { i } ( \cdot | I _ { i } ) \right)$ in $\mathcal { M } _ { \mathcal { S } }$   
+28 else   
+29 $\begin{array} { r l } & { \quad \hat { R } _ { - i } ( \cdot | I _ { i } ) \gets \mathcal { R } ( \cdot , I _ { i } | \theta _ { \mathcal { R } } ^ { t } ) \mathrm { ~ i f ~ } t > 1 \mathrm { ~ e l s e ~ } \overrightarrow { 0 } } \\ & { \sigma _ { - i } ( I _ { i } ) \gets \mathrm { C a l c u l a t e S t r a t e g y } ( \hat { R } _ { - i } ( \cdot | I _ { i } ) , I _ { i } ) } \\ & { a \sim \sigma _ { - i } ( I _ { i } ) } \\ & { \mathrm { r e t u r n ~ M C C F R - N N } ( t , h a , i , \pi _ { i } , \pi _ { i } ^ { r s ( k ) } ) } \end{array}$ . inference cumulative regret   
+30 . calculate current strategy   
+31 . Sample an action from $\sigma _ { - i } ( I _ { i } )$   
+32   
+33   
+34 Function CalculateStrategy $( R _ { i } ( \cdot | I _ { i } ) , I _ { i } )$ :   
+35 $\begin{array} { r } { s u m \gets \sum _ { a \in A ( I _ { i } ) } \operatorname* { m a x } ( R _ { i } ( a | I _ { i } ) , 0 ) } \end{array}$   
+36 For $a \in A ( I _ { i } )$ do   
+37 $\begin{array} { r } { \sigma _ { i } ( a | I _ { i } ) = \frac { \operatorname* { m a x } ( R _ { i } ( a | I _ { i } ) , 0 ) } { s u m } } \end{array}$ max(Ri(a|Ii),0) if sum > 0 else $\frac { 1 } { | A ( I _ { i } ) | }$
+
+38 return $\sigma _ { i } ( I _ { i } )$
+
+Algorithm 3 presents one application scenario of the proposed double neural method, which is based on the proposed mini-batch robust sampling method. The function MCCFR-NN will traverse the game tree like tabular MCCFR, which starts from the root history $h = \emptyset$ . Define $I _ { i }$ as the information set of $h$ . Suppose that player $i$ will sample $k$ actions according to the robust sampling. Then the function can be defined as follows. (1) If the history is terminal, the function returns the weighted utility. (2) If the history is the chance player, one action $a \in A ( I _ { i } )$ will be sampled according to the strategy $\sigma _ { - i } ( I _ { i } )$ . Then this action will be added to the history, i.e., $h  h a$ . (3) If $P ( I _ { i } ) \bar { = } i$ , the current strategy can be updated by the cumulative regret predicted by RSN. Then we sample $k$ actions according the specified sampling strategy profile $\bar { \sigma _ { i } ^ { r s ( k ) } }$ . After a recursive updating, we can obtain the counterfactual value and regret of each action at $I _ { i }$ . For the visited node, their counterfactual regrets and numerators of the corresponding average strategy will be stored in $\mathcal { M } _ { \mathcal { R } }$ and $\mathcal { M } _ { \mathcal { S } }$ respectively. (4) If $P ( I _ { i } )$ is the opponent, only one action will be sampled according the strategy $\sigma _ { - i } ( I _ { i } )$ .
+
+The function Mini-Batch-MCCFR-NN presents a mini-batch sampling method, where $b$ blocks will be sampled in parallel. This mini-batch method can help the MCCFR to achieve a more accurate estimation of CFV. The parallel sampling makes this method efficient in practice.
+
+# APPENDIX G THEORETICAL ANALYSIS
+
+# G.1 REACH PROBABILITY AND POSTERIOR PROBABILITY
+
+Lemma 1: The state reach probability of one player is proportional to posterior probability of the opponent’s hidden variable, i.e., $p ( h _ { - i } ^ { v } | I _ { i } ) \propto \bar { \pi _ { - i } ^ { \sigma } } \bar { ( } h )$ .
+
+Proof: For player $i$ at information set $I _ { i }$ and fixed $i ^ { \prime } s$ strategy profile $\sigma _ { i }$ , i.e., $\forall h \in I _ { i } , \pi _ { i } ^ { \sigma } ( h )$ is constant. Based on the defination of extensive-form game in Section 2.1, the cominbation of $I _ { i }$ and opponent’s hidden state $h _ { - i } ^ { v }$ can indicate a particular history $h = h _ { i } ^ { v } h _ { - i } ^ { v } a _ { 0 } a _ { 1 } . . . a _ { L - 1 }$ . With Bayes’ Theorem, we can inference the posterior probability of opponent’s private cards with Equation16
+
+$$
+\begin{array} { l } { { \displaystyle p ( h _ { - i } ^ { v } | I _ { i } ) = \frac { p ( h _ { - i } ^ { v } , I _ { i } ) } { p ( I _ { i } ) } = \frac { p ( h ) } { p ( I _ { i } ) } \propto p ( h ) } } \\ { { \displaystyle \propto p ( h _ { i } ^ { v } ) p ( h _ { - i } ^ { v } ) \prod _ { l = 1 } ^ { L } \sigma _ { P ( h _ { i } ^ { v } h _ { - i } ^ { v } a _ { 0 } a _ { 1 } \dots a _ { l - 1 } ) } ( a _ { l } | h _ { i } ^ { v } h _ { - i } ^ { v } a _ { 0 } a _ { 1 } \dots a _ { l - 1 } ) } } \\ { { \displaystyle \propto \pi ^ { \sigma } ( h ) = \pi _ { i } ^ { \sigma } ( h ) \pi _ { - i } ^ { \sigma } ( h ) } } \\ { { \displaystyle \propto \pi _ { - i } ^ { \sigma } ( h ) } } \end{array}
+$$
+
+# G.2 ROBUST SAMPLING, OUTCOME SAMPLING AND EXTERNAL SAMPLING
+
+Lemma 3: If $ { k } = \ m a x _ { I _ { i } \in \mathbb { Z } } | A ( I _ { i } ) |$ and $\forall i ~ \in ~ N , \forall I _ { i } ~ \in ~ \mathbb { Z } _ { i } , \forall a ~ \in ~ A ( I _ { i } ) , \sigma _ { i } ^ { r s ( k ) } ( a | I _ { i } ) ~ \sim$ u $n i f ( 0 , \left| A ( I _ { i } ) \right| )$ , then robust sampling is same with external sampling. (see the proof in section G.2)
+
+Lemma 4: If $k = 1$ and $\sigma _ { i } ^ { r s ( k ) } = \sigma _ { i }$ , then robust sampling is same with outcome sampling. (see the proof in section G.2)
+
+For robust sampling, given strategy profile $\sigma$ and the sampled block $Q _ { j }$ according to sampling profile $\sigma ^ { r s ( k ) } = ( \sigma _ { i } ^ { r s ( k ) } , \sigma _ { - i } )$ = (σrs(k)i , , then $q ( \boldsymbol { z } ) = \pi _ { i } ^ { \sigma ^ { r s ( k ) } } ( \boldsymbol { z } ) \pi _ { - i } ^ { \sigma } ( \boldsymbol { z } )$ , and the regret of action $a \in A ^ { r s ( k ) } ( I _ { i } )$ is
+
+$$
+\begin{array} { l l l } { { \displaystyle { \overline { { { \vartheta } } } _ { i } ^ { \sigma } ( ( a | I _ { i } ) | Q _ { j } ) = \widetilde { v } _ { i } ^ { \sigma } ( ( a | I _ { i } ) | Q _ { j } ) - \widetilde { v } _ { i } ^ { \sigma } ( I _ { i } | Q _ { j } ) } } } \\ { { \displaystyle { = \sum _ { z \in Q _ { j } , h a \Xi z , h \in I _ { i } } \frac { 1 } { q ( z ) } \pi _ { - i } ^ { \sigma } ( z ) \pi _ { i } ^ { \sigma } ( h a , z ) u _ { i } ( z ) - \sum _ { z \in Q _ { j } , h \subseteq z } \frac { 1 } { q ( z ) } \pi _ { - i } ^ { \sigma } ( z ) \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ( z ) } } } \\ { { \displaystyle { = \sum _ { z \in Q _ { j } , h a \Xi z , h \in I _ { i } } \frac { u _ { i } ( z ) } { \pi _ { i } ^ { \sigma \kappa ( k ) } ( z ) } \pi _ { i } ^ { \sigma } ( h a , z ) - \sum _ { z \in Q _ { j } , h \subseteq z , h \in I _ { i } } \frac { u _ { i } ( z ) } { \pi _ { i } ^ { \sigma \kappa ( k ) } ( z ) } \pi _ { i } ^ { \sigma } ( h , z ) } } } \\ { { \displaystyle { = \sum _ { z \in Q _ { j } , h a \Xi z , h \in I _ { i } } \pi _ { i } ^ { \sigma } ( h a , z ) u _ { i } ^ { \tau s } ( z ) - \sum _ { z \in Q _ { j } , h \subseteq z , h \in I _ { i } } \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ^ { \tau s } ( z ) } , } } \end{array}
+$$
+
+where $\begin{array} { r } { u _ { i } ^ { r s } ( z ) = \frac { u _ { i } ( z ) } { \pi _ { i } ^ { \sigma ^ { r s ( k ) } } ( z ) } } \end{array}$ is the weighted utility according to reach probability $\pi _ { i } ^ { \sigma ^ { r s ( k ) } } ( z )$ . Because the weighted utility no long requires explicit knowledge of the opponent’s strategy, we can use this sampling method for online regret minimization.
+
+Generally, if player $i$ randomly selects $m i n ( k , | A ( I _ { i } ) | )$ actions according to discrete uniform distribution $u n i f ( 0 , | A ( I _ { i } ) | )$ at information set $I _ { i }$ , i.e., $\begin{array} { r } { \sigma _ { i } ^ { r s ( k ) } ( a | I _ { i } ) = \frac { m i n ( k , | A ( I _ { i } ) | ) } { | A ( I _ { i } ) | } } \end{array}$ min(k,|A(Ii)|) , then
+
+$$
+\pi _ { i } ^ { \sigma ^ { r s ( k ) } } ( I _ { i } ) = \prod _ { \substack { h \in I _ { i } , h ^ { \prime } \subseteq h , h ^ { \prime } a \subseteq h , h ^ { \prime } \in I _ { i } ^ { \prime } } } \frac { m i n ( k , | A ( I _ { i } ^ { \prime } ) | ) } { | A ( I _ { i } ^ { \prime } ) | }
+$$
+
+and $u _ { i } ^ { r s } ( z )$ is a constant number when given the sampling profile $\sigma ^ { r s ( k ) }$ .
+
+Specifically,
+
+• if $k = m a x _ { I _ { i } \in I } | A ( I _ { i } ) |$ , then σrs(k)i (Ii) = 1, urs(k)i (z) = ui(z), and
+
+$$
+\tilde { r } _ { i } ^ { \sigma } ( ( a | I _ { i } ) | Q _ { j } ) = \sum _ { z \in Q _ { j } , h \sqsubseteq z , h \in I _ { i } } u _ { i } ( z ) ( \pi _ { i } ^ { \sigma } ( h a , z ) - \pi _ { i } ^ { \sigma } ( h , z ) )
+$$
+
+Therefore, robust sampling is same with external sampling when $k = m a x _ { I _ { i } \in I } | A ( I _ { i } ) |$
+
+• if $k = 1$ and $\sigma _ { i } ^ { r s ( k ) } = \sigma _ { i }$ , only one history $z$ is sampled in this case,then urs(k)i (z) = $\frac { u _ { i } ( z ) } { \pi _ { i } ^ { \sigma _ { i } } ( z ) }$ , $\exists h \in I _ { i }$ , for $a \in A ^ { r s ( k ) } ( I _ { i } )$
+
+$$
+\begin{array} { l } { { \displaystyle \tilde { r } _ { i } ^ { \sigma } ( ( a | I _ { i } ) | Q _ { j } ) = \tilde { r } _ { i } ^ { \sigma } ( ( a | h ) | Q _ { j } ) } } \\ { { \displaystyle = \sum _ { z \in Q _ { j } , h a \subseteq z } \pi _ { i } ^ { \sigma } ( h a , z ) u _ { i } ^ { r s } ( z ) - \sum _ { z \in Q _ { j } , h \subseteq z } \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ^ { r s } ( z ) } } \\ { { \displaystyle = \frac { ( 1 - \sigma _ { i } ( a | h ) ) u _ { i } ( z ) } { \pi _ { i } ^ { \sigma } ( h a ) } } } \end{array}
+$$
+
+For $a \not \in A ^ { r s ( k ) } ( I _ { i } )$ , the regret will be $\tilde { r } _ { i } ^ { \sigma } ( ( a | h ) | j ) = 0 - \tilde { v } _ { i } ^ { \sigma } ( h | j )$ . Therefore, robust sampling is same with outcome sampling when $k = 1$ and $\boldsymbol { \sigma } _ { i } ^ { r s ( k ) } = \boldsymbol { \sigma } _ { i }$
+
+• if $k = 1$ , and player $i$ randomly selects one action according to discrete uniform distribution uni $f ( 0 , \left| A ( I _ { i } ) \right| )$ at information set $I _ { i }$ , then $\begin{array} { r } { u _ { i } ^ { r s ( 1 ) } ( z ) = \frac { { u _ { i } } ( z ) } { \pi _ { i } ^ { \sigma ^ { r s ( k ) } } ( z ) } } \end{array}$ is a constant, $\exists h \in I _ { i }$ , for $a \in A ^ { r s ( k ) } ( I _ { i } )$
+
+$$
+\begin{array} { l } { { \displaystyle \tilde { r } _ { i } ^ { \sigma } ( ( a | I _ { i } ) | Q _ { j } ) = \sum _ { z \in Q _ { j } , h a \subseteq z , h \in I _ { i } } \pi _ { i } ^ { \sigma } ( h a , z ) u _ { i } ^ { r s } ( z ) - \sum _ { z \in Q _ { j } , h \subseteq z , h \in I _ { i } } \pi _ { i } ^ { \sigma } ( h , z ) u _ { i } ^ { r s } ( z ) } } \\ { { \mathrm { ~ } = ( 1 - \sigma _ { i } ( a | h ) ) \pi _ { i } ^ { \sigma } ( h a , z ) u _ { i } ^ { r s ( 1 ) } ( z ) } } \end{array}
+$$
+
+if action $a$ is not sampled at state $h$ , the regret is $\tilde { r } _ { i } ^ { \sigma } ( ( a | h ) | j ) = 0 - \tilde { v } _ { i } ^ { \sigma } ( h | j )$ . Compared to outcome sampling, the robust sampling in that case have a lower variance because of the constant uri $u _ { i } ^ { r s ( 1 ) } ( z )$ .
+
+# Proof:
+
+$$
+\begin{array} { r l } { E _ { \mathcal { G } \sim \mathrm { m a t s o n a l i z } } [ E _ { i } ^ { \prime } ( \lambda | \delta ) ] } & { = E _ { \mathcal { G } \sim \mathrm { m a t s o n } } [ \Gamma _ { i } ^ { \prime } ( \lambda | \delta ) ] ^ { \epsilon } ( \begin{array} { l } { E _ { i } ^ { \prime } \lambda | \delta | } \\ { 1 } \end{array} ) } \\ & { = E _ { \mathcal { G } \sim \mathrm { m a t s o n } } ( ( \begin{array} { l l l } { E _ { i } ^ { \prime } } & { \sum _ { i = 1 } ^ { \infty } \frac { E _ { i } ^ { \prime } ( \lambda ) \epsilon _ { i } ^ { \prime } ( \delta ) \lambda _ { i } ^ { \prime } \delta ( k _ { i } ) \lambda _ { i } ^ { \prime } \lambda _ { i } ^ { \prime } } } \\ { \sum _ { i = 1 } ^ { \infty } \lambda _ { i } \epsilon _ { i } \epsilon _ { i } \epsilon _ { i } ^ { \prime } \delta ( k _ { i } ) \lambda _ { i } ^ { \prime } } \end{array} ) ) } \\ & { = E _ { \mathcal { F } \sim \mathrm { m a t s o n } } ( ( \begin{array} { l } { 1 } \\ { \delta } \\ { \frac { 1 } { \delta } } \\ { \gamma _ { j } \cdots \epsilon _ { i } ^ { \prime } ( \tau _ { i } ^ { \prime } ( 1 / \Phi ^ { 2 } ) ) } \\ { 1 } \end{array} ) ) } \\ & { = \frac { 1 } { \delta } \frac { 1 } { \delta \alpha _ { 1 } } ( \begin{array} { l } { 1 } \\ { 1 } \end{array} \frac { E _ { i } ^ { \prime } } { \delta ( \frac { E _ { i } ^ { \prime } } { \delta } ) ^ { \epsilon } ( \tau _ { i } \mathcal { G } ) ^ { 2 } } ) } \\ &  - \frac { 1 } { \delta } \frac { 1 } { \delta \alpha _ { 1 } } ( \frac { 1 } { \delta } \frac { 1 } { \delta } \frac { E _ { i } ^ { \prime } }  \delta ( \frac { E _ { i } ^ { \prime } } { \delta } ) ^ { \epsilon } ( \frac { E _ { i } ^ { \prime } } { \delta } ) ^ { \epsilon } ( \frac { 1 } { \delta } ) ^ { \epsilon } ( \frac { 1 } { \delta } ) ^ { \epsilon } ( \frac { 1 } { \delta } ) ^ { \epsilon } ( \frac { 1 }  \end{array}
+$$

parse/train/H1g6osRcFQ/H1g6osRcFQ.md

@@ -0,0 +1,341 @@
+# POLICY TRANSFER WITH STRATEGY OPTIMIZATION
+
+Wenhao Yu, C. Karen Liu, Greg Turk   
+School of Interactive Computing   
+Georgia Institute of Technology   
+Atlanta, GA   
+wenhaoyu@gatech.edu, {karenliu,turk}@cc.gatech.edu
+
+# ABSTRACT
+
+Computer simulation provides an automatic and safe way for training robotic control policies to achieve complex tasks such as locomotion. However, a policy trained in simulation usually does not transfer directly to the real hardware due to the differences between the two environments. Transfer learning using domain randomization is a promising approach, but it usually assumes that the target environment is close to the distribution of the training environments, thus relying heavily on accurate system identification. In this paper, we present a different approach that leverages domain randomization for transferring control policies to unknown environments. The key idea that, instead of learning a single policy in the simulation, we simultaneously learn a family of policies that exhibit different behaviors. When tested in the target environment, we directly search for the best policy in the family based on the task performance, without the need to identify the dynamic parameters. We evaluate our method on five simulated robotic control problems with different discrepancies in the training and testing environment and demonstrate that our method can overcome larger modeling errors compared to training a robust policy or an adaptive policy.
+
+# 1 INTRODUCTION
+
+Recent developments in Deep Reinforcement Learning (DRL) have shown the potential to learn complex robotic controllers in an automatic way with minimal human intervention. However, due to the high sample complexity of DRL algorithms, directly training control policies on the hardware still remains largely impractical for agile tasks such as locomotion.
+
+A promising direction to address this issue is to use the idea of transfer learning which learns a model in a source environment and transfers it to a target environment of interest. In the context of learning robotic control policies, we can consider the real world the target environment and the computer simulation the source environment. Learning in simulated environment provides a safe and efficient way to explore large variety of different situations that a real robot might encounter. However, due to the model discrepancy between physics simulation and the real-world environment, also known as the Reality Gap (Boeing & Braunl, 2012; Koos et al., 2010), the trained policy usually fails in ¨ the target environment. Efforts have been made to analyze the cause of the Reality Gap (Neunert et al., 2017) and to develop more accurate computer simulation (Tan et al., 2018) to improve the ability of a policy when transferred it to real hardware. Orthogonal to improving the fidelity of the physics simulation, researchers have also attempted to cross the reality gap by training more capable policies that succeed in a large variety of simulated environments. Our method falls into the second category.
+
+To develop a policy capable of performing in various environments with different governing dynamics, one can consider to train a robust policy or to train an adaptive policy. In both cases, the policy is trained in environments with randomized dynamics. A robust policy is trained under a range of dynamics without identifying the specific dynamic parameters. Such a policy can only perform well if the simulation is a good approximation of the real world dynamics. In addition, for more agile motor skills, robust policies may appear over-conservative due to the uncertainty in the training environments. On the other hand, when an adaptive policy is used, it learns to first identify, implicitly or explicitly, the dynamics of its environment, and then selects the best action according to the identified dynamics. Being able to act differently according to the dynamics allows the adaptive policy to achieve higher performance on a larger range of dynamic systems. However, when the target dynamics is notably different from the training dynamics, it may still produce sub-optimal results for two reasons. First, when a sequence of novel observations is presented, the learned identification model in an adaptive policy may produce inaccurate estimations. Second, even when the identification model is perfect, the corresponding action may not be optimal for the new situation.
+
+In this work, we introduce a new method that enjoys the versatility of an adaptive policy, while avoiding the challenges of system identification. Instead of relating the observations in the target environment to the similar experiences in the training environment, our method searches for the best policy directly based on the task performance in the target environment.
+
+Our algorithm can be divided to two stages. The first stage trains a family of policies, each optimized for a particular vector of dynamic parameters. The family of policies can be parameterized by the dynamic parameters in a continuous representation. Each member of the family, referred to as a strategy, is a policy associated with particular dynamic parameters. Using a locomotion controller as an example, a strategy associated with low friction coefficient may exhibit cautious walking motion, while a strategy associated with high friction coefficient may result in more aggressive running motion. In the second stage we perform a search over the strategies in the target environment to find the one that achieves the highest task performance.
+
+We evaluate our method on three examples that demonstrate transfer of a policy learned in one simulator DART, to another simulator MuJoCo. Due to the differences in the constraint solvers, these simulators can produce notably different simulation results. A more detailed description of the differences between DART and MuJoCo is provided in Appendix A. We also add latency to the MuJoCo environment to mimic a real world scenario, which further increases the difficulty of the transfer. In addition, we use a quadruped robot simulated in Bullet to demonstrate that our method can overcome actuator modeling errors. Latency and actuator modeling have been found to be important for Sim-to-Real transfer of locomotion policies (Tan et al., 2018; Neunert et al., 2017). Finally, we transfer a policy learned for a robot composed of rigid bodies to a robot whose end-effector is deformable, demonstrating the possiblity of using our method to transfer to problems that are challenging to model faithfully.
+
+# 2 RELATED WORK
+
+While DRL has demonstrated its ability to learn control policies for complex and dynamic motor skills in simulation (Schulman et al., 2015; 2017; Peng et al., 2018a; 2017; Yu et al., 2018; Heess et al., 2017), very few learning algorithms have successfully transferred these policies to the real world. Researchers have proposed to address this issue by optimizing or learning a simulation model using data from the real-world (Tan et al., 2018; 2016; Deisenroth & Rasmussen, 2011; Ha & Yamane, 2015; Abbeel & Ng, 2005). The main drawback for these methods is that for highly agile and high dimensional control problems, fitting an accurate dynamic model can be challenging and data inefficient.
+
+Complementary to learning an accurate simulation model, a different line of research in sim-to-real transfer is to learn policies that can work under a large variety of simulated environments. One common approach is domain randomization. Training a robust policy with domain randomization has been shown to improve the ability to transfer a policy (Tan et al., 2018; Tobin et al., 2017; Rajeswaran et al., 2016; Pinto et al., 2017). Tobin et al. (2017) trained an object detector with randomized appearance and applied it in a real-world gripping task. Tan et al. (2018) showed that training a robust policy with randomized dynamic parameters is crucial for transferring quadruped locomotion to the real world. Designing the parameters and range of the domain to be randomized requires specific knowledge for different tasks. If the range is set too high, the policy may learn a conservative strategy or fail to learn the task, while a small range may not provide enough variation for the policy to transfer to real-world.
+
+A similar idea is to train an adaptive policy with the current and the past observations as input. Such an adaptive policy is able to identify the dynamic parameters online either implicitly (OpenAI et al., 2018; Peng et al., 2018b) or explicitly (Yu et al., 2017) and apply actions appropriate for different system dynamics. Recently, adaptive policies have been used for sim-to-real transfer, such as in-hand manipulation tasks (OpenAI et al., 2018) or non-prehensile manipulation tasks (Peng et al., 2018b). Instead of training one robust or adaptive policy, Zhang et al. (2018) trained multiple policies for a set of randomized environments and learned to combine them linearly in a separate set of environments. The main advantage of these methods is that they can be trained entirely in simulation and deployed in real-world without further fine-tuning. However, policies trained in simulation may not generalize well when the discrepancy between the target environment and the simulation is too large. Our method also uses dynamic randomization to train policies that exhibit different strategies for different dynamics, however, instead of relying on the simulation to learn an identification model for selecting the strategy, we propose to directly optimize the strategy in the target environment.
+
+A few recent works have also proposed the idea of training policies in a source environment and fine-tune it in the target environment. For example, Cully et al. (2015) proposed MAP-Elite to learn a large set of controllers and applied Bayesian optimization for fast adaptation to hardware damages. Their approach searches for individual controllers for discrete points in a behavior space, instead of a parameterized family of policies as in our case, making it potentially challenging to be applied to higher dimensional behavior spaces. Rusu et al. (2016) used progressive network to adapt the policy to new environments by designing a policy architecture that can effectively utilize previously learned representations. Chen et al. (2018) learned an implicit representation of the environment variations by optimizing a latent policy input for each discrete instance of the environment. They showed that fine-tuning on this learned policy achieved improved learning efficiency. In contrast to prior work in which the fine-tuning phase adjusts the neural network weights in the target environment, we optimize only the dynamics parameters input to the policy. This allows our policies to adapt to the target environments with less data and to use sparse reward signal.
+
+# 3 BACKGROUND
+
+We formulate the motor skill learning problem as a Markov Decision Process (MDP), $\begin{array} { r l } { \mathcal { M } } & { { } = } \end{array}$ $( S , { \mathcal { A } } , r , { \mathcal { P } } , p _ { 0 } , \gamma )$ , where $s$ is the state space, $\mathcal { A }$ is the action space, $r : \mathcal { S } \times \mathcal { A } \mapsto \mathbb { R }$ is the reward function, ${ \mathcal { P } } : { \mathcal { S } } \times { \mathcal { A } } \mapsto { \mathcal { S } }$ is the transition function, $p _ { 0 }$ is the initial state distribution and $\gamma$ is the discount factor. The goal of reinforcement learning is to find a control policy $\pi : { \mathcal { S } } \mapsto A$ that maximizes the expected accumulated reward: $J _ { \mathcal { M } } ( \pi ) = \mathbb { E } _ { \tau = ( s _ { 0 } , a _ { 0 } , \ldots , s _ { T } ) } \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } , a _ { t } )$ , where $\pmb { s } _ { 0 } \sim p _ { 0 } , \pmb { a } _ { t } \sim \pi ( \pmb { s } _ { t } )$ and $\pmb { s } _ { t + 1 } = \mathcal { P } ( \pmb { s } _ { t } , \pmb { a } _ { t } )$ . In practice, we usually only have access to an observation of the robot that contains a partial information of the robot’s state. In this case, we will have a Partially-Observable Markov Decision Process (POMDP) and the policy would become $\pi : \mathcal { O } \mapsto \mathcal { A }$ , where $\mathcal { O }$ is the observation space.
+
+In the context of transfer learning, we can define a source MDP $\mathcal { M } ^ { s }$ and a target MDP $\mathcal { M } ^ { t }$ and the goal would be to learn a policy $\pi ^ { s }$ for $\mathcal { M } ^ { s }$ such that it also works well on $\mathcal { M } ^ { t }$ . In this work, $\mathcal { P }$ is regarded as a parameterized space of transition functions, $\pmb { s } _ { t + 1 } = \mathcal { P } _ { \mu } ( \pmb { s } _ { t } , \pmb { a } _ { t } )$ , where $\mu$ is a vector of physical parameters defining the dynamic model (e.g. friction coefficient). The transfer learning in this context learns a policy under ${ \mathcal { P } } ^ { s }$ and transfers to $\mathcal { P } ^ { t }$ , where $\mathcal { P } ^ { s } \neq \mathcal { P } ^ { t }$ .
+
+# 4 METHODS
+
+We propose a new method for transferring a policy learned in simulated environment to a target environment with unknown dynamics. Our algorithm consists of two stages: learning a family of policies and optimizing strategy.
+
+# 4.1 LEARNING A FAMILY OF POLICIES
+
+The first stage of our method is to learn a family of policies, each for a particular dynamics $\mathcal { P } _ { \mu } ^ { s } ( \cdot )$ . One can potentially train each policy individually and interpolate them to cover the space of $\mu$ (Stulp et al., 2013; Da Silva et al., 2012). However, as the dimension of $\mu$ increases, the number of policies required for interpolation grows exponentially.
+
+Since many of these policies are trained under similar dynamics, our method merges them into one neural network and trains the entire family of policies simultaneously. We follow the work by $\mathrm { Y u }$ et al. (2017), which trains a policy $\pi : ( o , \mu ) \mapsto a$ that takes as input not only the observation of the robot $^ o$ , but also the physical parameters $\mu$ . At the beginning of each rollout during the training, we randomly pick a new set of physical parameters for the simulation and fix it throughout the rollout. After training the policy this way, we obtain a family of policies that is parameterized by the dynamics parameters $\mu$ . Given a particular $\mu$ , we define the corresponding policy as $\pi _ { \mu } : o \mapsto a$ . We will call such an instantiated policy a strategy.
+
+# 4.2 OPTIMIZATING STRATEGY
+
+The second stage of our method is to search for the optimal strategy in the space of $\mu$ for the target environment. Previousand the corresponding work learns a mapping between the experiences under source dynamics . When new experiences are generated in the target environment, this m $\mathcal { P } _ { \mu } ^ { s }$ $\mu$   
+ping will identify a $\mu$ based on similar experiences previously generated in the source environment. While using experience similarity as a metric to identify $\mu$ transfers well to a target environment that has the same dynamic parameter space ( $\mathrm { Y u }$ et al., 2017), it does not generalize well when the dynamic parameter space is different.
+
+Since our goal is to find a strategy that works well in the target environment, a more direct approach is to use the performance of the task, i.e. the accumulated reward, in the target environment as the metric to search for the strategy:
+
+$$
+\mu ^ { * } = \arg \operatorname* { m a x } _ { \mu } J _ { \mathcal { M } ^ { t } } ( \pi _ { \mu } ) .
+$$
+
+Solving Equation 1 can be done efficiently because the search space in Equation 1 is the space of dynamic parameters $\mu$ , rather than the space of policies, which are represented as neural networks in our implementation. To further reduce the number of samples from the target environment needed for solving Equation 1, we investigated a number of algorithms, including Bayesian optimization, model-based methods and an evolutionary algorithm (CMA). A detailed description and comparison of these methods are provided in Appendix C.
+
+We chose Covariance Matrix Adaptation (CMA) (Hansen et al., 1995), because it reliably outperforms other methods in terms of sample-efficiency. At each iteration of CMA, a set of samples are drawn from a Gaussian distribution over the space of $\mu$ . For each sample, we instantiate a strategy $\pi _ { \mu }$ and use it to generate rollouts in the target environment. The fitness of the sample is determined by evaluating the rollouts using $J _ { \mathcal { M } ^ { t } }$ . Based on the fitness values of the samples in the current iteration, the mean and the covariance matrix of the Gaussian distribution are updated for the next iteration.
+
+# 5 EXPERIMENTS
+
+To evaluate the ability of our method to overcome the reality gap, we train policies for four locomotion control tasks (hopper, walker2d, half cheetah, quadruped robot) and transfer each policy to environments with different dynamics. To mimic the reality gap seen in the real-world, we use target environments that are different from the source environments in their contact modeling, latency or actuator modeling. In addition, we also test the ability of our method to generalize to discrepancies in body mass, terrain slope and end-effector materials. Figure 1 shows the source and target environments for all the tasks and summarizes the modeled reality gap in each task. During training, we choose different combinations of dynamic parameters to randomize and make sure they do not overlap with the variations in the testing environments. For clarity of exposition, we denote the dimension of the dynamic parameters that are randomized during training as $d i m ( \mu )$ . For all examples, we use the Proximal Policy Optimization (PPO) (Schulman et al., 2017) to optimize the control policy. A more detailed description of the experiment setup as well as the simulated reality gaps are provided in Appendix B. For each example presented, we run three trials with different random seeds and report the mean and one standard deviation for the total reward.
+
+![](images/23bb588f419146a89f6e197de56aeaa70d7e3a5c7e5a68269bc43bf9b377e8bc.jpg)  
+Figure 1: The environments used in our experiments. Environments in the top row are source environments and environments in the bottom row are the target environments we want to transfer the policy to. (a) Hopper from DART to MuJoCo. (b) Walker2d from DART to MuJoCo with latency. (c) HalfCheetah from DART to MuJoCo with latency. (d) Minitaur robot from inaccurate motor modeling to accurate motor modeling. (e) Hopper from rigid to soft foot.
+
+# 5.1 BASELINE METHODS
+
+We compare our method, Strategy Optimization with CMA-ES (SO-CMA) to three baseline methods: training a robust policy (Robust), training an adaptive policy (Hist) and training a Universal Policy with Online System Identification (UPOSI) ( $\mathrm { Y u }$ et al., 2017). The robust policy is represented as a feed forward neural network, which takes as input the most recent observation from the robot, i.e. $\pi _ { r o b u s t } : o \mapsto { \pmb a }$ . The policy needs to learn actions that work for all the training environments, but the dynamic parameters cannot be identified from its input. In contrast, an adaptive policy is given a history of observations as input, i.e. $\pi _ { a d a p t } : \left( \pmb { O } _ { t - h } , \ldots , \pmb { O } _ { t } \right) \mapsto \pmb { a } _ { t }$ . This allows the policy to potentially identify the environment being tested and adaptively choose the actions based on the identified environment. There are many possible ways to train an adaptive policy, for example, one can use an LSTM network to represent the policy or use a history of observations as input to a feed-forward network. We find that for the tasks we demonstrate, directly training an LSTM policy using PPO is much less efficient and reaches lower end performance than training a feed-forward network with history input. Therefore, in our experiments we use a feed-forward network with a history of 10 observations to represent the adaptive policy $\pi _ { a d a p t }$ . We also compare our method to UPOSI, which decouples the learning of an adaptive policy into training a universal policy via reinforcement learning and a system identification model via supervised learning. In theory UPOSI and Hist should achieve similar performance, while in practice we expect UPOSI to learn more efficiently due to the decoupling. We adopt the same training procedure as done by Yu et al. (2017), and use a history of 10 observations as input to the online system identification model. For fair comparison, we continue to train the baseline methods after transferring to the target environment, using the same amount of samples SO-CMA consumes in the target environment. We refer this additional training step as ‘fine-tuning’. In addition to the baseline methods, we also compare our method to the performance of policies trained directly in the target environments, which serves as an ‘Oracle’ benchmark. The Oracle policies for Hopper, Walke2d, HalfCheetah and Hopper Soft was trained for 1, 000, 000 samples in the target environment as in Schulman et al. (2017). For the quadruped example, we run PPO for 5, 000, 000 samples, similar to Tan et al. (2018). We detail the process of ‘fine-tuning’ in Appendix B.4
+
+# 5.2 HOPPER DART TO MUJOCO
+
+In the first example, we build a single-legged robot in DART similar to the Hopper environment simulated by MuJoCo in OpenAI Gym (Brockman et al., 2016). We investigate two questions in this example: 1) does SO-CMA work better than alternative methods in transferring to unknown environments? and 2) how does the choice of $d i m ( \mu )$ affect the performance of policy transfer? To this end, we perform experiments with $d i m ( \mu ) = 2$ , 5 and 10. For the experiment with $d i m ( \mu ) = 2$ , we randomize the mass of the robot’s foot and the restitution coefficient between the foot and the ground. For $d i m ( \mu ) = 5$ , we in addition randomize the friction coefficient, the mass of the robot’s torso and the joint strength of the robot. We further include the mass of the rest two body parts and the joint damping to construct the randomized dynamic parameters for $d i m ( \mu ) = 1 0$ . The specific ranges of randomization are described in Appendix B.4.
+
+We first evaluate how the performance of different methods varies with the number of samples in the target environment. As shown in Figure 2, when $d i m ( \mu )$ is low, none of the four methods were able to transfer to the MuJoCo Hopper successfully. This is possibly due to there not being enough variation in the dynamics to learn diverse strategies. When $d i m ( \mu ) = 5$ , SO-CMA can successfully transfer the policy to MuJoCo Hopper with good performance, while the baseline methods were not able to adapt to the new environment using the same sample budget. We further increase $d i m ( \mu )$ to 10 as shown in Figure 2 (c) and find that SO-CMA achieved similar end performance to $d i m ( \mu ) = 5$ , while the baselines do not transfer well to the target environment.
+
+We further investigate whether SO-CMA can generalize to differences in joint limits in addition to the discrepancies between DART and MuJoCo. Specifically, we vary the magnitude of the ankle joint limit in [0.5, 1.0] radians (default is 0.785) for the MuJoCo Hopper, and run all the methods with 30, 000 samples. The result can be found in Figure 3. We can see a similar trend that with low $d i m ( \mu )$ the transfer is challenging, and with higher value of $d i m ( \mu )$ SO-CMA is able to achieve notably better transfer performance than the baseline methods.
+
+![](images/fb940f7d02bfa88c2693b4e9aeefc9d6ae5fa53bf09462e4220af6545d802315.jpg)  
+Figure 2: Transfer performance vs Sample number in target environment for the Hopper example. Policies are trained to transfer from DART to MuJoCo.
+
+![](images/abe0303a24e26f811d07b8378f9d08f41aece9aaaa757c2d335b24089fbd12ea.jpg)  
+Figure 3: Transfer performance for the Hopper example. Policies are traiend to transfer from DART to MuJoCo with different ankle joint limits (horizontal axis). All trials run with total sample number of 30, 000 in the target environment.
+
+# 5.3 WALKER2D DART TO MUJOCO WITH LATENCY
+
+In this example, we use the lower body of a biped robot constrained to a $2 D$ plane, according to the Walker2d environment in OpenAI Gym. We find that with different initializations of the policy network, training could lead to drastically different gaits, e.g. hopping with both legs, running with one legs dragging the other, normal running, etc. Some of these gaits are more robust to environment changes than others, which makes analyzing the performance of transfer learning algorithms challenging. To make sure the policies are more comparable, we use the symmetry loss from Yu et al. (2018), which leads to all policies learning a symmetric running gait. To mimic modeling error seen on real robots, we add a latency of 8ms to the MuJoCo simulator. We train policies with $d i m ( \mu ) = 8 $ , for which we randomize the friction coefficient, restitution coefficient and the joint damping of the six joints during training. Figure 4 (a) shows the transfer performance of different method with respect to the sample numbers in the target environment.
+
+We further vary the mass of the robot’s right foot in $[ 2 , 9 ] \mathrm { k g }$ in the MuJoCo Walker2d environment and compare the transfer performance of SO-CMA to the baselines. The default foot mass is $2 . 9 \mathrm { k g }$ . We use in total 30, 000 samples in the target environment for all methods being compared and the results can be found in Figure 4 (b). In both cases, our method achieves notably better performance than Hist and UPOSI, while being comparable to Robust.
+
+![](images/09bc3de0a18c8e3f07367ec79cbc5641c9e576c83e5eb0f6e9247a632eda827c.jpg)  
+Figure 4: Transfer performance for the Walker2d example. (a) Transfer performance vs sample number in target environment on flat surface. (b) Transfer performance vs foot mass, trained with 30, 000 samples in the target environment.
+
+# 5.4 HALFCHEETAH DART TO MUJOCO WITH DELAY
+
+In the third example, we train policies for the HalfCheetah environment from OpenAI Gym. We again test the performance of transfer from DART to MuJoCo for this example. In addition, we add a latency of $5 0 \mathrm { m s }$ to the target environment. We randomize 11 dynamic parameters in the source environment consisting of the mass of all body parts, the friction coefficient and the restitution coefficient during training, i.e. $d i m ( \mu ) = 1 1$ . The results of the performance with respect to sample numbers in target environment can be found in Figure 5 (a). We in addition evaluate transfer to environments where the slope of the ground varies, as shown in Figure 5 (b). We can see that SO-CMA outperforms Robust and Hist, while achieves similar performance as UPOSI.
+
+![](images/ec021bc147c130f7744825d553e77231606f3f1479dded4990d86a3e6ddffec1.jpg)  
+Figure 5: Transfer performance for the HalfCheetah example. (a) Transfer performance vs sample number in target environment on flat surface. (b) Transfer performance vs surface slope, trained with $3 0 , 0 0 0$ samples in the target environment.
+
+# 5.5 QUADRUPED ROBOT WITH ACTUATOR MODELING ERROR
+
+As demonstrated by Tan et al. (2018), when a robust policy is used, having an accurate actuator model is important to the successful transfer of policy from simulation to real-world for a quadruped robot, Minitaur (Figure 1 (d)). Specifically, they found that when a linear torque-current relation is assumed in the actuator dynamics in the simulation, the policy learned in simulation transfers poorly to the real hardware. When the actuator dynamics is modeled more accurately, in their case using a non-linear torque-current relation, the transfer performance were notably improved.
+
+In our experiment, we investigate whether SO-CMA is able to overcome the error in actuator models. We use the same simulation environment from Tan et al. (2018), which is simulated in Bullet (Coumans & Bai, 2016-2017). During the training of the policy, we use a linear torque-current relation for the actuator model, and we transfer the learned policy to an environment with the more accurate non-linear torque-current relation. We use the same 25 dynamic parameters and corresponding ranges used by Tan et al. (2018) for dynamics randomization during training. When applying the robust policy to the accurate actuator model, we observe that the quadruped tends to sink to the ground, similar to what was observed by Tan et al. (2018). SO-CMA, on the other hand, can successfully transfer a policy trained with a crude actuator model to an environment with more realistic actuators(Figure 6 (a)).
+
+![](images/1cf91bc494f72050e45655080e7d71240fa246df3fc927f94827297f9f3d245c.jpg)  
+Figure 6: Transfer performance for the Quadruped example (a) and the Soft-foot Hopper example (b).
+
+# 5.6 HOPPER RIGID TO DEFORMABLE FOOT
+
+Applying deep reinforcement learning to environments with deformable objects can be computationally inefficient (Clegg et al., 2018). Being able to transfer a policy trained in a purely rigid-body environment to an environment containing deformable objects can greatly improve the efficiency of learning. In our last example, we transfer a policy trained for the Hopper example with rigid objects only to a Hopper model with a deformable foot (Figre 1 (e)). The soft foot is modeled using the soft shape in DART, which uses an approximate but relatively efficient way of modeling deformable objects (Jain & Liu, 2011). We train policies in the rigid Hopper environment and randomize the same set of dynamic parameters as in the in the DART-to-MuJoCo transfer example with $\dim ( \mu ) = 5$ . We then transfer the learned policy to the soft Hopper environment where the Hopper’s foot is deformable. The results can be found in Figure 6 (b). SO-CMA is able to successfully control the robot to move forward without falling, while the baseline methods fail to do so.
+
+# 6 DISCUSSIONS
+
+We have demonstrated that our method, SO-CMA, can successfully transfer policies trained in one environment to a notably different one with a relatively low amount of samples. One advantage of SO-CMA, compared to the baselines, is that it works consistently well across different examples, while none of the baseline methods achieve successful transfer for all the examples.
+
+We hypothesize that the large variance in the performance of the baseline methods is due to their sensitivity to the type of task being tested. For example, if there exists a robust controller that works for a large range of different dynamic parameters $\mu$ in the task, such as a bipedal running motion in the Walker2d example, training a Robust policy may achieve good performance in transfer. However, when the optimal controller is more sensitive to $\mu$ , Robust policies may learn to use overly-conservative strategies, leading to sub-optimal performance (e.g. in HalfCheetah) or fail to perform the task (e.g. in Hopper). On the other hand, if the target environment is not significantly different from the training environments, UPOSI may achieve good performance, as in HalfCheetah. However, as the reality gap becomes larger, the system identification model in UPOSI may fail to produce good estimates and result in non-optimal actions. Furthermore, Hist did not achieve successful transfer in any of the examples, possibly due to two reasons: 1) it shares similar limitation to UPOSI when the reality gap is large and 2) it is in general more difficult to train Hist due to the larger input space, so that with a limited sample budget it is challenging to fine-tune Hist effectively.
+
+We also note that although in some examples certain baseline method may achieve successful transfer, the fine-tuning process of these methods relies on having a dense reward signal. In practice, one may only have access to a sparse reward signal in the target environment, e.g. distance traveled before falling to the ground. Our method, using an evolutionary algorithm (CMA), naturally handles sparse rewards and thus the performance gap between our method (SO-CMA) and the baseline methods will likely be large if a sparse reward is used.
+
+# 7 CONCLUSION
+
+We have proposed a policy transfer algorithm where we first learn a family of policies simultaneously in a source environment that exhibits different behaviors and then search directly for a policy in the family that performs the best in the target environment. We show that our proposed method can overcome large modeling errors, including those commonly seen on real robotic platforms with relatively low amount of samples in the target environment. These results suggest that our method has the potential to transfer policies trained in simulation to real hardware.
+
+There are a few interesting directions that merit further investigations. First, it would be interesting to explore other approaches for learning a family of policies that exhibit different behaviors. One such example is the method proposed by Eysenbach et al. (2018), where an agent learns diverse skills without a reward function in an unsupervised manner. Another example is the HCP-I policy proposed by Chen et al. (2018), which learns a latent representation of the environment variations implicitly. Equipping our policy with memories is another interesting direction to investigate. The addition of memory will extend our method to target environments that vary over time. We have investigated in a few options for strategy optimization and found that CMA-ES works well for our examples. However, it would be desired if we can find a way to further reduce the sample required in the target environment. One possible direction is to warm-start the optimization using models learned in simulation, such as the calibration model in Zhang et al. (2018) or the online system identification model in Yu et al. (2017).
+
+# REFERENCES
+
+Pycma. URL https://github.com/CMA-ES/pycma.
+
+Pieter Abbeel and Andrew Y. Ng. Exploration and Apprenticeship Learning in Reinforcement Learning. In International Conference on Machine Learning, pp. 1–8, 2005.
+
+Adrian Boeing and Thomas Braunl. Leveraging multiple simulators for crossing the reality gap. In ¨ Control Automation Robotics & Vision (ICARCV), 2012 12th International Conference on, pp. 1113–1119. IEEE, 2012.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Tao Chen, Adithyavairavan Murali, and Abhinav Gupta. Hardware conditioned policies for multirobot transfer learning. NIPS, 2018.
+
+Alexander Clegg, Wenhao Yu, Jie Tan, C. Karen Liu, and Greg Turk. Learning to dress: Synthesizing human dressing motion via deep reinforcement learning. ACM Transactions on Graphics (TOG), 37(6), 2018.
+
+Erwin Coumans and Yunfei Bai. Pybullet, a python module for physics simulation in robotics, games and machine learning., 2016-2017. URL http://pybullet.org.
+
+Antoine Cully, Jeff Clune, Danesh Tarapore, and Jean-Baptiste Mouret. Robots that can adapt like animals. Nature, 521(7553):503, 2015.
+
+Bruno Da Silva, George Konidaris, and Andrew Barto. Learning parameterized skills. arXiv preprint arXiv:1206.6398, 2012.
+
+Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pp. 465–472, 2011.
+
+Prafulla Dhariwal, Christopher Hesse, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Openai baselines. https://github.com/openai/baselines, 2017.
+
+Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is all you need: Learning skills without a reward function. arXiv preprint arXiv:1802.06070, 2018.
+
+Sehoon Ha. Pydart2, 2016. URL https://github.com/sehoonha/pydart2.
+
+Sehoon Ha and Katsu Yamane. Reducing Hardware Experiments for Model Learning and Policy Optimization. IROS, 2015.
+
+Nikolaus Hansen, Andreas Ostermeier, and Andreas Gawelczyk. On the adaptation of arbitrary normal mutation distributions in evolution strategies: The generating set adaptation. In ICGA, pp. 57–64, 1995.
+
+Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Sumit Jain and C Karen Liu. Controlling physics-based characters using soft contacts. ACM Transactions on Graphics (TOG), 30(6):163, 2011.
+
+Sylvain Koos, Jean-Baptiste Mouret, and Stephane Doncieux. Crossing the reality gap in evolution- ´ ary robotics by promoting transferable controllers. In Proceedings of the 12th annual conference on Genetic and evolutionary computation, pp. 119–126. ACM, 2010.
+
+Jeongseok Lee, Michael X Grey, Sehoon Ha, Tobias Kunz, Sumit Jain, Yuting Ye, Siddhartha S Srinivasa, Mike Stilman, and C Karen Liu. Dart: Dynamic animation and robotics toolkit. The Journal of Open Source Software, 3(22):500, 2018.
+
+Michael Neunert, Thiago Boaventura, and Jonas Buchli. Why off-the-shelf physics simulators fail in evaluating feedback controller performance-a case study for quadrupedal robots. In Advances in Cooperative Robotics, pp. 464–472. World Scientific, 2017.
+
+OpenAI, :, M. Andrychowicz, B. Baker, M. Chociej, R. Jozefowicz, B. McGrew, J. Pachocki, A. Petron, M. Plappert, G. Powell, A. Ray, J. Schneider, S. Sidor, J. Tobin, P. Welinder, L. Weng, and W. Zaremba. Learning Dexterous In-Hand Manipulation. ArXiv e-prints, August 2018.
+
+Xue Bin Peng, Glen Berseth, KangKang Yin, and Michiel Van De Panne. Deeploco: Dynamic locomotion skills using hierarchical deep reinforcement learning. ACM Transactions on Graphics (TOG), 36(4):41, 2017.
+
+Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018a.
+
+Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 1–8. IEEE, 2018b.
+
+Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial reinforcement learning. arXiv preprint arXiv:1703.02702, 2017.
+
+Aravind Rajeswaran, Sarvjeet Ghotra, Balaraman Ravindran, and Sergey Levine. Epopt: Learning robust neural network policies using model ensembles. arXiv preprint arXiv:1610.01283, 2016.
+
+Andrei A Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. ¨ Sim-to-real robot learning from pixels with progressive nets. arXiv preprint arXiv:1610.04286, 2016.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Freek Stulp, Gennaro Raiola, Antoine Hoarau, Serena Ivaldi, and Olivier Sigaud. Learning compact parameterized skills with a single regression. parameters, 5:9, 2013.
+
+Jie Tan, Kristin Siu, and C Karen Liu. Contact handling for articulated rigid bodies using lcp.
+
+Jie Tan, Zhaoming Xie, Byron Boots, and C Karen Liu. Simulation-based design of dynamic controllers for humanoid balancing. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on, pp. 2729–2736. IEEE, 2016.
+
+Jie Tan, Tingnan Zhang, Erwin Coumans, Atil Iscen, Yunfei Bai, Danijar Hafner, Steven Bohez, and Vincent Vanhoucke. Sim-to-real: Learning agile locomotion for quadruped robots. In Proceedings of Robotics: Science and Systems, Pittsburgh, Pennsylvania, June 2018. doi: 10.15607/RSS.2018. XIV.010.
+
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In Intelligent Robots and Systems (IROS), 2017 IEEE/RSJ International Conference on, pp. 23–30. IEEE, 2017.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Markus Wulfmeier, Ingmar Posner, and Pieter Abbeel. Mutual alignment transfer learning. arXiv preprint arXiv:1707.07907, 2017.
+
+Wenhao Yu and C. Karen Liu. Dartenv, 2017. URL https://github.com/DartEnv/ dart-env.
+
+Wenhao Yu, Jie Tan, C. Karen Liu, and Greg Turk. Preparing for the unknown: Learning a universal policy with online system identification. In Proceedings of Robotics: Science and Systems, Cambridge, Massachusetts, July 2017. doi: 10.15607/RSS.2017.XIII.048.
+
+Wenhao Yu, Greg Turk, and C. Karen Liu. Learning symmetric and low-energy locomotion. ACM Transactions on Graphics (Proc. SIGGRAPH 2018 - to appear), 37(4), 2018.
+
+Chao Zhang, Yang Yu, and Zhi-Hua Zhou. Learning environmental calibration actions for policy self-evolution. In IJCAI, pp. 3061–3067, 2018.
+
+# A DIFFERENCES BETWEEN DART AND MUJOCO
+
+DART (Lee et al., 2018) and MuJoCo (Todorov et al., 2012) are both physically-based simulators that computes how the state of virtual character or robot evolves over time and interacts with other objects in a physical way. Both of them have been demonstrated for transferring controllers learned for a simulated robot to a real hardware (Tan et al., 2018; 2016), and there has been work trying to transfer policies between DART and MuJoCo (Wulfmeier et al., 2017). The two simulators are similar in many aspects, for example both of them uses generalized coordinates for representing the state of a robot. Despite the many similarities between DART and MuJoCo, there are a few important differences between them that makes transferring a policy trained in one simulator to the other challenging. For the examples of DART-to-MuJoCo transfer presented in this paper, there are three major differences as described below:
+
+# 1. Contact Handling
+
+Contact modeling is important for robotic control applications, especially for locomotion tasks, where robots heavily rely on manipulating contacts between end-effector and the ground to move forward. In DART, contacts are handled by solving a linear complementarity problem (LCP) (Tan et al.), which ensures that in the next timestep, the objects will not penetrate with each other, while satisfying the laws of physics. In MuJoCo, the contact dynamics is modeled using a complementarity-free formulation, which means the objects might penetrate with each other. The resulting impulse will increase with the penetration depth and separate the penetrating objects eventually.
+
+# 2. Joint Limits
+
+Similar to the contact solver, DART tries to solve the joint limit constraints exactly so that the joint limit is not violated in the next timestep, while MuJoCo uses a soft constraint formulation, which means the character may violate the joint limit constraint.
+
+# 3. Armature
+
+In MuJoCo, a diagonal matrix $\sigma \mathbb { I } _ { n }$ is added to the joint space inertia matrix that can help stabilize the simulation, where $\sigma \in \mathbb { R }$ is a scalar named Armature in MuJoCo and $\mathbb { I } _ { n }$ is the $n \times n$ identity matrix. This is not modeled in DART.
+
+To illustrate how much difference these simulator characteristics can lead to, we compare the Hopper example in DART and MuJoCo by simulating both using the same sequence of randomly generated actions from an identical state. We plot the linear position and velocity of the torso and foot of the robot, which is shown in Figure 7. We can see that due to the differences in the dynamics, the two simulators would control the robot to reach notably different states even though the initial state and control signals are identical.
+
+![](images/b17b952e2ebc3eb53964b202de9d7a8c7a5feb8c7ccd48dbd165a5d2d499d629.jpg)  
+Figure 7: Comparison of DART and MuJoCo environments under the same control signals. The red curves represent position or velocity in the forward direction and the green curves represent position or velocity in the upward direction.
+
+# B EXPERIMENT DETAILS
+
+# B.1 EXPERIMENT SETTINGS
+
+We use Proximal Policy Optimization (PPO) implemented in OpenAI Baselines (Dhariwal et al., 2017) for training all the policies in our experiments. For simulation in DART, we use DartEnv (Yu
+
+Table 1: Environment Details   
+
+<table><tr><td>Environment</td><td>Observation</td><td>Action</td><td>Reward</td></tr><tr><td>Hopper</td><td>11</td><td>3</td><td>0.001||at|2 +1 Se</td></tr><tr><td>Walker2d</td><td>17</td><td>6</td><td>- 0.001||at|²2+1</td></tr><tr><td>HalfCheetah</td><td>17</td><td>6</td><td>− 0.1||at|2+1 svel</td></tr><tr><td>Quadruped</td><td>12</td><td>8</td><td>gel△t -0.008△tlat : qtl</td></tr></table>
+
+& Liu, 2017), which implements the continuous control benchmarks in OpenAI Gym using PyDart (Ha, 2016). For all of our examples, we represent the policy as a feed-forward neural network with three hidden layers, each consists of 64 hidden nodes.
+
+# B.2 ENVIRONMENT DETAILS
+
+The observation space, action space and the reward function used in all of our examples can be found in Table 1. For the Walker2d environment, we found that with the original environment settings in OpenAI Gym, the robot sometimes learn to hop forward, possibly due to the ankle being too strong. Therefore, we reduce the torque limit of the ankle joint in both DART and MuJoCo environment for the Walker2d problem from $[ - 1 0 0 , 1 0 0 ]$ to $[ - 2 0 , \dot { 2 } 0 ]$ . We found that with this modification, we can reliably learn locomotion gaits that are closer to a human running gait.
+
+Below we list the dynamic randomization settings used in our experiments. Table 2, Table 3 and Table 4 shows the range of the randomization for different dynamic parameters in different environments. For the quadruped example, we used the same settings as in Tan et al. (2018).
+
+Table 2: Dynamic Randomization details for Hopper   
+
+<table><tr><td>Dynamic Parmeter</td><td>Range</td></tr><tr><td>Friction Coefficient Restitution Coefficient</td><td>[0.2, 1.0]</td></tr><tr><td>Mass</td><td>[0.0, 0.3] [2.0, 15.0]kg</td></tr><tr><td>Joint Damping</td><td>[0.5,3]</td></tr><tr><td>Joint Torque Scale</td><td>[50%,150%]</td></tr></table>
+
+Table 3: Dynamic Randomization details for Walker2d   
+
+<table><tr><td>Dynamic Parmeter</td><td>Range</td></tr><tr><td>Friction Coefficient</td><td>[0.2,1.0]</td></tr><tr><td>Restitution Coefficient</td><td>[0.0,0.8]</td></tr><tr><td>Joint Damping</td><td>[0.1,3.0]</td></tr></table>
+
+# B.3 SIMULATED REALITY GAPS
+
+To evaluate the ability of our method to overcome the modeling error, we designed six types of modeling errors. Each example shown in our experiments contains one or more modeling errors listed below.
+
+# 1. DART to MuJoCo
+
+For the Hopper, Walker2d and HalfCheetah example, we trained policies that transfers from DART environment to MuJoCo environment. As discussed in Appendix A, the major differences between DART and MuJoCo are contacts, joint limits and armature.
+
+# 2. Latency
+
+The second type of modeling error we tested is latency in the signals. Specifically, we model the latency between when an observation $o$ is sent out from the robot, and when the action corresponding to this observation $a = \pi ( o )$ is executed on the robot. When a policy
+
+Table 4: Dynamic Randomization details for HalfCheetah   
+
+<table><tr><td>Dynamic Parmeter</td><td>Range</td></tr><tr><td>Friction Coefficient</td><td>[0.2,1.0]</td></tr><tr><td>Restitution Coefficient</td><td>[0.0,0.5]</td></tr><tr><td>Mass</td><td>[1.0, 15.0]kg</td></tr><tr><td>Joint Torque Scale</td><td>[30%,150%]</td></tr></table>
+
+is trained without any delay, it is usually very challenging to transfer it to problems with delay added. The value of delay is usually below $5 0 \mathrm { m s }$ and we use 8ms and $5 0 \mathrm { m s }$ in our examples.
+
+# 3. Actuator Modeling Error
+
+As noted by Tan et al. (2018), error in actuator modeling is an important factor that contributes to the reality gap. They solved it by identifying a more accurate actuator model by fitting a piece-wise linear function for the torque-current relation. We use their identified actuator model as the ground-truth target environment in our experiments and used the ideal linear torque-current relation in the source environments.
+
+# 4. Foot Mass
+
+In the example of Walker2d, we vary the mass of the right foot on the robot to create a family of target environments for testing. The range of the torso mass varies in $[ 2 , 9 ] \mathrm { k g }$ .
+
+# 5. Terrain Slope
+
+In the example of HalfCheetah, we vary the slope of the ground to create a family of target environments for testing. This is implemented as rotating the gravity direction by the same angle. The angle varies in the range $[ - 0 . 1 8 , 0 . 0 ]$ radians.
+
+# 6. Rigid to Deformable
+
+The last type of modeling error we test is that a deformable object in the target environment is modeled as a rigid object in the source environment. The deformable object is modeled using the soft shape object in DART. In our example, we created a deformable box of size $0 . 5 m \times 0 . 1 9 m \times 0 . 1 3 m$ around the foot of the Hopper. We set the stiffness of the deformable object to be 10, 000 and the damping to be 1.0. We refer readers to Jain & Liu (2011) for more details of the softbody simulation.
+
+# B.4 POLICY TRAINING
+
+For training policies in the source environment, we run PPO for 500 iterations. In each iteration, we sample 40, 000 steps from the source environment to update the policy. For the rest of the hyperparameters, we use the default value from OpenAI Baselines (Dhariwal et al., 2017). We use a large batch size in our experiments as the policy needs to be trained to work on different dynamic parameters $\mu$ .
+
+For fine-tuning of the Robust and Adaptive policy in the target environment, we sample 2, 000 steps from the target environment at each iteration of PPO, which is the default value used in OpenAI Baselines. Here we use a smaller batch size for two reasons: 1) since the policy is trained to work on only one dynamics, we do not need as many samples to optimize the policy in general and 2) the fine-tuning process has a limited sample budget and thus we want to use a smaller batch size so that the policy can be improved more. In the case where we use a maximum of 50, 000 samples for fine-tuning, this amounts to 50 iterations of PPO updates. Furthermore, we use a maximum rollout length of 1, 000, while the actual length of the rollout collected during training is general shorter due to the early termination, e.g. when the robot falls to the ground. Therefore, with 50, 000 samples in total, the fine-tuning process usually consists of $1 0 0 \sim 3 0 0$ rollouts, depending on the task.
+
+# B.5 STRATEGY OPTIMIZATION WITH CMA-ES
+
+We use the CMA-ES implementation in python by (PyC). At each iteration of CMA-ES, we generate $4 + \left\lfloor 3 * l o g ( N ) \right\rfloor$ samples from the latest Gaussian distribution, where $N$ is the dimension of the
+
+dynamic parameters. During evaluation of each sample $\mu _ { i }$ , we run the policy $\pi _ { \mu _ { i } }$ in the target environment for three trials and average the returns to obtain the fitness of this sample.
+
+# C ALTERNATIVE METHODS FOR STRATEGY OPTIMIZATION
+
+In addition to CMA-ES, we have also experimented with a few other options for finding the best $\mu$ such that $\pi _ { \mu }$ works well in the target environment. Here we show some experiment results for Strategy Optimization with Bayesian Optimization (SO-BO) and Model-based Optimization (SOMB).
+
+# C.1 BAYESIAN OPTIMIZATION
+
+Bayesian Optimization is a gradient-free optimization method that is known to work well for low dimensional continuous problems where evaluating the quality of each sample can be expensive. The main idea in Bayesian optimization is to incrementally build a Gaussian process (GP) model that estimates the loss of a given search parameter. At each iteration, a new sample is drawn by optimizing an acquisition function on the GP model. The acquisition function takes into account the exploration (search where the GP has low uncertainty) and exploitation (search where the GP predicts low loss). The new sample is then evaluated and added to the training dataset for GP.
+
+We test Bayesian Optimization on the Hopper and Quadruped example, as shown in Figure 8. We can see that Bayesian Optimization can achieve comparable performance as CMA-ES and thus is a viable choice to our problem. However, SO-BA appears in general noisier than CMA-ES and is in general less computationally efficient due to the re-fitting of GP models.
+
+![](images/f25926185e5de0a1c408858fe2eee24392721704b4c32c9220d10b08a2fbd7ca.jpg)  
+Figure 8: Comparison of SO-CMA and SO-BA for Hopper and Quadruped examples.
+
+# C.2 MODEL-BASED OPTIMIZATION
+
+Another possible way to perform strategy optimization is to use a model-based method. In a modelbased method, we learn the dynamics of the target environment using generic models such as neural networks, Gaussian process, linear functions, etc. After we have learned a dynamics model, we can use it as an approximation of the target environment to optimize $\mu$ .
+
+We first tried using feed-forward neural networks to learn the dynamics and optimize $\mu$ . However, this method was not able to reliably find $\mu$ that lead to good performance. This is possibly due to that any error in the prediction of the states would quickly accumulate over time and lead to inaccurate predictions. In addition, this method would not be able to handle problems where latency is involved.
+
+In the experiments presented here, we learn the dynamics of the target environment with a Long Short Term Memory (LSTM) network (Hochreiter & Schmidhuber, 1997). Given a target environment, we first sample $\mu$ uniformly and collect experience using $\pi _ { \mu }$ until we have 5, 000 samples. We use these samples to fit an initial LSTM dynamic model. We then alternate between finding the best dynamic parameters $\hat { \mu }$ such that $\pi _ { \hat { \mu } }$ achieves the best performance under the latest LSTM dynamic model and update the LSTM dynamic model using data generated from $\pi _ { \hat { \mu } }$ . This is repeated until we have reached the sample budget.
+
+We found that LSTM notably outperformed feed-forward networks when applied to strategy optimization. One result for Hopper DART-to-MuJoCo can be found in Figure 9. It can be seen that Model-based method with LSTM is able to achieve similar performance as CMA-ES.
+
+![](images/724df08e9dd0b211cf4be395d58b1aba73c687e48fdff7587dccc37fb0374f57.jpg)  
+Figure 9: Comparison of SO-CMA and SO-MB for Hopper DART-to-MuJoCo transfer.
+
+Model-based method provides more flexibility over CMA-ES and Bayesian optimization. For example, if the target environment changes over time, it may be desired to have $\mu$ also be time-varying. However, this would lead to a high dimensional search space, which might require significantly more samples for CMA-ES or Bayesian Optimization to solve the problem. If we can learn an accurate enough model from the data, we can use it to generate synthetic data for solving the problem.
+
+However, there are two major drawbacks for Model-based method. The first is that to learn the dynamics model, we need to have access to the full state of the robot, which can be challenging or troublesome in the real-world. In contrast, CMA-ES and Bayesian optimization only require the final return of a rollout. Second, the Model-based method is significantly slower to run than the other methods due to the frequent training of the LSTM network.

parse/train/H1g6osRcFQ/H1g6osRcFQ_content_list.json

@@ -0,0 +1,1912 @@
+[
+    {
+        "type": "text",
+        "text": "POLICY TRANSFER WITH STRATEGY OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            799,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wenhao Yu, C. Karen Liu, Greg Turk   \nSchool of Interactive Computing   \nGeorgia Institute of Technology   \nAtlanta, GA   \nwenhaoyu@gatech.edu, {karenliu,turk}@cc.gatech.edu ",
+        "bbox": [
+            184,
+            143,
+            671,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            252,
+            544,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Computer simulation provides an automatic and safe way for training robotic control policies to achieve complex tasks such as locomotion. However, a policy trained in simulation usually does not transfer directly to the real hardware due to the differences between the two environments. Transfer learning using domain randomization is a promising approach, but it usually assumes that the target environment is close to the distribution of the training environments, thus relying heavily on accurate system identification. In this paper, we present a different approach that leverages domain randomization for transferring control policies to unknown environments. The key idea that, instead of learning a single policy in the simulation, we simultaneously learn a family of policies that exhibit different behaviors. When tested in the target environment, we directly search for the best policy in the family based on the task performance, without the need to identify the dynamic parameters. We evaluate our method on five simulated robotic control problems with different discrepancies in the training and testing environment and demonstrate that our method can overcome larger modeling errors compared to training a robust policy or an adaptive policy. ",
+        "bbox": [
+            233,
+            284,
+            764,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            334,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent developments in Deep Reinforcement Learning (DRL) have shown the potential to learn complex robotic controllers in an automatic way with minimal human intervention. However, due to the high sample complexity of DRL algorithms, directly training control policies on the hardware still remains largely impractical for agile tasks such as locomotion. ",
+        "bbox": [
+            176,
+            563,
+            823,
+            617
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A promising direction to address this issue is to use the idea of transfer learning which learns a model in a source environment and transfers it to a target environment of interest. In the context of learning robotic control policies, we can consider the real world the target environment and the computer simulation the source environment. Learning in simulated environment provides a safe and efficient way to explore large variety of different situations that a real robot might encounter. However, due to the model discrepancy between physics simulation and the real-world environment, also known as the Reality Gap (Boeing & Braunl, 2012; Koos et al., 2010), the trained policy usually fails in ¨ the target environment. Efforts have been made to analyze the cause of the Reality Gap (Neunert et al., 2017) and to develop more accurate computer simulation (Tan et al., 2018) to improve the ability of a policy when transferred it to real hardware. Orthogonal to improving the fidelity of the physics simulation, researchers have also attempted to cross the reality gap by training more capable policies that succeed in a large variety of simulated environments. Our method falls into the second category. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To develop a policy capable of performing in various environments with different governing dynamics, one can consider to train a robust policy or to train an adaptive policy. In both cases, the policy is trained in environments with randomized dynamics. A robust policy is trained under a range of dynamics without identifying the specific dynamic parameters. Such a policy can only perform well if the simulation is a good approximation of the real world dynamics. In addition, for more agile motor skills, robust policies may appear over-conservative due to the uncertainty in the training environments. On the other hand, when an adaptive policy is used, it learns to first identify, implicitly or explicitly, the dynamics of its environment, and then selects the best action according to the identified dynamics. Being able to act differently according to the dynamics allows the adaptive policy to achieve higher performance on a larger range of dynamic systems. However, when the target dynamics is notably different from the training dynamics, it may still produce sub-optimal results for two reasons. First, when a sequence of novel observations is presented, the learned identification model in an adaptive policy may produce inaccurate estimations. Second, even when the identification model is perfect, the corresponding action may not be optimal for the new situation. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce a new method that enjoys the versatility of an adaptive policy, while avoiding the challenges of system identification. Instead of relating the observations in the target environment to the similar experiences in the training environment, our method searches for the best policy directly based on the task performance in the target environment. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our algorithm can be divided to two stages. The first stage trains a family of policies, each optimized for a particular vector of dynamic parameters. The family of policies can be parameterized by the dynamic parameters in a continuous representation. Each member of the family, referred to as a strategy, is a policy associated with particular dynamic parameters. Using a locomotion controller as an example, a strategy associated with low friction coefficient may exhibit cautious walking motion, while a strategy associated with high friction coefficient may result in more aggressive running motion. In the second stage we perform a search over the strategies in the target environment to find the one that achieves the highest task performance. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            368
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on three examples that demonstrate transfer of a policy learned in one simulator DART, to another simulator MuJoCo. Due to the differences in the constraint solvers, these simulators can produce notably different simulation results. A more detailed description of the differences between DART and MuJoCo is provided in Appendix A. We also add latency to the MuJoCo environment to mimic a real world scenario, which further increases the difficulty of the transfer. In addition, we use a quadruped robot simulated in Bullet to demonstrate that our method can overcome actuator modeling errors. Latency and actuator modeling have been found to be important for Sim-to-Real transfer of locomotion policies (Tan et al., 2018; Neunert et al., 2017). Finally, we transfer a policy learned for a robot composed of rigid bodies to a robot whose end-effector is deformable, demonstrating the possiblity of using our method to transfer to problems that are challenging to model faithfully. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            344,
+            570
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While DRL has demonstrated its ability to learn control policies for complex and dynamic motor skills in simulation (Schulman et al., 2015; 2017; Peng et al., 2018a; 2017; Yu et al., 2018; Heess et al., 2017), very few learning algorithms have successfully transferred these policies to the real world. Researchers have proposed to address this issue by optimizing or learning a simulation model using data from the real-world (Tan et al., 2018; 2016; Deisenroth & Rasmussen, 2011; Ha & Yamane, 2015; Abbeel & Ng, 2005). The main drawback for these methods is that for highly agile and high dimensional control problems, fitting an accurate dynamic model can be challenging and data inefficient. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Complementary to learning an accurate simulation model, a different line of research in sim-to-real transfer is to learn policies that can work under a large variety of simulated environments. One common approach is domain randomization. Training a robust policy with domain randomization has been shown to improve the ability to transfer a policy (Tan et al., 2018; Tobin et al., 2017; Rajeswaran et al., 2016; Pinto et al., 2017). Tobin et al. (2017) trained an object detector with randomized appearance and applied it in a real-world gripping task. Tan et al. (2018) showed that training a robust policy with randomized dynamic parameters is crucial for transferring quadruped locomotion to the real world. Designing the parameters and range of the domain to be randomized requires specific knowledge for different tasks. If the range is set too high, the policy may learn a conservative strategy or fail to learn the task, while a small range may not provide enough variation for the policy to transfer to real-world. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A similar idea is to train an adaptive policy with the current and the past observations as input. Such an adaptive policy is able to identify the dynamic parameters online either implicitly (OpenAI et al., 2018; Peng et al., 2018b) or explicitly (Yu et al., 2017) and apply actions appropriate for different system dynamics. Recently, adaptive policies have been used for sim-to-real transfer, such as in-hand manipulation tasks (OpenAI et al., 2018) or non-prehensile manipulation tasks (Peng et al., 2018b). Instead of training one robust or adaptive policy, Zhang et al. (2018) trained multiple policies for a set of randomized environments and learned to combine them linearly in a separate set of environments. The main advantage of these methods is that they can be trained entirely in simulation and deployed in real-world without further fine-tuning. However, policies trained in simulation may not generalize well when the discrepancy between the target environment and the simulation is too large. Our method also uses dynamic randomization to train policies that exhibit different strategies for different dynamics, however, instead of relying on the simulation to learn an identification model for selecting the strategy, we propose to directly optimize the strategy in the target environment. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A few recent works have also proposed the idea of training policies in a source environment and fine-tune it in the target environment. For example, Cully et al. (2015) proposed MAP-Elite to learn a large set of controllers and applied Bayesian optimization for fast adaptation to hardware damages. Their approach searches for individual controllers for discrete points in a behavior space, instead of a parameterized family of policies as in our case, making it potentially challenging to be applied to higher dimensional behavior spaces. Rusu et al. (2016) used progressive network to adapt the policy to new environments by designing a policy architecture that can effectively utilize previously learned representations. Chen et al. (2018) learned an implicit representation of the environment variations by optimizing a latent policy input for each discrete instance of the environment. They showed that fine-tuning on this learned policy achieved improved learning efficiency. In contrast to prior work in which the fine-tuning phase adjusts the neural network weights in the target environment, we optimize only the dynamics parameters input to the policy. This allows our policies to adapt to the target environments with less data and to use sparse reward signal. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            429
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            326,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We formulate the motor skill learning problem as a Markov Decision Process (MDP), $\\begin{array} { r l } { \\mathcal { M } } & { { } = } \\end{array}$ $( S , { \\mathcal { A } } , r , { \\mathcal { P } } , p _ { 0 } , \\gamma )$ , where $s$ is the state space, $\\mathcal { A }$ is the action space, $r : \\mathcal { S } \\times \\mathcal { A } \\mapsto \\mathbb { R }$ is the reward function, ${ \\mathcal { P } } : { \\mathcal { S } } \\times { \\mathcal { A } } \\mapsto { \\mathcal { S } }$ is the transition function, $p _ { 0 }$ is the initial state distribution and $\\gamma$ is the discount factor. The goal of reinforcement learning is to find a control policy $\\pi : { \\mathcal { S } } \\mapsto A$ that maximizes the expected accumulated reward: $J _ { \\mathcal { M } } ( \\pi ) = \\mathbb { E } _ { \\tau = ( s _ { 0 } , a _ { 0 } , \\ldots , s _ { T } ) } \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r ( s _ { t } , a _ { t } )$ , where $\\pmb { s } _ { 0 } \\sim p _ { 0 } , \\pmb { a } _ { t } \\sim \\pi ( \\pmb { s } _ { t } )$ and $\\pmb { s } _ { t + 1 } = \\mathcal { P } ( \\pmb { s } _ { t } , \\pmb { a } _ { t } )$ . In practice, we usually only have access to an observation of the robot that contains a partial information of the robot’s state. In this case, we will have a Partially-Observable Markov Decision Process (POMDP) and the policy would become $\\pi : \\mathcal { O } \\mapsto \\mathcal { A }$ , where $\\mathcal { O }$ is the observation space. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the context of transfer learning, we can define a source MDP $\\mathcal { M } ^ { s }$ and a target MDP $\\mathcal { M } ^ { t }$ and the goal would be to learn a policy $\\pi ^ { s }$ for $\\mathcal { M } ^ { s }$ such that it also works well on $\\mathcal { M } ^ { t }$ . In this work, $\\mathcal { P }$ is regarded as a parameterized space of transition functions, $\\pmb { s } _ { t + 1 } = \\mathcal { P } _ { \\mu } ( \\pmb { s } _ { t } , \\pmb { a } _ { t } )$ , where $\\mu$ is a vector of physical parameters defining the dynamic model (e.g. friction coefficient). The transfer learning in this context learns a policy under ${ \\mathcal { P } } ^ { s }$ and transfers to $\\mathcal { P } ^ { t }$ , where $\\mathcal { P } ^ { s } \\neq \\mathcal { P } ^ { t }$ . ",
+        "bbox": [
+            174,
+            621,
+            825,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            712,
+            290,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a new method for transferring a policy learned in simulated environment to a target environment with unknown dynamics. Our algorithm consists of two stages: learning a family of policies and optimizing strategy. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 LEARNING A FAMILY OF POLICIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            805,
+            454,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first stage of our method is to learn a family of policies, each for a particular dynamics $\\mathcal { P } _ { \\mu } ^ { s } ( \\cdot )$ . One can potentially train each policy individually and interpolate them to cover the space of $\\mu$ (Stulp et al., 2013; Da Silva et al., 2012). However, as the dimension of $\\mu$ increases, the number of policies required for interpolation grows exponentially. ",
+        "bbox": [
+            174,
+            833,
+            823,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since many of these policies are trained under similar dynamics, our method merges them into one neural network and trains the entire family of policies simultaneously. We follow the work by $\\mathrm { Y u }$ et al. (2017), which trains a policy $\\pi : ( o , \\mu ) \\mapsto a$ that takes as input not only the observation of the robot $^ o$ , but also the physical parameters $\\mu$ . At the beginning of each rollout during the training, we randomly pick a new set of physical parameters for the simulation and fix it throughout the rollout. After training the policy this way, we obtain a family of policies that is parameterized by the dynamics parameters $\\mu$ . Given a particular $\\mu$ , we define the corresponding policy as $\\pi _ { \\mu } : o \\mapsto a$ . We will call such an instantiated policy a strategy. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 OPTIMIZATING STRATEGY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            214,
+            397,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The second stage of our method is to search for the optimal strategy in the space of $\\mu$ for the target environment. Previousand the corresponding work learns a mapping between the experiences under source dynamics . When new experiences are generated in the target environment, this m $\\mathcal { P } _ { \\mu } ^ { s }$ $\\mu$   \nping will identify a $\\mu$ based on similar experiences previously generated in the source environment. While using experience similarity as a metric to identify $\\mu$ transfers well to a target environment that has the same dynamic parameter space ( $\\mathrm { Y u }$ et al., 2017), it does not generalize well when the dynamic parameter space is different. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since our goal is to find a strategy that works well in the target environment, a more direct approach is to use the performance of the task, i.e. the accumulated reward, in the target environment as the metric to search for the strategy: ",
+        "bbox": [
+            174,
+            348,
+            825,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7e5f30baf780685b4f05c445a7118fd12fa614bd43d59b3a18898688bbeff9e.jpg",
+        "text": "$$\n\\mu ^ { * } = \\arg \\operatorname* { m a x } _ { \\mu } J _ { \\mathcal { M } ^ { t } } ( \\pi _ { \\mu } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            422,
+            583,
+            450
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Solving Equation 1 can be done efficiently because the search space in Equation 1 is the space of dynamic parameters $\\mu$ , rather than the space of policies, which are represented as neural networks in our implementation. To further reduce the number of samples from the target environment needed for solving Equation 1, we investigated a number of algorithms, including Bayesian optimization, model-based methods and an evolutionary algorithm (CMA). A detailed description and comparison of these methods are provided in Appendix C. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We chose Covariance Matrix Adaptation (CMA) (Hansen et al., 1995), because it reliably outperforms other methods in terms of sample-efficiency. At each iteration of CMA, a set of samples are drawn from a Gaussian distribution over the space of $\\mu$ . For each sample, we instantiate a strategy $\\pi _ { \\mu }$ and use it to generate rollouts in the target environment. The fitness of the sample is determined by evaluating the rollouts using $J _ { \\mathcal { M } ^ { t } }$ . Based on the fitness values of the samples in the current iteration, the mean and the covariance matrix of the Gaussian distribution are updated for the next iteration. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            691,
+            326,
+            708
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the ability of our method to overcome the reality gap, we train policies for four locomotion control tasks (hopper, walker2d, half cheetah, quadruped robot) and transfer each policy to environments with different dynamics. To mimic the reality gap seen in the real-world, we use target environments that are different from the source environments in their contact modeling, latency or actuator modeling. In addition, we also test the ability of our method to generalize to discrepancies in body mass, terrain slope and end-effector materials. Figure 1 shows the source and target environments for all the tasks and summarizes the modeled reality gap in each task. During training, we choose different combinations of dynamic parameters to randomize and make sure they do not overlap with the variations in the testing environments. For clarity of exposition, we denote the dimension of the dynamic parameters that are randomized during training as $d i m ( \\mu )$ . For all examples, we use the Proximal Policy Optimization (PPO) (Schulman et al., 2017) to optimize the control policy. A more detailed description of the experiment setup as well as the simulated reality gaps are provided in Appendix B. For each example presented, we run three trials with different random seeds and report the mean and one standard deviation for the total reward. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/23bb588f419146a89f6e197de56aeaa70d7e3a5c7e5a68269bc43bf9b377e8bc.jpg",
+        "image_caption": [
+            "Figure 1: The environments used in our experiments. Environments in the top row are source environments and environments in the bottom row are the target environments we want to transfer the policy to. (a) Hopper from DART to MuJoCo. (b) Walker2d from DART to MuJoCo with latency. (c) HalfCheetah from DART to MuJoCo with latency. (d) Minitaur robot from inaccurate motor modeling to accurate motor modeling. (e) Hopper from rigid to soft foot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            99,
+            790,
+            323
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 BASELINE METHODS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            361,
+            436
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare our method, Strategy Optimization with CMA-ES (SO-CMA) to three baseline methods: training a robust policy (Robust), training an adaptive policy (Hist) and training a Universal Policy with Online System Identification (UPOSI) ( $\\mathrm { Y u }$ et al., 2017). The robust policy is represented as a feed forward neural network, which takes as input the most recent observation from the robot, i.e. $\\pi _ { r o b u s t } : o \\mapsto { \\pmb a }$ . The policy needs to learn actions that work for all the training environments, but the dynamic parameters cannot be identified from its input. In contrast, an adaptive policy is given a history of observations as input, i.e. $\\pi _ { a d a p t } : \\left( \\pmb { O } _ { t - h } , \\ldots , \\pmb { O } _ { t } \\right) \\mapsto \\pmb { a } _ { t }$ . This allows the policy to potentially identify the environment being tested and adaptively choose the actions based on the identified environment. There are many possible ways to train an adaptive policy, for example, one can use an LSTM network to represent the policy or use a history of observations as input to a feed-forward network. We find that for the tasks we demonstrate, directly training an LSTM policy using PPO is much less efficient and reaches lower end performance than training a feed-forward network with history input. Therefore, in our experiments we use a feed-forward network with a history of 10 observations to represent the adaptive policy $\\pi _ { a d a p t }$ . We also compare our method to UPOSI, which decouples the learning of an adaptive policy into training a universal policy via reinforcement learning and a system identification model via supervised learning. In theory UPOSI and Hist should achieve similar performance, while in practice we expect UPOSI to learn more efficiently due to the decoupling. We adopt the same training procedure as done by Yu et al. (2017), and use a history of 10 observations as input to the online system identification model. For fair comparison, we continue to train the baseline methods after transferring to the target environment, using the same amount of samples SO-CMA consumes in the target environment. We refer this additional training step as ‘fine-tuning’. In addition to the baseline methods, we also compare our method to the performance of policies trained directly in the target environments, which serves as an ‘Oracle’ benchmark. The Oracle policies for Hopper, Walke2d, HalfCheetah and Hopper Soft was trained for 1, 000, 000 samples in the target environment as in Schulman et al. (2017). For the quadruped example, we run PPO for 5, 000, 000 samples, similar to Tan et al. (2018). We detail the process of ‘fine-tuning’ in Appendix B.4 ",
+        "bbox": [
+            174,
+            450,
+            825,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.2 HOPPER DART TO MUJOCO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            413,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the first example, we build a single-legged robot in DART similar to the Hopper environment simulated by MuJoCo in OpenAI Gym (Brockman et al., 2016). We investigate two questions in this example: 1) does SO-CMA work better than alternative methods in transferring to unknown environments? and 2) how does the choice of $d i m ( \\mu )$ affect the performance of policy transfer? To this end, we perform experiments with $d i m ( \\mu ) = 2$ , 5 and 10. For the experiment with $d i m ( \\mu ) = 2$ , we randomize the mass of the robot’s foot and the restitution coefficient between the foot and the ground. For $d i m ( \\mu ) = 5$ , we in addition randomize the friction coefficient, the mass of the robot’s torso and the joint strength of the robot. We further include the mass of the rest two body parts and the joint damping to construct the randomized dynamic parameters for $d i m ( \\mu ) = 1 0$ . The specific ranges of randomization are described in Appendix B.4. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate how the performance of different methods varies with the number of samples in the target environment. As shown in Figure 2, when $d i m ( \\mu )$ is low, none of the four methods were able to transfer to the MuJoCo Hopper successfully. This is possibly due to there not being enough variation in the dynamics to learn diverse strategies. When $d i m ( \\mu ) = 5$ , SO-CMA can successfully transfer the policy to MuJoCo Hopper with good performance, while the baseline methods were not able to adapt to the new environment using the same sample budget. We further increase $d i m ( \\mu )$ to 10 as shown in Figure 2 (c) and find that SO-CMA achieved similar end performance to $d i m ( \\mu ) = 5$ , while the baselines do not transfer well to the target environment. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            305
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We further investigate whether SO-CMA can generalize to differences in joint limits in addition to the discrepancies between DART and MuJoCo. Specifically, we vary the magnitude of the ankle joint limit in [0.5, 1.0] radians (default is 0.785) for the MuJoCo Hopper, and run all the methods with 30, 000 samples. The result can be found in Figure 3. We can see a similar trend that with low $d i m ( \\mu )$ the transfer is challenging, and with higher value of $d i m ( \\mu )$ SO-CMA is able to achieve notably better transfer performance than the baseline methods. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb940f7d02bfa88c2693b4e9aeefc9d6ae5fa53bf09462e4220af6545d802315.jpg",
+        "image_caption": [
+            "Figure 2: Transfer performance vs Sample number in target environment for the Hopper example. Policies are trained to transfer from DART to MuJoCo. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            407,
+            826,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/abe0303a24e26f811d07b8378f9d08f41aece9aaaa757c2d335b24089fbd12ea.jpg",
+        "image_caption": [
+            "Figure 3: Transfer performance for the Hopper example. Policies are traiend to transfer from DART to MuJoCo with different ankle joint limits (horizontal axis). All trials run with total sample number of 30, 000 in the target environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            609,
+            825,
+            748
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 WALKER2D DART TO MUJOCO WITH LATENCY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            547,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this example, we use the lower body of a biped robot constrained to a $2 D$ plane, according to the Walker2d environment in OpenAI Gym. We find that with different initializations of the policy network, training could lead to drastically different gaits, e.g. hopping with both legs, running with one legs dragging the other, normal running, etc. Some of these gaits are more robust to environment changes than others, which makes analyzing the performance of transfer learning algorithms challenging. To make sure the policies are more comparable, we use the symmetry loss from Yu et al. (2018), which leads to all policies learning a symmetric running gait. To mimic modeling error seen on real robots, we add a latency of 8ms to the MuJoCo simulator. We train policies with $d i m ( \\mu ) = 8 $ , for which we randomize the friction coefficient, restitution coefficient and the joint damping of the six joints during training. Figure 4 (a) shows the transfer performance of different method with respect to the sample numbers in the target environment. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We further vary the mass of the robot’s right foot in $[ 2 , 9 ] \\mathrm { k g }$ in the MuJoCo Walker2d environment and compare the transfer performance of SO-CMA to the baselines. The default foot mass is $2 . 9 \\mathrm { k g }$ . We use in total 30, 000 samples in the target environment for all methods being compared and the results can be found in Figure 4 (b). In both cases, our method achieves notably better performance than Hist and UPOSI, while being comparable to Robust. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/09bc3de0a18c8e3f07367ec79cbc5641c9e576c83e5eb0f6e9247a632eda827c.jpg",
+        "image_caption": [
+            "Figure 4: Transfer performance for the Walker2d example. (a) Transfer performance vs sample number in target environment on flat surface. (b) Transfer performance vs foot mass, trained with 30, 000 samples in the target environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            233,
+            286,
+            756,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.4 HALFCHEETAH DART TO MUJOCO WITH DELAY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            535,
+            555,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the third example, we train policies for the HalfCheetah environment from OpenAI Gym. We again test the performance of transfer from DART to MuJoCo for this example. In addition, we add a latency of $5 0 \\mathrm { m s }$ to the target environment. We randomize 11 dynamic parameters in the source environment consisting of the mass of all body parts, the friction coefficient and the restitution coefficient during training, i.e. $d i m ( \\mu ) = 1 1$ . The results of the performance with respect to sample numbers in target environment can be found in Figure 5 (a). We in addition evaluate transfer to environments where the slope of the ground varies, as shown in Figure 5 (b). We can see that SO-CMA outperforms Robust and Hist, while achieves similar performance as UPOSI. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec021bc147c130f7744825d553e77231606f3f1479dded4990d86a3e6ddffec1.jpg",
+        "image_caption": [
+            "Figure 5: Transfer performance for the HalfCheetah example. (a) Transfer performance vs sample number in target environment on flat surface. (b) Transfer performance vs surface slope, trained with $3 0 , 0 0 0$ samples in the target environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            233,
+            696,
+            758,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.5 QUADRUPED ROBOT WITH ACTUATOR MODELING ERROR ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            104,
+            604,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As demonstrated by Tan et al. (2018), when a robust policy is used, having an accurate actuator model is important to the successful transfer of policy from simulation to real-world for a quadruped robot, Minitaur (Figure 1 (d)). Specifically, they found that when a linear torque-current relation is assumed in the actuator dynamics in the simulation, the policy learned in simulation transfers poorly to the real hardware. When the actuator dynamics is modeled more accurately, in their case using a non-linear torque-current relation, the transfer performance were notably improved. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            213
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our experiment, we investigate whether SO-CMA is able to overcome the error in actuator models. We use the same simulation environment from Tan et al. (2018), which is simulated in Bullet (Coumans & Bai, 2016-2017). During the training of the policy, we use a linear torque-current relation for the actuator model, and we transfer the learned policy to an environment with the more accurate non-linear torque-current relation. We use the same 25 dynamic parameters and corresponding ranges used by Tan et al. (2018) for dynamics randomization during training. When applying the robust policy to the accurate actuator model, we observe that the quadruped tends to sink to the ground, similar to what was observed by Tan et al. (2018). SO-CMA, on the other hand, can successfully transfer a policy trained with a crude actuator model to an environment with more realistic actuators(Figure 6 (a)). ",
+        "bbox": [
+            173,
+            220,
+            825,
+            359
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1cf91bc494f72050e45655080e7d71240fa246df3fc927f94827297f9f3d245c.jpg",
+        "image_caption": [
+            "Figure 6: Transfer performance for the Quadruped example (a) and the Soft-foot Hopper example (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            372,
+            756,
+            542
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.6 HOPPER RIGID TO DEFORMABLE FOOT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            478,
+            613
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Applying deep reinforcement learning to environments with deformable objects can be computationally inefficient (Clegg et al., 2018). Being able to transfer a policy trained in a purely rigid-body environment to an environment containing deformable objects can greatly improve the efficiency of learning. In our last example, we transfer a policy trained for the Hopper example with rigid objects only to a Hopper model with a deformable foot (Figre 1 (e)). The soft foot is modeled using the soft shape in DART, which uses an approximate but relatively efficient way of modeling deformable objects (Jain & Liu, 2011). We train policies in the rigid Hopper environment and randomize the same set of dynamic parameters as in the in the DART-to-MuJoCo transfer example with $\\dim ( \\mu ) = 5$ . We then transfer the learned policy to the soft Hopper environment where the Hopper’s foot is deformable. The results can be found in Figure 6 (b). SO-CMA is able to successfully control the robot to move forward without falling, while the baseline methods fail to do so. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            320,
+            816
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have demonstrated that our method, SO-CMA, can successfully transfer policies trained in one environment to a notably different one with a relatively low amount of samples. One advantage of SO-CMA, compared to the baselines, is that it works consistently well across different examples, while none of the baseline methods achieve successful transfer for all the examples. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that the large variance in the performance of the baseline methods is due to their sensitivity to the type of task being tested. For example, if there exists a robust controller that works for a large range of different dynamic parameters $\\mu$ in the task, such as a bipedal running motion in the Walker2d example, training a Robust policy may achieve good performance in transfer. However, when the optimal controller is more sensitive to $\\mu$ , Robust policies may learn to use overly-conservative strategies, leading to sub-optimal performance (e.g. in HalfCheetah) or fail to perform the task (e.g. in Hopper). On the other hand, if the target environment is not significantly different from the training environments, UPOSI may achieve good performance, as in HalfCheetah. However, as the reality gap becomes larger, the system identification model in UPOSI may fail to produce good estimates and result in non-optimal actions. Furthermore, Hist did not achieve successful transfer in any of the examples, possibly due to two reasons: 1) it shares similar limitation to UPOSI when the reality gap is large and 2) it is in general more difficult to train Hist due to the larger input space, so that with a limited sample budget it is challenging to fine-tune Hist effectively. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also note that although in some examples certain baseline method may achieve successful transfer, the fine-tuning process of these methods relies on having a dense reward signal. In practice, one may only have access to a sparse reward signal in the target environment, e.g. distance traveled before falling to the ground. Our method, using an evolutionary algorithm (CMA), naturally handles sparse rewards and thus the performance gap between our method (SO-CMA) and the baseline methods will likely be large if a sparse reward is used. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            318,
+            382
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have proposed a policy transfer algorithm where we first learn a family of policies simultaneously in a source environment that exhibits different behaviors and then search directly for a policy in the family that performs the best in the target environment. We show that our proposed method can overcome large modeling errors, including those commonly seen on real robotic platforms with relatively low amount of samples in the target environment. These results suggest that our method has the potential to transfer policies trained in simulation to real hardware. ",
+        "bbox": [
+            174,
+            397,
+            823,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There are a few interesting directions that merit further investigations. First, it would be interesting to explore other approaches for learning a family of policies that exhibit different behaviors. One such example is the method proposed by Eysenbach et al. (2018), where an agent learns diverse skills without a reward function in an unsupervised manner. Another example is the HCP-I policy proposed by Chen et al. (2018), which learns a latent representation of the environment variations implicitly. Equipping our policy with memories is another interesting direction to investigate. The addition of memory will extend our method to target environments that vary over time. We have investigated in a few options for strategy optimization and found that CMA-ES works well for our examples. However, it would be desired if we can find a way to further reduce the sample required in the target environment. One possible direction is to warm-start the optimization using models learned in simulation, such as the calibration model in Zhang et al. (2018) or the online system identification model in Yu et al. (2017). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            676,
+            285,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pycma. URL https://github.com/CMA-ES/pycma. ",
+        "bbox": [
+            173,
+            699,
+            573,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pieter Abbeel and Andrew Y. Ng. Exploration and Apprenticeship Learning in Reinforcement Learning. In International Conference on Machine Learning, pp. 1–8, 2005. ",
+        "bbox": [
+            173,
+            720,
+            821,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adrian Boeing and Thomas Braunl. Leveraging multiple simulators for crossing the reality gap. In ¨ Control Automation Robotics & Vision (ICARCV), 2012 12th International Conference on, pp. 1113–1119. IEEE, 2012. ",
+        "bbox": [
+            176,
+            757,
+            821,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016. ",
+        "bbox": [
+            174,
+            808,
+            821,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tao Chen, Adithyavairavan Murali, and Abhinav Gupta. Hardware conditioned policies for multirobot transfer learning. NIPS, 2018. ",
+        "bbox": [
+            173,
+            844,
+            821,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexander Clegg, Wenhao Yu, Jie Tan, C. Karen Liu, and Greg Turk. Learning to dress: Synthesizing human dressing motion via deep reinforcement learning. ACM Transactions on Graphics (TOG), 37(6), 2018. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Erwin Coumans and Yunfei Bai. Pybullet, a python module for physics simulation in robotics, games and machine learning., 2016-2017. URL http://pybullet.org. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antoine Cully, Jeff Clune, Danesh Tarapore, and Jean-Baptiste Mouret. Robots that can adapt like animals. Nature, 521(7553):503, 2015. ",
+        "bbox": [
+            171,
+            142,
+            823,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bruno Da Silva, George Konidaris, and Andrew Barto. Learning parameterized skills. arXiv preprint arXiv:1206.6398, 2012. ",
+        "bbox": [
+            173,
+            181,
+            821,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pp. 465–472, 2011. ",
+        "bbox": [
+            173,
+            220,
+            826,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prafulla Dhariwal, Christopher Hesse, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Openai baselines. https://github.com/openai/baselines, 2017. ",
+        "bbox": [
+            173,
+            273,
+            826,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is all you need: Learning skills without a reward function. arXiv preprint arXiv:1802.06070, 2018. ",
+        "bbox": [
+            171,
+            327,
+            823,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sehoon Ha. Pydart2, 2016. URL https://github.com/sehoonha/pydart2. ",
+        "bbox": [
+            174,
+            366,
+            741,
+            382
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sehoon Ha and Katsu Yamane. Reducing Hardware Experiments for Model Learning and Policy Optimization. IROS, 2015. ",
+        "bbox": [
+            174,
+            392,
+            821,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nikolaus Hansen, Andreas Ostermeier, and Andreas Gawelczyk. On the adaptation of arbitrary normal mutation distributions in evolution strategies: The generating set adaptation. In ICGA, pp. 57–64, 1995. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            537,
+            823,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sumit Jain and C Karen Liu. Controlling physics-based characters using soft contacts. ACM Transactions on Graphics (TOG), 30(6):163, 2011. ",
+        "bbox": [
+            171,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sylvain Koos, Jean-Baptiste Mouret, and Stephane Doncieux. Crossing the reality gap in evolution- ´ ary robotics by promoting transferable controllers. In Proceedings of the 12th annual conference on Genetic and evolutionary computation, pp. 119–126. ACM, 2010. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeongseok Lee, Michael X Grey, Sehoon Ha, Tobias Kunz, Sumit Jain, Yuting Ye, Siddhartha S Srinivasa, Mike Stilman, and C Karen Liu. Dart: Dynamic animation and robotics toolkit. The Journal of Open Source Software, 3(22):500, 2018. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Neunert, Thiago Boaventura, and Jonas Buchli. Why off-the-shelf physics simulators fail in evaluating feedback controller performance-a case study for quadrupedal robots. In Advances in Cooperative Robotics, pp. 464–472. World Scientific, 2017. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "OpenAI, :, M. Andrychowicz, B. Baker, M. Chociej, R. Jozefowicz, B. McGrew, J. Pachocki, A. Petron, M. Plappert, G. Powell, A. Ray, J. Schneider, S. Sidor, J. Tobin, P. Welinder, L. Weng, and W. Zaremba. Learning Dexterous In-Hand Manipulation. ArXiv e-prints, August 2018. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Glen Berseth, KangKang Yin, and Michiel Van De Panne. Deeploco: Dynamic locomotion skills using hierarchical deep reinforcement learning. ACM Transactions on Graphics (TOG), 36(4):41, 2017. ",
+        "bbox": [
+            173,
+            828,
+            823,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018a. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 1–8. IEEE, 2018b. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial reinforcement learning. arXiv preprint arXiv:1703.02702, 2017. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aravind Rajeswaran, Sarvjeet Ghotra, Balaraman Ravindran, and Sergey Levine. Epopt: Learning robust neural network policies using model ensembles. arXiv preprint arXiv:1610.01283, 2016. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. ¨ Sim-to-real robot learning from pixels with progressive nets. arXiv preprint arXiv:1610.04286, 2016. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            311
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Freek Stulp, Gennaro Raiola, Antoine Hoarau, Serena Ivaldi, and Olivier Sigaud. Learning compact parameterized skills with a single regression. parameters, 5:9, 2013. ",
+        "bbox": [
+            173,
+            357,
+            825,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jie Tan, Kristin Siu, and C Karen Liu. Contact handling for articulated rigid bodies using lcp. ",
+        "bbox": [
+            171,
+            395,
+            787,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jie Tan, Zhaoming Xie, Byron Boots, and C Karen Liu. Simulation-based design of dynamic controllers for humanoid balancing. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on, pp. 2729–2736. IEEE, 2016. ",
+        "bbox": [
+            171,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jie Tan, Tingnan Zhang, Erwin Coumans, Atil Iscen, Yunfei Bai, Danijar Hafner, Steven Bohez, and Vincent Vanhoucke. Sim-to-real: Learning agile locomotion for quadruped robots. In Proceedings of Robotics: Science and Systems, Pittsburgh, Pennsylvania, June 2018. doi: 10.15607/RSS.2018. XIV.010. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In Intelligent Robots and Systems (IROS), 2017 IEEE/RSJ International Conference on, pp. 23–30. IEEE, 2017. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            173,
+            601,
+            821,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Markus Wulfmeier, Ingmar Posner, and Pieter Abbeel. Mutual alignment transfer learning. arXiv preprint arXiv:1707.07907, 2017. ",
+        "bbox": [
+            171,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenhao Yu and C. Karen Liu. Dartenv, 2017. URL https://github.com/DartEnv/ dart-env. ",
+        "bbox": [
+            169,
+            690,
+            823,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenhao Yu, Jie Tan, C. Karen Liu, and Greg Turk. Preparing for the unknown: Learning a universal policy with online system identification. In Proceedings of Robotics: Science and Systems, Cambridge, Massachusetts, July 2017. doi: 10.15607/RSS.2017.XIII.048. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            771
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenhao Yu, Greg Turk, and C. Karen Liu. Learning symmetric and low-energy locomotion. ACM Transactions on Graphics (Proc. SIGGRAPH 2018 - to appear), 37(4), 2018. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chao Zhang, Yang Yu, and Zhi-Hua Zhou. Learning environmental calibration actions for policy self-evolution. In IJCAI, pp. 3061–3067, 2018. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A DIFFERENCES BETWEEN DART AND MUJOCO ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            598,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "DART (Lee et al., 2018) and MuJoCo (Todorov et al., 2012) are both physically-based simulators that computes how the state of virtual character or robot evolves over time and interacts with other objects in a physical way. Both of them have been demonstrated for transferring controllers learned for a simulated robot to a real hardware (Tan et al., 2018; 2016), and there has been work trying to transfer policies between DART and MuJoCo (Wulfmeier et al., 2017). The two simulators are similar in many aspects, for example both of them uses generalized coordinates for representing the state of a robot. Despite the many similarities between DART and MuJoCo, there are a few important differences between them that makes transferring a policy trained in one simulator to the other challenging. For the examples of DART-to-MuJoCo transfer presented in this paper, there are three major differences as described below: ",
+        "bbox": [
+            174,
+            133,
+            825,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. Contact Handling ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            286,
+            349,
+            300
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Contact modeling is important for robotic control applications, especially for locomotion tasks, where robots heavily rely on manipulating contacts between end-effector and the ground to move forward. In DART, contacts are handled by solving a linear complementarity problem (LCP) (Tan et al.), which ensures that in the next timestep, the objects will not penetrate with each other, while satisfying the laws of physics. In MuJoCo, the contact dynamics is modeled using a complementarity-free formulation, which means the objects might penetrate with each other. The resulting impulse will increase with the penetration depth and separate the penetrating objects eventually. ",
+        "bbox": [
+            230,
+            304,
+            823,
+            415
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. Joint Limits ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            420,
+            313,
+            434
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Similar to the contact solver, DART tries to solve the joint limit constraints exactly so that the joint limit is not violated in the next timestep, while MuJoCo uses a soft constraint formulation, which means the character may violate the joint limit constraint. ",
+        "bbox": [
+            232,
+            436,
+            823,
+            478
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. Armature ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            484,
+            297,
+            497
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In MuJoCo, a diagonal matrix $\\sigma \\mathbb { I } _ { n }$ is added to the joint space inertia matrix that can help stabilize the simulation, where $\\sigma \\in \\mathbb { R }$ is a scalar named Armature in MuJoCo and $\\mathbb { I } _ { n }$ is the $n \\times n$ identity matrix. This is not modeled in DART. ",
+        "bbox": [
+            232,
+            500,
+            823,
+            541
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To illustrate how much difference these simulator characteristics can lead to, we compare the Hopper example in DART and MuJoCo by simulating both using the same sequence of randomly generated actions from an identical state. We plot the linear position and velocity of the torso and foot of the robot, which is shown in Figure 7. We can see that due to the differences in the dynamics, the two simulators would control the robot to reach notably different states even though the initial state and control signals are identical. ",
+        "bbox": [
+            173,
+            555,
+            825,
+            638
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/b17b952e2ebc3eb53964b202de9d7a8c7a5feb8c7ccd48dbd165a5d2d499d629.jpg",
+        "image_caption": [
+            "Figure 7: Comparison of DART and MuJoCo environments under the same control signals. The red curves represent position or velocity in the forward direction and the green curves represent position or velocity in the upward direction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            650,
+            825,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            398,
+            853
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            383,
+            883
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We use Proximal Policy Optimization (PPO) implemented in OpenAI Baselines (Dhariwal et al., 2017) for training all the policies in our experiments. For simulation in DART, we use DartEnv (Yu ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e690d97edc060a36b10f579f1a1746f864ffd4cb04a159c4fff273437eac9ff.jpg",
+        "table_caption": [
+            "Table 1: Environment Details "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Environment</td><td>Observation</td><td>Action</td><td>Reward</td></tr><tr><td>Hopper</td><td>11</td><td>3</td><td>0.001||at|2 +1 Se</td></tr><tr><td>Walker2d</td><td>17</td><td>6</td><td>- 0.001||at|²2+1</td></tr><tr><td>HalfCheetah</td><td>17</td><td>6</td><td>− 0.1||at|2+1 svel</td></tr><tr><td>Quadruped</td><td>12</td><td>8</td><td>gel△t -0.008△tlat : qtl</td></tr></table>",
+        "bbox": [
+            269,
+            128,
+            727,
+            217
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "& Liu, 2017), which implements the continuous control benchmarks in OpenAI Gym using PyDart (Ha, 2016). For all of our examples, we represent the policy as a feed-forward neural network with three hidden layers, each consists of 64 hidden nodes. ",
+        "bbox": [
+            176,
+            233,
+            823,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.2 ENVIRONMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            292,
+            388,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The observation space, action space and the reward function used in all of our examples can be found in Table 1. For the Walker2d environment, we found that with the original environment settings in OpenAI Gym, the robot sometimes learn to hop forward, possibly due to the ankle being too strong. Therefore, we reduce the torque limit of the ankle joint in both DART and MuJoCo environment for the Walker2d problem from $[ - 1 0 0 , 1 0 0 ]$ to $[ - 2 0 , \\dot { 2 } 0 ]$ . We found that with this modification, we can reliably learn locomotion gaits that are closer to a human running gait. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            404
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Below we list the dynamic randomization settings used in our experiments. Table 2, Table 3 and Table 4 shows the range of the randomization for different dynamic parameters in different environments. For the quadruped example, we used the same settings as in Tan et al. (2018). ",
+        "bbox": [
+            176,
+            410,
+            825,
+            452
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/0089e3c42ec29feb1d160d0564454c2cd3ba5b7aa60240798fda1e6030511b55.jpg",
+        "table_caption": [
+            "Table 2: Dynamic Randomization details for Hopper "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dynamic Parmeter</td><td>Range</td></tr><tr><td>Friction Coefficient Restitution Coefficient</td><td>[0.2, 1.0]</td></tr><tr><td>Mass</td><td>[0.0, 0.3] [2.0, 15.0]kg</td></tr><tr><td>Joint Damping</td><td>[0.5,3]</td></tr><tr><td>Joint Torque Scale</td><td>[50%,150%]</td></tr></table>",
+        "bbox": [
+            361,
+            494,
+            633,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/5929c095c06a6dd380964c38c58ffd8197969d3faedeee1c0d92a51e555a3b81.jpg",
+        "table_caption": [
+            "Table 3: Dynamic Randomization details for Walker2d "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dynamic Parmeter</td><td>Range</td></tr><tr><td>Friction Coefficient</td><td>[0.2,1.0]</td></tr><tr><td>Restitution Coefficient</td><td>[0.0,0.8]</td></tr><tr><td>Joint Damping</td><td>[0.1,3.0]</td></tr></table>",
+        "bbox": [
+            372,
+            633,
+            622,
+            705
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.3 SIMULATED REALITY GAPS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            720,
+            411,
+            736
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the ability of our method to overcome the modeling error, we designed six types of modeling errors. Each example shown in our experiments contains one or more modeling errors listed below. ",
+        "bbox": [
+            176,
+            747,
+            825,
+            789
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. DART to MuJoCo ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            803,
+            354,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the Hopper, Walker2d and HalfCheetah example, we trained policies that transfers from DART environment to MuJoCo environment. As discussed in Appendix A, the major differences between DART and MuJoCo are contacts, joint limits and armature. ",
+        "bbox": [
+            227,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. Latency ",
+        "text_level": 1,
+        "bbox": [
+            212,
+            866,
+            287,
+            880
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The second type of modeling error we tested is latency in the signals. Specifically, we model the latency between when an observation $o$ is sent out from the robot, and when the action corresponding to this observation $a = \\pi ( o )$ is executed on the robot. When a policy ",
+        "bbox": [
+            228,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/d25efa3c48061889c4d83dff15fbf7f05cc7dc89bebf502d94716184b5d07b25.jpg",
+        "table_caption": [
+            "Table 4: Dynamic Randomization details for HalfCheetah "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dynamic Parmeter</td><td>Range</td></tr><tr><td>Friction Coefficient</td><td>[0.2,1.0]</td></tr><tr><td>Restitution Coefficient</td><td>[0.0,0.5]</td></tr><tr><td>Mass</td><td>[1.0, 15.0]kg</td></tr><tr><td>Joint Torque Scale</td><td>[30%,150%]</td></tr></table>",
+        "bbox": [
+            361,
+            131,
+            633,
+            215
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "is trained without any delay, it is usually very challenging to transfer it to problems with delay added. The value of delay is usually below $5 0 \\mathrm { m s }$ and we use 8ms and $5 0 \\mathrm { m s }$ in our examples. ",
+        "bbox": [
+            232,
+            233,
+            823,
+            275
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. Actuator Modeling Error ",
+        "text_level": 1,
+        "bbox": [
+            212,
+            281,
+            398,
+            296
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As noted by Tan et al. (2018), error in actuator modeling is an important factor that contributes to the reality gap. They solved it by identifying a more accurate actuator model by fitting a piece-wise linear function for the torque-current relation. We use their identified actuator model as the ground-truth target environment in our experiments and used the ideal linear torque-current relation in the source environments. ",
+        "bbox": [
+            232,
+            299,
+            823,
+            367
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. Foot Mass ",
+        "text_level": 1,
+        "bbox": [
+            212,
+            375,
+            303,
+            387
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the example of Walker2d, we vary the mass of the right foot on the robot to create a family of target environments for testing. The range of the torso mass varies in $[ 2 , 9 ] \\mathrm { k g }$ . ",
+        "bbox": [
+            225,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. Terrain Slope ",
+        "text_level": 1,
+        "bbox": [
+            212,
+            425,
+            323,
+            439
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the example of HalfCheetah, we vary the slope of the ground to create a family of target environments for testing. This is implemented as rotating the gravity direction by the same angle. The angle varies in the range $[ - 0 . 1 8 , 0 . 0 ]$ radians. ",
+        "bbox": [
+            230,
+            441,
+            823,
+            483
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6. Rigid to Deformable ",
+        "text_level": 1,
+        "bbox": [
+            212,
+            489,
+            370,
+            503
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The last type of modeling error we test is that a deformable object in the target environment is modeled as a rigid object in the source environment. The deformable object is modeled using the soft shape object in DART. In our example, we created a deformable box of size $0 . 5 m \\times 0 . 1 9 m \\times 0 . 1 3 m$ around the foot of the Hopper. We set the stiffness of the deformable object to be 10, 000 and the damping to be 1.0. We refer readers to Jain & Liu (2011) for more details of the softbody simulation. ",
+        "bbox": [
+            232,
+            507,
+            825,
+            589
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.4 POLICY TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            608,
+            346,
+            622
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For training policies in the source environment, we run PPO for 500 iterations. In each iteration, we sample 40, 000 steps from the source environment to update the policy. For the rest of the hyperparameters, we use the default value from OpenAI Baselines (Dhariwal et al., 2017). We use a large batch size in our experiments as the policy needs to be trained to work on different dynamic parameters $\\mu$ . ",
+        "bbox": [
+            174,
+            635,
+            825,
+            704
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For fine-tuning of the Robust and Adaptive policy in the target environment, we sample 2, 000 steps from the target environment at each iteration of PPO, which is the default value used in OpenAI Baselines. Here we use a smaller batch size for two reasons: 1) since the policy is trained to work on only one dynamics, we do not need as many samples to optimize the policy in general and 2) the fine-tuning process has a limited sample budget and thus we want to use a smaller batch size so that the policy can be improved more. In the case where we use a maximum of 50, 000 samples for fine-tuning, this amounts to 50 iterations of PPO updates. Furthermore, we use a maximum rollout length of 1, 000, while the actual length of the rollout collected during training is general shorter due to the early termination, e.g. when the robot falls to the ground. Therefore, with 50, 000 samples in total, the fine-tuning process usually consists of $1 0 0 \\sim 3 0 0$ rollouts, depending on the task. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            851
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.5 STRATEGY OPTIMIZATION WITH CMA-ES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            513,
+            883
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use the CMA-ES implementation in python by (PyC). At each iteration of CMA-ES, we generate $4 + \\left\\lfloor 3 * l o g ( N ) \\right\\rfloor$ samples from the latest Gaussian distribution, where $N$ is the dimension of the ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "dynamic parameters. During evaluation of each sample $\\mu _ { i }$ , we run the policy $\\pi _ { \\mu _ { i } }$ in the target environment for three trials and average the returns to obtain the fitness of this sample. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C ALTERNATIVE METHODS FOR STRATEGY OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            679,
+            167
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In addition to CMA-ES, we have also experimented with a few other options for finding the best $\\mu$ such that $\\pi _ { \\mu }$ works well in the target environment. Here we show some experiment results for Strategy Optimization with Bayesian Optimization (SO-BO) and Model-based Optimization (SOMB). ",
+        "bbox": [
+            174,
+            183,
+            825,
+            238
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.1 BAYESIAN OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            255,
+            398,
+            270
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Bayesian Optimization is a gradient-free optimization method that is known to work well for low dimensional continuous problems where evaluating the quality of each sample can be expensive. The main idea in Bayesian optimization is to incrementally build a Gaussian process (GP) model that estimates the loss of a given search parameter. At each iteration, a new sample is drawn by optimizing an acquisition function on the GP model. The acquisition function takes into account the exploration (search where the GP has low uncertainty) and exploitation (search where the GP predicts low loss). The new sample is then evaluated and added to the training dataset for GP. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            378
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We test Bayesian Optimization on the Hopper and Quadruped example, as shown in Figure 8. We can see that Bayesian Optimization can achieve comparable performance as CMA-ES and thus is a viable choice to our problem. However, SO-BA appears in general noisier than CMA-ES and is in general less computationally efficient due to the re-fitting of GP models. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            441
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/f25926185e5de0a1c408858fe2eee24392721704b4c32c9220d10b08a2fbd7ca.jpg",
+        "image_caption": [
+            "Figure 8: Comparison of SO-CMA and SO-BA for Hopper and Quadruped examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            450,
+            825,
+            560
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.2 MODEL-BASED OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            612,
+            431,
+            626
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Another possible way to perform strategy optimization is to use a model-based method. In a modelbased method, we learn the dynamics of the target environment using generic models such as neural networks, Gaussian process, linear functions, etc. After we have learned a dynamics model, we can use it as an approximation of the target environment to optimize $\\mu$ . ",
+        "bbox": [
+            174,
+            637,
+            823,
+            693
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We first tried using feed-forward neural networks to learn the dynamics and optimize $\\mu$ . However, this method was not able to reliably find $\\mu$ that lead to good performance. This is possibly due to that any error in the prediction of the states would quickly accumulate over time and lead to inaccurate predictions. In addition, this method would not be able to handle problems where latency is involved. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            768
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In the experiments presented here, we learn the dynamics of the target environment with a Long Short Term Memory (LSTM) network (Hochreiter & Schmidhuber, 1997). Given a target environment, we first sample $\\mu$ uniformly and collect experience using $\\pi _ { \\mu }$ until we have 5, 000 samples. We use these samples to fit an initial LSTM dynamic model. We then alternate between finding the best dynamic parameters $\\hat { \\mu }$ such that $\\pi _ { \\hat { \\mu } }$ achieves the best performance under the latest LSTM dynamic model and update the LSTM dynamic model using data generated from $\\pi _ { \\hat { \\mu } }$ . This is repeated until we have reached the sample budget. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            875
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We found that LSTM notably outperformed feed-forward networks when applied to strategy optimization. One result for Hopper DART-to-MuJoCo can be found in Figure 9. It can be seen that Model-based method with LSTM is able to achieve similar performance as CMA-ES. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/724df08e9dd0b211cf4be395d58b1aba73c687e48fdff7587dccc37fb0374f57.jpg",
+        "image_caption": [
+            "Figure 9: Comparison of SO-CMA and SO-MB for Hopper DART-to-MuJoCo transfer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            364,
+            109,
+            604,
+            252
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Model-based method provides more flexibility over CMA-ES and Bayesian optimization. For example, if the target environment changes over time, it may be desired to have $\\mu$ also be time-varying. However, this would lead to a high dimensional search space, which might require significantly more samples for CMA-ES or Bayesian Optimization to solve the problem. If we can learn an accurate enough model from the data, we can use it to generate synthetic data for solving the problem. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            363
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "However, there are two major drawbacks for Model-based method. The first is that to learn the dynamics model, we need to have access to the full state of the robot, which can be challenging or troublesome in the real-world. In contrast, CMA-ES and Bayesian optimization only require the final return of a rollout. Second, the Model-based method is significantly slower to run than the other methods due to the frequent training of the LSTM network. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            440
+        ],
+        "page_idx": 15
+    }
+]

parse/train/Hkl5aoR5tm/Hkl5aoR5tm.md

@@ -0,0 +1,335 @@
+# ON SELF MODULATION FOR GENERATIVE ADVERSARIAL NETWORKS
+
+Ting Chen∗ University of California, Los Angeles tingchen@cs.ucla.edu
+
+Mario Lucic, Neil Houlsby, Sylvain Gelly Google Brain {lucic,neilhoulsby,sylvaingelly}@google.com
+
+# ABSTRACT
+
+Training Generative Adversarial Networks (GANs) is notoriously challenging. We propose and study an architectural modification, self-modulation, which improves GAN performance across different data sets, architectures, losses, regularizers, and hyperparameter settings. Intuitively, self-modulation allows the intermediate feature maps of a generator to change as a function of the input noise vector. While reminiscent of other conditioning techniques, it requires no labeled data. In a large-scale empirical study we observe a relative decrease of $5 \% - 3 5 \%$ in FID. Furthermore, all else being equal, adding this modification to the generator leads to improved performance in $1 2 4 / 1 4 4$ $( 8 6 \% )$ of the studied settings. Selfmodulation is a simple architectural change that requires no additional parameter tuning, which suggests that it can be applied readily to any GAN.1
+
+# 1 INTRODUCTION
+
+Generative Adversarial Networks (GANs) are a powerful class of generative models successfully applied to a variety of tasks such as image generation (Zhang et al., 2017; Miyato et al., 2018; Karras et al., 2017), learned compression (Tschannen et al., 2018), super-resolution (Ledig et al., 2017), inpainting (Pathak et al., 2016), and domain transfer (Isola et al., 2016; Zhu et al., 2017).
+
+Training GANs is a notoriously challenging task (Goodfellow et al., 2014; Arjovsky et al., 2017; Lucic et al., 2018) as one is searching in a high-dimensional parameter space for a Nash equilibrium of a non-convex game. As a practical remedy one applies (usually a variant of) stochastic gradient descent, which can be unstable and lack guarantees Salimans et al. (2016). As a result, one of the main research challenges is to stabilize GAN training. Several approaches have been proposed, including varying the underlying divergence between the model and data distributions (Arjovsky et al., 2017; Mao et al., 2016), regularization and normalization schemes (Gulrajani et al., 2017; Miyato et al., 2018), optimization schedules (Karras et al., 2017), and specific neural architectures (Radford et al., 2016; Zhang et al., 2018). A particularly successful approach is based on conditional generation; where the generator (and possibly discriminator) are given side information, for example class labels Mirza & Osindero (2014); Odena et al. (2017); Miyato & Koyama (2018). In fact, state-of-the-art conditional GANs inject side information via conditional batch normalization (CBN) layers (De Vries et al., 2017; Miyato & Koyama, 2018; Zhang et al., 2018). While this approach does help, a major drawback is that it requires external information, such as labels or embeddings, which is not always available.
+
+In this work we show that GANs benefit from self-modulation layers in the generator. Our approach is motivated by Feature-wise Linear Modulation in supervised learning (Perez et al., 2018; De Vries et al., 2017), with one key difference: instead of conditioning on external information, we condition on the generator’s own input. As self-modulation requires a simple change which is easily applicable to all popular generator architectures, we believe that is a useful addition to the GAN toolbox.
+
+Summary of contributions. We provide a simple yet effective technique that can added universally to yield better GANs. We demonstrate empirically that for a wide variety of settings (loss functions, regularizers and normalizers, neural architectures, and optimization settings) that the proposed approach yields between a $5 \%$ and $3 5 \%$ improvement in sample quality. When using fixed hyperparameters settings our approach outperforms the baseline in $8 6 \% ( 1 2 4 / 1 4 4 )$ of cases. Further, we show that self-modulation still helps even if label information is available. Finally, we discuss the effects of this method in light of recently proposed diagnostic tools, generator conditioning (Odena et al., 2018) and precision/recall for generative models (Sajjadi et al., 2018).
+
+![](images/de7a45665cecf0ce02880f528fcb3eb5593669fa2d3f85053324703415580e05.jpg)  
+Figure 1: (a) The proposed Self-Modulation framework for a generator network, where middle layers are directly modulated as a function of the generator input $_ z$ . (b) A simple MLP based modulation function that transforms input $_ z$ to the modulation variables $\beta ( z )$ and $\gamma ( z )$ .
+
+# 2 SELF-MODULATION FOR GENERATIVE ADVERSARIAL NETWORKS
+
+Several recent works observe that conditioning the generative process on side information (such as labels or class embeddings) leads to improved models (Mirza & Osindero, 2014; Odena et al., 2017; Miyato & Koyama, 2018). Two major approaches to conditioning on side information $\pmb { s }$ have emerged: (1) Directly concatenate the side information $\pmb { s }$ with the noise vector $_ z$ (Mirza & Osindero, 2014), i.e. $z ^ { \prime } = [ s , z ]$ . (2) Condition the hidden layers directly on $\pmb { s }$ , which is usually instantiated via conditional batch normalization (De Vries et al., 2017; Miyato & Koyama, 2018).
+
+Despite the success of conditional approaches, two concerns arise. The first is practical; side information is often unavailable. The second is conceptual; unsupervised models, such as GANs, seek to model data without labels. Including them side-steps the challenge and value of unsupervised learning.
+
+We propose self-modulating layers for the generator network. In these layers the hidden activations are modulated as a function of latent vector $_ z$ . In particular, we apply modulation in a feature-wise fashion which allows the model to re-weight the feature maps as a function of the input. This is also motivated by the FiLM layer for supervised models (Perez et al., 2018; De Vries et al., 2017) in which a similar mechanism is used to condition a supervised network on side information.
+
+Batch normalization (Ioffe & Szegedy, 2015) can improve the training of deep neural nets, and it is widely used in both discriminative and generative modeling (Szegedy et al., 2015; Radford et al., 2016; Miyato et al., 2018). It is thus present in most modern networks, and provides a convenient entry point for self-modulation. Therefore, we present our method in the context of its application via batch normalization. In batch normalization the activations of a layer, $^ { h }$ , are transformed as
+
+$$
+h _ { \ell } ^ { \prime } = \gamma \odot \frac { h _ { \ell } - \mu } { \sigma } + \beta ,
+$$
+
+where $\pmb { \mu }$ and $\sigma ^ { 2 }$ are the estimated mean and variances of the features across the data, and $\gamma$ and $\beta$ are learnable scale and shift parameters.
+
+Self-modulation for unconditional (without side information) generation. In this case the proposed method replaces the non-adaptive parameters $\beta$ and $\gamma$ with input-dependent $\beta ( z )$ and $\gamma ( z )$ , respectively. These are parametrized by a neural network applied to the generator’s input (Figure 1). In particular, for layer $\ell$ , we compute
+
+$$
+h _ { \ell } ^ { \prime } = \gamma _ { \ell } ( z ) \odot \frac { h _ { \ell } - \mu } { \sigma } + \beta _ { \ell } ( z )
+$$
+
+Table 1: Techniques for generator conditioning and modulation.   
+
+<table><tr><td></td><td>Only first layer</td><td>Other Arbitrary layers</td></tr><tr><td>Side information s</td><td>N/A</td><td>Conditional batch normalization (De Vries et al., 2017; Miyato &amp; Koyama, 2018)</td></tr><tr><td>Latent vector z</td><td>Unconditional Generator (Goodfellow et al., 2014)</td><td>(Unconditional) Self-Modulation (this work)</td></tr><tr><td>Both s and z</td><td>Conditional Generator (Mirza &amp; Osindero, 2014)</td><td>(Conditional) Self-Modulation (this work)</td></tr></table>
+
+In general, it suffices that $\gamma _ { \ell } ( \cdot )$ and $\beta _ { \ell } ( \cdot )$ are differentiable. In this work, we use a small onehidden layer feed-forward network (MLP) with ReLU activation applied to the generator input $_ { z }$ . Specifically, given parameter matrices $U ^ { ( \ell ) }$ and $V ^ { ( \ell ) }$ , and a bias vector $\pmb { b } ^ { ( \ell ) }$ , we compute
+
+$$
+\gamma _ { \ell } ( z ) = V ^ { ( \ell ) } \operatorname* { m a x } ( 0 , U ^ { ( \ell ) } z + \pmb { b } ^ { ( \ell ) } ) .
+$$
+
+We do the same for $\beta ( z )$ with independent parameters.
+
+Self-modulation for conditional (with side information) generation. Having access to side information proved to be useful for conditional generation. The use of labels in the generator (and possibly discriminator) was introduced by Mirza & Osindero (2014) and later adapted by Odena et al. (2017); Miyato $\&$ Koyama (2018). In case that side information is available (e.g. class labels $y )$ , it can be readily incorporated into the proposed method. This can be achieved by simply composing the information $y$ with the input $z \in \bar { \mathbb { R } ^ { d } }$ via some learnable function $g$ , i.e. $z ^ { \prime } = g ( y , z )$ . In this work we opt for the simplest option and instantiate $g$ as a bi-linear interaction between $_ z$ and two trainable embedding functions $\dot { \boldsymbol { E } } , \boldsymbol { E } ^ { \prime } : \boldsymbol { Y }  \mathbb { R } ^ { d }$ of the class label $y$ , as
+
+$$
+z ^ { \prime } = z + \mathrm { E } ( y ) + z \odot \mathrm { E } ^ { \prime } ( y ) .
+$$
+
+This conditionally composed $z ^ { \prime }$ can be directly used in Equation 1. Despite its simplicity, we demonstrate that it outperforms the standard conditional models.
+
+Discussion. Table 1 summarizes recent techniques for generator conditioning. While we choose to implement this approach via batch normalization, it can also operate independently by removing the normalization part in the Equation 1. We made this pragmatic choice due to the fact that such conditioning is common (Radford et al., 2016; Miyato et al., 2018; Miyato & Koyama, 2018).
+
+The second question is whether one benefits from more complex modulation architectures, such as using an attention network (Vaswani et al., 2017) whereby $\beta$ and $\gamma$ could be made dependent on all upstream activations, or constraining the elements in $\gamma$ to $( 0 , 1 )$ which would yield a similar gating mechanism to an LSTM cell (Hochreiter & Schmidhuber, 1997). Based on initial experiments we concluded that this additional complexity does not yield a substantial increase in performance.
+
+# 3 EXPERIMENTS
+
+We perform a large-scale study of self-modulation to demonstrate that this method yields robust improvements in a variety of settings. We consider loss functions, architectures, discriminator regularization/normalization strategies, and a variety of hyperparameter settings collected from recent studies (Radford et al., 2016; Gulrajani et al., 2017; Miyato et al., 2018; Lucic et al., 2018; Kurach et al., 2018). We study both unconditional (without labels) and conditional (with labels) generation. Finally, we analyze the results through the lens of the condition number of the generator’s Jacobian as suggested by Odena et al. (2018), and precision and recall as defined in Sajjadi et al. (2018).
+
+# 3.1 EXPERIMENTAL SETTINGS
+
+Loss functions. We consider two loss functions. The first one is the non-saturating loss proposed in Goodfellow et al. (2014):
+
+$$
+\begin{array} { r l } & { V _ { D } ( G , D ) = \mathbb { E } _ { { \pmb { x } } \sim P _ { d } ( { \pmb { x } } ) } [ \log \sigma ( D ( { \pmb { x } } ) ) ] + \mathbb { E } _ { { \pmb { z } } \sim P ( { \pmb { z } } ) } [ \log ( 1 - \sigma ( D ( G ( { \pmb { z } } ) ) ) ) ] } \\ & { V _ { G } ( G , D ) = - \mathbb { E } _ { { \pmb { z } } \sim P ( { \pmb { z } } ) } [ \log \sigma ( D ( G ( { \pmb { z } } ) ) ) ] } \end{array}
+$$
+
+The second one is the hinge loss used in Miyato et al. (2018):
+
+$$
+\begin{array} { r l } & { V _ { D } ( G , D ) = \mathbb { E } _ { \mathbf { x } \sim P _ { d } ( \mathbf { x } ) } [ \operatorname* { m i n } ( 0 , - 1 + D ( \mathbf { x } ) ) ] + \mathbb { E } _ { \mathbf { z } \sim P ( \mathbf { z } ) } [ \operatorname* { m i n } ( 0 , - 1 - D ( G ( z ) ) ) ] } \\ & { V _ { G } ( G , D ) = - \mathbb { E } _ { \mathbf { z } \sim P ( z ) } [ D ( G ( z ) ) ] } \end{array}
+$$
+
+Controlling the Lipschitz constant of the discriminator. The discriminator’s Lipschitz constant is a central quantity analyzed in the GAN literature (Miyato et al., 2018; Zhou et al., 2018). We consider two state-of-the-art techniques: gradient penalty (Gulrajani et al., 2017), and spectral normalization (Miyato et al., 2018). Without normalization and regularization the models can perform poorly on some datasets. For the gradient penalty regularizer we consider regularization strength $\bar { \lambda } \in \{ 1 , 1 0 \}$ .
+
+Network architecture. We use two popular architecture types: one based on DCGAN (Radford et al., 2016), and another from Miyato et al. (2018) which incorporates residual connections (He et al., 2016). The details can be found in the appendix.
+
+Optimization hyper-parameters. We train all models for $1 0 0 \mathrm { k }$ generator steps with the Adam optimizer (Kingma & Ba, 2014) (We also perform a subset of the studies with 500K steps and discuss it in. We test two popular settings of the Adam hyperparameters $( \beta _ { 1 } , \beta _ { 2 } )$ : (0.5, 0.999) and $( 0 , 0 . 9 )$ . Previous studies find that multiple discriminator steps per generator step can help the training (Goodfellow et al., 2014; Salimans et al., 2016), thus we also consider both 1 and 2 discriminator steps per generator step2. In total, this amounts to three different sets of hyperparameters for $( \beta _ { 1 } , \beta _ { 2 }$ , disc iter): $( 0 , 0 . 9 , 1 )$ , $( 0 , 0 . 9 , 2 )$ , (0.5, 0.999, 1). We fix the learning rate to 0.0002 as in Miyato et al. (2018). All models are trained with batch size of 64 on a single nVidia P100 GPU. We report the best performing model attained during the training period; although the results follow the same pattern if the final model is report.
+
+Datasets. We consider four datasets: CIFAR10, CELEBA-HQ, LSUN-BEDROOM, and IMAGENET. The LSUN-BEDROOM dataset (Yu et al., 2015) contains around 3M images. We partition the images randomly into a test set containing 30588 images and a train set containing the rest. CELEBAHQ contains $3 0 \mathrm { k }$ images (Karras et al., 2017). We use the $1 2 8 \times 1 2 8 \times 3$ version obtained by running the code provided by the authors3. We use 3000 examples as the test set and the remaining examples as the training set. CIFAR10 contains 70K images $( 3 2 \times 3 2 \times 3 )$ , partitioned into 60000 training instances and 10000 testing instances. Finally, we evaluate our method on IMAGENET, which contains 1.3M training images and 50K test images. We re-size the images to $1 2 8 \times 1 2 8 \times 3$ as done in Miyato & Koyama (2018) and Zhang et al. (2018).
+
+Metrics. Quantitative evaluation of generative models remains one of the most challenging tasks. This is particularly true in the context of implicit generative models where likelihood cannot be effectively evaluated. Nevertheless, two quantitative measures have recently emerged: The Inception Score and the Frechet Inception Distance. While both of these scores have some drawbacks, they correlate well with scores assigned by human annotators and are somewhat robust.
+
+Inception Score (IS) (Salimans et al., 2016) posits that that the conditional label distribution $p ( y | \mathbf { \boldsymbol { x } } )$ of samples containing meaningful objects should have low entropy, while the marginal label distribution $p ( y )$ should have high entropy. Formally, $\begin{array} { r } { \mathrm { I S } ( G ) = \exp ( \mathbb { E } _ { x \sim G } [ \mathrm { d } _ { \mathrm { K L } } ( p ( y | x ) , p ( y ) ] ) } \end{array}$ . The score is computed using an Inception classifier (Szegedy et al., 2015). Drawbacks of applying IS to model comparison are discussed in Barratt & Sharma (2018).
+
+An alternative score, the Frechet Inception Distance (FID), requires no labeled data (Heusel et al., 2017). The real and generated samples are first embedded into a feature space (using a specific layer of InceptionNet). Then, a multivariate Gaussian is fit each dataset and the distance is computed as $\mathrm { F I D } ( x , g ) = | | \mu _ { x } - \mu _ { g } | | _ { 2 } ^ { 2 } + \operatorname { T r } ( \Sigma _ { x } + \Sigma _ { g } - 2 ( \Sigma _ { x } \Sigma _ { g } ) ^ { \frac { 1 } { 2 } } )$ , where $\mu$ and $\Sigma$ denote the empirical mean and covariance and subscripts $x$ and $g$ denote the true and generated data, respectively. FID was shown to be robust to various manipulations and sensitive to mode dropping (Heusel et al., 2017).
+
+Table 2: In the unpaired setting (as defined in Section 3.2), we compute the median score (across random seeds) and report the best attainable score across considered optimization hyperparameters. SELF-MOD is the method introduced in Section 2 and BASELINE refers to batch normalization. We observe that the proposed approach outperforms the baseline in 30 out of 32 settings. The relative improvement is detailed in Table 3. The standard error of the median is within $3 \%$ in the majority of the settings and is presented in Table 6 for clarity.   
+
+<table><tr><td>TYPE</td><td>ARCH</td><td>Loss</td><td>METHOD</td><td>BEDROOM</td><td>CELEBAHQ</td><td>CIFAR10</td><td>IMAGENET</td></tr><tr><td rowspan="7">GRADIENT PENALTY</td><td rowspan="5">RES</td><td>HINGE</td><td>SELF-MOD</td><td>22.62</td><td>27.03</td><td>26.93</td><td>78.31</td></tr><tr><td rowspan="2"></td><td>BASELINE</td><td>27.75</td><td>30.02</td><td>28.14</td><td>86.23</td></tr><tr><td>SELF-MOD</td><td>25.30</td><td>26.65</td><td>26.74</td><td>85.67</td></tr><tr><td rowspan="2">NS HINGE</td><td>BASELINE</td><td>36.79</td><td>33.72</td><td>28.61</td><td>98.38</td></tr><tr><td>SELF-MOD</td><td>110.86</td><td>55.63</td><td>33.58</td><td>90.67</td></tr><tr><td rowspan="2">SNDC NS</td><td>BASELINE</td><td>119.59</td><td>68.51</td><td>36.24</td><td>116.25</td></tr><tr><td></td><td>SELF-MOD</td><td>120.73</td><td>125.44 33.70</td><td>101.40</td></tr><tr><td rowspan="8">SPECTRAL NORM</td><td rowspan="4">RES</td><td rowspan="2"></td><td>BASELINE</td><td>134.13</td><td>131.89</td><td>37.12</td><td>122.74</td></tr><tr><td>SELF-MOD</td><td>14.32</td><td>24.50</td><td>18.54</td><td>68.90</td></tr><tr><td rowspan="2">HINGE</td><td>BASELINE</td><td>17.10</td><td>26.15</td><td>20.08</td><td>78.62</td></tr><tr><td>SELF-MOD</td><td>14.80</td><td>26.27</td><td>20.63</td><td>80.48</td></tr><tr><td rowspan="4">SNDC</td><td rowspan="2">NS</td><td>BASELINE</td><td>17.50</td><td>30.22</td><td>23.81</td><td>120.82</td></tr><tr><td>SELF-MOD</td><td>48.07</td><td>22.51</td><td>24.66</td><td>75.87</td></tr><tr><td rowspan="2">HINGE</td><td>BASELINE</td><td>38.31</td><td>27.20</td><td>26.33</td><td>90.01</td></tr><tr><td>SELF-MOD</td><td>46.65</td><td>24.73</td><td>26.09</td><td>76.69</td></tr><tr><td rowspan="2"></td><td rowspan="2"></td><td>NS</td><td>BASELINE</td><td>40.80</td><td>28.16</td><td>27.41</td><td>93.25</td></tr><tr><td></td><td>SELF-MOD</td><td>14.32</td><td>22.51</td><td>18.54</td><td>68.90</td></tr><tr><td rowspan="2">BEST OF ABOVE</td><td rowspan="2"></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>BASELINE</td><td>17.10</td><td>26.15</td><td>20.08</td><td>78.62</td></tr></table>
+
+# 3.2 ROBUSTNESS EXPERIMENTS FOR UNCONDITIONAL GENERATION
+
+To test robustness, we run a Cartesian product of the parameters in Section 3.1 which results in 36 settings for each dataset (2 losses, 2 architectures, 3 hyperparameter settings for spectral normalization, and 6 for gradient penalty). For each setting we run five random seeds for self-modulation and the baseline (no self-modulation, just batch normalization). We compute the median score across random seeds which results in 1440 trained models.
+
+We distinguish between two sets of experiments. In the unpaired setting we define the model as the tuple of loss, regularizer/normalization, neural architecture, and conditioning (self-modulated or classic batch normalization). For each model compute the minimum FID across optimization hyperparameters $\beta _ { 1 }$ , $\beta _ { 2 }$ , disc iters). We therefore compare the performance of self-modulation and baseline for each model after hyperparameter optimization. The results of this study are reported in Table 2, and the relative improvements are in Table 3 and Figure 2.
+
+We observe the following: (1) When using the RESNET style architecture, the proposed method outperforms the baseline in all considered settings. (2) When using the SNDCGAN architecture, it outperforms the baseline in $8 7 . 5 \%$ of the cases. The breakdown by datasets is shown in Figure 2. (3) The improvement can be as high as a $3 3 \%$ reduction in FID. (4) We observe similar improvement to the inception score, reported in the appendix.
+
+In the second setting, the paired setting, we assess how effective is the technique when simply added to an existing model with the same set of hyperparameters. In particular, we fix everything except the type of conditioning – the model tuple now includes the optimization hyperparameters. This results in 36 settings for each data set for a total of 144 comparisons. We observe that selfmodulation outperforms the baseline in 124/144 settings. These results suggest that self-modulation can be applied to most GANs even without additional hyperparameter tuning.
+
+Conditional Generation. We demonstrate that self-modulation also works for label-conditional generation. Here, one is given access the class label which may be used by the generator and the discriminator. We compare two settings: (1) Generator conditioning is applied via label-conditional Batch Norm (De Vries et al., 2017; Miyato & Koyama, 2018) with no use of labels in the discriminator (G-COND). (2) Generator conditioning applied as above, but with projection based conditioning in the discriminator (intuitively it encourages the discriminator to use label discriminative features to distinguish true/fake samples), as in Miyato & Koyama (2018) (P-CGAN). The former can be considered as a special case of the latter where discriminator conditioning is disabled. For P-CGAN, we use the architectures and hyper-parameter settings of Miyato & Koyama (2018). See the appendix, Section B.3 for details. In both cases, we compare standard label-conditional batch normalization to self-modulation with additional labels, as discussed in Section 2, Equation 3.
+
+Table 3: Reduction in FID over a large class of hyperparameter settings, losses, regularization, and normalization schemes. We observe from $4 . 3 \%$ to $33 \%$ decrease in FID. When applied to the RESNET architecture, independently of the loss, regularization, and normalization, SELF-MOD always outperforms the baseline. For SNDCGAN we observe an improvement in $8 7 . 5 \%$ of the cases (all except two on LSUN-BEDROOM).   
+
+<table><tr><td></td><td colspan="4">REDUCTION(%)</td><td colspan="3">REDUCTION(%)</td></tr><tr><td>MODEL</td><td colspan="2">RESNET</td><td>SNDC</td><td>MODEL</td><td></td><td>RESNET</td><td>SNDC</td></tr><tr><td>HINGE-GP</td><td>BEDROOM</td><td>18.50</td><td>7.30</td><td>NS-GP</td><td>BEDROOM</td><td>31.22</td><td>9.99</td></tr><tr><td></td><td>CELEBAHQ</td><td>9.94</td><td>18.81</td><td></td><td>CELEBAHQ</td><td>20.96</td><td>4.89</td></tr><tr><td></td><td>CIFAR10</td><td>4.30</td><td>7.33</td><td></td><td>CIFAR10</td><td>6.51</td><td>9.21</td></tr><tr><td></td><td>IMAGENET</td><td>9.18</td><td>22.01</td><td></td><td>IMAGENET</td><td>12.92</td><td>17.39</td></tr><tr><td>HINGE-SN</td><td>BEDROOM</td><td>16.25</td><td>-25.48</td><td>NS-SN</td><td>BEDROOM</td><td>15.43</td><td>-14.35</td></tr><tr><td></td><td>CELEBAHQ</td><td>6.31</td><td>17.26</td><td></td><td>CELEBAHQ</td><td>13.08</td><td>12.20</td></tr><tr><td></td><td>CIFAR10</td><td>7.67</td><td>6.35</td><td></td><td>CIFAR10</td><td>13.36</td><td>4.83</td></tr><tr><td></td><td>IMAGENET</td><td>12.37</td><td>15.72</td><td></td><td>IMAGENET</td><td>33.39</td><td>17.76</td></tr></table>
+
+![](images/0f0391b8111d7189abe53091de2608cfc492320b7760bcfde0c893c378df0647.jpg)  
+Figure 2: In Figure (a) we observe that the proposed method outperforms the baseline in the unpaired setting. Figure (b) shows the number of models which fall in 80-th percentile in terms of FID (with reverse ordering). We observe that the majority “good” models utilize self-modulation. Figure (c) shows that applying self-conditioning is more beneficial on the later layers, but should be applied to each layer for optimal performance. This effect persists across all considered datasets, see the appendix.
+
+The results are shown in Table 4. Again, we observe that the simple incorporation of self-modulation leads to a significant improvement in performance in the considered settings.
+
+Training for longer on IMAGENET. To demonstrate that self-modulation continues to yield improvement after training for longer, we train IMAGENET for $5 0 0 \mathrm { k }$ generator steps. Due to the increased computational demand we use a single setting for the unconditional and conditional settings models following Miyato et al. (2018) and Miyato & Koyama (2018), but using only two discriminator steps per generator. We expect that the results would continue to improve if training longer. However, currently results from 500k steps require training for ${ \sim } 1 0$ days on a P100 GPU.
+
+We compute the median FID across 3 random seeds. After $5 0 0 \mathrm { k }$ steps the baseline unconditional model attains FID 60.4, self-modulation attains 53.7 ( $1 1 \%$ improvement). In the conditional setting self-modulation improves the FID from 50.6 to 43.9 $13 \%$ improvement). The improvements in IS are from 14.1 to 15.1, and 20.1 to 22.2 in unconditional and conditional setting, respectively.
+
+Table 4: FID and IS scores in label conditional setting.   
+
+<table><tr><td></td><td></td><td colspan="2">UNCONDITIONAL</td><td colspan="2">G-COND</td><td colspan="2">P-CGAN</td></tr><tr><td></td><td>SCORE</td><td>BASELINE</td><td>SELF-MOD</td><td>BASELINE</td><td>SELF-MOD</td><td>BASELINE</td><td>SELF-MOD</td></tr><tr><td>CIFAR10</td><td>FID</td><td>20.41</td><td>18.58</td><td>21.08</td><td>18.39</td><td>16.06</td><td>14.19</td></tr><tr><td>IMAGENET</td><td>FID</td><td>81.07</td><td>69.53</td><td>80.43</td><td>68.93</td><td>70.28</td><td>66.09</td></tr><tr><td>CIFAR10</td><td>IS</td><td>7.89</td><td>8.31</td><td>8.11</td><td>8.34</td><td>8.53</td><td>8.71</td></tr><tr><td>IMAGENET</td><td>IS</td><td>11.16</td><td>12.52</td><td>11.16</td><td>12.48</td><td>13.62</td><td>14.14</td></tr></table>
+
+Where to apply self-modulation? Given the robust improvements of the proposed method, an immediate question is where to apply the modulation. We tested two settings: (1) applying modulation to every batch normalization layer, and (2) applying it to a single layer. The results of this ablation are in Figure 2. These results suggest that the benefit of self-modulation is greatest in the last layer, as may be intuitive, but applying it to each layer is most effective.
+
+# 4 RELATED WORK
+
+Conditional GANs. Conditioning on side information, such as class labels, has been shown to improve the performance of GANs. Initial proposals were based on concatenating this additional feature with the input vector (Mirza & Osindero, 2014; Radford et al., 2016; Odena et al., 2017). Recent approaches, such as the projection cGAN (Miyato & Koyama, 2018) injects label information into the generator architecture using conditional Batch Norm layers (De Vries et al., 2017). Self-modulation is a simple yet effective complementary addition to this line of work which makes a significant difference when no side information is available. In addition, when side information is available it can be readily applied as discussed in Section 2 and leads to further improvements.
+
+Conditional Modulation. Conditional modulation, using side information to modulate the computation flow in neural networks, is a rich idea which has been applied in various contexts (beyond GANs). In particular, Dumoulin et al. (2017) apply Conditional Instance Normalization (Ulyanov et al., 2016) to image style-transfer (Dumoulin et al., 2017). Kim et al. (2017) use Dynamic Layer Normalization (Ba et al., 2016) for adaptive acoustic modelling. Feature-wise Linear Modulation (Perez et al., 2018) generalizes this family of methods by conditioning the Batch Norm scaling and bias factors (which correspond to multiplicative and additive interactions) on general external embedding vectors in supervised learning. The proposed method applies to generators in GAN (unsupervised learning), and it works with both unconditional (without side information) and conditional (with side information) settings.
+
+Multiplicative and Additive Modulation. Existing conditional modulations mentioned above are usually instantiated via Batch Normalization, which include both multiplicative and additive modulation. These two types of modulation also link to other techniques widely used in neural network literature. The multiplicative modulation is closely related to Gating, which is adopted in LSTM (Hochreiter & Schmidhuber, 1997), gated PixelCNN (van den Oord et al., 2016), Convolutional Sequence-to-sequence networks (Gehring et al., 2017) and Squeeze-and-excitation Networks (Hu et al., 2018). The additive modulation is closely related to Residual Networks (He et al., 2016). The proposed method adopts both types of modulation.
+
+# 5 DISCUSSION
+
+We present a generator modification that improves the performance of most GANs. This technique is simple to implement and can be applied to all popular GANs, therefore we believe that selfmodulation is a useful addition to the GAN toolbox.
+
+Our results suggest that self-modulation clearly yields performance gains, however, they do not say how this technique results in better models. Interpretation of deep networks is a complex topic, especially for GANs, where the training process is less well understood. Rather than purely speculate, we compute two diagnostic statistics that were proposed recently ignite the discussion of the method’s effects.
+
+![](images/b92252ecc1b3d163ac9499693afc0091eab89aa9ad14f6d4cfed662301d10657.jpg)  
+Figure 3: Each point corresponds to a single model/hyperparameter setting. The left-hand plots show the log condition number of the generator versus the FID score. The right-hand plots show the generator precision/recall curves. The $r$ values for the correlation between log condition number and FID on CIFAR10 are 0.67 and 0.83 for Self-Mod and Base, respectively. For IMAGENET they are 0.24 and 0.39 for Self-Mod and Base, respectively. LSUN-BEDROOM and CELEBA-HQ are in the appendix.
+
+First, we compute the condition number of the generators Jacobian. Odena et al. (2018) provide evidence that better generators have a Jacobian with lower condition number and hence regularize using this quantity. We estimate the generator condition number in the same was as Odena et al. (2018). We compute the Jacobian $\begin{array} { r } { ( \bar { J } _ { z } ) _ { i , j } \ = \ \frac { \delta G ( z ) _ { i } } { \delta z _ { j } } } \end{array}$ at each $_ { z }$ in a minibatch, then average the logarithm of the condition numbers computed from each Jacobian.
+
+Second, we compute a notion of precision and recall for generative models. Sajjadi et al. (2018) define the quantities, $F _ { 8 }$ and $F _ { 1 / 8 }$ , for generators. These quantities relate intuitively to the traditional precision and recall metrics for classification. Generating points which have low probability under the true data distribution is interpreted as a loss in precision, and is penalized by the $F _ { 8 }$ score. Failing to generate points that have high probability under the true data distributions is interpreted as a loss in recall, and is penalized by the $F _ { 1 / 8 }$ score.
+
+Figure 3 shows both statistics. The left hand plot shows the condition number plotted against FID score for each model. We observe that poor models tend to have large condition numbers; the correlation, although noisy, is always positive. This result corroborates the observations in (Odena et al., 2018). However, we notice an inverse trend in the vicinity of the best models. The cluster of the best models with self-modulation has lower FID, but higher condition number, than the best models without self-modulation. Overall the correlation between FID and condition number is smaller for self-modulated models. This is surprising, it appears that rather than unilaterally reducing the condition number, self-modulation provides some training stability, yielding models with a small range of generator condition numbers.
+
+The right-hand plot in Figure 3 shows the $F _ { 8 }$ and $F _ { 1 / 8 }$ scores. Models in the upper-left quadrant cover true data modes better (higher precision), and models in the lower-right quadrant produce more modes (higher recall). Self-modulated models tend to favor higher recall. This effect is most pronounced on IMAGENET.
+
+Overall these diagnostics indicate that self-modulation stabilizes the generator towards favorable conditioning values. It also appears to improve mode coverage. However, these metrics are very new; further development of analysis tools and theoretical study is needed to better disentangle the symptoms and causes of the self-modulation technique, and indeed of others.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Ilya Tolstikhin for helpful discussions. We would also like to thank Xiaohua Zhai, Marcin Michalski, Karol Kurach and Anton Raichuk for their help with infustrature. We also appreciate general discussions with Olivier Bachem, Alexander Kolesnikov, Thomas Unterthiner, and Josip Djolonga. Finally, we are grateful for the support of other members of the Google Brain team.
+
+# REFERENCES
+
+Mart´ın Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In International Conference on Machine Learning (ICML), 2017.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Shane Barratt and Rishi Sharma. A note on the inception score. arXiv preprint arXiv:1801.01973, 2018.
+
+Harm De Vries, Florian Strub, Jer´ emie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron C ´ Courville. Modulating early visual processing by language. In Advances in Neural Information Processing Systems (NIPS), 2017.
+
+Vincent Dumoulin, Jonathon Shlens, and Manjunath Kudlur. A learned representation for artistic style. International Conference on Learning Representations (ICLR), 2017.
+
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann Dauphin. Convolutional sequence to sequence learning. In International Conference on Machine Learning (ICML), 2017.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems (NIPS), 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of Wasserstein GANs. Advances in Neural Information Processing Systems (NIPS), 2017.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Gunter Klambauer, and ¨ Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a Nash equilibrium. In Advances in Neural Information Processing Systems (NIPS), 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arxiv, 2016.
+
+Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. Advances in Neural Information Processing Systems (NIPS), 2017.
+
+Taesup Kim, Inchul Song, and Yoshua Bengio. Dynamic layer normalization for adaptive neural acoustic modeling in speech recognition. In INTERSPEECH, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Karol Kurach, Mario Lucic, Xiaohua Zhai, Marcin Michalski, and Sylvain Gelly. The GAN Landscape: Losses, Architectures, Regularization, and Normalization. arXiv preprint arXiv:1807.04720, 2018.
+
+Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are GANs Created Equal? A Large-scale Study. In Advances in Neural Information Processing Systems (NIPS), 2018.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. International Conference on Computer Vision (ICCV), 2016.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.
+
+Takeru Miyato and Masanori Koyama. cgans with projection discriminator. International Conference on Learning Representations (ICLR), 2018.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. International Conference on Learning Representations (ICLR), 2018.
+
+Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier GANs. In International Conference on Machine Learning (ICML), 2017.
+
+Augustus Odena, Jacob Buckman, Catherine Olsson, Tom B Brown, Christopher Olah, Colin Raffel, and Ian Goodfellow. Is generator conditioning causally related to gan performance? arXiv preprint arXiv:1802.08768, 2018.
+
+Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. Film: Visual reasoning with a general conditioning layer. AAAI, 2018.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. International Conference on Learning Representations (ICLR), 2016.
+
+Mehdi SM Sajjadi, Olivier Bachem, Mario Lucic, Olivier Bousquet, and Sylvain Gelly. Assessing generative models via precision and recall. In Advances in Neural Information Processing Systems (NIPS), 2018.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Computer Vision and Pattern Recognition (CVPR), 2015.
+
+Michael Tschannen, Eirikur Agustsson, and Mario Lucic. Deep generative models for distributionpreserving lossy compression. In Advances in Neural Information Processing Systems (NIPS), 2018.
+
+D Ulyanov, A Vedaldi, and VS Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv preprint arXiv:1607.08022, 2016.
+
+Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+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 (NIPS), 2017.
+
+Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365, 2015.
+
+Han Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaolei Huang, Xiaogang Wang, and Dimitris Metaxas. Stackgan: Text to photo-realistic image synthesis with stacked generative adversarial networks. International Conference on Computer Vision (ICCV), 2017.
+
+Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv preprint arXiv:1805.08318, 2018.
+
+Zhiming Zhou, Yuxuan Song, Lantao Yu, and Yong Yu. Understanding the effectiveness of lipschitz constraint in training of gans via gradient analysis. arXiv preprint arXiv:1807.00751, 2018.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arXiv preprint, 2017.
+
+A ADDITIONAL RESULTS
+
+# A.1 INCEPTION SCORES
+
+Table 5: In the unpaired setting (as defined in Section 3.2), we compute the median score (across random seeds) and report the best attainable score across considered optimization hyperparameters. SELF-MOD is the method introduced in Section 2 and BASELINE refers to batch normalization.   
+
+<table><tr><td>TYPE</td><td>ARCH</td><td>Loss</td><td>METHOD</td><td>BEDROOM</td><td>CELEBAHQ</td><td>CIFAR10</td><td>IMAGENET</td></tr><tr><td rowspan="8">GRADIENT PENALTY</td><td rowspan="4">RESNET</td><td rowspan="2">HINGE</td><td>SELF-MOD</td><td>5.28±0.18</td><td>2.92 ± 0.13</td><td>7.71 ± 0.59</td><td>11.52 ± 0.07</td></tr><tr><td>BASELINE</td><td>4.72 ± 0.11</td><td>2.80±0.08</td><td>7.35± 0.02</td><td>10.26 ± 0.09</td></tr><tr><td rowspan="2">NS</td><td>SELF-MOD</td><td>4.96 ± 0.17</td><td>2.61± 0.05</td><td>7.70 ± 0.05</td><td>10.74±1.20</td></tr><tr><td>BASELINE</td><td>4.54 ± 0.11</td><td>2.60±0.25</td><td>7.26 ± 0.03</td><td>9.49 ± 0.12</td></tr><tr><td rowspan="4">SNDCGAN</td><td rowspan="2">HINGE</td><td>SELF-MOD</td><td>6.34±0.07</td><td>3.05±0.12</td><td>7.37± 0.04</td><td>10.99 ± 0.06</td></tr><tr><td>BASELINE</td><td>5.02 ±0.05</td><td>3.08 ±0.09</td><td>6.88± 0.05</td><td>8.11 ± 0.06</td></tr><tr><td rowspan="2">NS</td><td>SELF-MOD</td><td>6.31±0.05</td><td>3.07±0.05</td><td>7.28±0.06</td><td>10.06±0.10</td></tr><tr><td>BASELINE</td><td>4.71 ± 0.05</td><td>3.21±0.20</td><td>6.86 ±0.06</td><td>7.24 ± 0.16</td></tr><tr><td rowspan="6">SPECTRAL NORM</td><td rowspan="4">RESNET</td><td rowspan="2">HINGE</td><td>SELF-MOD</td><td>3.94±0.22</td><td>3.65±0.16</td><td>8.29±0.03</td><td>12.67 ± 0.07</td></tr><tr><td>BASELINE</td><td>4.32 ± 0.17</td><td>3.26 ± 0.16</td><td>8.00±0.03</td><td>11.29 ± 0.12</td></tr><tr><td rowspan="2">NS</td><td>SELF-MOD</td><td>4.61 ±0.18</td><td>3.32 ±0.09</td><td>8.23±0.04</td><td>11.52 ± 0.28</td></tr><tr><td>BASELINE</td><td>4.07 ± 0.21</td><td>2.58 ± 0.08</td><td>7.93 ± 0.04</td><td>7.40 ±0.60</td></tr><tr><td rowspan="4">SNDCGAN</td><td rowspan="2">HINGE</td><td>SELF-MOD</td><td>5.85±0.07</td><td>2.74 ±0.02</td><td>7.90±0.04</td><td>12.50 ± 0.12</td></tr><tr><td>BASELINE</td><td>4.82 ± 0.12</td><td>2.40± 0.02</td><td>7.48± 0.04</td><td>9.62 ±0.10</td></tr><tr><td rowspan="2">NS</td><td>SELF-MOD</td><td>5.73±0.07</td><td>2.55±0.02</td><td>7.84 ±0.02</td><td>11.95 ± 0.09</td></tr><tr><td>BASELINE</td><td>4.39 ± 0.14</td><td>2.33 ± 0.01</td><td>7.37 ± 0.04</td><td>9.28±0.13</td></tr></table>
+
+A.2 FIDS   
+Table 6: Table 2 with the standard error of the median.   
+
+<table><tr><td>TYPE</td><td>ARCH</td><td>Loss</td><td>METHOD</td><td>BEDROOM</td><td>CELEBAHQ</td><td>CIFAR10</td><td>IMAGENET</td></tr><tr><td rowspan="7">GRADIENT PENALTY</td><td rowspan="5">RES</td><td rowspan="2">HINGE</td><td>SELF-MOD</td><td>22.62 ± 64.79</td><td>27.03 ±0.29</td><td>26.93 ± 13.52</td><td>78.31 ±0.96</td></tr><tr><td>BASE</td><td>27.75 ± 1.01</td><td>30.02 ± 0.69</td><td>28.14 ±0.52</td><td>86.23 ± 1.34</td></tr><tr><td rowspan="2">NS</td><td>SELF-MOD</td><td>25.30 ± 1.21</td><td>26.65±13.16</td><td>26.74 ± 0.42</td><td>85.67 ± 11.94</td></tr><tr><td>BASE</td><td>36.79 ±0.25</td><td>33.72 ± 0.78</td><td>28.61± 0.27</td><td>98.38 ± 1.48</td></tr><tr><td rowspan="3">HINGE SNDC</td><td>SELF-MOD</td><td>110.86 ± 1.72</td><td>55.63±0.53</td><td>33.58± 0.47</td><td>90.67 ± 0.49</td></tr><tr><td rowspan="2">NS</td><td>BASE</td><td>119.59 ± 1.71</td><td>68.51 ± 1.66</td><td>36.24 ±0.69</td><td>116.25 ± 0.48</td></tr><tr><td>SELF-MOD</td><td>120.73 ± 2.10</td><td>125.44 ± 11.27</td><td>33.70±0.47</td><td>101.40 ± 1.17</td></tr><tr><td rowspan="7">SPECTRAL NORM</td><td rowspan="5">RES</td><td rowspan="2">HINGE</td><td>BASE</td><td>134.13 ± 2.40</td><td>131.89 ± 42.16</td><td>37.12± 0.62</td><td>122.74 ± 0.58</td></tr><tr><td>SELF-MOD</td><td>14.32 ± 0.40</td><td>24.50±0.46</td><td>18.54 ±0.15</td><td>68.90±0.67</td></tr><tr><td rowspan="2">NS</td><td>BASE</td><td>17.10 ± 1.44</td><td>26.15 ± 0.70</td><td>20.08 ± 0.31</td><td>78.62 ± 0.97</td></tr><tr><td>SELF-MOD</td><td>14.80±0.40</td><td>26.27 ± 0.48</td><td>20.63±0.20</td><td>80.48 ±2.43</td></tr><tr><td rowspan="2">HINGE</td><td>BASE</td><td>17.50 ± 0.64</td><td>30.22 ± 0.48</td><td>23.81± 0.17</td><td>120.82 ± 6.82</td></tr><tr><td>SELF-MOD</td><td>48.07 ±1.77</td><td>22.51± 0.38</td><td>24.66±0.40</td><td>75.87±0.37</td></tr><tr><td rowspan="4">SNDC</td><td rowspan="2">NS</td><td>BASE</td><td>38.31 ± 1.42</td><td>27.20± 0.80</td><td>26.33± 0.54</td><td>90.01 ± 1.06</td></tr><tr><td>SELF-MOD</td><td>46.65 ± 2.72</td><td>24.73 ± 0.25</td><td>26.09±0.19</td><td>76.69±0.89</td></tr><tr><td rowspan="2"></td><td>BASE</td><td>40.80 ± 1.75</td><td>28.16 ± 0.17</td><td>27.41 ± 0.43</td><td>93.25± 0.35</td></tr><tr><td>SELF-MOD</td><td>14.32</td><td>22.51</td><td>18.54</td><td>68.90</td></tr><tr><td rowspan="2">BEST OF ABOVE</td><td rowspan="2"></td><td>BASELINE</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>17.10</td><td>26.15</td><td>20.08</td><td>78.62</td></tr></table>
+
+# A.3 WHICH LAYER TO MODULATE?
+
+Figure 4 presents the performance when modulating different layers of the generator for each dataset.
+
+![](images/1e8fe1aff8c96286aff45170ca4eb53d680ad76a040947de0480299f60a61164.jpg)  
+Figure 4: FID distributions resulting from Self-Modulation on different layers.
+
+A.4 CONDITIONING AND PRECISION/RECALL
+
+Figure 5 presents the generator Jacobian condition number and precision/recall plot for each dataset.
+
+# B MODEL ARCHITECTURES
+
+We describe the model structures that are used in our experiments in this section.
+
+# B.1 SNDCGAN ARCHITECTURES
+
+The SNDCGAN architecture we follows the ones used in Miyato et al. (2018). Since the resolution of images in CIFAR10is $3 2 \times 3 2 \times 3$ , while resolutions of images in other datasets are $1 2 8 \times 1 2 8 \times 3$ . There are slightly differences in terms of spatial dimensions for both architectures. The proposed self-modulation is applied to replace existing BN layer, we term it sBN (self-modulated BN) for short in Table 7, 8, 9, 10.
+
+# B.2 RESNET ARCHITECTURES
+
+The ResNet architecture we also follows the ones used in Miyato et al. (2018). Again, due to the resolution differences, two ResNet architectures are used in this work. The proposed self-modulation is applied to replace existing BN layer, we term it sBN (self-modulated BN) for short in Table 11, 12, 13, 14.
+
+# B.3 CONDITIONAL GAN ARCHITECTURE
+
+For the conditional setting with label information available, we adopt the Projection Based Conditional GAN (P-cGAN) (Miyato & Koyama, 2018). There are both conditioning in generators as well ad discriminators. For generator, conditional batch norm is applied via conditioning on label information, more specifically, this can be expressed as follows,
+
+$$
+h _ { \ell } ^ { \prime } = \gamma _ { y } \odot \frac { h _ { \ell } - \mu } { \sigma } + \beta _ { y }
+$$
+
+Where each label $y$ is associated with a scaling and shifting parameters independently.
+
+For discriminator label conditioning, the dot product between final layer feature $\phi ( { \pmb x } )$ and label embedding $\operatorname { E } ( y )$ is added back to the discriminator output logits, i.e. $D ( { \pmb x } , y ) = \Psi ( \phi ( { \pmb x } ) ) +$ $\phi ( \pmb { x } ) ^ { T } \mathrm { E } ( \bar { y } )$ where $\phi ( { \pmb x } )$ represents the final feature representation layer of input $_ { \textbf { \em x } }$ , and $\psi ( \cdot )$ is the linear transformation maps the feature vector into a real number. Intuitively, this type of conditional discriminator encourages discriminator to use label discriminative features to distinguish true/fake samples. Both the above conditioning strategies do not dependent on the specific architectures, and can be applied to above architectures with small modifications.
+
+![](images/39b3ef4c0a1b595727479553de000d89503f9c8cb41e91fea90c04ffc690f686.jpg)  
+Figure 5: Each point in each plot corresponds to a single model for all parameter configurations. The model with mean FID score across the five random seeds was chosen. The left-hand plots show the log condition number of the generator versus the FID score for each model. The right-hand generator precision/recall metrics.
+
+We use the same architectures and hyper-parameter settings4 as in Miyato & Koyama (2018). More specifically, the architecture is the same as ResNet above, and we compare in two settings: (1) only generator label conditioning is applied, and there is no projection based conditioning in the discriminator, and (2) both generator and discriminator conditioning are applied, which is the standard full P-cGAN.
+
+Table 7: SNDCGAN Generator with $3 2 \times 3 2 \times 3$ resolution. sBN denotes BN with self-modulation as proposed.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z ~N(0,I)</td><td>128</td></tr><tr><td>Fully Connected</td><td>Linear Reshape</td><td>2.2:512 2×2×512</td></tr><tr><td>Deconv</td><td>sBN, ReLU Deconv4x4,stride=2</td><td>2×2×512 4×4×256</td></tr><tr><td>Deconv</td><td>sBN, ReLU</td><td>4×4×256</td></tr><tr><td>Deconv</td><td>Deconv4x4,stride=2 sBN,ReLU</td><td>8×8×128 8×8×128</td></tr><tr><td rowspan="2"></td><td>Deconv4x4,stride=2</td><td>16 ×16 × 64</td></tr><tr><td>sBN,ReLU</td><td></td></tr><tr><td rowspan="2">Deconv</td><td></td><td>16×16×64</td></tr><tr><td>Deconv4x4,stride=2 Tanh</td><td>32 ×32×3 32 × 32×3</td></tr></table>
+
+Table 8: SNDCGAN Discriminator with $3 2 \times 3 2 \times 3$ resolution.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td>-</td><td>32×32×3</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>32×32×64</td></tr><tr><td>LeakyReLU</td><td>32 × 32 × 64</td></tr><tr><td rowspan="2">Conv</td><td>Conv4x4,stride=2</td><td>16×16×128</td></tr><tr><td>LeakyReLU</td><td>16 × 16 ×128</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>16×16×128</td></tr><tr><td>LeakyReLU</td><td>16 × 16 × 128</td></tr><tr><td rowspan="2">Conv</td><td>Conv4x4,stride=2</td><td>8×8×256</td></tr><tr><td>LeakyReLU</td><td>8×8×256</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>8×8×256</td></tr><tr><td>LeakyReLU</td><td>8×8×256</td></tr><tr><td rowspan="2">Conv</td><td>Conv4x4,stride=2</td><td>4×4×512</td></tr><tr><td>LeakyReLU</td><td>4 × 4× 512</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>4×4×512</td></tr><tr><td>LeakyReLU</td><td>4×4×512</td></tr><tr><td rowspan="2">Fully connected</td><td>Reshape</td><td>4·4·512</td></tr><tr><td>Linear</td><td>1</td></tr></table>
+
+Table 9: SNDCGAN Gnerator with $1 2 8 \times 1 2 8 \times 3$ resolution. sBN denotes BN with self-modulation as proposed.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z~N(0,I)</td><td>128</td></tr><tr><td>Fully Connected</td><td>Linear Reshape</td><td>8.8.512 8×8×512</td></tr><tr><td>Deconv</td><td>sBN, ReLU Deconv4x4,stride=2</td><td>8×8×512 16 × 16× 256</td></tr><tr><td>Deconv</td><td>sBN,ReLU Deconv4x4,stride=2</td><td>16×16×256 32 × 32×128</td></tr><tr><td>Deconv</td><td>sBN,ReLU</td><td>32 × 32×128</td></tr><tr><td>Deconv</td><td>Deconv4x4,stride=2 sBN,ReLU Deconv4x4,stride=2</td><td>64× 64×64 64×64×64 128 × 128 ×3</td></tr></table>
+
+Table 10: SNDCGAN Discriminator with $1 2 8 \times 1 2 8 \times 3$ resolution.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td>1</td><td>128×128×3</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>128×128×64</td></tr><tr><td>LeakyReLU</td><td>128 × 128 × 64</td></tr><tr><td rowspan="2">Conv</td><td>Conv4x4,stride=2</td><td>64×64×128</td></tr><tr><td>LeakyReLU</td><td>64 × 64 ×128</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>64×64×128</td></tr><tr><td>LeakyReLU</td><td>64 × 64 ×128</td></tr><tr><td rowspan="2">Conv</td><td>Conv4x4,stride=2</td><td>32×32×256</td></tr><tr><td>LeakyReLU</td><td>32×32× 256</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>32 × 32× 256</td></tr><tr><td>LeakyReLU</td><td>32 ×32×256</td></tr><tr><td rowspan="2">Conv</td><td>Conv4x4,stride=2</td><td>16 × 16 × 512</td></tr><tr><td>LeakyReLU</td><td>16 × 16 × 512</td></tr><tr><td rowspan="2">Conv</td><td>Conv3x3,stride=1</td><td>16×16×512</td></tr><tr><td>LeakyReLU</td><td>16 ×16 × 512</td></tr><tr><td rowspan="2">Fully connected</td><td>Reshape</td><td>16·16·512</td></tr><tr><td>Linear</td><td>1</td></tr></table>
+
+Table 11: ResNet Generator with $3 2 \times 3 2 \times 3$ resolution. Each ResNet block has a skip-connection that uses upsampling of its input and a 1x1 convolution. sBN denotes BN with self-modulation as proposed.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z~N(0,1）</td><td>128</td></tr><tr><td>Fully connected</td><td>Linear</td><td>4·4·256 4×4×256</td></tr><tr><td rowspan="2">ResNetblock</td><td>Reshape sBN,ReLU</td><td>4×4×256</td></tr><tr><td>Upsample</td><td>8×8×256</td></tr><tr><td rowspan="3">ResNetblock</td><td>Conv3x3,sBN,ReLU</td><td>8×8×256</td></tr><tr><td>Conv3x3</td><td>8×8×256</td></tr><tr><td>sBN,ReLU</td><td>8×8×256</td></tr><tr><td rowspan="4"></td><td>Upsample</td><td>16 ×16× 256</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>16 × 16 × 256</td></tr><tr><td>Conv3x3</td><td></td></tr><tr><td>sBN,ReLU</td><td>16 ×16× 256</td></tr><tr><td rowspan="4">ResNetblock</td><td></td><td>16× 16 ×256</td></tr><tr><td>Upsample</td><td>32 × 32 × 256</td></tr><tr><td>Conv3x3,sBN,ReLU</td><td>32 × 32× 256</td></tr><tr><td>Conv3x3</td><td>32 × 32 × 256</td></tr><tr><td rowspan="2">Conv</td><td>sBN, ReLU</td><td>128×128×3</td></tr><tr><td>Conv3x3,Tanh</td><td>128× 128×3</td></tr></table>
+
+Table 12: ResNet Discriminator with $3 2 \times 3 2 \times 3$ resolution. Each ResNet block has a skipconnection that applies a 1x1 convolution with possible downsampling according to spatial dimension.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td></td><td>32×32×3</td></tr><tr><td rowspan="3">ResNet block</td><td>Conv3x3</td><td>32×32×128</td></tr><tr><td>ReLU,Conv3x3</td><td>32 × 32×128</td></tr><tr><td>Downsample</td><td>16 ×16×128</td></tr><tr><td rowspan="3">ResNetblock</td><td>ReLUConv3x3</td><td>16×16×128</td></tr><tr><td>ReLU,Conv3x3</td><td>16 × 16 ×128</td></tr><tr><td>Downsample</td><td>8×8×128</td></tr><tr><td rowspan="2">ResNetblock</td><td>ReLUConv3x3</td><td>8×8×128</td></tr><tr><td>ReLU,Conv3x3</td><td>8×8×128</td></tr><tr><td rowspan="2">ResNetblock</td><td>ReLU,Conv3x3</td><td>8×8×128</td></tr><tr><td>ReLU,Conv3x3</td><td>8×8×128</td></tr><tr><td>Fully connected</td><td>ReLU,GlobalSum pooling</td><td>128</td></tr><tr><td></td><td>Linear</td><td>1</td></tr></table>
+
+Table 13: ResNet Generator with $1 2 8 \times 1 2 8 \times 3$ resolution. Each ResNet block has a skip-connection that uses upsampling of its input and a 1x1 convolution. sBN denotes BN with self-modulation as proposed.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z~N(0,I)</td><td>128</td></tr><tr><td rowspan="2">Fully connected</td><td>Linear</td><td>4·4·1024</td></tr><tr><td>Reshape</td><td>4×4×1024</td></tr><tr><td rowspan="4">ResNetblock</td><td>sBN,ReLU</td><td>4×4×1024</td></tr><tr><td>Upsample</td><td>8×8× 1024</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>8×8× 1024</td></tr><tr><td>Conv3x3</td><td>8×8×1024</td></tr><tr><td rowspan="4">ResNetblock</td><td>sBN,ReLU</td><td>8×8×1024</td></tr><tr><td>Upsample</td><td>16 ×16 ×1024</td></tr><tr><td>Conv3x3,sBN,ReLU</td><td>16 × 16 ×1024</td></tr><tr><td>Conv3x3</td><td>16 × 16× 512</td></tr><tr><td rowspan="4">ResNetblock</td><td>sBN,ReLU</td><td>16× 16× 512</td></tr><tr><td>Upsample</td><td>32×32×5 512</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>32 × 32 × 512</td></tr><tr><td>Conv3x3</td><td>32 × 32 × 256</td></tr><tr><td rowspan="4">ResNetblock</td><td>sBN,ReLU</td><td>32 ×32×256</td></tr><tr><td>Upsample</td><td>64× 64×256</td></tr><tr><td>Conv3x3,sBN,ReLU</td><td>64 × 64× 256</td></tr><tr><td>Conv3x3</td><td>64 × 64×128</td></tr><tr><td rowspan="4">ResNetblock</td><td>sBN,ReLU</td><td>64×64×128</td></tr><tr><td>Upsample</td><td>128 ×128 ×128</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>128 × 128× 128</td></tr><tr><td>Conv3x3</td><td>128 ×128× 64</td></tr><tr><td rowspan="2">Conv</td><td>sBN,ReLU</td><td>128×128×3</td></tr><tr><td>Conv3x3,Tanh</td><td>128× 128×3</td></tr></table>
+
+Table 14: ResNet Discriminator with $1 2 8 \times 1 2 8 \times 3$ resolution. Each ResNet block has a skipconnection that applies a 1x1 convolution with possible downsampling according to spatial dimension.   
+
+<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td></td><td>128×128×3</td></tr><tr><td rowspan="3">ResNetblock</td><td>Conv3x3</td><td>128×128×64</td></tr><tr><td>ReLU,Conv3x3</td><td>128 ×128 × 64</td></tr><tr><td>Downsample</td><td>64× 64×64</td></tr><tr><td rowspan="3">ResNetblock</td><td>ReLU,Conv3x3</td><td>64×64×64</td></tr><tr><td>ReLU,Conv3x3</td><td>64 × 64×128</td></tr><tr><td>Downsample</td><td>32 × 32 × 128</td></tr><tr><td rowspan="3">ResNetblock</td><td>ReLU,Conv3x3</td><td>32×32×128</td></tr><tr><td>ReLU,Conv3x3</td><td>32 × 32 × 256</td></tr><tr><td>Downsample</td><td>16 × 16 × 256</td></tr><tr><td rowspan="3">ResNetblock</td><td>ReLU,Conv3x3</td><td>16×16×256</td></tr><tr><td>ReLU,Conv3x3</td><td>16 × 16 × 512</td></tr><tr><td>Downsample</td><td>8×8×512</td></tr><tr><td rowspan="3">ResNet block</td><td>ReLU,Conv3x3 ReLU,Conv3x3</td><td>8×8×512 8×8×1024</td></tr><tr><td></td><td></td></tr><tr><td>Downsample</td><td>4×4×1024</td></tr><tr><td rowspan="2">ResNet block</td><td>ReLU,Conv3x3</td><td>4×4×1024</td></tr><tr><td>ReLU,Conv3x3</td><td>4×4×1024</td></tr><tr><td>Fully connected</td><td>ReLU,GlobalSum pooling</td><td>1024</td></tr><tr><td colspan="2">Linear</td><td>1</td></tr></table>

parse/train/Hkl5aoR5tm/Hkl5aoR5tm_content_list.json

@@ -0,0 +1,1774 @@
+[
+    {
+        "type": "text",
+        "text": "ON SELF MODULATION FOR GENERATIVE ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen∗ University of California, Los Angeles tingchen@cs.ucla.edu ",
+        "bbox": [
+            184,
+            170,
+            431,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mario Lucic, Neil Houlsby, Sylvain Gelly Google Brain {lucic,neilhoulsby,sylvaingelly}@google.com ",
+        "bbox": [
+            449,
+            170,
+            867,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Training Generative Adversarial Networks (GANs) is notoriously challenging. We propose and study an architectural modification, self-modulation, which improves GAN performance across different data sets, architectures, losses, regularizers, and hyperparameter settings. Intuitively, self-modulation allows the intermediate feature maps of a generator to change as a function of the input noise vector. While reminiscent of other conditioning techniques, it requires no labeled data. In a large-scale empirical study we observe a relative decrease of $5 \\% - 3 5 \\%$ in FID. Furthermore, all else being equal, adding this modification to the generator leads to improved performance in $1 2 4 / 1 4 4$ $( 8 6 \\% )$ of the studied settings. Selfmodulation is a simple architectural change that requires no additional parameter tuning, which suggests that it can be applied readily to any GAN.1 ",
+        "bbox": [
+            233,
+            282,
+            764,
+            435
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            467,
+            334,
+            482
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) are a powerful class of generative models successfully applied to a variety of tasks such as image generation (Zhang et al., 2017; Miyato et al., 2018; Karras et al., 2017), learned compression (Tschannen et al., 2018), super-resolution (Ledig et al., 2017), inpainting (Pathak et al., 2016), and domain transfer (Isola et al., 2016; Zhu et al., 2017). ",
+        "bbox": [
+            174,
+            500,
+            825,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Training GANs is a notoriously challenging task (Goodfellow et al., 2014; Arjovsky et al., 2017; Lucic et al., 2018) as one is searching in a high-dimensional parameter space for a Nash equilibrium of a non-convex game. As a practical remedy one applies (usually a variant of) stochastic gradient descent, which can be unstable and lack guarantees Salimans et al. (2016). As a result, one of the main research challenges is to stabilize GAN training. Several approaches have been proposed, including varying the underlying divergence between the model and data distributions (Arjovsky et al., 2017; Mao et al., 2016), regularization and normalization schemes (Gulrajani et al., 2017; Miyato et al., 2018), optimization schedules (Karras et al., 2017), and specific neural architectures (Radford et al., 2016; Zhang et al., 2018). A particularly successful approach is based on conditional generation; where the generator (and possibly discriminator) are given side information, for example class labels Mirza & Osindero (2014); Odena et al. (2017); Miyato & Koyama (2018). In fact, state-of-the-art conditional GANs inject side information via conditional batch normalization (CBN) layers (De Vries et al., 2017; Miyato & Koyama, 2018; Zhang et al., 2018). While this approach does help, a major drawback is that it requires external information, such as labels or embeddings, which is not always available. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we show that GANs benefit from self-modulation layers in the generator. Our approach is motivated by Feature-wise Linear Modulation in supervised learning (Perez et al., 2018; De Vries et al., 2017), with one key difference: instead of conditioning on external information, we condition on the generator’s own input. As self-modulation requires a simple change which is easily applicable to all popular generator architectures, we believe that is a useful addition to the GAN toolbox. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Summary of contributions. We provide a simple yet effective technique that can added universally to yield better GANs. We demonstrate empirically that for a wide variety of settings (loss functions, regularizers and normalizers, neural architectures, and optimization settings) that the proposed approach yields between a $5 \\%$ and $3 5 \\%$ improvement in sample quality. When using fixed hyperparameters settings our approach outperforms the baseline in $8 6 \\% ( 1 2 4 / 1 4 4 )$ of cases. Further, we show that self-modulation still helps even if label information is available. Finally, we discuss the effects of this method in light of recently proposed diagnostic tools, generator conditioning (Odena et al., 2018) and precision/recall for generative models (Sajjadi et al., 2018). ",
+        "bbox": [
+            173,
+            854,
+            821,
+            882
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/de7a45665cecf0ce02880f528fcb3eb5593669fa2d3f85053324703415580e05.jpg",
+        "image_caption": [
+            "Figure 1: (a) The proposed Self-Modulation framework for a generator network, where middle layers are directly modulated as a function of the generator input $_ z$ . (b) A simple MLP based modulation function that transforms input $_ z$ to the modulation variables $\\beta ( z )$ and $\\gamma ( z )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            98,
+            774,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            309,
+            825,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 SELF-MODULATION FOR GENERATIVE ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            416,
+            756,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Several recent works observe that conditioning the generative process on side information (such as labels or class embeddings) leads to improved models (Mirza & Osindero, 2014; Odena et al., 2017; Miyato & Koyama, 2018). Two major approaches to conditioning on side information $\\pmb { s }$ have emerged: (1) Directly concatenate the side information $\\pmb { s }$ with the noise vector $_ z$ (Mirza & Osindero, 2014), i.e. $z ^ { \\prime } = [ s , z ]$ . (2) Condition the hidden layers directly on $\\pmb { s }$ , which is usually instantiated via conditional batch normalization (De Vries et al., 2017; Miyato & Koyama, 2018). ",
+        "bbox": [
+            173,
+            449,
+            825,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite the success of conditional approaches, two concerns arise. The first is practical; side information is often unavailable. The second is conceptual; unsupervised models, such as GANs, seek to model data without labels. Including them side-steps the challenge and value of unsupervised learning. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            595
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose self-modulating layers for the generator network. In these layers the hidden activations are modulated as a function of latent vector $_ z$ . In particular, we apply modulation in a feature-wise fashion which allows the model to re-weight the feature maps as a function of the input. This is also motivated by the FiLM layer for supervised models (Perez et al., 2018; De Vries et al., 2017) in which a similar mechanism is used to condition a supervised network on side information. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            672
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Batch normalization (Ioffe & Szegedy, 2015) can improve the training of deep neural nets, and it is widely used in both discriminative and generative modeling (Szegedy et al., 2015; Radford et al., 2016; Miyato et al., 2018). It is thus present in most modern networks, and provides a convenient entry point for self-modulation. Therefore, we present our method in the context of its application via batch normalization. In batch normalization the activations of a layer, $^ { h }$ , are transformed as ",
+        "bbox": [
+            173,
+            678,
+            825,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b32f1a0349b7a82ad73fde8987c92f857b6fbffb6945a2fd53bced944337618.jpg",
+        "text": "$$\nh _ { \\ell } ^ { \\prime } = \\gamma \\odot \\frac { h _ { \\ell } - \\mu } { \\sigma } + \\beta ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            757,
+            578,
+            789
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\mu }$ and $\\sigma ^ { 2 }$ are the estimated mean and variances of the features across the data, and $\\gamma$ and $\\beta$ are learnable scale and shift parameters. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Self-modulation for unconditional (without side information) generation. In this case the proposed method replaces the non-adaptive parameters $\\beta$ and $\\gamma$ with input-dependent $\\beta ( z )$ and $\\gamma ( z )$ , respectively. These are parametrized by a neural network applied to the generator’s input (Figure 1). In particular, for layer $\\ell$ , we compute ",
+        "bbox": [
+            174,
+            833,
+            823,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18d7cc46a2ab6e2573b74d689b94bfc029bb3bff7777e8a760c5258ed9b3dbfd.jpg",
+        "text": "$$\nh _ { \\ell } ^ { \\prime } = \\gamma _ { \\ell } ( z ) \\odot \\frac { h _ { \\ell } - \\mu } { \\sigma } + \\beta _ { \\ell } ( z )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            898,
+            604,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/661ad32f7160620b49ec6b9865b71485841dd577dc037eb9f15a1bfb32d1107b.jpg",
+        "table_caption": [
+            "Table 1: Techniques for generator conditioning and modulation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Only first layer</td><td>Other Arbitrary layers</td></tr><tr><td>Side information s</td><td>N/A</td><td>Conditional batch normalization (De Vries et al., 2017; Miyato &amp; Koyama, 2018)</td></tr><tr><td>Latent vector z</td><td>Unconditional Generator (Goodfellow et al., 2014)</td><td>(Unconditional) Self-Modulation (this work)</td></tr><tr><td>Both s and z</td><td>Conditional Generator (Mirza &amp; Osindero, 2014)</td><td>(Conditional) Self-Modulation (this work)</td></tr></table>",
+        "bbox": [
+            187,
+            126,
+            808,
+            239
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In general, it suffices that $\\gamma _ { \\ell } ( \\cdot )$ and $\\beta _ { \\ell } ( \\cdot )$ are differentiable. In this work, we use a small onehidden layer feed-forward network (MLP) with ReLU activation applied to the generator input $_ { z }$ . Specifically, given parameter matrices $U ^ { ( \\ell ) }$ and $V ^ { ( \\ell ) }$ , and a bias vector $\\pmb { b } ^ { ( \\ell ) }$ , we compute ",
+        "bbox": [
+            174,
+            261,
+            823,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ace668def33742142db8842d973fd5636554a50df4666ea67d2f287200a7161e.jpg",
+        "text": "$$\n\\gamma _ { \\ell } ( z ) = V ^ { ( \\ell ) } \\operatorname* { m a x } ( 0 , U ^ { ( \\ell ) } z + \\pmb { b } ^ { ( \\ell ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            309,
+            619,
+            329
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We do the same for $\\beta ( z )$ with independent parameters. ",
+        "bbox": [
+            174,
+            333,
+            535,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Self-modulation for conditional (with side information) generation. Having access to side information proved to be useful for conditional generation. The use of labels in the generator (and possibly discriminator) was introduced by Mirza & Osindero (2014) and later adapted by Odena et al. (2017); Miyato $\\&$ Koyama (2018). In case that side information is available (e.g. class labels $y )$ , it can be readily incorporated into the proposed method. This can be achieved by simply composing the information $y$ with the input $z \\in \\bar { \\mathbb { R } ^ { d } }$ via some learnable function $g$ , i.e. $z ^ { \\prime } = g ( y , z )$ . In this work we opt for the simplest option and instantiate $g$ as a bi-linear interaction between $_ z$ and two trainable embedding functions $\\dot { \\boldsymbol { E } } , \\boldsymbol { E } ^ { \\prime } : \\boldsymbol { Y }  \\mathbb { R } ^ { d }$ of the class label $y$ , as ",
+        "bbox": [
+            173,
+            354,
+            825,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2caa5b5fdead78945e3c2ff81f44a56ddfb541c8deb1f4f78759cf2823c9103.jpg",
+        "text": "$$\nz ^ { \\prime } = z + \\mathrm { E } ( y ) + z \\odot \\mathrm { E } ^ { \\prime } ( y ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            470,
+            596,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This conditionally composed $z ^ { \\prime }$ can be directly used in Equation 1. Despite its simplicity, we demonstrate that it outperforms the standard conditional models. ",
+        "bbox": [
+            174,
+            492,
+            823,
+            521
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Discussion. Table 1 summarizes recent techniques for generator conditioning. While we choose to implement this approach via batch normalization, it can also operate independently by removing the normalization part in the Equation 1. We made this pragmatic choice due to the fact that such conditioning is common (Radford et al., 2016; Miyato et al., 2018; Miyato & Koyama, 2018). ",
+        "bbox": [
+            173,
+            527,
+            825,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second question is whether one benefits from more complex modulation architectures, such as using an attention network (Vaswani et al., 2017) whereby $\\beta$ and $\\gamma$ could be made dependent on all upstream activations, or constraining the elements in $\\gamma$ to $( 0 , 1 )$ which would yield a similar gating mechanism to an LSTM cell (Hochreiter & Schmidhuber, 1997). Based on initial experiments we concluded that this additional complexity does not yield a substantial increase in performance. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            326,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We perform a large-scale study of self-modulation to demonstrate that this method yields robust improvements in a variety of settings. We consider loss functions, architectures, discriminator regularization/normalization strategies, and a variety of hyperparameter settings collected from recent studies (Radford et al., 2016; Gulrajani et al., 2017; Miyato et al., 2018; Lucic et al., 2018; Kurach et al., 2018). We study both unconditional (without labels) and conditional (with labels) generation. Finally, we analyze the results through the lens of the condition number of the generator’s Jacobian as suggested by Odena et al. (2018), and precision and recall as defined in Sajjadi et al. (2018). ",
+        "bbox": [
+            173,
+            710,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            825,
+            400,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Loss functions. We consider two loss functions. The first one is the non-saturating loss proposed in Goodfellow et al. (2014): ",
+        "bbox": [
+            174,
+            851,
+            825,
+            880
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f5a252832e8a9f60aaa7788c886bcec94d7e5a6566006d68043d9583fae95fc.jpg",
+        "text": "$$\n\\begin{array} { r l } & { V _ { D } ( G , D ) = \\mathbb { E } _ { { \\pmb { x } } \\sim P _ { d } ( { \\pmb { x } } ) } [ \\log \\sigma ( D ( { \\pmb { x } } ) ) ] + \\mathbb { E } _ { { \\pmb { z } } \\sim P ( { \\pmb { z } } ) } [ \\log ( 1 - \\sigma ( D ( G ( { \\pmb { z } } ) ) ) ) ] } \\\\ & { V _ { G } ( G , D ) = - \\mathbb { E } _ { { \\pmb { z } } \\sim P ( { \\pmb { z } } ) } [ \\log \\sigma ( D ( G ( { \\pmb { z } } ) ) ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            883,
+            741,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second one is the hinge loss used in Miyato et al. (2018): ",
+        "bbox": [
+            173,
+            103,
+            576,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96b4cee9ef4ad52b24c9c8efd05848bd569391db9bcd069ed48367b9236371f4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { V _ { D } ( G , D ) = \\mathbb { E } _ { \\mathbf { x } \\sim P _ { d } ( \\mathbf { x } ) } [ \\operatorname* { m i n } ( 0 , - 1 + D ( \\mathbf { x } ) ) ] + \\mathbb { E } _ { \\mathbf { z } \\sim P ( \\mathbf { z } ) } [ \\operatorname* { m i n } ( 0 , - 1 - D ( G ( z ) ) ) ] } \\\\ & { V _ { G } ( G , D ) = - \\mathbb { E } _ { \\mathbf { z } \\sim P ( z ) } [ D ( G ( z ) ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            137,
+            771,
+            176
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Controlling the Lipschitz constant of the discriminator. The discriminator’s Lipschitz constant is a central quantity analyzed in the GAN literature (Miyato et al., 2018; Zhou et al., 2018). We consider two state-of-the-art techniques: gradient penalty (Gulrajani et al., 2017), and spectral normalization (Miyato et al., 2018). Without normalization and regularization the models can perform poorly on some datasets. For the gradient penalty regularizer we consider regularization strength $\\bar { \\lambda } \\in \\{ 1 , 1 0 \\}$ . ",
+        "bbox": [
+            173,
+            202,
+            825,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Network architecture. We use two popular architecture types: one based on DCGAN (Radford et al., 2016), and another from Miyato et al. (2018) which incorporates residual connections (He et al., 2016). The details can be found in the appendix. ",
+        "bbox": [
+            174,
+            292,
+            823,
+            335
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Optimization hyper-parameters. We train all models for $1 0 0 \\mathrm { k }$ generator steps with the Adam optimizer (Kingma & Ba, 2014) (We also perform a subset of the studies with 500K steps and discuss it in. We test two popular settings of the Adam hyperparameters $( \\beta _ { 1 } , \\beta _ { 2 } )$ : (0.5, 0.999) and $( 0 , 0 . 9 )$ . Previous studies find that multiple discriminator steps per generator step can help the training (Goodfellow et al., 2014; Salimans et al., 2016), thus we also consider both 1 and 2 discriminator steps per generator step2. In total, this amounts to three different sets of hyperparameters for $( \\beta _ { 1 } , \\beta _ { 2 }$ , disc iter): $( 0 , 0 . 9 , 1 )$ , $( 0 , 0 . 9 , 2 )$ , (0.5, 0.999, 1). We fix the learning rate to 0.0002 as in Miyato et al. (2018). All models are trained with batch size of 64 on a single nVidia P100 GPU. We report the best performing model attained during the training period; although the results follow the same pattern if the final model is report. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We consider four datasets: CIFAR10, CELEBA-HQ, LSUN-BEDROOM, and IMAGENET. The LSUN-BEDROOM dataset (Yu et al., 2015) contains around 3M images. We partition the images randomly into a test set containing 30588 images and a train set containing the rest. CELEBAHQ contains $3 0 \\mathrm { k }$ images (Karras et al., 2017). We use the $1 2 8 \\times 1 2 8 \\times 3$ version obtained by running the code provided by the authors3. We use 3000 examples as the test set and the remaining examples as the training set. CIFAR10 contains 70K images $( 3 2 \\times 3 2 \\times 3 )$ , partitioned into 60000 training instances and 10000 testing instances. Finally, we evaluate our method on IMAGENET, which contains 1.3M training images and 50K test images. We re-size the images to $1 2 8 \\times 1 2 8 \\times 3$ as done in Miyato & Koyama (2018) and Zhang et al. (2018). ",
+        "bbox": [
+            173,
+            488,
+            825,
+            613
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Metrics. Quantitative evaluation of generative models remains one of the most challenging tasks. This is particularly true in the context of implicit generative models where likelihood cannot be effectively evaluated. Nevertheless, two quantitative measures have recently emerged: The Inception Score and the Frechet Inception Distance. While both of these scores have some drawbacks, they correlate well with scores assigned by human annotators and are somewhat robust. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inception Score (IS) (Salimans et al., 2016) posits that that the conditional label distribution $p ( y | \\mathbf { \\boldsymbol { x } } )$ of samples containing meaningful objects should have low entropy, while the marginal label distribution $p ( y )$ should have high entropy. Formally, $\\begin{array} { r } { \\mathrm { I S } ( G ) = \\exp ( \\mathbb { E } _ { x \\sim G } [ \\mathrm { d } _ { \\mathrm { K L } } ( p ( y | x ) , p ( y ) ] ) } \\end{array}$ . The score is computed using an Inception classifier (Szegedy et al., 2015). Drawbacks of applying IS to model comparison are discussed in Barratt & Sharma (2018). ",
+        "bbox": [
+            174,
+            696,
+            825,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An alternative score, the Frechet Inception Distance (FID), requires no labeled data (Heusel et al., 2017). The real and generated samples are first embedded into a feature space (using a specific layer of InceptionNet). Then, a multivariate Gaussian is fit each dataset and the distance is computed as $\\mathrm { F I D } ( x , g ) = | | \\mu _ { x } - \\mu _ { g } | | _ { 2 } ^ { 2 } + \\operatorname { T r } ( \\Sigma _ { x } + \\Sigma _ { g } - 2 ( \\Sigma _ { x } \\Sigma _ { g } ) ^ { \\frac { 1 } { 2 } } )$ , where $\\mu$ and $\\Sigma$ denote the empirical mean and covariance and subscripts $x$ and $g$ denote the true and generated data, respectively. FID was shown to be robust to various manipulations and sensitive to mode dropping (Heusel et al., 2017). ",
+        "bbox": [
+            174,
+            773,
+            825,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/e6bc88f76c3861ac2dfdd3e9a2daaea19bf78669df9c4b9b09885b6cd5628f20.jpg",
+        "table_caption": [
+            "Table 2: In the unpaired setting (as defined in Section 3.2), we compute the median score (across random seeds) and report the best attainable score across considered optimization hyperparameters. SELF-MOD is the method introduced in Section 2 and BASELINE refers to batch normalization. We observe that the proposed approach outperforms the baseline in 30 out of 32 settings. The relative improvement is detailed in Table 3. The standard error of the median is within $3 \\%$ in the majority of the settings and is presented in Table 6 for clarity. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>TYPE</td><td>ARCH</td><td>Loss</td><td>METHOD</td><td>BEDROOM</td><td>CELEBAHQ</td><td>CIFAR10</td><td>IMAGENET</td></tr><tr><td rowspan=\"7\">GRADIENT PENALTY</td><td rowspan=\"5\">RES</td><td>HINGE</td><td>SELF-MOD</td><td>22.62</td><td>27.03</td><td>26.93</td><td>78.31</td></tr><tr><td rowspan=\"2\"></td><td>BASELINE</td><td>27.75</td><td>30.02</td><td>28.14</td><td>86.23</td></tr><tr><td>SELF-MOD</td><td>25.30</td><td>26.65</td><td>26.74</td><td>85.67</td></tr><tr><td rowspan=\"2\">NS HINGE</td><td>BASELINE</td><td>36.79</td><td>33.72</td><td>28.61</td><td>98.38</td></tr><tr><td>SELF-MOD</td><td>110.86</td><td>55.63</td><td>33.58</td><td>90.67</td></tr><tr><td rowspan=\"2\">SNDC NS</td><td>BASELINE</td><td>119.59</td><td>68.51</td><td>36.24</td><td>116.25</td></tr><tr><td></td><td>SELF-MOD</td><td>120.73</td><td>125.44 33.70</td><td>101.40</td></tr><tr><td rowspan=\"8\">SPECTRAL NORM</td><td rowspan=\"4\">RES</td><td rowspan=\"2\"></td><td>BASELINE</td><td>134.13</td><td>131.89</td><td>37.12</td><td>122.74</td></tr><tr><td>SELF-MOD</td><td>14.32</td><td>24.50</td><td>18.54</td><td>68.90</td></tr><tr><td rowspan=\"2\">HINGE</td><td>BASELINE</td><td>17.10</td><td>26.15</td><td>20.08</td><td>78.62</td></tr><tr><td>SELF-MOD</td><td>14.80</td><td>26.27</td><td>20.63</td><td>80.48</td></tr><tr><td rowspan=\"4\">SNDC</td><td rowspan=\"2\">NS</td><td>BASELINE</td><td>17.50</td><td>30.22</td><td>23.81</td><td>120.82</td></tr><tr><td>SELF-MOD</td><td>48.07</td><td>22.51</td><td>24.66</td><td>75.87</td></tr><tr><td rowspan=\"2\">HINGE</td><td>BASELINE</td><td>38.31</td><td>27.20</td><td>26.33</td><td>90.01</td></tr><tr><td>SELF-MOD</td><td>46.65</td><td>24.73</td><td>26.09</td><td>76.69</td></tr><tr><td rowspan=\"2\"></td><td rowspan=\"2\"></td><td>NS</td><td>BASELINE</td><td>40.80</td><td>28.16</td><td>27.41</td><td>93.25</td></tr><tr><td></td><td>SELF-MOD</td><td>14.32</td><td>22.51</td><td>18.54</td><td>68.90</td></tr><tr><td rowspan=\"2\">BEST OF ABOVE</td><td rowspan=\"2\"></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>BASELINE</td><td>17.10</td><td>26.15</td><td>20.08</td><td>78.62</td></tr></table>",
+        "bbox": [
+            173,
+            195,
+            828,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 ROBUSTNESS EXPERIMENTS FOR UNCONDITIONAL GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            658,
+            547
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To test robustness, we run a Cartesian product of the parameters in Section 3.1 which results in 36 settings for each dataset (2 losses, 2 architectures, 3 hyperparameter settings for spectral normalization, and 6 for gradient penalty). For each setting we run five random seeds for self-modulation and the baseline (no self-modulation, just batch normalization). We compute the median score across random seeds which results in 1440 trained models. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We distinguish between two sets of experiments. In the unpaired setting we define the model as the tuple of loss, regularizer/normalization, neural architecture, and conditioning (self-modulated or classic batch normalization). For each model compute the minimum FID across optimization hyperparameters $\\beta _ { 1 }$ , $\\beta _ { 2 }$ , disc iters). We therefore compare the performance of self-modulation and baseline for each model after hyperparameter optimization. The results of this study are reported in Table 2, and the relative improvements are in Table 3 and Figure 2. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We observe the following: (1) When using the RESNET style architecture, the proposed method outperforms the baseline in all considered settings. (2) When using the SNDCGAN architecture, it outperforms the baseline in $8 7 . 5 \\%$ of the cases. The breakdown by datasets is shown in Figure 2. (3) The improvement can be as high as a $3 3 \\%$ reduction in FID. (4) We observe similar improvement to the inception score, reported in the appendix. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the second setting, the paired setting, we assess how effective is the technique when simply added to an existing model with the same set of hyperparameters. In particular, we fix everything except the type of conditioning – the model tuple now includes the optimization hyperparameters. This results in 36 settings for each data set for a total of 144 comparisons. We observe that selfmodulation outperforms the baseline in 124/144 settings. These results suggest that self-modulation can be applied to most GANs even without additional hyperparameter tuning. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Conditional Generation. We demonstrate that self-modulation also works for label-conditional generation. Here, one is given access the class label which may be used by the generator and the discriminator. We compare two settings: (1) Generator conditioning is applied via label-conditional Batch Norm (De Vries et al., 2017; Miyato & Koyama, 2018) with no use of labels in the discriminator (G-COND). (2) Generator conditioning applied as above, but with projection based conditioning in the discriminator (intuitively it encourages the discriminator to use label discriminative features to distinguish true/fake samples), as in Miyato & Koyama (2018) (P-CGAN). The former can be considered as a special case of the latter where discriminator conditioning is disabled. For P-CGAN, we use the architectures and hyper-parameter settings of Miyato & Koyama (2018). See the appendix, Section B.3 for details. In both cases, we compare standard label-conditional batch normalization to self-modulation with additional labels, as discussed in Section 2, Equation 3. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/072c28113bfd24b5f3a9b6b1fdbfe14e242e55b6652c46b35bc5168986039123.jpg",
+        "table_caption": [
+            "Table 3: Reduction in FID over a large class of hyperparameter settings, losses, regularization, and normalization schemes. We observe from $4 . 3 \\%$ to $33 \\%$ decrease in FID. When applied to the RESNET architecture, independently of the loss, regularization, and normalization, SELF-MOD always outperforms the baseline. For SNDCGAN we observe an improvement in $8 7 . 5 \\%$ of the cases (all except two on LSUN-BEDROOM). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">REDUCTION(%)</td><td colspan=\"3\">REDUCTION(%)</td></tr><tr><td>MODEL</td><td colspan=\"2\">RESNET</td><td>SNDC</td><td>MODEL</td><td></td><td>RESNET</td><td>SNDC</td></tr><tr><td>HINGE-GP</td><td>BEDROOM</td><td>18.50</td><td>7.30</td><td>NS-GP</td><td>BEDROOM</td><td>31.22</td><td>9.99</td></tr><tr><td></td><td>CELEBAHQ</td><td>9.94</td><td>18.81</td><td></td><td>CELEBAHQ</td><td>20.96</td><td>4.89</td></tr><tr><td></td><td>CIFAR10</td><td>4.30</td><td>7.33</td><td></td><td>CIFAR10</td><td>6.51</td><td>9.21</td></tr><tr><td></td><td>IMAGENET</td><td>9.18</td><td>22.01</td><td></td><td>IMAGENET</td><td>12.92</td><td>17.39</td></tr><tr><td>HINGE-SN</td><td>BEDROOM</td><td>16.25</td><td>-25.48</td><td>NS-SN</td><td>BEDROOM</td><td>15.43</td><td>-14.35</td></tr><tr><td></td><td>CELEBAHQ</td><td>6.31</td><td>17.26</td><td></td><td>CELEBAHQ</td><td>13.08</td><td>12.20</td></tr><tr><td></td><td>CIFAR10</td><td>7.67</td><td>6.35</td><td></td><td>CIFAR10</td><td>13.36</td><td>4.83</td></tr><tr><td></td><td>IMAGENET</td><td>12.37</td><td>15.72</td><td></td><td>IMAGENET</td><td>33.39</td><td>17.76</td></tr></table>",
+        "bbox": [
+            183,
+            183,
+            810,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f0391b8111d7189abe53091de2608cfc492320b7760bcfde0c893c378df0647.jpg",
+        "image_caption": [
+            "Figure 2: In Figure (a) we observe that the proposed method outperforms the baseline in the unpaired setting. Figure (b) shows the number of models which fall in 80-th percentile in terms of FID (with reverse ordering). We observe that the majority “good” models utilize self-modulation. Figure (c) shows that applying self-conditioning is more beneficial on the later layers, but should be applied to each layer for optimal performance. This effect persists across all considered datasets, see the appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            356,
+            797,
+            511
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            637,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Table 4. Again, we observe that the simple incorporation of self-modulation leads to a significant improvement in performance in the considered settings. ",
+        "bbox": [
+            176,
+            770,
+            821,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training for longer on IMAGENET. To demonstrate that self-modulation continues to yield improvement after training for longer, we train IMAGENET for $5 0 0 \\mathrm { k }$ generator steps. Due to the increased computational demand we use a single setting for the unconditional and conditional settings models following Miyato et al. (2018) and Miyato & Koyama (2018), but using only two discriminator steps per generator. We expect that the results would continue to improve if training longer. However, currently results from 500k steps require training for ${ \\sim } 1 0$ days on a P100 GPU. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compute the median FID across 3 random seeds. After $5 0 0 \\mathrm { k }$ steps the baseline unconditional model attains FID 60.4, self-modulation attains 53.7 ( $1 1 \\%$ improvement). In the conditional setting self-modulation improves the FID from 50.6 to 43.9 $13 \\%$ improvement). The improvements in IS are from 14.1 to 15.1, and 20.1 to 22.2 in unconditional and conditional setting, respectively. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/469d56e3cfbb9c76d6f4ede649c98e351d2cadf1755eae41cadaca8e489cbe8f.jpg",
+        "table_caption": [
+            "Table 4: FID and IS scores in label conditional setting. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"2\">UNCONDITIONAL</td><td colspan=\"2\">G-COND</td><td colspan=\"2\">P-CGAN</td></tr><tr><td></td><td>SCORE</td><td>BASELINE</td><td>SELF-MOD</td><td>BASELINE</td><td>SELF-MOD</td><td>BASELINE</td><td>SELF-MOD</td></tr><tr><td>CIFAR10</td><td>FID</td><td>20.41</td><td>18.58</td><td>21.08</td><td>18.39</td><td>16.06</td><td>14.19</td></tr><tr><td>IMAGENET</td><td>FID</td><td>81.07</td><td>69.53</td><td>80.43</td><td>68.93</td><td>70.28</td><td>66.09</td></tr><tr><td>CIFAR10</td><td>IS</td><td>7.89</td><td>8.31</td><td>8.11</td><td>8.34</td><td>8.53</td><td>8.71</td></tr><tr><td>IMAGENET</td><td>IS</td><td>11.16</td><td>12.52</td><td>11.16</td><td>12.48</td><td>13.62</td><td>14.14</td></tr></table>",
+        "bbox": [
+            173,
+            126,
+            836,
+            226
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            255,
+            823,
+            282
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Where to apply self-modulation? Given the robust improvements of the proposed method, an immediate question is where to apply the modulation. We tested two settings: (1) applying modulation to every batch normalization layer, and (2) applying it to a single layer. The results of this ablation are in Figure 2. These results suggest that the benefit of self-modulation is greatest in the last layer, as may be intuitive, but applying it to each layer is most effective. ",
+        "bbox": [
+            174,
+            289,
+            825,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            382,
+            344,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Conditional GANs. Conditioning on side information, such as class labels, has been shown to improve the performance of GANs. Initial proposals were based on concatenating this additional feature with the input vector (Mirza & Osindero, 2014; Radford et al., 2016; Odena et al., 2017). Recent approaches, such as the projection cGAN (Miyato & Koyama, 2018) injects label information into the generator architecture using conditional Batch Norm layers (De Vries et al., 2017). Self-modulation is a simple yet effective complementary addition to this line of work which makes a significant difference when no side information is available. In addition, when side information is available it can be readily applied as discussed in Section 2 and leads to further improvements. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            526
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Conditional Modulation. Conditional modulation, using side information to modulate the computation flow in neural networks, is a rich idea which has been applied in various contexts (beyond GANs). In particular, Dumoulin et al. (2017) apply Conditional Instance Normalization (Ulyanov et al., 2016) to image style-transfer (Dumoulin et al., 2017). Kim et al. (2017) use Dynamic Layer Normalization (Ba et al., 2016) for adaptive acoustic modelling. Feature-wise Linear Modulation (Perez et al., 2018) generalizes this family of methods by conditioning the Batch Norm scaling and bias factors (which correspond to multiplicative and additive interactions) on general external embedding vectors in supervised learning. The proposed method applies to generators in GAN (unsupervised learning), and it works with both unconditional (without side information) and conditional (with side information) settings. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Multiplicative and Additive Modulation. Existing conditional modulations mentioned above are usually instantiated via Batch Normalization, which include both multiplicative and additive modulation. These two types of modulation also link to other techniques widely used in neural network literature. The multiplicative modulation is closely related to Gating, which is adopted in LSTM (Hochreiter & Schmidhuber, 1997), gated PixelCNN (van den Oord et al., 2016), Convolutional Sequence-to-sequence networks (Gehring et al., 2017) and Squeeze-and-excitation Networks (Hu et al., 2018). The additive modulation is closely related to Residual Networks (He et al., 2016). The proposed method adopts both types of modulation. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            310,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We present a generator modification that improves the performance of most GANs. This technique is simple to implement and can be applied to all popular GANs, therefore we believe that selfmodulation is a useful addition to the GAN toolbox. ",
+        "bbox": [
+            176,
+            847,
+            823,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our results suggest that self-modulation clearly yields performance gains, however, they do not say how this technique results in better models. Interpretation of deep networks is a complex topic, especially for GANs, where the training process is less well understood. Rather than purely speculate, we compute two diagnostic statistics that were proposed recently ignite the discussion of the method’s effects. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b92252ecc1b3d163ac9499693afc0091eab89aa9ad14f6d4cfed662301d10657.jpg",
+        "image_caption": [
+            "Figure 3: Each point corresponds to a single model/hyperparameter setting. The left-hand plots show the log condition number of the generator versus the FID score. The right-hand plots show the generator precision/recall curves. The $r$ values for the correlation between log condition number and FID on CIFAR10 are 0.67 and 0.83 for Self-Mod and Base, respectively. For IMAGENET they are 0.24 and 0.39 for Self-Mod and Base, respectively. LSUN-BEDROOM and CELEBA-HQ are in the appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            99,
+            743,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            541,
+            823,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we compute the condition number of the generators Jacobian. Odena et al. (2018) provide evidence that better generators have a Jacobian with lower condition number and hence regularize using this quantity. We estimate the generator condition number in the same was as Odena et al. (2018). We compute the Jacobian $\\begin{array} { r } { ( \\bar { J } _ { z } ) _ { i , j } \\ = \\ \\frac { \\delta G ( z ) _ { i } } { \\delta z _ { j } } } \\end{array}$ at each $_ { z }$ in a minibatch, then average the logarithm of the condition numbers computed from each Jacobian. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Second, we compute a notion of precision and recall for generative models. Sajjadi et al. (2018) define the quantities, $F _ { 8 }$ and $F _ { 1 / 8 }$ , for generators. These quantities relate intuitively to the traditional precision and recall metrics for classification. Generating points which have low probability under the true data distribution is interpreted as a loss in precision, and is penalized by the $F _ { 8 }$ score. Failing to generate points that have high probability under the true data distributions is interpreted as a loss in recall, and is penalized by the $F _ { 1 / 8 }$ score. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows both statistics. The left hand plot shows the condition number plotted against FID score for each model. We observe that poor models tend to have large condition numbers; the correlation, although noisy, is always positive. This result corroborates the observations in (Odena et al., 2018). However, we notice an inverse trend in the vicinity of the best models. The cluster of the best models with self-modulation has lower FID, but higher condition number, than the best models without self-modulation. Overall the correlation between FID and condition number is smaller for self-modulated models. This is surprising, it appears that rather than unilaterally reducing the condition number, self-modulation provides some training stability, yielding models with a small range of generator condition numbers. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The right-hand plot in Figure 3 shows the $F _ { 8 }$ and $F _ { 1 / 8 }$ scores. Models in the upper-left quadrant cover true data modes better (higher precision), and models in the lower-right quadrant produce more modes (higher recall). Self-modulated models tend to favor higher recall. This effect is most pronounced on IMAGENET. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Overall these diagnostics indicate that self-modulation stabilizes the generator towards favorable conditioning values. It also appears to improve mode coverage. However, these metrics are very new; further development of analysis tools and theoretical study is needed to better disentangle the symptoms and causes of the self-modulation technique, and indeed of others. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            213,
+            334,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Ilya Tolstikhin for helpful discussions. We would also like to thank Xiaohua Zhai, Marcin Michalski, Karol Kurach and Anton Raichuk for their help with infustrature. We also appreciate general discussions with Olivier Bachem, Alexander Kolesnikov, Thomas Unterthiner, and Josip Djolonga. Finally, we are grateful for the support of other members of the Google Brain team. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            329,
+            285,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. �� In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            171,
+            353,
+            823,
+            382
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            171,
+            391,
+            823,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shane Barratt and Rishi Sharma. A note on the inception score. arXiv preprint arXiv:1801.01973, 2018. ",
+        "bbox": [
+            173,
+            430,
+            825,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Harm De Vries, Florian Strub, Jer´ emie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron C ´ Courville. Modulating early visual processing by language. In Advances in Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            176,
+            468,
+            823,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vincent Dumoulin, Jonathon Shlens, and Manjunath Kudlur. A learned representation for artistic style. International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            520,
+            823,
+            550
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann Dauphin. Convolutional sequence to sequence learning. In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            171,
+            558,
+            823,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems (NIPS), 2014. ",
+        "bbox": [
+            174,
+            597,
+            823,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of Wasserstein GANs. Advances in Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            173,
+            650,
+            823,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            169,
+            702,
+            825,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Gunter Klambauer, and ¨ Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a Nash equilibrium. In Advances in Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            176,
+            741,
+            823,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997. ",
+        "bbox": [
+            173,
+            792,
+            807,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In Computer Vision and Pattern Recognition (CVPR), 2018. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            176,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arxiv, 2016. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. Advances in Neural Information Processing Systems (NIPS), 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Taesup Kim, Inchul Song, and Yoshua Bengio. Dynamic layer normalization for adaptive neural acoustic modeling in speech recognition. In INTERSPEECH, 2017. ",
+        "bbox": [
+            171,
+            156,
+            823,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            195,
+            821,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karol Kurach, Mario Lucic, Xiaohua Zhai, Marcin Michalski, and Sylvain Gelly. The GAN Landscape: Losses, Architectures, Regularization, and Normalization. arXiv preprint arXiv:1807.04720, 2018. ",
+        "bbox": [
+            173,
+            234,
+            826,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            173,
+            286,
+            825,
+            343
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are GANs Created Equal? A Large-scale Study. In Advances in Neural Information Processing Systems (NIPS), 2018. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. International Conference on Computer Vision (ICCV), 2016. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014. ",
+        "bbox": [
+            173,
+            459,
+            823,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato and Masanori Koyama. cgans with projection discriminator. International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            500,
+            823,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier GANs. In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            171,
+            590,
+            823,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Jacob Buckman, Catherine Olsson, Tom B Brown, Christopher Olah, Colin Raffel, and Ian Goodfellow. Is generator conditioning causally related to gan performance? arXiv preprint arXiv:1802.08768, 2018. ",
+        "bbox": [
+            174,
+            630,
+            823,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. Film: Visual reasoning with a general conditioning layer. AAAI, 2018. ",
+        "bbox": [
+            173,
+            736,
+            823,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            173,
+            775,
+            823,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mehdi SM Sajjadi, Olivier Bachem, Mario Lucic, Olivier Bousquet, and Sylvain Gelly. Assessing generative models via precision and recall. In Advances in Neural Information Processing Systems (NIPS), 2018. ",
+        "bbox": [
+            171,
+            828,
+            821,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Computer Vision and Pattern Recognition (CVPR), 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Tschannen, Eirikur Agustsson, and Mario Lucic. Deep generative models for distributionpreserving lossy compression. In Advances in Neural Information Processing Systems (NIPS), 2018. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D Ulyanov, A Vedaldi, and VS Lempitsky. Instance normalization: The missing ingredient for fast stylization. arXiv preprint arXiv:1607.08022, 2016. ",
+        "bbox": [
+            173,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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 (NIPS), 2017. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365, 2015. ",
+        "bbox": [
+            171,
+            347,
+            826,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Han Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaolei Huang, Xiaogang Wang, and Dimitris Metaxas. Stackgan: Text to photo-realistic image synthesis with stacked generative adversarial networks. International Conference on Computer Vision (ICCV), 2017. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv preprint arXiv:1805.08318, 2018. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhiming Zhou, Yuxuan Song, Lantao Yu, and Yong Yu. Understanding the effectiveness of lipschitz constraint in training of gans via gradient analysis. arXiv preprint arXiv:1807.00751, 2018. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            517
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arXiv preprint, 2017. ",
+        "bbox": [
+            171,
+            526,
+            823,
+            555
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL RESULTS ",
+        "bbox": [
+            176,
+            103,
+            398,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 INCEPTION SCORES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            356,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/9680959c1020e9546bddd8dbef62182d14f84ef845ce72380f89d13fcdca8a50.jpg",
+        "table_caption": [
+            "Table 5: In the unpaired setting (as defined in Section 3.2), we compute the median score (across random seeds) and report the best attainable score across considered optimization hyperparameters. SELF-MOD is the method introduced in Section 2 and BASELINE refers to batch normalization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>TYPE</td><td>ARCH</td><td>Loss</td><td>METHOD</td><td>BEDROOM</td><td>CELEBAHQ</td><td>CIFAR10</td><td>IMAGENET</td></tr><tr><td rowspan=\"8\">GRADIENT PENALTY</td><td rowspan=\"4\">RESNET</td><td rowspan=\"2\">HINGE</td><td>SELF-MOD</td><td>5.28±0.18</td><td>2.92 ± 0.13</td><td>7.71 ± 0.59</td><td>11.52 ± 0.07</td></tr><tr><td>BASELINE</td><td>4.72 ± 0.11</td><td>2.80±0.08</td><td>7.35± 0.02</td><td>10.26 ± 0.09</td></tr><tr><td rowspan=\"2\">NS</td><td>SELF-MOD</td><td>4.96 ± 0.17</td><td>2.61± 0.05</td><td>7.70 ± 0.05</td><td>10.74±1.20</td></tr><tr><td>BASELINE</td><td>4.54 ± 0.11</td><td>2.60±0.25</td><td>7.26 ± 0.03</td><td>9.49 ± 0.12</td></tr><tr><td rowspan=\"4\">SNDCGAN</td><td rowspan=\"2\">HINGE</td><td>SELF-MOD</td><td>6.34±0.07</td><td>3.05±0.12</td><td>7.37± 0.04</td><td>10.99 ± 0.06</td></tr><tr><td>BASELINE</td><td>5.02 ±0.05</td><td>3.08 ±0.09</td><td>6.88± 0.05</td><td>8.11 ± 0.06</td></tr><tr><td rowspan=\"2\">NS</td><td>SELF-MOD</td><td>6.31±0.05</td><td>3.07±0.05</td><td>7.28±0.06</td><td>10.06±0.10</td></tr><tr><td>BASELINE</td><td>4.71 ± 0.05</td><td>3.21±0.20</td><td>6.86 ±0.06</td><td>7.24 ± 0.16</td></tr><tr><td rowspan=\"6\">SPECTRAL NORM</td><td rowspan=\"4\">RESNET</td><td rowspan=\"2\">HINGE</td><td>SELF-MOD</td><td>3.94±0.22</td><td>3.65±0.16</td><td>8.29±0.03</td><td>12.67 ± 0.07</td></tr><tr><td>BASELINE</td><td>4.32 ± 0.17</td><td>3.26 ± 0.16</td><td>8.00±0.03</td><td>11.29 ± 0.12</td></tr><tr><td rowspan=\"2\">NS</td><td>SELF-MOD</td><td>4.61 ±0.18</td><td>3.32 ±0.09</td><td>8.23±0.04</td><td>11.52 ± 0.28</td></tr><tr><td>BASELINE</td><td>4.07 ± 0.21</td><td>2.58 ± 0.08</td><td>7.93 ± 0.04</td><td>7.40 ±0.60</td></tr><tr><td rowspan=\"4\">SNDCGAN</td><td rowspan=\"2\">HINGE</td><td>SELF-MOD</td><td>5.85±0.07</td><td>2.74 ±0.02</td><td>7.90±0.04</td><td>12.50 ± 0.12</td></tr><tr><td>BASELINE</td><td>4.82 ± 0.12</td><td>2.40± 0.02</td><td>7.48± 0.04</td><td>9.62 ±0.10</td></tr><tr><td rowspan=\"2\">NS</td><td>SELF-MOD</td><td>5.73±0.07</td><td>2.55±0.02</td><td>7.84 ±0.02</td><td>11.95 ± 0.09</td></tr><tr><td>BASELINE</td><td>4.39 ± 0.14</td><td>2.33 ± 0.01</td><td>7.37 ± 0.04</td><td>9.28±0.13</td></tr></table>",
+        "bbox": [
+            209,
+            217,
+            782,
+            439
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/b5881a511703ac6eb2017d00bd5b9e696133c6812247ec29a0942083510c3116.jpg",
+        "table_caption": [
+            "A.2 FIDS ",
+            "Table 6: Table 2 with the standard error of the median. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>TYPE</td><td>ARCH</td><td>Loss</td><td>METHOD</td><td>BEDROOM</td><td>CELEBAHQ</td><td>CIFAR10</td><td>IMAGENET</td></tr><tr><td rowspan=\"7\">GRADIENT PENALTY</td><td rowspan=\"5\">RES</td><td rowspan=\"2\">HINGE</td><td>SELF-MOD</td><td>22.62 ± 64.79</td><td>27.03 ±0.29</td><td>26.93 ± 13.52</td><td>78.31 ±0.96</td></tr><tr><td>BASE</td><td>27.75 ± 1.01</td><td>30.02 ± 0.69</td><td>28.14 ±0.52</td><td>86.23 ± 1.34</td></tr><tr><td rowspan=\"2\">NS</td><td>SELF-MOD</td><td>25.30 ± 1.21</td><td>26.65±13.16</td><td>26.74 ± 0.42</td><td>85.67 ± 11.94</td></tr><tr><td>BASE</td><td>36.79 ±0.25</td><td>33.72 ± 0.78</td><td>28.61± 0.27</td><td>98.38 ± 1.48</td></tr><tr><td rowspan=\"3\">HINGE SNDC</td><td>SELF-MOD</td><td>110.86 ± 1.72</td><td>55.63±0.53</td><td>33.58± 0.47</td><td>90.67 ± 0.49</td></tr><tr><td rowspan=\"2\">NS</td><td>BASE</td><td>119.59 ± 1.71</td><td>68.51 ± 1.66</td><td>36.24 ±0.69</td><td>116.25 ± 0.48</td></tr><tr><td>SELF-MOD</td><td>120.73 ± 2.10</td><td>125.44 ± 11.27</td><td>33.70±0.47</td><td>101.40 ± 1.17</td></tr><tr><td rowspan=\"7\">SPECTRAL NORM</td><td rowspan=\"5\">RES</td><td rowspan=\"2\">HINGE</td><td>BASE</td><td>134.13 ± 2.40</td><td>131.89 ± 42.16</td><td>37.12± 0.62</td><td>122.74 ± 0.58</td></tr><tr><td>SELF-MOD</td><td>14.32 ± 0.40</td><td>24.50±0.46</td><td>18.54 ±0.15</td><td>68.90±0.67</td></tr><tr><td rowspan=\"2\">NS</td><td>BASE</td><td>17.10 ± 1.44</td><td>26.15 ± 0.70</td><td>20.08 ± 0.31</td><td>78.62 ± 0.97</td></tr><tr><td>SELF-MOD</td><td>14.80±0.40</td><td>26.27 ± 0.48</td><td>20.63±0.20</td><td>80.48 ±2.43</td></tr><tr><td rowspan=\"2\">HINGE</td><td>BASE</td><td>17.50 ± 0.64</td><td>30.22 ± 0.48</td><td>23.81± 0.17</td><td>120.82 ± 6.82</td></tr><tr><td>SELF-MOD</td><td>48.07 ±1.77</td><td>22.51± 0.38</td><td>24.66±0.40</td><td>75.87±0.37</td></tr><tr><td rowspan=\"4\">SNDC</td><td rowspan=\"2\">NS</td><td>BASE</td><td>38.31 ± 1.42</td><td>27.20± 0.80</td><td>26.33± 0.54</td><td>90.01 ± 1.06</td></tr><tr><td>SELF-MOD</td><td>46.65 ± 2.72</td><td>24.73 ± 0.25</td><td>26.09±0.19</td><td>76.69±0.89</td></tr><tr><td rowspan=\"2\"></td><td>BASE</td><td>40.80 ± 1.75</td><td>28.16 ± 0.17</td><td>27.41 ± 0.43</td><td>93.25± 0.35</td></tr><tr><td>SELF-MOD</td><td>14.32</td><td>22.51</td><td>18.54</td><td>68.90</td></tr><tr><td rowspan=\"2\">BEST OF ABOVE</td><td rowspan=\"2\"></td><td>BASELINE</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>17.10</td><td>26.15</td><td>20.08</td><td>78.62</td></tr></table>",
+        "bbox": [
+            184,
+            521,
+            810,
+            770
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 WHICH LAYER TO MODULATE? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            433,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 presents the performance when modulating different layers of the generator for each dataset. ",
+        "bbox": [
+            173,
+            128,
+            823,
+            145
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1e8fe1aff8c96286aff45170ca4eb53d680ad76a040947de0480299f60a61164.jpg",
+        "image_caption": [
+            "Figure 4: FID distributions resulting from Self-Modulation on different layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            156,
+            823,
+            277
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 CONDITIONING AND PRECISION/RECALL ",
+        "bbox": [
+            173,
+            333,
+            504,
+            348
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 presents the generator Jacobian condition number and precision/recall plot for each dataset. ",
+        "bbox": [
+            173,
+            359,
+            821,
+            375
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B MODEL ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            407,
+            421,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We describe the model structures that are used in our experiments in this section. ",
+        "bbox": [
+            173,
+            439,
+            700,
+            454
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.1 SNDCGAN ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            469,
+            424,
+            484
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The SNDCGAN architecture we follows the ones used in Miyato et al. (2018). Since the resolution of images in CIFAR10is $3 2 \\times 3 2 \\times 3$ , while resolutions of images in other datasets are $1 2 8 \\times 1 2 8 \\times 3$ . There are slightly differences in terms of spatial dimensions for both architectures. The proposed self-modulation is applied to replace existing BN layer, we term it sBN (self-modulated BN) for short in Table 7, 8, 9, 10. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.2 RESNET ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            583,
+            400,
+            597
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The ResNet architecture we also follows the ones used in Miyato et al. (2018). Again, due to the resolution differences, two ResNet architectures are used in this work. The proposed self-modulation is applied to replace existing BN layer, we term it sBN (self-modulated BN) for short in Table 11, 12, 13, 14. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            665
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.3 CONDITIONAL GAN ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            681,
+            475,
+            696
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the conditional setting with label information available, we adopt the Projection Based Conditional GAN (P-cGAN) (Miyato & Koyama, 2018). There are both conditioning in generators as well ad discriminators. For generator, conditional batch norm is applied via conditioning on label information, more specifically, this can be expressed as follows, ",
+        "bbox": [
+            174,
+            708,
+            825,
+            763
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b93d1a6fa16d4b95606227e50304035cdf3271658c7a7498652a54e4edd3df6d.jpg",
+        "text": "$$\nh _ { \\ell } ^ { \\prime } = \\gamma _ { y } \\odot \\frac { h _ { \\ell } - \\mu } { \\sigma } + \\beta _ { y }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            768,
+            584,
+            800
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Where each label $y$ is associated with a scaling and shifting parameters independently. ",
+        "bbox": [
+            171,
+            804,
+            740,
+            820
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For discriminator label conditioning, the dot product between final layer feature $\\phi ( { \\pmb x } )$ and label embedding $\\operatorname { E } ( y )$ is added back to the discriminator output logits, i.e. $D ( { \\pmb x } , y ) = \\Psi ( \\phi ( { \\pmb x } ) ) +$ $\\phi ( \\pmb { x } ) ^ { T } \\mathrm { E } ( \\bar { y } )$ where $\\phi ( { \\pmb x } )$ represents the final feature representation layer of input $_ { \\textbf { \\em x } }$ , and $\\psi ( \\cdot )$ is the linear transformation maps the feature vector into a real number. Intuitively, this type of conditional discriminator encourages discriminator to use label discriminative features to distinguish true/fake samples. Both the above conditioning strategies do not dependent on the specific architectures, and can be applied to above architectures with small modifications. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/39b3ef4c0a1b595727479553de000d89503f9c8cb41e91fea90c04ffc690f686.jpg",
+        "image_caption": [
+            "Figure 5: Each point in each plot corresponds to a single model for all parameter configurations. The model with mean FID score across the five random seeds was chosen. The left-hand plots show the log condition number of the generator versus the FID score for each model. The right-hand generator precision/recall metrics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            103,
+            790,
+            751
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use the same architectures and hyper-parameter settings4 as in Miyato & Koyama (2018). More specifically, the architecture is the same as ResNet above, and we compare in two settings: (1) only generator label conditioning is applied, and there is no projection based conditioning in the discriminator, and (2) both generator and discriminator conditioning are applied, which is the standard full P-cGAN. ",
+        "bbox": [
+            176,
+            847,
+            823,
+            876
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/3505a1437c88a934158f5c94cb4485d931e26be48ecc713b4bae7f2fdd562139.jpg",
+        "table_caption": [
+            "Table 7: SNDCGAN Generator with $3 2 \\times 3 2 \\times 3$ resolution. sBN denotes BN with self-modulation as proposed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z ~N(0,I)</td><td>128</td></tr><tr><td>Fully Connected</td><td>Linear Reshape</td><td>2.2:512 2×2×512</td></tr><tr><td>Deconv</td><td>sBN, ReLU Deconv4x4,stride=2</td><td>2×2×512 4×4×256</td></tr><tr><td>Deconv</td><td>sBN, ReLU</td><td>4×4×256</td></tr><tr><td>Deconv</td><td>Deconv4x4,stride=2 sBN,ReLU</td><td>8×8×128 8×8×128</td></tr><tr><td rowspan=\"2\"></td><td>Deconv4x4,stride=2</td><td>16 ×16 × 64</td></tr><tr><td>sBN,ReLU</td><td></td></tr><tr><td rowspan=\"2\">Deconv</td><td></td><td>16×16×64</td></tr><tr><td>Deconv4x4,stride=2 Tanh</td><td>32 ×32×3 32 × 32×3</td></tr></table>",
+        "bbox": [
+            318,
+            196,
+            679,
+            371
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e0c65f00bbe5c0ce10ca5037294807516ccab4b27762e0f10a8c4cdf4f14533.jpg",
+        "table_caption": [
+            "Table 8: SNDCGAN Discriminator with $3 2 \\times 3 2 \\times 3$ resolution. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td>-</td><td>32×32×3</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>32×32×64</td></tr><tr><td>LeakyReLU</td><td>32 × 32 × 64</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv4x4,stride=2</td><td>16×16×128</td></tr><tr><td>LeakyReLU</td><td>16 × 16 ×128</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>16×16×128</td></tr><tr><td>LeakyReLU</td><td>16 × 16 × 128</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv4x4,stride=2</td><td>8×8×256</td></tr><tr><td>LeakyReLU</td><td>8×8×256</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>8×8×256</td></tr><tr><td>LeakyReLU</td><td>8×8×256</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv4x4,stride=2</td><td>4×4×512</td></tr><tr><td>LeakyReLU</td><td>4 × 4× 512</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>4×4×512</td></tr><tr><td>LeakyReLU</td><td>4×4×512</td></tr><tr><td rowspan=\"2\">Fully connected</td><td>Reshape</td><td>4·4·512</td></tr><tr><td>Linear</td><td>1</td></tr></table>",
+        "bbox": [
+            323,
+            136,
+            676,
+            377
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/d357d6c93904cae7abbe82d6f3c10f2237e3559158f5f79577b9295979105f0f.jpg",
+        "table_caption": [
+            "Table 9: SNDCGAN Gnerator with $1 2 8 \\times 1 2 8 \\times 3$ resolution. sBN denotes BN with self-modulation as proposed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z~N(0,I)</td><td>128</td></tr><tr><td>Fully Connected</td><td>Linear Reshape</td><td>8.8.512 8×8×512</td></tr><tr><td>Deconv</td><td>sBN, ReLU Deconv4x4,stride=2</td><td>8×8×512 16 × 16× 256</td></tr><tr><td>Deconv</td><td>sBN,ReLU Deconv4x4,stride=2</td><td>16×16×256 32 × 32×128</td></tr><tr><td>Deconv</td><td>sBN,ReLU</td><td>32 × 32×128</td></tr><tr><td>Deconv</td><td>Deconv4x4,stride=2 sBN,ReLU Deconv4x4,stride=2</td><td>64× 64×64 64×64×64 128 × 128 ×3</td></tr></table>",
+        "bbox": [
+            315,
+            444,
+            683,
+            618
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/2eca512614d3e70efb0ebd1aeebfeeef8e85c727185d455691edf5627411ae91.jpg",
+        "table_caption": [
+            "Table 10: SNDCGAN Discriminator with $1 2 8 \\times 1 2 8 \\times 3$ resolution. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td>1</td><td>128×128×3</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>128×128×64</td></tr><tr><td>LeakyReLU</td><td>128 × 128 × 64</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv4x4,stride=2</td><td>64×64×128</td></tr><tr><td>LeakyReLU</td><td>64 × 64 ×128</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>64×64×128</td></tr><tr><td>LeakyReLU</td><td>64 × 64 ×128</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv4x4,stride=2</td><td>32×32×256</td></tr><tr><td>LeakyReLU</td><td>32×32× 256</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>32 × 32× 256</td></tr><tr><td>LeakyReLU</td><td>32 ×32×256</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv4x4,stride=2</td><td>16 × 16 × 512</td></tr><tr><td>LeakyReLU</td><td>16 × 16 × 512</td></tr><tr><td rowspan=\"2\">Conv</td><td>Conv3x3,stride=1</td><td>16×16×512</td></tr><tr><td>LeakyReLU</td><td>16 ×16 × 512</td></tr><tr><td rowspan=\"2\">Fully connected</td><td>Reshape</td><td>16·16·512</td></tr><tr><td>Linear</td><td>1</td></tr></table>",
+        "bbox": [
+            318,
+            671,
+            678,
+            911
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/86666c3304ea01297011d2e8232c42543b80b0e854e48b1fd389f16b86badc95.jpg",
+        "table_caption": [
+            "Table 11: ResNet Generator with $3 2 \\times 3 2 \\times 3$ resolution. Each ResNet block has a skip-connection that uses upsampling of its input and a 1x1 convolution. sBN denotes BN with self-modulation as proposed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z~N(0,1）</td><td>128</td></tr><tr><td>Fully connected</td><td>Linear</td><td>4·4·256 4×4×256</td></tr><tr><td rowspan=\"2\">ResNetblock</td><td>Reshape sBN,ReLU</td><td>4×4×256</td></tr><tr><td>Upsample</td><td>8×8×256</td></tr><tr><td rowspan=\"3\">ResNetblock</td><td>Conv3x3,sBN,ReLU</td><td>8×8×256</td></tr><tr><td>Conv3x3</td><td>8×8×256</td></tr><tr><td>sBN,ReLU</td><td>8×8×256</td></tr><tr><td rowspan=\"4\"></td><td>Upsample</td><td>16 ×16× 256</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>16 × 16 × 256</td></tr><tr><td>Conv3x3</td><td></td></tr><tr><td>sBN,ReLU</td><td>16 ×16× 256</td></tr><tr><td rowspan=\"4\">ResNetblock</td><td></td><td>16× 16 ×256</td></tr><tr><td>Upsample</td><td>32 × 32 × 256</td></tr><tr><td>Conv3x3,sBN,ReLU</td><td>32 × 32× 256</td></tr><tr><td>Conv3x3</td><td>32 × 32 × 256</td></tr><tr><td rowspan=\"2\">Conv</td><td>sBN, ReLU</td><td>128×128×3</td></tr><tr><td>Conv3x3,Tanh</td><td>128× 128×3</td></tr></table>",
+        "bbox": [
+            310,
+            224,
+            687,
+            462
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a42a13d3c70087f6f89c20106e70d9e9f89e46f3d88aff44bc299c51f146f03.jpg",
+        "table_caption": [
+            "Table 12: ResNet Discriminator with $3 2 \\times 3 2 \\times 3$ resolution. Each ResNet block has a skipconnection that applies a 1x1 convolution with possible downsampling according to spatial dimension. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td></td><td>32×32×3</td></tr><tr><td rowspan=\"3\">ResNet block</td><td>Conv3x3</td><td>32×32×128</td></tr><tr><td>ReLU,Conv3x3</td><td>32 × 32×128</td></tr><tr><td>Downsample</td><td>16 ×16×128</td></tr><tr><td rowspan=\"3\">ResNetblock</td><td>ReLUConv3x3</td><td>16×16×128</td></tr><tr><td>ReLU,Conv3x3</td><td>16 × 16 ×128</td></tr><tr><td>Downsample</td><td>8×8×128</td></tr><tr><td rowspan=\"2\">ResNetblock</td><td>ReLUConv3x3</td><td>8×8×128</td></tr><tr><td>ReLU,Conv3x3</td><td>8×8×128</td></tr><tr><td rowspan=\"2\">ResNetblock</td><td>ReLU,Conv3x3</td><td>8×8×128</td></tr><tr><td>ReLU,Conv3x3</td><td>8×8×128</td></tr><tr><td>Fully connected</td><td>ReLU,GlobalSum pooling</td><td>128</td></tr><tr><td></td><td>Linear</td><td>1</td></tr></table>",
+        "bbox": [
+            297,
+            664,
+            699,
+            852
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab8074f2dcdc55206e58907cdce04227554c8bfc98c64c412d851d1bfbb3b6a5.jpg",
+        "table_caption": [
+            "Table 13: ResNet Generator with $1 2 8 \\times 1 2 8 \\times 3$ resolution. Each ResNet block has a skip-connection that uses upsampling of its input and a 1x1 convolution. sBN denotes BN with self-modulation as proposed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Latent noise</td><td>z~N(0,I)</td><td>128</td></tr><tr><td rowspan=\"2\">Fully connected</td><td>Linear</td><td>4·4·1024</td></tr><tr><td>Reshape</td><td>4×4×1024</td></tr><tr><td rowspan=\"4\">ResNetblock</td><td>sBN,ReLU</td><td>4×4×1024</td></tr><tr><td>Upsample</td><td>8×8× 1024</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>8×8× 1024</td></tr><tr><td>Conv3x3</td><td>8×8×1024</td></tr><tr><td rowspan=\"4\">ResNetblock</td><td>sBN,ReLU</td><td>8×8×1024</td></tr><tr><td>Upsample</td><td>16 ×16 ×1024</td></tr><tr><td>Conv3x3,sBN,ReLU</td><td>16 × 16 ×1024</td></tr><tr><td>Conv3x3</td><td>16 × 16× 512</td></tr><tr><td rowspan=\"4\">ResNetblock</td><td>sBN,ReLU</td><td>16× 16× 512</td></tr><tr><td>Upsample</td><td>32×32×5 512</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>32 × 32 × 512</td></tr><tr><td>Conv3x3</td><td>32 × 32 × 256</td></tr><tr><td rowspan=\"4\">ResNetblock</td><td>sBN,ReLU</td><td>32 ×32×256</td></tr><tr><td>Upsample</td><td>64× 64×256</td></tr><tr><td>Conv3x3,sBN,ReLU</td><td>64 × 64× 256</td></tr><tr><td>Conv3x3</td><td>64 × 64×128</td></tr><tr><td rowspan=\"4\">ResNetblock</td><td>sBN,ReLU</td><td>64×64×128</td></tr><tr><td>Upsample</td><td>128 ×128 ×128</td></tr><tr><td>Conv3x3, sBN,ReLU</td><td>128 × 128× 128</td></tr><tr><td>Conv3x3</td><td>128 ×128× 64</td></tr><tr><td rowspan=\"2\">Conv</td><td>sBN,ReLU</td><td>128×128×3</td></tr><tr><td>Conv3x3,Tanh</td><td>128× 128×3</td></tr></table>",
+        "bbox": [
+            302,
+            178,
+            694,
+            516
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/9cf61cfe596f058fe9708dbfd62429b2bae28fbc38f7ed338be6d0099043a3fa.jpg",
+        "table_caption": [
+            "Table 14: ResNet Discriminator with $1 2 8 \\times 1 2 8 \\times 3$ resolution. Each ResNet block has a skipconnection that applies a 1x1 convolution with possible downsampling according to spatial dimension. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Details</td><td>Output size</td></tr><tr><td>Input image</td><td></td><td>128×128×3</td></tr><tr><td rowspan=\"3\">ResNetblock</td><td>Conv3x3</td><td>128×128×64</td></tr><tr><td>ReLU,Conv3x3</td><td>128 ×128 × 64</td></tr><tr><td>Downsample</td><td>64× 64×64</td></tr><tr><td rowspan=\"3\">ResNetblock</td><td>ReLU,Conv3x3</td><td>64×64×64</td></tr><tr><td>ReLU,Conv3x3</td><td>64 × 64×128</td></tr><tr><td>Downsample</td><td>32 × 32 × 128</td></tr><tr><td rowspan=\"3\">ResNetblock</td><td>ReLU,Conv3x3</td><td>32×32×128</td></tr><tr><td>ReLU,Conv3x3</td><td>32 × 32 × 256</td></tr><tr><td>Downsample</td><td>16 × 16 × 256</td></tr><tr><td rowspan=\"3\">ResNetblock</td><td>ReLU,Conv3x3</td><td>16×16��256</td></tr><tr><td>ReLU,Conv3x3</td><td>16 × 16 × 512</td></tr><tr><td>Downsample</td><td>8×8×512</td></tr><tr><td rowspan=\"3\">ResNet block</td><td>ReLU,Conv3x3 ReLU,Conv3x3</td><td>8×8×512 8×8×1024</td></tr><tr><td></td><td></td></tr><tr><td>Downsample</td><td>4×4×1024</td></tr><tr><td rowspan=\"2\">ResNet block</td><td>ReLU,Conv3x3</td><td>4×4×1024</td></tr><tr><td>ReLU,Conv3x3</td><td>4×4×1024</td></tr><tr><td>Fully connected</td><td>ReLU,GlobalSum pooling</td><td>1024</td></tr><tr><td colspan=\"2\">Linear</td><td>1</td></tr></table>",
+        "bbox": [
+            294,
+            622,
+            702,
+            898
+        ],
+        "page_idx": 17
+    }
+]

parse/train/pmWeMLm411_/pmWeMLm411_.md

@@ -0,0 +1,345 @@
+# Learning High-Precision Bounding Box for Rotated Object Detection via Kullback-Leibler Divergence
+
+Xue Yang1∗, Xiaojiang Yang1, Jirui Yang2, Qi $\mathbf { M i n g ^ { 3 } }$ , Wentao Wang1, Qi Tian4, Junchi Yan1†
+
+1Department of Computer Science and Engineering,   
+MoE Key Lab of Artificial Intelligence, AI Institute, Shanghai Jiao Tong University 2University of Chinese Academy of Sciences 3Beijing Institute of Technology 4Huawei Inc.   
+{yangxue-2019-sjtu, yangxiaojiang, wwt117, yanjunchi}@sjtu.edu.cn {yangjirui123, chaser.ming}@gmail.com tian.qi1@huawei.com
+
+# Abstract
+
+Existing rotated object detectors are mostly inherited from the horizontal detection paradigm, as the latter has evolved into a well-developed area. However, these detectors are difficult to perform prominently in high-precision detection due to the limitation of current regression loss design, especially for objects with large aspect ratios. Taking the perspective that horizontal detection is a special case for rotated object detection, in this paper, we are motivated to change the design of rotation regression loss from induction paradigm to deduction methodology, in terms of the relation between rotation and horizontal detection. We show that one essential challenge is how to modulate the coupled parameters in the rotation regression loss, as such the estimated parameters can influence to each other during the dynamic joint optimization, in an adaptive and synergetic way. Specifically, we first convert the rotated bounding box into a 2-D Gaussian distribution, and then calculate the Kullback-Leibler Divergence (KLD) between the Gaussian distributions as the regression loss. By analyzing the gradient of each parameter, we show that KLD (and its derivatives) can dynamically adjust the parameter gradients according to the characteristics of the object. For instance, it will adjust the importance (gradient weight) of the angle parameter according to the aspect ratio. This mechanism can be vital for high-precision detection as a slight angle error would cause a serious accuracy drop for large aspect ratios objects. More importantly, we have proved that KLD is scale invariant. We further show that the KLD loss can be degenerated into the popular $l _ { n }$ -norm loss for horizontal detection. Experimental results on seven datasets using different detectors show its consistent superiority, and codes are available at https://github.com/yangxue0827/RotationDetection.
+
+# 1 Introduction
+
+As a fundamental building block for visual analysis across aerial images, scene text etc., rotated object detection has recently been developed rapidly [1, 2, 3, 4, 5, 6], which benefit themselves from the well-established horizontal detection approaches [7, 8, 9, 10, 11]. Specifically, many works [12, 13, 14, 15] build themselves upon the previously established horizontal detection pipeline from an inductive perspective, as shown in Figure 1(a). However, these detectors are often unable to cope with challenging scenes well due to the limitations of current regression loss, such as large aspect ratio objects, dense scenes, etc., resulting in obvious disadvantages in high-precision detection.
+
+![](images/adaf3c1f2bbcb2c5599b616937bb064ee17111411b9959f879f91afd840c27ab.jpg)  
+(a) Previous methods follow the induction paradigm (b) Our proposed method adopts a deduction methodolfrom special horizontal to general rotated detection. ogy from general rotated to special horizontal detection.
+
+Figure 1: Methodological road-map difference between horizontal detection (special case) and rotation detection (general case) in the previous methods [1, 12, 13, 14, 15] and the proposed method.
+
+In this paper, we take a step back, and aim to develop (from a deductive perspective) a unified regression framework for rotation detection and its special case: horizontal detection. In fact, our new framework enjoys a coherent property that it can be degenerated into the current commonly used regression loss (e.g. $l _ { n }$ -norm) in special cases (horizontal detection), as shown in Figure 1(b).
+
+For a devising a rotation regression loss for high-precision rotation detection, one important observation is that the importance of different parameters to different types of objects can vary. For example, the angle parameter $\mathbf { \eta } ^ { ( \theta ) }$ and the center point parameter $( x , y )$ are important for large aspect ratio objects and small objects, respectively. In another word, it is conjectured that regression loss should be self-modulated during the learning process and calls for more dynamic optimization strategy.
+
+Inspired by the above ideas, we first convert the rotated bounding box $B ( x , y , h , w , \theta )$ into a 2-D Gaussian distribution $\scriptstyle { \mathcal { N } } ( \mu , \Sigma )$ . As a standard distance metric, we then use the Kullback-Leibler Divergence (KLD) [16] to calculate the distribution distance between the predicted bounding box and ground truth as the regression loss. We compare KLD with Smooth L1 loss [7] and another distance metric, Gaussian Wasserstein Distance (GWD) [5, 17], and find that KLD has a more complete parameter optimization mechanism. In particular, by analyzing the gradient of the parameters during learning, we show that the optimization of one parameter will be affected by other parameters (as the gradient weight). It means that the model will adaptively adjust the optimization strategy given a specific configuration of an object for detection, as shown can lead to excellent performance in high-precision detection. In addition, KLD is proven scale invariant, which is an important property that Smooth L1 loss and GWD do not possess. As the horizontal bounding box is a special case of the rotated bounding box, we show that KLD can also be degenerated into the $l _ { n }$ -norm loss as commonly used in existing horizontal detection pipeline. The highlights of this paper are four-folds:
+
+1) Differing from the dominant existing practices that build rotation detectors heavily upon the horizontal detectors, we develop new rotation detection loss from scratch and show that it is coherent with existing horizontal detection protocol in its degenerated case for horizontal detection.
+
+2) To achieve a more principled measurement between the prediction and ground truth, instead of computing the difference for each physically-meaningful parameter related to the bounding box which are in different scales and units, we innovatively convert the regression loss of rotation detection into the KLD of two 2-D Gaussian distributions, leading to a clean and coherent regression loss.
+
+3) Through the gradient analysis of each parameter in KLD, we further find that the self-modulated optimization mechanism of KLD greatly promotes the improvement of high-precision detection, which verify the advantage of our loss design. More importantly, we have theoretically shown (in appendix) that KLD is scale invariant for detection, which is crucial for the rotation cases.
+
+4) Extensive experimental results on seven public datasets and two popular detectors show the effectiveness of our approach, which achieves new state-of-the-art performance for rotation detection. The source codes [18] are made public available.
+
+# 2 Background
+
+We first generally discuss the related works on both horizontal and rotated object detection. Then we summarize the current design paradigm of rotation regression loss from two kinds of methodologies,
+
+![](images/4b769006e4636b5c067d44167d8d6bbee7c94f8501ed47c4364ba8b1e85fc549.jpg)  
+Figure 2: Visual comparison between Smooth L1 loss (left), GWD (middle) and KLD (right).
+
+as shown in Figure 1: one is inductive that tries to develop the general rotation detection from the special and classic horizontal detection pipeline. While the other is deductive that aims to devise a general rotation detection pipeline with horizontal detection as its special case.
+
+# 2.1 Related Works
+
+Horizontal object detection. Horizontal object detection which covers most existing detection literature, normally uses a horizontal bounding box to represent the object. The mainstream classical object detection algorithms can be roughly divided according to the following standards: Two[7, 8, 9, 11] or Single-stage [10, 19, 20] object detection, Anchor-free [21, 22, 23] or Anchor-based [8, 9, 10] object detection and CNN [8, 10, 21] or Transformer-based [24, 25] object detection. Although the pipelines may vary, the mainstream regression loss often uses the popular $l _ { n }$ -norm loss (such as smooth L1 loss) or IoU-based loss (such as GIoU [26], and DIoU [27]). These abovementioned detectors have also been widely used in other scenarios and have achieved satisfactory performance. However, horizontal detectors do not provide accurate orientation and scale information.
+
+Rotated object detection. Recent advances in rotation detection [3, 4, 12, 14, 28] are mainly driven by adapting the horizontal object detectors with rotated bounding boxes to represent multi-oriented objects. To accurately predict the rotated bounding box, most rotation detection methods extend the $l _ { n }$ -norm [12, 15, 29, 30, 31] used in horizontal detection, or construct a differentiable approximate IoU loss [3, 5, 32]. From scratch, we try to change the design of rotation regression loss from induction paradigm to deduction methodology, which in fact is a generalization to the horizontal case.
+
+In the following, we describe the existing works from the induction and deduction methodologies.
+
+# 2.2 Inductive Thinking of Loss Design: from Special Horizon to General Rotation Detection
+
+Regression loss is a vital part of most current object detection algorithms. For horizontal bounding box regression, the model [7, 8, 9, 10, 11] mainly outputs four items for location and size:
+
+$$
+t _ { x } ^ { p } = { \frac { x _ { p } - x _ { a } } { w _ { a } } } , t _ { y } ^ { p } = { \frac { y _ { p } - y _ { a } } { h _ { a } } } , t _ { w } ^ { p } = \ln \left( { \frac { w _ { p } } { w _ { a } } } \right) , t _ { h } ^ { p } = \ln \left( { \frac { h _ { p } } { h _ { a } } } \right)
+$$
+
+to match the four targets from the ground truth
+
+$$
+t _ { x } ^ { t } = \frac { x _ { t } - x _ { a } } { w _ { a } } , t _ { y } ^ { t } = \frac { y _ { t } - y _ { a } } { h _ { a } } , t _ { w } ^ { t } = \ln \left( \frac { w _ { t } } { w _ { a } } \right) , t _ { h } ^ { t } = \ln \left( \frac { h _ { t } } { h _ { a } } \right)
+$$
+
+where $x , y , h , w$ denote the center coordinates, height and width, respectively. Variables $x _ { t } , x _ { a } , x _ { p }$ are for the ground-truth box, anchor box, and predicted box, respectively (likewise for $y , w , h )$ .
+
+Extending the above horizontal case, existing rotation detection models [1, 12, 13, 14, 15] also use regression loss which simply involves an extra angle parameter $\theta$ :
+
+$$
+t _ { \theta } ^ { p } = f ( \theta _ { p } - \theta _ { a } ) , t _ { \theta } ^ { t } = f ( \theta _ { t } - \theta _ { a } )
+$$
+
+where $f ( \cdot )$ is used to deal with angular periodicity, such as trigonometric functions, modulo, etc.
+
+The overall regression loss for rotation detection is:
+
+$$
+L _ { r e g } = { l _ { n } } \mathrm { { - n o r m } } \left( \Delta t _ { x } , \Delta t _ { y } , \Delta t _ { w } , \Delta t _ { h } , \Delta t _ { \theta } \right)
+$$
+
+where $\begin{array} { r } { \Delta t { _ x } = t _ { x } ^ { p } - t _ { x } ^ { t } = \frac { \Delta x } { w _ { a } } } \end{array}$ , $\begin{array} { r } { \Delta t { _ y } = t _ { y } ^ { p } - t _ { y } ^ { t } = \frac { \Delta y } { h _ { a } } } \end{array}$ , $\Delta t _ { w } = t _ { w } ^ { p } - t _ { w } ^ { t } = \ln ( w _ { p } / w _ { t } )$ , $\Delta t _ { h } = t _ { h } ^ { p } - t _ { h } ^ { t } =$ $\ln ( h _ { p } / h _ { t } )$ , and $\Delta t _ { \theta } = t _ { \theta } ^ { p } - t _ { \theta } ^ { t } = \Delta \theta$ .
+
+It can be seen that parameters are optimized independently, making the loss (or detection accuracy) sensitive to the under-fitting of any of the parameters. This mechanism is fatal to high-precision detection. Taking the left side of Figure 2 as an example, the detection result based on the Smooth L1 loss often shows the deviation of the center point or angle. Moreover, different types of objects have different sensitivity to these five parameters. For example, the angle parameter is very important for detecting objects with large aspect ratios. This requires to select an appropriate set of weights given a specific single object sample during the training, which is nontrivial or even unrealistic.
+
+# 2.3 Deductive Thinking of Loss Design: from General Rotation to Special Horizon Detection
+
+To break the original inductive design paradigm, we adopt deductive paradigm to construct more accurate rotation regression loss. Here we rephrase the main idea in the recent work [5], which converts a arbitrary-oriented bounding box $B ( x , y , h , w , \theta )$ into a 2-D Gaussian $\scriptstyle { \mathcal { N } } ( { \boldsymbol { \mu } } , { \boldsymbol { \Sigma } } )$ , as illustracted in Figure 3. Then the distance between two Gaussian is calculated as the final loss. Specifically, the conversion is:
+
+![](images/104967e9905e1aafd7ed866bb4956ee3996ceb2a1a928f0d6e52ebc6bdaebedc.jpg)  
+Figure 3: Top: rotated box $B ( x , y , h , w , \theta )$ . D Gaussian dist. $\mathcal { N } ( \pmb { \mu } , \pmb { \Sigma } )$ .
+
+$$
+\begin{array} { r l r } {  { \mu = ( x , y ) ^ { \top } } } \\ & { } & { \mathbf { B } \mathbf { 0 } \mathbf { t } \mathbf { 0 } \mathbf { m } : 2 ^ { - } } \\ & { } & { \quad \mathbf { \Sigma } \mathbf { \Sigma } ^ { 1 / 2 } = \mathbf { R } \mathbf { A } \mathbf { R } ^ { \top } = ( \begin{array} { c c } { \cos \theta } & { - \sin \theta } \\ { \sin \theta } & { \cos \theta } \end{array} ) ( \begin{array} { c c } { \frac { w } { 2 } } & { 0 } \\ { 0 } & { \frac { h } { 2 } } \end{array} ) ( \begin{array} { c c } { \cos \theta } & { \sin \theta } \\ { - \sin \theta } & { \cos \theta } \end{array} ) } \\ & { } & { = ( \begin{array} { c c } { \frac { w } { 2 } \cos ^ { 2 } \theta + \frac { h } { 2 } \sin ^ { 2 } \theta } & { \frac { w - h } { 2 } \cos \theta \sin \theta } \\ { \frac { w - h } { 2 } \cos \theta \sin \theta } & { \frac { w } { 2 } \sin ^ { 2 } \theta + \frac { h } { 2 } \cos ^ { 2 } \theta } \end{array} ) _ { c \in \mathrm { \Delta } } } \end{array}
+$$
+
+where $\mathbf { R }$ represents the rotation matrix, and $\pmb { \Lambda }$ represents the diagonal matrix of eigenvalues.
+
+The recent work [5] analyzes that the introduction of $\scriptstyle { \mathcal { N } } ( \mu , \Sigma )$ can solve the inconsistency between metric and loss, boundary discontinuity and square-like problem. On this basis, we further study how to design high-precision detection regression loss through new parameter space. Our view is that the self-modulated mechanism is positively correlated with the final high-precision performance.
+
+Gaussian Wasserstein Distance. The Wasserstein distance [5, 17] between two probability measures $\mathbf { X } _ { p } \sim \mathcal { N } _ { p } ( \pmb { \mu } _ { p } , \pmb { \Sigma } _ { p } )$ and $\mathbf { X } _ { t } \sim \mathcal { N } _ { t } ( \mu _ { t } , \Sigma _ { t } )$ expressed as:
+
+$$
+\begin{array} { r } { \mathbf { D } _ { w } ( { \mathcal N } _ { p } , { \mathcal N } _ { t } ) ^ { 2 } = \underbrace { \| \mu _ { p } - \mu _ { t } \| _ { 2 } ^ { 2 } } _ { \mathrm { c e n t e r ~ d i s t a n c e } } + \underbrace { { \mathbf { T r } } ( \Sigma _ { p } + \Sigma _ { t } - 2 \big ( \Sigma _ { p } ^ { 1 / 2 } \Sigma _ { t } \Sigma _ { p } ^ { 1 / 2 } \big ) ^ { 1 / 2 } ) } _ { \mathrm { c o u p l i n g ~ t e r m s ~ a b o u t } ~ h _ { p } , ~ w _ { p } ~ \mathrm { a n d } ~ \theta _ { p } } } \end{array}
+$$
+
+Eq. 6 shows that the Gaussian Wasserstein Distance (GWD) is mainly divided into two parts: the distance between the center points $( x , y )$ and the coupling terms about $h$ , $w$ and $\theta$ . Accordingly, the regression loss based on GWD can be regarded as a semi-coupled loss. Although GWD can greatly improve the performance of high-precision rotation detection due to the coupling between part of the parameters, the independent optimization of the center point make the detection result slightly shifted (see Figure 2). Note that GWD is not scale invariant, which is not detection friendly.
+
+When all the boxes are horizontal $\theta = 0 ^ { \circ }$ ), Eq. 6 can be further simplified:
+
+$$
+\begin{array} { r l } & { \mathbf { D } _ { w } ^ { h } ( { \mathcal N } _ { p } , { \mathcal N } _ { t } ) ^ { 2 } = \lVert \mu _ { p } - \mu _ { t } \rVert _ { 2 } ^ { 2 } + \lVert \Sigma _ { p } ^ { 1 / 2 } - \Sigma _ { t } ^ { 1 / 2 } \rVert _ { F } ^ { 2 } } \\ & { \qquad = ( x _ { p } - x _ { t } ) ^ { 2 } + ( y _ { p } - y _ { t } ) ^ { 2 } + \left( ( w _ { p } - w _ { t } ) ^ { 2 } + ( h _ { p } - h _ { t } ) ^ { 2 } \right) / 4 } \\ & { \qquad = l _ { 2 } \mathbf { - n o r m } ( \Delta x , \Delta y , \Delta w / 2 , \Delta h / 2 ) } \end{array}
+$$
+
+where $\| \cdot \| _ { F }$ is the Frobenius norm. Although Eq. 7 can still be used as the regression loss of horizontal detection, Eq. 4 and 7 are not completely consistent.
+
+Although GWD scheme has played a preliminary exploration of the deductive paradigm, it does not focus on achieving high-precision detection and scale invariance. In the following, we will propose our new approach based on the Kullback-Leibler divergence (KLD) [16].
+
+# 3 Proposed Approach
+
+Kullback-Leibler Divergence. To explore the more appropriate regression loss, we adopt the Kullback-Leibler divergence (KLD) [16]. Similarly, the KLD between two 2-D Gaussian is:
+
+$$
+\mathbf D _ { k l } ( \mathcal N _ { p } | | \mathcal N _ { t } ) = \frac { 1 } { 2 } ( \mu _ { p } - \mu _ { t } ) ^ { \top } \Sigma _ { t } ^ { - 1 } ( \mu _ { p } - \mu _ { t } ) + \frac { 1 } { 2 } \mathbf T \mathbf r ( \Sigma _ { t } ^ { - 1 } \Sigma _ { p } ) + \frac { 1 } { 2 } \ln \frac { | \Sigma _ { t } | } { | \Sigma _ { p } | } - 1
+$$
+
+{zcoupling terms about hp, wp and $\theta _ { p }$
+
+or
+
+$$
+\mathbf { D } _ { k l } ( { \mathcal { N } } _ { t } | | { \mathcal { N } } _ { p } ) = { \frac { 1 } { 2 } } ( \mu _ { p } - \mu _ { t } ) ^ { \top } \Sigma _ { p } ^ { - 1 } ( \mu _ { p } - \mu _ { t } ) + { \frac { 1 } { 2 } } \mathbf { T r } ( \Sigma _ { p } ^ { - 1 } \Sigma _ { t } ) + { \frac { 1 } { 2 } } \ln { \frac { | \Sigma _ { p } | } { | \Sigma _ { t } | } } - 1
+$$
+
+It can be seen that each item in $\mathbf { D } _ { k l } ( \mathcal { N } _ { t } | | \mathcal { N } _ { p } )$ is composed of partial parameter coupling, which makes all parameters form a chain coupling relationship. In the optimization process of the KLD-based detector, the parameters influence each other and are jointly optimized which make optimization mechanism of the model is self-modulated. In contrast, $\dot { \mathbf Ḋ \ Ḋ \boldsymbol Ḋ k l Ḍ Ḍ } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } )$ and GWD are both semicoupled, but $\mathbf { D } _ { k l } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } )$ has a better central point optimization mechanism.
+
+Although KLD is asymmetric, we find that the optimization principles of these two forms are similar by analyzing the gradients of various parameters and experimental results. Take the relatively simple $\mathbf { D } _ { k l } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } )$ as an example, according to Eq. 5, each item of Eq. 8 can be expressed as
+
+$$
+\left( \mu _ { p } - \mu _ { t } \right) ^ { \top } \Sigma _ { t } ^ { - 1 } ( \mu _ { p } - \mu _ { t } ) = \frac { 4 \left( \Delta x \cos \theta _ { t } + \Delta y \sin \theta _ { t } \right) ^ { 2 } } { w _ { t } ^ { 2 } } + \frac { 4 \left( \Delta y \cos \theta _ { t } - \Delta x \sin \theta _ { t } \right) ^ { 2 } } { h _ { t } ^ { 2 } } .
+$$
+
+$$
+\mathbf { T r } ( \Sigma _ { t } ^ { - 1 } \Sigma _ { p } ) = \frac { h _ { p } ^ { 2 } } { w _ { t } ^ { 2 } } \sin ^ { 2 } \Delta \theta + \frac { w _ { p } ^ { 2 } } { h _ { t } ^ { 2 } } \sin ^ { 2 } \Delta \theta + \frac { h _ { p } ^ { 2 } } { h _ { t } ^ { 2 } } \cos ^ { 2 } \Delta \theta + \frac { w _ { p } ^ { 2 } } { w _ { t } ^ { 2 } } \cos ^ { 2 } \Delta \theta
+$$
+
+$$
+\ln \frac { | \Sigma _ { t } | } { | \Sigma _ { p } | } = \ln \frac { h _ { t } ^ { 2 } } { h _ { p } ^ { 2 } } + \ln \frac { w _ { t } ^ { 2 } } { w _ { p } ^ { 2 } }
+$$
+
+where $\Delta x = x _ { p } - x _ { t } , \Delta y = y _ { p } - y _ { t } , \Delta \theta = \theta _ { p } - \theta _ { t }$ .
+
+Analysis of high-precision detection. Without loss of generality, we set $\theta _ { t } = 0 ^ { \circ }$ , then
+
+$$
+\frac { \partial \mathbf { D } _ { k l } ( \mu _ { p } ) } { \partial \mu _ { p } } = \left( \frac { 4 } { w _ { t } ^ { 2 } } \Delta x , \frac { 4 } { h _ { t } ^ { 2 } } \Delta y \right) ^ { \top }
+$$
+
+The weights $1 / w _ { t } ^ { 2 }$ and $1 / h _ { t } ^ { 2 }$ will make the model dynamically adjust the optimization of the object position according to the scale. For example, when the object scale is small or an edge is too short, the model will pay more attention to the optimization of the offset of the corresponding direction. For this kind of object, a slight deviation on the corresponding direction will often cause a sharp drop in IoU. When ${ \theta } _ { t } \ne 0 ^ { \circ }$ , the gradient of the object offset ( $\Delta x$ and $\Delta y$ ) will be dynamically adjusted according to the $\theta _ { t }$ for better optimization. In contrast, the gradient of the center point in GWD and $\mathrm { L _ { 2 } }$ -norm are ∂Dw(µp)∂µ = (2∆x, 2∆y)> and $\begin{array} { r } { \frac { \partial L _ { 2 } ( \mu _ { p } ) } { \partial \mu _ { p } } = ( \frac { 2 } { w _ { a } ^ { 2 } } \Delta x , \frac { 2 } { h _ { a } ^ { 2 } } \Delta y ) ^ { \top } } \end{array}$ . The former cannot adjust the dynamic gradient according to the length and width of the object. The latter is based on the length and width of the anchor $( w _ { a } , h _ { a } )$ to adjust the gradient instead of the target object $( w _ { t } , h _ { t } )$ , which is almost ineffective for those detectors [3, 13, 15, 28, 29, 33, 34] that use horizontal anchors for rotation detection. More importantly, they are not related to the angle of the target object. Therefore, the detection result of the GWD-based and $\mathrm { L } _ { n }$ -norm models will show a slight deviation, while the detection result of the KLD-based model is quite accurate, as shown in Figure 2.
+
+For $h _ { p }$ and $w _ { p }$ , we have
+
+$$
+\frac { \partial \mathbf { D } _ { k l } ( \Sigma _ { p } ) } { \partial \ln h _ { p } } = \frac { h _ { p } ^ { 2 } } { h _ { t } ^ { 2 } } \cos ^ { 2 } \Delta \theta + \frac { h _ { p } ^ { 2 } } { w _ { t } ^ { 2 } } \sin ^ { 2 } \Delta \theta - 1 , \quad \frac { \partial \mathbf { D } _ { k l } ( \Sigma _ { p } ) } { \partial \ln w _ { p } } = \frac { w _ { p } ^ { 2 } } { w _ { t } ^ { 2 } } \cos ^ { 2 } \Delta \theta + \frac { w _ { p } ^ { 2 } } { h _ { t } ^ { 2 } } \sin ^ { 2 } \Delta \theta - 1
+$$
+
+On the one hand, the optimization of the $h _ { p }$ and $w _ { p }$ is affected by the $\Delta \theta$ . When $\Delta \theta \ : = \ : 0 ^ { \circ }$ , $\begin{array} { r } { \frac { \partial \mathbf { D } _ { k l } \left( \pmb { \Sigma } _ { p } \right) } { \partial \ln h _ { p } } = \frac { h _ { p } ^ { 2 } } { h _ { t } ^ { 2 } } - 1 , \frac { \partial \mathbf { D } _ { k l } \left( \pmb { \Sigma } _ { p } \right) } { \partial \ln w _ { p } } = \frac { w _ { p } ^ { 2 } } { w _ { t } ^ { 2 } } - 1 } \end{array}$ , which means that the smaller targeted height or width leads to heavier penalty on its matching loss. This is desirable, as smaller height or width needs higher matching precision. On the other hand, the optimization of $\Delta \theta$ is also affected by $h _ { p }$ and $w _ { p }$ :
+
+$$
+\frac { \partial \mathbf { D } _ { k l } \bigl ( \Sigma _ { p } \bigr ) } { \partial \theta _ { p } } = \biggl ( \frac { h _ { p } ^ { 2 } - w _ { p } ^ { 2 } } { w _ { t } ^ { 2 } } + \frac { w _ { p } ^ { 2 } - h _ { p } ^ { 2 } } { h _ { t } ^ { 2 } } \biggr ) \sin 2 \Delta \theta
+$$
+
+when $w _ { p } = w _ { t } , h _ { p } = h _ { t }$ , then $\begin{array} { r } { \frac { \partial \mathbf { D } _ { k l } ( \Sigma _ { p } ) } { \partial \theta _ { p } } = \left( \frac { h _ { t } ^ { 2 } } { w _ { t } ^ { 2 } } + \frac { w _ { t } ^ { 2 } } { h _ { t } ^ { 2 } } - 2 \right) \sin 2 \Delta \theta \ge \sin 2 \Delta \theta } \end{array}$ , the condition for the equality sign is $h _ { t } = w _ { t }$ . This shows that the larger the aspect ratio of the object, the model will pay more attention to the optimization of the angle. This is the main reason why the KLD-based model has a huge advantage in high-precision detection indicators as a slight angle error would cause a serious accuracy drop for large aspect ratios objects. Through the above analysis, we find that when one of the parameters is optimized, the other parameters will be used as its weight to dynamically adjust the optimization rate. In other words, the optimization of parameters is no longer independent, that is, optimizing one parameter will also promote the optimization of other parameters. The optimization of this virtuous circle is the key to KLD as an excellent rotation regression loss. In addition, $\mathbf { D } _ { k l } ( \mathcal { N } _ { t } | | \mathcal { N } _ { p } )$ has similar properties, refer to appendix for details.
+
+Scale invariance. For a full-rank matrix M, $| \mathbf { M } | \neq 0$ , we have $\mathbf { D } _ { k l } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) = \mathbf { D } _ { k l } ( \mathcal { N } _ { p ^ { \prime } } | | \mathcal { N } _ { t ^ { \prime } } )$ , where $\mathbf { X } _ { p ^ { \prime } } = \mathbf { M } \mathbf { X } _ { p } \sim { \mathcal { N } } _ { p } ( \mathbf { M } { \pmb { \mu } } _ { p } , \mathbf { M } { \pmb { \Sigma } } _ { p } \mathbf { M } ^ { \top } )$ , $\mathbf { X } _ { t ^ { \prime } } = \mathbf { M } \mathbf { X } _ { t } \sim { \mathcal { N } } _ { t } ( \mathbf { M } { \pmb { \mu } } _ { t } , \mathbf { M } \pmb { \Sigma } _ { t } \mathbf { M } ^ { \top } )$ . Therefore, the affine invariance (including scale invariance when $\mathbf { M } = k \mathbf { I }$ , where I denotes identity matrix) of KLD can be proven (see proof in appendix). Compared with $\mathrm { L } _ { n }$ -norm and GWD, KLD is more suitable for replacing the non-differentiable rotated IoU loss for its consistency with detection metric.
+
+Horizontal special case. For horizontal detection, combine Eq. 8 to Eq. 12, we have
+
+$$
+\begin{array} { c } { { { \bf D } _ { k l } ^ { h } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) = \displaystyle \frac { 1 } { 2 } \left( \frac { w _ { p } ^ { 2 } } { w _ { t } ^ { 2 } } + \frac { h _ { p } ^ { 2 } } { h _ { t } ^ { 2 } } + \frac { 4 \Delta ^ { 2 } x } { w _ { t } ^ { 2 } } + \frac { 4 \Delta ^ { 2 } y } { h _ { t } ^ { 2 } } + \mathrm { l n } \frac { w _ { t } ^ { 2 } } { w _ { p } ^ { 2 } } + \mathrm { l n } \frac { h _ { t } ^ { 2 } } { h _ { p } ^ { 2 } } - 2 \right) } } \\ { { = 2 l _ { 2 } { \bf - n } { \mathrm { o r m } } ( \Delta t _ { x } , \Delta t _ { y } ) + l _ { 1 } { \bf - n } { \mathrm { o r m } } ( \Delta t _ { w } , \Delta t _ { h } ) + \displaystyle \frac { 1 } { 2 } l _ { 2 } { \bf - n } { \mathrm { o r m } } ( \frac { 1 } { \Delta t _ { w } } , \frac { 1 } { \Delta t _ { h } } ) - 1 } } \end{array}
+$$
+
+where the first two terms of Eq. 16 are very similar to Eq. 4, and the divisor part of the two terms $x$ and $y$ is the main difference $\frac { \Delta x } { w _ { t } }$ vs. ∆x ).
+
+Variants of KLD. We have also introduced some variants [35, 36] of KLD to further verify the influence of asymmetry on rotation detection can be ignored. The variants mainly including
+
+$$
+\begin{array} { r l } & { \mathbf { D } _ { k l _ { - } m i n ( m a x ) } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) = \operatorname* { m i n } ( \operatorname* { m a x } ) \left( \mathbf { D } _ { k l } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) , \mathbf { D } _ { k l } ( \mathcal { N } _ { t } | | \mathcal { N } _ { p } ) \right) } \\ & { \qquad \mathbf { D } _ { j s } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) = \displaystyle \frac { 1 } { 2 } \left( \mathbf { D } _ { k l } \left( \mathcal { N } _ { t } | | \frac { \mathcal { N } _ { p } + \mathcal { N } _ { t } } { 2 } \right) + \mathbf { D } _ { k l } \left( \mathcal { N } _ { p } | | \frac { \mathcal { N } _ { p } + \mathcal { N } _ { t } } { 2 } \right) \right) } \\ & { \qquad \mathbf { D } _ { j e f } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) = \mathbf { D } _ { k l } ( \mathcal { N } _ { t } | | \mathcal { N } _ { p } ) + \mathbf { D } _ { k l } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) } \end{array}
+$$
+
+Rotation regression loss. The whole training process of detector is as follows: i) predict offset $( \mathit { t } _ { x } ^ { p } , \mathit { t } _ { y } ^ { p } , \mathit { t } _ { w } ^ { p } , \mathit { t } _ { h } ^ { p } , \mathit { t } _ { \theta } ^ { p } )$ ; ii) decode prediction box; iii) convert prediction box and target ground-truth into Gaussian distribution; iv) calculate KLD of two Gaussian distributions. Therefore, the inference time remains unchanged. We normalize the distance function as our final regression loss $\mathcal { L } _ { r e g }$ :
+
+$$
+\mathcal { L } _ { r e g } = 1 - \frac { 1 } { \tau + f ( \mathbf { D } ) } , \quad \tau \geq 1
+$$
+
+where $f ( \cdot )$ denotes a non-linear function to transform the distance $\mathbf { D }$ to make the loss more smooth and expressive. In this paper, we mainly use two nonlinear functions, $s q r t ( \mathbf { D } )$ and $\ln ( \mathbf { D } + 1 )$ . The hyperparameter $\tau$ modulates the entire loss. The multi-task loss is:
+
+$$
+\mathcal { L } = \frac { \lambda _ { 1 } } { N _ { p o s } } \sum _ { n = 1 } ^ { N _ { p o s } } \mathcal { L } _ { r e g } ( b _ { n } , g t _ { n } ) + \frac { \lambda _ { 2 } } { N } \sum _ { n = 1 } ^ { N } \mathcal { L } _ { c l s } ( p _ { n } , t _ { n } )
+$$
+
+where $N _ { p o s }$ and $N$ indicate the number of positive and all anchors. $b _ { n }$ denotes the $n$ -th bounding box, $g t _ { n }$ is the $n$ -th target ground-truth. $t _ { n }$ denotes the label of $n$ -th object, $p _ { n }$ is the $n$ -th probability distribution of various classes calculated by sigmoid function. The hyper-parameter $\lambda _ { 1 }$ , $\lambda _ { 2 }$ control the trade-off and are set to $\{ 2 , 1 \}$ by default. The classification loss $L _ { c l s }$ is set as focal loss [10].
+
+Table 1: Ablation study of the loss form and hyperparameter on HRSC2016.   
+
+<table><tr><td rowspan="2">Loss</td><td rowspan="2">Dkl</td><td rowspan="2">f(Dkl)</td><td colspan="4">LG(f(Dkl),T)</td></tr><tr><td>T=1</td><td>T=2</td><td>T=3</td><td>T=5</td></tr><tr><td>f(Dkl)=sqrt(Dkt) f(Dkl)=log(Dkl+1)</td><td>0.20</td><td>82.96 83.23</td><td>84.85 85.25</td><td>84.15 83.63</td><td>75.23 80.79</td><td>73.32 73.44</td></tr></table>
+
+Table 2: Ablation of different KLD-based regression loss form. The based detector is RetinaNet.   
+
+<table><tr><td>Dataset</td><td>Dkz(NplINt)</td><td>Dkt(Nt|/Np)</td><td>Dkl_min(NpllNt)</td><td>Dkl_max(NpllNt)</td><td>Djs(NplINt)</td><td>Djeffreys(Npl/Nt)</td></tr><tr><td>DOTA-v1.0</td><td>70.17</td><td>70.64</td><td>70.71</td><td>70.55</td><td>69.67</td><td>70.56</td></tr><tr><td>HRSC2016</td><td>82.83</td><td>83.82</td><td>83.60</td><td>82.70</td><td>84.06</td><td>83.66</td></tr></table>
+
+Table 3: Ablation study of normalization. The based detector is RetinaNet.   
+
+<table><tr><td rowspan="2">Loss</td><td rowspan="2">Norm by Eq. 18</td><td colspan="3">HRSC2016</td><td>DOTA-v1.0</td></tr><tr><td>Hmean50</td><td>Hmean75</td><td>Hmean50:95</td><td>AP50</td></tr><tr><td rowspan="2">Smooth L1</td><td>w/</td><td>78.99</td><td>43.12</td><td>43.47</td><td>64.95</td></tr><tr><td>w/o</td><td>84.80</td><td>48.42</td><td>47.76</td><td>65.73</td></tr></table>
+
+# 4 Experiment
+
+# 4.1 Datasets and Implementation Details
+
+Our experiments are conducted over a variety of datasets, including three large-scale public datasets for aerial images i.e. DOTA [37], UCAS-AOD [38], HRSC2016 [39], as well as scene text dataset ICDAR2015 [40], MLT [41] and MSRA-TD500 [42].
+
+DOTA is one of the largest dataset for oriented object detection in aerial images with three released versions: DOTA-v1.0, DOTA-v1.5 and DOTA- $\mathbf { \sigma } \cdot \mathbf { v } 2 . 0$ . DOTA-v1.0 contains 15 common categories, 2,806 images and 188,282 instances. The proportions of the training set, validation set, and testing set in DOTA-v1.0 are 1/2, 1/6, and $1 / 3$ , respectively. In contrast, DOTA-v1.5 uses the same images as DOTA-v1.0, but extremely small instances (less than 10 pixels) are also annotated. Moreover, a new category, containing 402,089 instances in total is added in this version. While DOTA- $\mathbf { \sigma } \cdot \mathbf { v } 2 . 0$ contains 18 common categories, 11,268 images and 1,793,658 instances. Compared to DOTA-v1.5, it further includes the new categories. The 11,268 images in DOTA- $\mathbf { \sigma } \cdot \mathbf { v } 2 . 0$ are split into training, validation, test-dev, and test-challenge sets. We divide the images into $6 0 0 \times 6 0 0$ subimages with an overlap of 150 pixels and scale it to $8 0 0 \times 8 0 0$ , in line with the cropping protocol in literature [5, 28].
+
+UCAS-AOD contains 1,510 aerial images of approximately $6 5 9 \times 1$ , 280 pixels, with two categories of 14,596 instances in total. In line with [31, 37], we randomly select 1,110 for training and 400 for testing. HRSC2016 contains images from two scenarios including ships on sea and ships close inshore. The training, validation and test set include 436, 181 and 444 images.
+
+ICDAR2015, MLT and MSRA-TD500 are commonly used for oriented scene text detection and spotting. ICDAR2015 includes 1,000 training images and 500 testing images. ICDAR2017 MLT is a multi-lingual text dataset, which includes 7,200 training images, 1,800 validation images and 9,000 testing images. MSRA-TD500 dataset consists of 300 training images and 200 testing images.
+
+We use Tensorflow [43] to implement the proposed methods on a server with Tesla V100 and 32G memory. The experiments are all initialized by ResNet50 [44] by default unless otherwise specified. Weight decay and momentum are set 0.0001 and 0.9, respectively. We employ MomentumOptimizer over 8 GPUs with a total of 8 images per minibatch (1 image per GPU).
+
+All the used datasets are trained by 20 epochs in total, and the learning rate is reduced tenfold at 12 epochs and 16 epochs, respectively. The initial learning rate is set to 5e-4. The number of image iterations per epoch for DOTA-v1.0, DOTA-v1.5, DOTA-v2.0, UCAS-AOD, HRSC2016, ICDAR2015, MLT and MSRA-TD500 are 54k, 64k, 80k, 5k, 10k, 10k, 10k and $5 \mathrm { k }$ respectively, and doubled if data augmentation (include random rotation, flipping, and graying) or multi-scale training is used.
+
+# 4.2 Ablation Study and Further Comparison
+
+Regression loss form and hyperparameter. Table 1 compares three forms of KLD-based regression loss on HRSC2016, including $\mathbf { D } _ { k l }$ , $f ( \mathbf Ḋ x Ḍ _ { k l } )$ and $\mathcal { L } _ { r e g } ( f ( \bar { \mathbf { D } _ { k l } } ) , \tau )$ . Due to extreme sensitivity to large errors, the performance of $\mathbf { D } _ { k l }$ is extremely poor, only ${ \bf 0 . 2 0 \% }$ . Through a simple nonlinear linear transformation, the performance can be increased to $\mathbf { 8 2 . 9 6 \% }$ and $8 3 . 2 3 \%$ corresponding to sqrt and log. We further perform a detailed hyperparameter experiment on the loss $\mathcal { L } _ { r e g }$ proposed in this paper, and the performance reaches the optimal when $\tau = 1$ , $f ( \mathbf { D } _ { k l } ) = \log ( \mathbf { D } _ { k l } ^ { - } + 1 )$ , about $8 5 . 2 5 \%$ . Keeping the same loss pattern, we compare six KLD-based distance functions in Table 2, and conclude that the asymmetry of KLD does not have much impact on performance. In subsequent experiments, we use $\mathcal { L } _ { r e g } ( \log ( \mathbf { D } _ { k l } ( \mathcal { N } _ { p } | | \mathcal { N } _ { t } ) ) , 1 )$ as the basic setting.
+
+Table 4: High-precision detection experiment under different regression loss. ‘R’, ‘F’ and ‘G’ indicate random rotation, flipping, and graying, respectively. The resolution of HRSC2016, MSRA-TD500 and ICDAR2015 are $5 0 0 \times 5 0 0$ , $8 0 0 \times 1 , 0 0 0$ and $8 0 0 \times 1 , 0 0 0$ , respectively.   
+
+<table><tr><td>Method</td><td>Dataset</td><td>Data Aug.</td><td>Reg. Loss</td><td>Hmean50/AP50</td><td>Hmean60/AP60</td><td>Hmean75/AP75</td><td>Hmeang5/AP85</td><td>Hmean50:95/AP50:95</td></tr><tr><td rowspan="2">RetinaNet</td><td rowspan="4">HRSC2016</td><td rowspan="4"></td><td>84.28</td><td>74.74</td><td>48.42</td><td>12.56</td><td></td><td>47.76</td></tr><tr><td>Smooth L1 GWD KLD</td><td>85.56 (+1.28)</td><td>84.04 (+9.30)</td><td>60.31 (+11.89)</td><td>17.14 (+4.58)</td><td>52.89 (+5.13)</td></tr><tr><td>R+F+G</td><td>87.45 (+3.17)</td><td>86.72 (+11.98)</td><td>72.39 (+23.97)</td><td>27.68 (+15.12)</td><td></td><td>57.80 (+10.04)</td></tr><tr><td>Smooth L1 GWD</td><td>88.52 89.43 (+0.91)</td><td>79.01 88.89 (+9.88)</td><td>43.42 65.88 (+22.46)</td><td>4.58</td><td></td><td>46.18 56.07 (+9.89)</td></tr><tr><td rowspan="6">RDet RetinaNet</td><td rowspan="2">MSRA-TD500</td><td>R+F</td><td>KLD</td><td>89.97 (+1.45)</td><td>89.73 (+10.72)</td><td>77.38 (+33.96)</td><td>15.02 (+10.44) 25.12 (+20.54)</td><td>61.40 (+15.22)</td></tr><tr><td>Smooth L1</td><td>70.98</td><td>62.42</td><td></td><td>36.73</td><td>12.56</td><td>37.89</td></tr><tr><td rowspan="6"></td><td rowspan="2"></td><td>GWD</td><td>76.76 (+5.78)</td><td>68.58 (+6.16)</td><td>44.21 (+7.48)</td><td>17.75 (+5.19)</td><td>43.62 (+5.73)</td></tr><tr><td>KLD</td><td>76.96 (+5.98)</td><td>70.08 (+7.66)</td><td>46.95 (+10.22)</td><td>19.59 (+7.03)</td><td>45.24 (+7.35)</td></tr><tr><td rowspan="2">F</td><td>Smooth L1</td><td>69.78</td><td>64.15</td><td>36.97</td><td>8.71</td><td>37.73</td></tr><tr><td>GWD</td><td>74.29 (+4.51)</td><td>68.34 (+4.19)</td><td>43.39 (+6.42)</td><td>10.50 (+1.79)</td><td>41.68 (+3.95)</td></tr><tr><td rowspan="2"></td><td>KLD</td><td>75.32 (+5.54)</td><td>69.94 (+5.79)</td><td>44.46 (+7.49)</td><td>10.70 (+1.99)</td><td>42.68 (+4.95)</td></tr><tr><td>Smooth L1</td><td>74.83</td><td>69.46</td><td>42.02</td><td>11.59</td><td>41.98</td></tr><tr><td rowspan="6">RDet</td><td rowspan="2">R+F ICDAR2015</td><td>GWD</td><td>76.15 (+1.32)</td><td>71.26 (+1.80)</td><td>45.59 (+3.57)</td><td>11.65 (+0.06)</td><td>43.58 (+1.60)</td></tr><tr><td>KLD</td><td>77.92 (+3.09)</td><td>72.77 (+3.31)</td><td>43.27 (+1.25)</td><td>11.09 (-0.50)</td><td>43.65 (+1.67)</td></tr><tr><td rowspan="2">F</td><td>Smooth L1</td><td>74.28</td><td>68.12</td><td>35.73</td><td>8.01</td><td>39.10</td></tr><tr><td>GWD</td><td>75.59 (+1.31)</td><td>68.36 (+0.24)</td><td>40.24 (+4.51)</td><td>9.15 (+1.14)</td><td>40.80 (+1.70)</td></tr><tr><td rowspan="2"></td><td>KLD</td><td>77.72 (+2.43)</td><td>71.99 (+3.87)</td><td>43.95 (+8.22)</td><td>10.43 (+2.42)</td><td>43.29 (+4.19)</td></tr><tr><td>Smooth L1</td><td>75.53</td><td>69.69</td><td>37.69</td><td>9.03</td><td>40.56</td></tr><tr><td rowspan="2"></td><td rowspan="2">R+F</td><td>GWD</td><td>77.09 (+1.56)</td><td>71.52 (+1.83)</td><td>41.08 (+3.39)</td><td>10.10 (+1.07)</td><td>42.17 (+1.61)</td></tr><tr><td>KLD</td><td>79.63 (+4.63)</td><td>73.30 (+3.61)</td><td>43.51 (+5.82)</td><td>10.61 (+1.58)</td><td>43.61 (+3.05)</td></tr></table>
+
+Ablation study of normalization. As mentioned above, the use of Eq. 18 is to smooth its excessively rapid growth trend and play a role of normalization. This extra normalization questions if the KLD is actually contributing or simply produces noise in the results. In order to further prove that our method is indeed effective, we also perform a normalization operation on the Smooth L1 loss to eliminate the interference caused by normalization. As shown in Table 3, there is a significant drop in performance after using the normalization. The above experimental results prove that the effectiveness of KLD does not come from Eq. 18.
+
+High-precision detection experiment. We expect that the designed rotation regression loss can show advantages in high-precision detection. Table 4 shows the comparison of the high-precision detection results of three different regression losses using Smooth L1, GWD and KLD on different datasets and different detectors. For the HRSC2016 dataset containing a large number of ship with large aspect ratios, GWD-based RetinaNet has a $1 1 . 8 9 \%$ improvement over Smooth L1 on $\mathsf { A P } _ { 7 5 }$ , KLD even gets a $2 3 . 9 7 \%$ gain. Even with a stronger $\mathbb { R } ^ { 3 }$ Det detector, KLD and GWD still increased by $3 3 . 9 6 \%$ and $2 2 . 4 6 \%$ in $\mathsf { A P } _ { 7 5 }$ , and $1 5 . 2 2 \%$ and $9 . 8 9 \%$ in ${ \mathrm { A P } } _ { 5 0 : 9 5 }$ . The same experimental conclusion are also reflected in the other two scene text datasets MASR-TF500 and ICDAR2015, which is KLD $> \mathrm { G W D } > \mathrm { S m o o t h ~ L 1 }$ 1. In general, the self-modulation optimization mechanism has a significant help for high-precision detection. For a more intuitive comparison, we visually compare these three regression losses, as shown in Figure 2. Since the center point $( x , y )$ parameters in Smooth L1 Loss and GWD are independently optimized, their prediction results are slightly shifted. In contrast, the KLD-based prediction results are closer to the object boundary and show strong robustness in dense scenes. Similarly, GWD-based or KLD-based model has more accurate angle prediction capabilities than Smooth L1-based model due to their angle parameters $( \theta )$ are not independently optimized.
+
+Ablation study on more datasets. To make the results more credible, we continue to verify on the other five datasets, as shown in Table 5. The improvement of KLD on the three data sets of MLT, UCAS-AOD and DOTA-v1.0 is still considerable, with an increase of $9 . 1 7 \%$ , $1 . 5 8 \%$ , and $5 . 5 5 \%$ respectively. Note that for DOTA-v1.5 and DOTA- $\mathbf { \sigma } \cdot \mathbf { v } 2 . 0$ , which contain a large number of small objects (less than 10 pixels), KLD has achieved significant gains of $3 . 6 3 \%$ and $3 . 5 3 \%$ .
+
+Comparison of peer methods. Table 6 compares the six peer techniques, including IoU-Smooth L1 Loss [3], Modulated loss [45], RIL [34], CSL [4, 47], DCL [46], and GWD [5] on DOTA-v1.0. For fairness, these methods are all implemented on the same baseline method, and are trained and tested under the same environment and hyperparameters. We detail the accuracy of the seven categories, including large aspect ratio (e.g. BR, SV, LV, SH, HA) and square-like object (e.g. ST, RD), which can better reflect the real-world challenges and advantages of our method. Without bells and whistles, the combination of RetinaNet and KLD directly surpasses $\mathrm { R ^ { 3 } D e t }$ $( 7 1 . 2 8 \%$ vs. $7 0 . 6 6 \%$ in $\mathsf { A P } _ { 5 0 }$ and $6 9 . 4 1 \%$ vs. $6 8 . 3 1 \%$ in $7 { \mathrm { - } } \mathrm { A P _ { 5 0 } } .$ ). Even combined with ${ \tt R } ^ { \mathrm { 3 } } \mathrm { D e t }$ , KLD can still further improve performance of the large aspect ratio object $2 . 8 2 \%$ in $7 { \mathrm { - A P } } _ { 5 0 }$ ) and high-precision detection $( 6 . 0 7 \%$ in $\mathsf { A P } _ { 7 5 }$ and $3 . 6 5 \%$ $\mathrm { A P _ { 5 0 : 9 5 } }$ ). KLD-based method shows the best performer in almost all indicators. Similar conclusions can still be drawn on the more challenging datasets (DOTA-v1.5 and DOTA-v2.0), which contain more data and tiny object (less than 10 pixels).
+
+Table 5: More ablation experiments on other datasets.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Reg. Loss</td><td rowspan=1 colspan=1>MLT</td><td rowspan=1 colspan=1>UCAS-AOD</td><td rowspan=1 colspan=1>DOTA-v1.0</td><td rowspan=1 colspan=1>DOTA-v1.5</td><td rowspan=1 colspan=1>DOTA-v2.0</td></tr><tr><td rowspan=3 colspan=1>RetinaNet</td><td rowspan=3 colspan=1>Smooth L1GWDKLD</td><td rowspan=2 colspan=1>48.4254.58 (+6.16)</td><td rowspan=1 colspan=1>94.56</td><td rowspan=1 colspan=1>65.73</td><td rowspan=1 colspan=1>58.87</td><td rowspan=1 colspan=1>44.16</td></tr><tr><td rowspan=1 colspan=1>95.44 (+0.88)</td><td rowspan=1 colspan=1>68.93 (+3.20)</td><td rowspan=1 colspan=1>60.03 (+1.16)</td><td rowspan=1 colspan=1>46.65 (+2.49)</td></tr><tr><td rowspan=1 colspan=1>57.59 (+9.17)</td><td rowspan=1 colspan=1>96.14 (+1.58)</td><td rowspan=1 colspan=1>71.28 (+5.55)</td><td rowspan=1 colspan=1>62.50 (+3.63)</td><td rowspan=1 colspan=1>47.69 (+3.53)</td></tr></table>
+
+Table 6: Accuracy comparison between different rotation detectors on DOTA dataset. † and ‡ represent the large aspect ratio object and the square-like object, respectively. The bold red and blue fonts indicate the top two performances respectively. $D _ { o c }$ and $D _ { l e }$ represent OpenCV Definition $( \theta \in [ - 9 0 ^ { \circ } , 0 ^ { \circ } ) _ { , } ^ { }$ ) and Long Edge Definition $( \theta \in [ - 9 0 ^ { \circ } , 9 0 ^ { \circ } ) )$ ) of RBox.   
+
+<table><tr><td rowspan="2">Baseline</td><td rowspan="2">Method</td><td rowspan="2">Box Def.</td><td colspan="8">v1.0 tranval/test</td><td colspan="4">v1.0 train/val</td><td>v1.5</td><td>v2.0</td></tr><tr><td>BR</td><td>SVi</td><td>LVi</td><td>SH</td><td>HA</td><td>ST</td><td>RA</td><td>7-AP50</td><td>AP50</td><td>AP50</td><td>AP75</td><td>AP50:95</td><td>AP50</td><td>AP50</td></tr><tr><td rowspan="9">RetinaNet</td><td>-</td><td>Doc Dle</td><td>42.17 38.31</td><td>65.93 60.48</td><td>51.11 49.77</td><td>72.61</td><td>53.24</td><td>78.38 78.60</td><td>62.00</td><td>60.78</td><td>65.73</td><td>64.70</td><td>32.31</td><td>34.50</td><td>58.87 56.10</td><td>44.16 43.06</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>68.29</td><td>51.28</td><td></td><td>60.02</td><td>58.11</td><td>64.17</td><td>62.21</td><td>26.06</td><td>31.49</td><td></td><td></td></tr><tr><td>IoU-Smooth L1 [3]</td><td>Doc</td><td>44.32</td><td>63.03</td><td>51.25</td><td>72.78</td><td>56.21 53.64</td><td>77.98</td><td>63.22</td><td>61.26 61.21</td><td>66.99</td><td>64.61</td><td>34.17</td><td>36.23 34.61</td><td>59.16</td><td>46.31</td></tr><tr><td>Modulated Loss [45]</td><td>Doc</td><td>42.92</td><td>67.92 70.78</td><td>52.91</td><td>72.67</td><td></td><td>80.22</td><td>58.21</td><td></td><td>66.05</td><td>63.50</td><td>33.32</td><td></td><td>57.75</td><td>45.17</td></tr><tr><td>Modulated Loss [45]</td><td>Quad.</td><td>43.21</td><td></td><td>54.70</td><td>72.68</td><td>60.99</td><td>79.72</td><td>62.08</td><td>63.45</td><td>67.20</td><td>65.15</td><td>40.59</td><td>39.12</td><td>61.42</td><td>46.71</td></tr><tr><td>RIL[34]</td><td>Quad.</td><td>40.81</td><td>67.63</td><td>55.45</td><td>72.42</td><td>55.49</td><td>78.09</td><td>64.75</td><td>62.09</td><td>66.06</td><td>64.07</td><td>40.98</td><td>39.05</td><td>58.91</td><td>45.35</td></tr><tr><td>CSL[4]</td><td>Dle</td><td>42.25</td><td>68.28</td><td>54.51</td><td>72.85</td><td>53.10</td><td>75.59</td><td>58.99</td><td>60.80</td><td>67.38</td><td>64.40</td><td>32.58</td><td>35.04</td><td>58.55</td><td>43.34</td></tr><tr><td>DCL (BCL) [46]</td><td>Dle</td><td>41.40</td><td>65.82</td><td>56.27</td><td>73.80</td><td>54.30</td><td>79.02</td><td>60.25</td><td>61.55</td><td>67.39</td><td>65.93</td><td>35.66</td><td>36.71</td><td>59.38</td><td>45.46</td></tr><tr><td>GWD[5]</td><td>Doc Doc</td><td>44.07 44.00</td><td>71.92 74.45</td><td>62.56 72.48</td><td>77.94 84.30</td><td>60.25 65.54</td><td>79.64 80.03</td><td>63.52 65.05</td><td>65.70 69.41</td><td>68.93 71.28</td><td>65.44</td><td>38.68</td><td>38.71</td><td>60.03</td><td>46.65</td></tr><tr><td rowspan="4">RDet</td><td>KLD</td><td></td><td>44.15</td><td>75.09</td><td></td><td>86.04</td><td>56.49</td><td></td><td>61.01</td><td>68.31</td><td>70.66</td><td>68.14</td><td>44.48</td><td>42.15 38.46</td><td>62.50</td><td>47.69</td></tr><tr><td>- DCL (BCL) [46]</td><td>Doc</td><td>46.84</td><td></td><td>72.88</td><td></td><td></td><td>82.53</td><td></td><td></td><td></td><td>67.18</td><td>38.41</td><td></td><td>62.91</td><td>48.43</td></tr><tr><td></td><td>Dle Doc</td><td>46.73</td><td>74.87 75.84</td><td>74.96 78.00</td><td>85.70 86.71</td><td>57.72 62.69</td><td>84.06 83.09</td><td>63.77 61.12</td><td>69.70 70.60</td><td>71.21 71.56</td><td>67.45</td><td>35.44</td><td>37.54</td><td>61.98</td><td>48.71</td></tr><tr><td>GWD[5] KLD</td><td>Doc</td><td>48.34</td><td>75.09</td><td>78.88</td><td>86.52</td><td>65.48</td><td>82.08</td><td>61.51</td><td>71.13</td><td>71.73</td><td>69.28 68.87</td><td>43.35 44.48</td><td>41.56 42.11</td><td>63.22 65.18</td><td>49.25 50.90</td></tr></table>
+
+Horizontal detection verification. As analyzed by Eq. 16, KLD can be degenerated into the common regression loss in horizontal detection task. Table 7 compares the regression loss Smooth L1 and IoU/GIoU for horizontal detection with the proposed regression loss KLD on MS COCO [48] dataset. The results show that our KLD is not worse than other losses on the Faster RCNN [8], RetinaNet [10] and FCOS [21], and even has an improvement of $0 . 6 \%$ on RetinaNet. The ground truth for rotation detection is the minimum circumscribed rectangle, which means that ground truth can well reflect the true scale and direction information of the object. The “horizontal special case” described in this paper also meets the above requirements, the horizontal circumscribed rectangle is equal to the minimum circumscribed rectangle at this time. Although the ground truth of the COCO is a horizontal box, it is not the minimum circumscribed rectangle, which means that it loses the direction information and accurate scale information of the object. For example, a baseball bat placed obliquely in the image, the height and width of its horizontal circumscribed rectangle do not represent the height and width of the object itself. This causes that when KLD is applied to the COCO, the optimization mechanism of KLD that dynamically adjusts the angle gradient according to the aspect ratio is meaningless, which affects the improvement of the final performance. In general, this is a defect in the dataset annotation itself, not that KLD is not good enough. In fact, it is inappropriate to use the COCO to discuss $\theta = 0 ^ { \circ }$ , because the COCO discards $\theta$ parameter. In addition, $\theta = 0 ^ { \circ }$ describes the instances in the horizontal position, but not mean all instances of the dataset are in a horizontal position. This paper uses COCO to discuss the “horizontal special case” to express that even if the dataset has certain labeling defects, KLD can have certain effects. After all, it is difficult to observe the performance improvement of all horizontal objects on the rotating dataset.
+
+# 4.3 Comparisons with the State-of-the-Art Methods
+
+The evaluation is performed on the DOTA, which contains a considerable number of categories, complexity scenes. Our single-scale model RetinaNet-KLD-R50 and ${ \tt R } ^ { 3 }$ Det-KLD-R50 achieve $7 5 . 2 8 \%$ and $7 7 . 3 6 \%$ respectively. They outperform multi-scale models as shown in Table 8. With large backbone and multi-scale testing, our method further achieves state-of-the-art accuracy $8 0 . 6 3 \%$ .
+
+Table 7: Performance evaluation of KLD on classic horizontal detection.   
+
+<table><tr><td rowspan=1 colspan=1>Detector</td><td rowspan=1 colspan=1>Regression Loss</td><td rowspan=1 colspan=1>AP</td><td rowspan=1 colspan=1>AP50</td><td rowspan=1 colspan=1>AP75</td><td rowspan=1 colspan=1>AP</td><td rowspan=1 colspan=1>APm</td><td rowspan=1 colspan=1>AP</td></tr><tr><td rowspan=3 colspan=1>RetinaNet [10]</td><td rowspan=2 colspan=1>Smooth L1GIoU</td><td rowspan=2 colspan=1>37.237.4</td><td rowspan=1 colspan=1>56.6</td><td rowspan=1 colspan=1>39.7</td><td rowspan=1 colspan=1>21.4</td><td rowspan=1 colspan=1>41.1</td><td rowspan=1 colspan=1>48.0</td></tr><tr><td rowspan=1 colspan=1>56.7</td><td rowspan=1 colspan=1>39.7</td><td rowspan=1 colspan=1>22.2</td><td rowspan=1 colspan=1>41.7</td><td rowspan=1 colspan=1>48.1</td></tr><tr><td rowspan=1 colspan=1>KLD</td><td rowspan=1 colspan=1>38.0</td><td rowspan=1 colspan=1>56.4</td><td rowspan=1 colspan=1>40.6</td><td rowspan=1 colspan=1>23.3</td><td rowspan=1 colspan=1>43.2</td><td rowspan=1 colspan=1>49.3</td></tr><tr><td rowspan=2 colspan=1>Faster RCNN [8]</td><td rowspan=1 colspan=1>Smooth L1GIoU</td><td rowspan=1 colspan=1>37.938.3</td><td rowspan=1 colspan=1>58.858.7</td><td rowspan=1 colspan=1>41.041.5</td><td rowspan=1 colspan=1>22.422.5</td><td rowspan=1 colspan=1>41.441.7</td><td rowspan=1 colspan=1>49.149.7</td></tr><tr><td rowspan=1 colspan=1>KLD</td><td rowspan=1 colspan=1>38.2</td><td rowspan=1 colspan=1>58.7</td><td rowspan=1 colspan=1>41.7</td><td rowspan=1 colspan=1>22.6</td><td rowspan=1 colspan=1>41.8</td><td rowspan=1 colspan=1>49.3</td></tr><tr><td rowspan=2 colspan=1>FCOS [21]</td><td rowspan=1 colspan=1>IoU</td><td rowspan=1 colspan=1>36.6</td><td rowspan=1 colspan=1>56.0</td><td rowspan=1 colspan=1>38.8</td><td rowspan=1 colspan=1>21.0</td><td rowspan=1 colspan=1>40.6</td><td rowspan=1 colspan=1>47.0</td></tr><tr><td rowspan=1 colspan=1>KLD</td><td rowspan=1 colspan=1>36.8</td><td rowspan=1 colspan=1>56.3</td><td rowspan=1 colspan=1>39.1</td><td rowspan=1 colspan=1>21.7</td><td rowspan=1 colspan=1>40.8</td><td rowspan=1 colspan=1>47.5</td></tr></table>
+
+Table 8: AP on different objects on DOTA-v1.0. Here R-101 denotes ResNet-101 (likewise for R-50, R-152), and RX-101 and H-104 represent ResNeXt101 [49] and Hourglass-104 [50], respectively. MS indicates that multi-scale training/testing is used. Red and blue indicate the top two performances.   
+
+<table><tr><td></td><td>Method</td><td>Backbone</td><td>MS</td><td>PL</td><td>BD</td><td>BR</td><td>GTF</td><td>SV</td><td>LV</td><td>SH</td><td>TC</td><td>BC</td><td>ST</td><td>SBF</td><td>RA</td><td>HA</td><td>SP</td><td>HC</td><td>AP50</td></tr><tr><td rowspan="8">P1s-or</td><td>ICN [31]</td><td>R-101</td><td>√</td><td>81.40</td><td>74.30</td><td>47.70</td><td>70.30</td><td>64.90</td><td>67.80</td><td>70.00</td><td>90.80</td><td>79.10</td><td>78.20</td><td>53.60</td><td>62.90</td><td>67.00</td><td>64.20</td><td>50.20</td><td>68.20</td></tr><tr><td>RoI-Trans. [12]</td><td>R-101</td><td>√</td><td>88.64</td><td>78.52</td><td>43.44</td><td>75.92</td><td>68.81</td><td>73.68</td><td>83.59</td><td>90.74</td><td>77.27</td><td>81.46</td><td>58.39</td><td>53.54</td><td>62.83</td><td>58.93</td><td>47.67</td><td>69.56</td></tr><tr><td>SCRDet [3]</td><td>R-101</td><td></td><td>89.98</td><td>80.65</td><td>52.09</td><td>68.36</td><td>68.36</td><td>60.32</td><td>72.41</td><td>90.85</td><td>87.94</td><td>86.86</td><td>65.02</td><td>66.68</td><td>66.25</td><td>68.24</td><td>65.21</td><td>72.61</td></tr><tr><td>Gliding Vertex [51]</td><td>R-101</td><td></td><td>89.64</td><td>85.00</td><td>52.26</td><td>77.34</td><td>73.01</td><td>73.14</td><td>86.82</td><td>90.74</td><td>79.02</td><td>86.81</td><td>59.55</td><td>70.91</td><td>72.94</td><td>70.86</td><td>57.32</td><td>75.02</td></tr><tr><td>Mask OBB[52]</td><td>RX-101</td><td></td><td>89.56</td><td>85.95</td><td>54.21</td><td>72.90</td><td>76.52</td><td>74.16</td><td>85.63</td><td>89.85</td><td>83.81</td><td>86.48</td><td>54.89</td><td>69.64</td><td>73.94</td><td>69.06</td><td>63.32</td><td>75.33</td></tr><tr><td>CenterMap OBB [53]</td><td>R-101</td><td>√</td><td>89.83</td><td>84.41</td><td>54.60</td><td>70.25</td><td>77.66</td><td>78.32</td><td>87.19</td><td>90.66</td><td>84.89</td><td>85.27</td><td>56.46</td><td>69.23</td><td>74.13</td><td>71.56</td><td>66.06</td><td>76.03</td></tr><tr><td>FPN-CSL [4]</td><td>R-152</td><td>√</td><td>90.25</td><td>85.53</td><td>54.64</td><td>75.31</td><td>70.44</td><td>73.51</td><td>77.62</td><td>90.84</td><td>86.15</td><td>86.69</td><td>69.60</td><td>68.04</td><td>73.83</td><td>71.10</td><td>68.93</td><td>76.17</td></tr><tr><td>RSDet-II [45]</td><td>R-152</td><td>v</td><td>89.93</td><td>84.45</td><td>53.77</td><td>74.35</td><td>71.52</td><td>78.31</td><td>78.12</td><td>91.14</td><td>87.35</td><td>86.93</td><td>65.64</td><td>65.17</td><td>75.35</td><td>79.74</td><td>63.31</td><td>76.34</td></tr><tr><td>SCRDet++ [54] ReDet [55] PloU [32]</td><td>R-101</td><td></td><td></td><td>90.05 84.39</td><td>55.44</td><td>73.99</td><td>77.54</td><td>71.11</td><td>86.05</td><td></td><td>90.67</td><td>87.32</td><td>87.08</td><td>69.62</td><td>68.90 73.74</td><td>71.29</td><td>65.08</td><td>76.81</td><td></td></tr><tr><td rowspan="11">sessssert</td><td></td><td>ReR-50</td><td>√</td><td>88.81</td><td>82.48</td><td>60.83</td><td>80.82</td><td>78.34</td><td>86.06</td><td>88.31</td><td>90.87</td><td>88.77</td><td>87.03</td><td>68.65</td><td>66.90</td><td>79.26</td><td>79.71</td><td>74.67</td><td>80.10</td></tr><tr><td></td><td>DLA-34 [56]</td><td></td><td>80.90</td><td>69.70</td><td>24.10</td><td>60.20</td><td>38.30</td><td>64.40</td><td>64.80</td><td>90.90</td><td>77.20</td><td>70.40</td><td>46.50</td><td>37.10</td><td>57.10</td><td>61.90</td><td>64.00</td><td>60.50</td></tr><tr><td>O²-DNet [57]</td><td>H-104</td><td>√</td><td>89.31</td><td>82.14</td><td>47.33</td><td>61.21</td><td>71.32</td><td>74.03</td><td>78.62</td><td>90.76</td><td>82.23</td><td>81.36</td><td>60.93</td><td>60.17</td><td>58.21</td><td>66.98</td><td>61.03</td><td>71.04</td></tr><tr><td>DAL[15]</td><td>R-101</td><td>√</td><td>88.61</td><td>79.69</td><td>46.27</td><td>70.37</td><td>65.89</td><td>76.10</td><td>78.53</td><td>90.84</td><td>79.98</td><td>78.41</td><td>58.71</td><td>62.02</td><td>69.23</td><td>71.32</td><td>60.65</td><td>71.78</td></tr><tr><td>P-RSDet[58]</td><td>R-101</td><td>√</td><td>88.58</td><td>77.83</td><td>50.44</td><td>69.29</td><td>71.10</td><td>75.79</td><td>78.66</td><td>90.88</td><td>80.10</td><td>81.71</td><td>57.92</td><td>63.03</td><td>66.30</td><td>69.77</td><td>63.13</td><td>72.30</td></tr><tr><td>BBAVectors [59]</td><td>R-101</td><td>√</td><td>88.35</td><td>79.96</td><td>50.69</td><td>62.18</td><td>78.43</td><td>78.98</td><td>87.94</td><td>90.85</td><td>83.58</td><td>84.35</td><td>54.13</td><td>60.24</td><td>65.22</td><td>64.28</td><td>55.70</td><td>72.32</td></tr><tr><td>DRN[14]</td><td>H-104</td><td></td><td>89.71</td><td>82.34</td><td>47.22</td><td>64.10</td><td>76.22 78.53</td><td>74.43</td><td>85.84</td><td>90.57</td><td>86.18</td><td>84.89 86.87</td><td>57.65</td><td>61.93</td><td>69.30</td><td>69.63</td><td>58.48</td><td>73.23</td></tr><tr><td>PolarDet [60]</td><td>R-101 R-101</td><td>&lt;</td><td>89.65 89.15</td><td>87.07 83.92</td><td>48.14 52.51</td><td>70.97 73.06</td><td>77.81</td><td>80.34 79.00</td><td>87.45</td><td>90.76</td><td>85.63</td><td></td><td>61.64 63.96</td><td>70.32</td><td>71.92</td><td>73.09</td><td>67.15</td><td>76.64</td></tr><tr><td>RDD [61]</td><td>R-152</td><td></td><td>89.06</td><td>84.32</td><td>55.33</td><td>77.53</td><td>76.95</td><td>70.28</td><td>87.08 83.95</td><td>90.62 89.75</td><td>86.72 84.51</td><td>87.15 86.06</td><td>73.47</td><td>70.29</td><td>76.98</td><td>75.79</td><td>72.15</td><td>77.75</td></tr><tr><td>GWD[5]</td><td>R-50</td><td></td><td>88.91</td><td>83.71</td><td>50.10</td><td>68.75</td><td>78.20</td><td>76.05</td><td>84.58</td><td>89.41</td><td>86.15</td><td>85.28</td><td>63.15</td><td>67.77 60.90</td><td>72.60</td><td>75.76</td><td>74.17</td><td>77.43</td></tr><tr><td>KLD</td><td>R-50</td><td>√</td><td>88.91</td><td>85.23</td><td>53.64</td><td>81.23</td><td>78.20</td><td>76.99</td><td>84.58</td><td>89.50</td><td>86.84</td><td>86.38</td><td>71.69</td><td>68.06</td><td>75.06 75.95</td><td>71.51 72.23</td><td>67.45 75.42</td><td>75.28</td></tr><tr><td rowspan="8">Praesege DCL [46] RIDet [34] S2A-Net [13]</td><td>CFC-Net [33]</td><td></td><td>√</td><td>89.08</td><td>80.41</td><td>52.41</td><td>70.02</td><td>76.28</td><td>78.11</td><td>87.21</td><td>90.89</td><td>84.47</td><td>85.64</td><td>60.51</td><td></td><td></td><td></td><td></td><td>78.32</td></tr><tr><td>RDet [28]</td><td>R-101 R-152</td><td>&lt;</td><td>89.80</td><td>83.77</td><td>48.11</td><td>66.77</td><td>78.76</td><td>83.27</td><td>87.84</td><td>90.82</td><td>85.38</td><td>85.51</td><td>65.67</td><td>61.52 62.68</td><td>67.82 67.53</td><td>68.02 78.56</td><td>50.09 72.62</td><td>73.50 76.47</td></tr><tr><td>DAL[15]</td><td>R-50</td></table>
+
+# 5 Discussions
+
+Limitations. Despite the theoretical grounds and the promising experimental justifications, our method has an obvious limitation that it cannot be directly applied to quadrilateral detection [34, 45].
+
+Potential negative societal impacts. Our findings provides a simple regression loss for highprecision rotation detection. However, our research may be applied to some sensitive fields, such as remote sensing, aviation, and unmanned aerial vehicles.
+
+Conclusion. Departure from the vast existing literature in object detection, in this paper we have designed a new regression loss for rotation detection from scratch and consider the popular horizontal detection as its special case. Specifically, we calculate the KLD between the Gaussian distributions corresponding to the rotated bounding box as the regression loss, and we find that in the learning procedure guided by the KLD loss, the gradient of the parameters can be dynamically adjusted according to the characteristics of the object which is a desirable property for robust object detection, regardless its rotation, size and aspect ratio etc. We also proved that KLD has scale invariance, which is crucial for detection tasks. Interestingly, we have shown that KLD can be degenerated into the currently commonly used $l _ { n }$ -norm loss in the horizontal detection task. Extensive experimental results across different detectors and datasets show the effectiveness of our approach.
+
+# Acknowledgments and Disclosure of Funding
+
+This work was partly supported by National Key Research and Development Program of China (2018AAA0100704), Shanghai Municipal Science and Technology Major Project (2021SHZDZX0102) and NSFC (U20B2068, 72061127003, 61972250). Xue Yang was also partly supported by Wu Wen Jun Honorary Doctoral Scholarship, AI Institute, Shanghai Jiao Tong University, Shanghai, China.
+
+References   
+[1] X. Yang, H. Sun, K. Fu, J. Yang, X. Sun, M. Yan, and Z. Guo, “Automatic ship detection in remote sensing images from google earth of complex scenes based on multiscale rotation dense feature pyramid networks,” Remote Sensing, vol. 10, no. 1, p. 132, 2018.   
+[2] X. Yang, H. Sun, X. Sun, M. Yan, Z. Guo, and K. Fu, “Position detection and direction prediction for arbitrary-oriented ships via multitask rotation region convolutional neural network,” IEEE Access, vol. 6, pp. 50 839–50 849, 2018.   
+[3] X. Yang, J. Yang, J. Yan, Y. Zhang, T. Zhang, Z. Guo, X. Sun, and K. Fu, “Scrdet: Towards more robust detection for small, cluttered and rotated objects,” in Proceedings of the IEEE International Conference on Computer Vision, 2019, pp. 8232–8241.   
+[4] X. Yang and J. Yan, “Arbitrary-oriented object detection with circular smooth label,” in European Conference on Computer Vision. Springer, 2020, pp. 677–694.   
+[5] X. Yang, J. Yan, M. Qi, W. Wang, Z. Xiaopeng, and T. Qi, “Rethinking rotated object detection with gaussian wasserstein distance loss,” in International Conference on Machine Learning, 2021.   
+[6] Q. Ming, L. Miao, Z. Zhou, J. Song, and X. Yang, “Sparse label assignment for oriented object detection in aerial images,” Remote Sensing, vol. 13, no. 14, p. 2664, 2021.   
+[7] R. Girshick, “Fast r-cnn,” in Proceedings of the IEEE International Conference on Computer Vision, 2015, pp. 1440–1448.   
+[8] S. Ren, K. He, R. Girshick, and J. Sun, “Faster r-cnn: Towards real-time object detection with region proposal networks,” in Advances in neural information processing systems, 2015, pp. 91–99.   
+[9] T.-Y. Lin, P. Dollár, R. Girshick, K. He, B. Hariharan, and S. Belongie, “Feature pyramid networks for object detection,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017, pp. 2117–2125.   
+[10] T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár, “Focal loss for dense object detection,” in Proceedings of the IEEE International Conference on Computer Vision, 2017, pp. 2980–2988.   
+[11] J. Dai, Y. Li, K. He, and J. Sun, “R-fcn: Object detection via region-based fully convolutional networks,” in Advances in neural information processing systems, 2016, pp. 379–387.   
+[12] J. Ding, N. Xue, Y. Long, G.-S. Xia, and Q. Lu, “Learning roi transformer for oriented object detection in aerial images,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2019, pp. 2849–2858.   
+[13] J. Han, J. Ding, J. Li, and G.-S. Xia, “Align deep features for oriented object detection,” IEEE Transactions on Geoscience and Remote Sensing, 2021.   
+[14] X. Pan, Y. Ren, K. Sheng, W. Dong, H. Yuan, X. Guo, C. Ma, and C. Xu, “Dynamic refinement network for oriented and densely packed object detection,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2020, pp. 11 207–11 216.   
+[15] Q. Ming, Z. Zhou, L. Miao, H. Zhang, and L. Li, “Dynamic anchor learning for arbitrary-oriented object detection,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 35, no. 3, 2021, pp. 2355–2363.   
+[16] S. Kullback and R. A. Leibler, “On information and sufficiency,” The annals of mathematical statistics, vol. 22, no. 1, pp. 79–86, 1951.   
+[17] C. Villani, Optimal transport: old and new. Springer Science & Business Media, 2008, vol. 338.   
+[18] X. Yang, Y. Zhou, and J. Yan, “Alpharotate: A rotation detection benchmark using tensorflow,” arXiv preprint arXiv:2111.06677, 2021.   
+[19] J. Redmon, S. Divvala, R. Girshick, and A. Farhadi, “You only look once: Unified, real-time object detection,” in Proceedings of the IEEE conference on computer vision and pattern recognition, 2016, pp. 779–788.   
+[20] W. Liu, D. Anguelov, D. Erhan, C. Szegedy, S. Reed, C.-Y. Fu, and A. C. Berg, “Ssd: Single shot multibox detector,” in European conference on computer vision. Springer, 2016, pp. 21–37.   
+[21] Z. Tian, C. Shen, H. Chen, and T. He, “Fcos: Fully convolutional one-stage object detection,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, 2019, pp. 9627–9636.   
+[22] X. Zhou, D. Wang, and P. Krähenbühl, “Objects as points,” arXiv preprint arXiv:1904.07850, 2019.   
+[23] Z. Yang, S. Liu, H. Hu, L. Wang, and S. Lin, “Reppoints: Point set representation for object detection,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, 2019, pp. 9657–9666.   
+[24] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko, “End-to-end object detection with transformers,” in European Conference on Computer Vision. Springer, 2020, pp. 213–229.   
+[25] X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai, “Deformable detr: Deformable transformers for end-to-end object detection,” in International Conference on Learning Representations, 2020.   
+[26] H. Rezatofighi, N. Tsoi, J. Gwak, A. Sadeghian, I. Reid, and S. Savarese, “Generalized intersection over union: A metric and a loss for bounding box regression,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2019, pp. 658–666.   
+[27] Z. Zheng, P. Wang, W. Liu, J. Li, R. Ye, and D. Ren, “Distance-iou loss: Faster and better learning for bounding box regression.” in Proceedings of the AAAI Conference on Artificial Intelligence, 2020, pp. 12 993–13 000.   
+[28] X. Yang, J. Yan, Z. Feng, and T. He, “R3det: Refined single-stage detector with feature refinement for rotating object,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 35, no. 4, 2021, pp. 3163–3171.   
+[29] Y. Jiang, X. Zhu, X. Wang, S. Yang, W. Li, H. Wang, P. Fu, and Z. Luo, “R2cnn: rotational region cnn for orientation robust scene text detection,” arXiv preprint arXiv:1706.09579, 2017.   
+[30] J. Ma, W. Shao, H. Ye, L. Wang, H. Wang, Y. Zheng, and X. Xue, “Arbitrary-oriented scene text detection via rotation proposals,” IEEE Transactions on Multimedia, vol. 20, no. 11, pp. 3111–3122, 2018.   
+[31] S. M. Azimi, E. Vig, R. Bahmanyar, M. Körner, and P. Reinartz, “Towards multi-class object detection in unconstrained remote sensing imagery,” in Asian Conference on Computer Vision. Springer, 2018, pp. 150–165.   
+[32] Z. Chen, K. Chen, W. Lin, J. See, H. Yu, Y. Ke, and C. Yang, “Piou loss: Towards accurate oriented object detection in complex environments,” in European Conference on Computer Vision. Springer, 2020, pp. 195–211.   
+[33] Q. Ming, L. Miao, Z. Zhou, and Y. Dong, “Cfc-net: A critical feature capturing network for arbitraryoriented object detection in remote sensing images,” arXiv preprint arXiv:2101.06849, 2021.   
+[34] Q. Ming, L. Miao, Z. Zhou, X. Yang, and Y. Dong, “Optimization for arbitrary-oriented object detection via representation invariance loss,” IEEE Geoscience and Remote Sensing Letters, 2021.   
+[35] C. Manning and H. Schutze, Foundations of statistical natural language processing. MIT press, 1999.   
+[36] H. Jeffreys, “An invariant form for the prior probability in estimation problems,” Proceedings of the Royal Society of London. Series A. Mathematical and Physical Sciences, vol. 186, no. 1007, pp. 453–461, 1946.   
+[37] G.-S. Xia, X. Bai, J. Ding, Z. Zhu, S. Belongie, J. Luo, M. Datcu, M. Pelillo, and L. Zhang, “Dota: A large-scale dataset for object detection in aerial images,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2018, pp. 3974–3983.   
+[38] H. Zhu, X. Chen, W. Dai, K. Fu, Q. Ye, and J. Jiao, “Orientation robust object detection in aerial images using deep convolutional neural network,” in 2015 IEEE International Conference on Image Processing. IEEE, 2015, pp. 3735–3739.   
+[39] Z. Liu, L. Yuan, L. Weng, and Y. Yang, “A high resolution optical satellite image dataset for ship recognition and some new baselines,” in Proceedings of the International Conference on Pattern Recognition Applications and Methods, vol. 2, 2017, pp. 324–331.   
+[40] D. Karatzas, L. Gomez-Bigorda, A. Nicolaou, S. Ghosh, A. Bagdanov, M. Iwamura, J. Matas, L. Neumann, V. R. Chandrasekhar, S. Lu et al., “Icdar 2015 competition on robust reading,” in 2015 13th International Conference on Document Analysis and Recognition. IEEE, 2015, pp. 1156–1160.   
+[41] N. Nayef, F. Yin, I. Bizid, H. Choi, Y. Feng, D. Karatzas, Z. Luo, U. Pal, C. Rigaud, J. Chazalon et al., “Icdar2017 robust reading challenge on multi-lingual scene text detection and script identification-rrc-mlt,” in 2017 14th IAPR International Conference on Document Analysis and Recognition, vol. 1. IEEE, 2017, pp. 1454–1459.   
+[42] C. Yao, X. Bai, W. Liu, Y. Ma, and Z. Tu, “Detecting texts of arbitrary orientations in natural images,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. IEEE, 2012, pp. 1083–1090.   
+[43] M. Abadi, P. Barham, J. Chen, Z. Chen, A. Davis, J. Dean, M. Devin, S. Ghemawat, G. Irving, M. Isard et al., “Tensorflow: A system for large-scale machine learning,” in 12th {USENIX} symposium on operating systems design and implementation ({OSDI} 16), 2016, pp. 265–283.   
+[44] K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016, pp. 770–778.   
+[45] W. Qian, X. Yang, S. Peng, J. Yan, and Y. Guo, “Learning modulated loss for rotated object detection,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 35, no. 3, 2021, pp. 2458–2466.   
+[46] X. Yang, L. Hou, Y. Zhou, W. Wang, and J. Yan, “Dense label encoding for boundary discontinuity free rotation detection,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2021, pp. 15 819–15 829.   
+[47] X. Yang, J. Yan, and T. He, “On the arbitrary-oriented object detection: Classification based approaches revisited,” arXiv preprint arXiv:2003.05597, 2020.   
+[48] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick, “Microsoft coco: Common objects in context,” in European conference on computer vision. Springer, 2014, pp. 740–755.   
+[49] S. Xie, R. Girshick, P. Dollár, Z. Tu, and K. He, “Aggregated residual transformations for deep neural networks,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017, pp. 1492–1500.   
+[50] A. Newell, K. Yang, and J. Deng, “Stacked hourglass networks for human pose estimation,” in European Conference on Computer Vision. Springer, 2016, pp. 483–499.   
+[51] Y. Xu, M. Fu, Q. Wang, Y. Wang, K. Chen, G.-S. Xia, and X. Bai, “Gliding vertex on the horizontal bounding box for multi-oriented object detection,” IEEE transactions on pattern analysis and machine intelligence, vol. 43, no. 4, pp. 1452–1459, 2020.   
+[52] J. Wang, J. Ding, H. Guo, W. Cheng, T. Pan, and W. Yang, “Mask obb: A semantic attention-based mask oriented bounding box representation for multi-category object detection in aerial images,” Remote Sensing, vol. 11, no. 24, p. 2930, 2019.   
+[53] J. Wang, W. Yang, H.-C. Li, H. Zhang, and G.-S. Xia, “Learning center probability map for detecting objects in aerial images,” IEEE Transactions on Geoscience and Remote Sensing, vol. 59, no. 5, pp. 4307–4323, 2020.   
+[54] X. Yang, J. Yan, X. Yang, J. Tang, W. Liao, and T. He, “Scrdet++: Detecting small, cluttered and rotated objects via instance-level feature denoising and rotation loss smoothing,” arXiv preprint arXiv:2004.13316, 2020.   
+[55] J. Han, J. Ding, N. Xue, and G.-S. Xia, “Redet: A rotation-equivariant detector for aerial object detection,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2021, pp. 2786–2795.   
+[56] F. Yu, D. Wang, E. Shelhamer, and T. Darrell, “Deep layer aggregation,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2018, pp. 2403–2412.   
+[57] H. Wei, Y. Zhang, Z. Chang, H. Li, H. Wang, and X. Sun, “Oriented objects as pairs of middle lines,” ISPRS Journal of Photogrammetry and Remote Sensing, vol. 169, pp. 268–279, 2020.   
+[58] L. Zhou, H. Wei, H. Li, W. Zhao, Y. Zhang, and Y. Zhang, “Arbitrary-oriented object detection in remote sensing images based on polar coordinates,” IEEE Access, vol. 8, pp. 223 373–223 384, 2020.   
+[59] J. Yi, P. Wu, B. Liu, Q. Huang, H. Qu, and D. Metaxas, “Oriented object detection in aerial images with box boundary-aware vectors,” in Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, 2021, pp. 2150–2159.   
+[60] P. Zhao, Z. Qu, Y. Bu, W. Tan, and Q. Guan, “Polardet: A fast, more precise detector for rotated target in aerial images,” International Journal of Remote Sensing, vol. 42, no. 15, pp. 5821–5851, 2021.   
+[61] B. Zhong and K. Ao, “Single-stage rotation-decoupled detector for oriented object,” Remote Sensing, vol. 12, no. 19, p. 3262, 2020.