Add files using upload-large-folder tool

parse/train/03x6x6qNwJ3/03x6x6qNwJ3.md

@@ -0,0 +1,265 @@
+# GradInit: Learning to Initialize Neural Networks for Stable and Efficient Training
+
+Chen Zhu University of Maryland chenzhu@cs.umd.edu
+
+Renkun Ni University of Maryland rn9zm@cs.umd.edu
+
+Zheng Xu Google Research xuzheng@google.com
+
+Kezhi Kong University of Maryland kong@cs.umd.edu
+
+W. Ronny Huang Google Research wrh@google.com
+
+Tom Goldstein University of Maryland tomg@cs.umd.edu
+
+# Abstract
+
+Innovations in neural architectures have fostered significant breakthroughs in language modeling and computer vision. Unfortunately, novel architectures often result in challenging hyper-parameter choices and training instability if the network parameters are not properly initialized. A number of architecture-specific initialization schemes have been proposed, but these schemes are not always portable to new architectures. This paper presents GradInit, an automated and architecture agnostic method for initializing neural networks. GradInit is based on a simple heuristic; the norm of each network layer is adjusted so that a single step of SGD or Adam with prescribed hyperparameters results in the smallest possible loss value. This adjustment is done by introducing a scalar multiplier variable in front of each parameter block, and then optimizing these variables using a simple numerical scheme. GradInit accelerates the convergence and test performance of many convolutional architectures, both with or without skip connections, and even without normalization layers. It also improves the stability of the original Transformer architecture for machine translation, enabling training it without learning rate warmup using either Adam or SGD under a wide range of learning rates and momentum coefficients. Code is available at https://github.com/zhuchen03/gradinit.
+
+# 1 Introduction
+
+The initialization of network parameters has a strong impact on the training stability and performance of deep neural networks. Initializations that prevent gradient explosion/vanishing in back propagation played a key role in early successes with feed-forward networks [1, 2]. Even with cleverly designed initialization rules, complex models with many layers or multiple branches can still suffer from instability. For example, the original Transformer model [3] does not converge without learning rate warmup using the default initialization [4–6]; RoBERTa [7] and GPT-3 $\pmb { \| \widetilde { \ 8 } \| }$ have to tune the $\beta _ { 2 }$ parameter of Adam for stability when the batch size is large. Recent innovations have shown that architecture-specific initializations, which are carefully derived to maintain stability, can promote convergence without needing normalization layers [5, 9–12]. Unfortunately, the reliance on analytically derived initializations makes it difficult to realize the benefits of these methods when performing architecture search, training networks with branched or heterogeneous components, or proposing altogether new architectures.
+
+In this work, we propose a simple method for learning the initialization of a network with any architecture. Typically, initialization schemes draw parameters independently from a zero-mean distribution, with the variance of each distribution set to pre-determined values depending on the dimensions of the layers [1, 2]. Rather than deriving a closed-form expression for the these distribution parameters, our method re-scales each random weight tensor (e.g. convolution kernels) directly by a learned scalar coefficient. This small set of coefficients is optimized to make the first step of a stochastic optimizer (e.g. SGD or Adam) as effective as possible at minimizing the training loss, while preventing the initial gradient norm from exploding. In addition, this process is designed to take into account the direction, step size, and stochasticity of the optimizer. Finally, after the variance has been learned for each parameter tensor, the random network parameters are re-scaled and optimization proceeds as normal. We empirically find that our methods can make the initialization fall into a smooth loss region, reduce the inter-sample gradient variance, and accelerates training.
+
+Our proposed method, GradInit, is architecture agnostic, and works with both Adam and SGD optimizers. In the vision domain, we show it accelerates the convergence and test performance of a variety of deep architectures, from the vanilla feed-forward VGG net to ResNet, with or without Batch Normalization. It is efficient and scalable, finding good initializations using less than $1 \%$ of the total training time in our experiments, and it improves the initialization of ResNet-50 on ImageNet to obtain better final test accuracy. In the language domain, GradInit enables training the original Transformer model $\pmb { \mathbb { B } }$ using either Adam or SGD without learning rate warmup for machine translation, which is commonly acknowledged to be difficult [4, 13]. As an extreme example of the capabilities of GradInit, we use it to initialize and train a 1202-layer ResNet that achieves significantly higher test accuracy than ResNet-110, which other initialization methods have failed to achieve.
+
+Finally, by visualizing the initial norms and gradient variances of the weights before and after GradInit is applied, we show that GradInit is a useful tool for identifying potential causes for instability at initialization, such as those imposed by normalization layers, and we summarize interesting scale patterns learned by GradInit that can be helpful for designing better initialization rules.
+
+# 2 Related Work
+
+Controlling the norms of network parameters at initialization has proven to be an effective approach for speeding up and stabilizing training. Glorot and Bengio $\mathbb { M }$ studied how the variance of features evolves with depth in feed-forward linear neural networks by assuming both activations and weight tensors are independent and identical random variables. They developed a technique in which the variance of each filter scales with its fan-in (the number of input neurons). This style of analysis was later generalized to the case of ReLU networks $\pmb { \mathbb { Z } } ] \mathbf { l }$ . These two analyses are most effective for feed-forward networks without skip connections or normalization layers. Based on the orthogonal initialization scheme $\pmb { \mathbb { I } }$ , Mishkin and Matas $[ \overline { { 1 5 } } ]$ proposed an iterative procedure to rescale the orthogonally initialized weights of each layer in feedforward networks so that the activations of that layer have unit variance. However, this method fails to prevent the blowup of activations with depth for ResNets [16]. Recently, Gurbuzbalaban and Hu $[ \textcircled { 1 7 } ]$ proposed initialization schemes such that the network can provably preserve any given moment of order $s \in ( 0 , 2 ]$ for the output of each layer. The motivation is that the stochastic gradient updates can result in heavy-tailedness in the distribution of the network weights with a potentially infinite variance, but finite $s$ -order moment $\mathbb { \lVert \rVert }$ . Again, these initialization schemes can only be applied for feed-forward neural networks.
+
+For more complex architectures, normalization layers $\mathbb { n m }$ and skip connections $\scriptstyle { \left\| { \overline { { 2 1 } } } \right\| }$ stabilized training dynamics and improved the state-of-the-art. Similarly, learning rate warmup is a common trick for training large Transformers $\pmb { \mathbb { B } } \|$ . These methods make training tractable for some models, but do not eliminate the high initial gradient variance that destabilizes training when the network is deep [9–11] or when the normalization layers are not carefully positioned [4].
+
+Several authors have proposed better initializations for networks with skip connections. This is often achieved by replacing the normalization layers with simpler scaling or bias operations, and scaling the weight matrices in each layer so that the variance of activations does not increase with depth [9– 12]. Similar analysis has been applied to self attention in Transformers [5]. Without removing the normalization layers, it is possbile to stabilize the initial parameter updates by introducing carefully initialized learnable scale factors to the skip connections $\pmb { \Vert 6 \Vert }$ or the residual branches $\pmb { \left. 2 2 \right. }$ . However, such techniques are often restricted to one specific architecture such as ResNets.
+
+Recently, Dauphin and Schoenholz $\mathbb { \left[ \left[ 1 6 \right] \right] }$ proposed a task-agnostic and automatic initialization method, MetaInit, for any neural network achitecture. MetaInit optimized the norms of weight tensors to minimize the “gradient quotient”, which measures the effect of curvature near the initial parameters, on minibatches of random Gaussian samples. However, as training data is usually accessible for most tasks of interest, it is simpler and potentially more efficient to use the training data for initialization. MetaInit also involves the gradient of a Hessian-vector product that requires computing a “gradient of the gradient” multiple times in tandem, which is very computationally intensive. Our proposed method distinguishes itself from MetaInit in the following ways: (i) Our method is more computationally efficient. MetaInit involves computing third-order derivatives, results in long computing times and high memory usage. The memory overhead of MetaInit is more of an issue for networks with normalization layers. For the relatively small-scale CIFAR-10 problem with batch size 64, MetaInit requires three GPUs (RTX 2080Ti), while the proposed GradInit needs just one. (ii) Our method takes the stochasticity of minibatches into consideration. MetaInit uses the local curvature evaluated on a single minibatch, which fails to capture the variance of the loss/gradient between two different stochastic minibatches. (iii) Our method considers the training dynamics of different optimization algorithms including the learning rate and the direction of the gradient step, and effectively handles different optimizers including SGD and Adam.
+
+# 3 Method
+
+We aim to develop an initialization scheme applicable to arbitrary network architectures. Since previous works [1, 2, 9, 16, 10, 12] have shown that the initial weight norms effectively control the initial gradient norm on average, our method rescales the randomly initialized weight matrices using learnable scale factors.1
+
+Using a small number of gradient descent steps on these scale factors, the proposed GradInit method chooses the initialization scalars so that the loss after the first gradient step taken by a stochastic optimizer (SGD or Adam) is as low as possible. The process of learning initialization coefficients accounts for the chosen learning rate, optimizer, and other parameters. To prevent gradient explosion, our method enforces a constraint that the gradient norm is no larger than a constant $\gamma$ .
+
+Note that for scale-invariant weights, e.g., convolution kernels before BN layers, rescaling still changes their learning dynamics by changing their effective learning rate $\pm \sqrt { 2 3 } \sqrt { 2 4 } ]$ . Empirically, GradInit goes beyond simply preventing exploding or vanishing gradients; it also reduces the gradient variance, making the initialization fall into a smooth loss region with small gradient variance so that training is fast, see discussion about Figure $^ 1$ and comparisons in Figure $2 .$
+
+# 3.1 Efficient Learning-based Initialization via Constrained Optimization
+
+We begin by filling all the weight matrices $\{ W _ { 1 } , \hdots , W _ { M } \}$ of the network with values drawn from independent zero-mean Gaussian distributions, except for the scales and biases of the normalization layers (if any), which are initialized to 1 and 0 respectively. During the initialization process, we keep $\{ W _ { 1 } , \hdots , W _ { M } \}$ constant, but we multiply each $W _ { i }$ with a learnable non-negative scale factor $\alpha _ { i }$ (initialized to 1). After initialization, we rescale the weights by the learned scale factors, and start training without the learnable scale factors just as normal. We use $\pmb { m } = \{ \alpha _ { 1 } , . . . , \alpha _ { M } \}$ to denote the set of scale factors, and $\pmb { \theta } _ { m } = \{ \alpha _ { 1 } \pmb { W } _ { 1 } , \ldots , \alpha _ { M } \pmb { W } _ { M } \}$ is the set of rescaled weight matrices.
+
+Let $\begin{array} { r } { L ( S ; \pmb { \theta } ) = \frac { 1 } { | S | } \sum _ { x \in S } \ell ( x ; \pmb { \theta } ) } \end{array}$ be the average loss of the model parameterized by $\pmb \theta$ on a minibatch of samples $S$ , where $| S |$ is the number of samples in the minibatch. We use $\pmb { g } _ { S , \pmb { \theta } } = \nabla _ { \pmb { \theta } } L ( S ; \pmb { \theta } )$ as a shorthand for the gradient of $\pmb { \theta }$ . During standard training, this gradient is preprocessed/preconditioned by the optimization algorithm $\mathcal { A }$ , and then used to update the network parameters. GradInit solves the following constrained optimization problem:
+
+$$
+\begin{array} { r l } { \underset { m } { \mathrm { m i n i m i z e } } } & { L ( \tilde { S } ; \pmb { \theta } _ { m } - \eta \mathcal { A } [ \pmb { g } _ { S , \pmb { \theta } _ { m } } ] ) , } \\ { \mathrm { s u b j e c t ~ t o ~ } } & { \| \pmb { g } _ { S , \pmb { \theta } _ { m } } \| _ { p , s } \le \gamma , } \end{array}
+$$
+
+where $S$ and $\tilde { S }$ are two different minibatches, $\eta$ is a prescribed learning rate for the optimization algorithm $\mathcal { A }$ , $p _ { \mathcal { A } }$ is the $\ell _ { p }$ -norm associated with $\mathcal { A }$ , and $\gamma$ is the upper bound for the norm. For the first gradient step, Adam uses $\mathcal { A } [ g _ { S , \theta _ { m } } ] = \mathrm { s i g n } ( g _ { S , \theta _ { m } } ) \left[ \left[ 2 5 \right] \right]$ , while SGD uses $\mathcal { A } [ g ( S ; \theta _ { m } ) ] =$
+
+$\gamma \pmb { g } ( S ; \pmb { \theta } _ { m } ) / \| \pmb { g } ( S ; \pmb { \theta } _ { m } ) \| _ { 2 }$ . We show how to choose $\gamma$ and $p _ { \cal A }$ without tuning in Section 3.3. We discuss the formulation of this problem and how to solve it below.
+
+# 3.2 Solving the Constrained Problem
+
+The problem $( 1 )$ is solved using a stochastic gradient descent method in which we sample new mini-batches on each iteration. Since the proposed method uses gradient updates to compute the initialization, we dub it GradInit. We propose a simple solver to optimize objective $( 1 )$ in Algorithm 1 A key feature of our method is that is makes a simple approximation: after $g _ { S , \theta _ { m } }$ is computed on the forward pass of an iteration, we treat $\mathcal { A } [ \pmb { g } _ { S } , \pmb { \theta } _ { m } ]$ as a constant and do not back-propagate through $\mathcal { A } [ \pmb { g } _ { S } , \pmb { \theta } _ { m } ]$ on the backward pass. We make this choice to keep computing costs low, and because it is not possible to back-propagate through the non-differentiable sign function for Adam.
+
+Algorithm 1 GradInit for learning the initialization of neural networks.   
+
+<table><tr><td></td><td>1: Input: Target optimization algorithm Aand learning raten for model training, initial model parameters 0o, learningrateTof the GradInit scales m,total iterations T,upper boundof the gradienty,lower bound for</td><td></td></tr><tr><td>2:mi←1</td><td>the initialization scalars α= O.01.</td><td></td></tr><tr><td></td><td>3: for t = 1 to T do</td><td></td></tr><tr><td>4:</td><td>Sample St from training set.</td><td></td></tr><tr><td>5:</td><td>Lt←S l(xk;0mt)，gt←VθLt</td><td></td></tr><tr><td>6:</td><td>if |lgtllpA &gt;γ then</td><td></td></tr><tr><td>7:</td><td>mt+1 ← mt -TVmtllgtllpA</td><td></td></tr><tr><td>8:</td><td>else</td><td></td></tr><tr><td>9:</td><td>Sample St from training set.</td><td></td></tr><tr><td>10:</td><td>Lt+1←s∑x∈ste(xk;Omt-nAlgt]）</td><td></td></tr><tr><td>11: 12:</td><td>mt+1←mt-TVmtLt+1</td><td></td></tr></table>
+
+To enforce the constraint in $( 1 )$ , we test whether the constraint is satisfied after computing $\pmb { g } ( S ; \pmb { \theta } _ { m } )$ . If not, we take a gradient descent step to minimize $\| \pmb { g } ( S ; \pmb { \theta } _ { m } ) \| _ { p _ { A } }$ , which involves computing second A order derivatives. If the constraint is satisfied, then we instead compute a gradient descent step for the loss. In addition, we set a lower bound $\underline { { \alpha } } = 0 . 0 1$ for all $\alpha _ { i }$ . We find that this prevents scalars from landing on small values during minimization and keeps the GradInit optimizer stable. In our experiments, we find the only layer that ever hit this lower bound is the final FC layer on some networks (see the figures in Section $4 . 1 )$ . We find this procedure converges reliably within 2000 iterations for ImageNet, and fewer than 400 iterations for CIFAR-10, taking less than $1 \%$ of the total training time on both problems. We also find it works well to set the step size $\tau$ to values within the range between $1 0 ^ { - 3 }$ and $1 0 ^ { - 1 }$ . During initialization, the gradient norm constraint is satisfied for the majority of iterations. The choice of $\gamma , p _ { \mathcal { A } }$ will be discussed in Section $3 . 3 .$
+
+Stochasticity of mini-batching. The objective in $\mathbb { \underline { { ( 1 ) } } }$ uses two different mini-batches; $S$ is used to compute the gradient, and $\tilde { S }$ is used to compute the loss. Ideally, $S$ and $\tilde { S }$ should be independently sampled from the training set to capture the randomness of the stochastic optimizer. However, when the network has large initial gradient variance, the gradients on $S$ and $\tilde { S }$ usually differ a lot, and for $\tilde { S }$ , the gradient update step $\theta _ { m } - \eta \mathcal { A } \left[ g _ { S , \theta _ { m } } \right]$ becomes more similar to adding random perturbations to the parameters. We find our objective less effective at accelerating convergence in this case, as shown by the first-epoch accuracy $( A c c _ { 1 } )$ in Table $\nsupseteq$ On the other hand, the randomness is not captured if $S = \tilde { S }$ , and we find empirically that $\theta _ { m }$ can exploit the loss by increasing the gradient norm and destabilize training in this case (see Table $\textcircled{8}$ . Without excessive tuning, we find that we get more reliable behavior for different architectures when $\tilde { S }$ is a mixture of $50 \%$ samples from $S$ and $50 \%$ re-sampled training data, and use this setting by default unless otherwise stated.
+
+Table 1: Accuracies on CIFAR-10 using different overlapping ratios of $\tilde { S }$ and $S$ for GradInit.   
+
+<table><tr><td>Model</td><td>Sns |S]</td><td>Acc1</td><td>AcCbest</td></tr><tr><td>VGG-19</td><td>0</td><td>21.9 ± 4.4</td><td>94.5 ± 0.1</td></tr><tr><td>w/o BN</td><td>0.5</td><td>29.3 ± 0.6</td><td>94.7± 0.02</td></tr><tr><td>(20.03 M)</td><td>1</td><td>28.7 ± 1.0</td><td>94.5 ± 0.1</td></tr></table>
+
+# 3.3 Setting and Enforcing the Constraint
+
+The constraint in $( 1 )$ is included to prevent the network from minimizing the loss in a trivial way by blowing up the initial gradient. In other words, we want the optimizer to achieve small loss by choosing an effective search direction rather than by taking an extremely large step in a sub-optimal direction.
+
+Setting $p _ { \cal A }$ and $\gamma$ through first-order approximation. We show that $p _ { \mathcal { A } }$ and $\gamma$ can be set easily with a rule of thumb and without a parameter search. From the first-order approximation, we expect the first gradient step to result in a change in the loss on $S$ as following:
+
+$$
+L ( S ; \theta _ { m } - \eta \mathcal { A } [ g _ { S , \theta _ { m } } ] ) - L ( S ; \theta _ { m } ) \approx - \eta \mathcal { A } [ g _ { S , \theta _ { m } } ] ^ { T } g _ { S , \theta _ { m } } = \left\{ \begin{array} { l l } { - \eta \| g _ { S , \theta _ { m } } \| _ { 2 } ^ { 2 } , } & { \mathrm { i f ~ } \mathcal { A } \mathrm { ~ i s ~ S G D } , } \\ { - \eta \| g _ { S , \theta _ { m } } \| _ { 1 } , } & { \mathrm { i f ~ } \mathcal { A } \mathrm { ~ i s ~ A d a m } . } \end{array} \right.
+$$
+
+To effectively bound the approximated change in Eq. $\bigtriangledown$ we choose $\ell _ { p _ { A } }$ to be the $\ell _ { 2 }$ and $\ell _ { 1 }$ norm for ASGD and Adam respectively, so when the constraint is satisifed, the maximum change in the loss, according to our local approximation, is $\eta \gamma ^ { 2 }$ for SGD and $\eta \gamma$ for Adam. We recommend setting $\gamma$ such that $\eta \gamma ^ { 2 } = 0 . 1$ for SGD and $\eta \gamma = 0 . 1$ for Adam. According to the linear approximations, this limits the gradient magnitude so that the first step of SGD can decrease the loss by at most 0.1. This simple rule was used across all vision and language experiments.
+
+Why a constraint and not a penalty? Instead of formulating GradInit as a constrained optimization, one can alternatively formulate it as minimizing the objective with a gradient penalty: minimize $L ( \tilde { S } ; \theta _ { m } - \eta A \left[ \pmb { g } _ { S , \theta _ { m } } \right] ) + \lambda \Vert \pmb { g } _ { S ; \theta _ { m } } \Vert _ { p _ { A } }$ , where $\lambda > 0$ is the penalty strength.
+
+The penalized objective has two drawbacks compared to the constrained one in Eq. $^ { 1 . }$ First, every gradient descent step on the penalized objective involves second-order gradients due to the gradient regularization, while the constrained form does not need second-order gradients when the constraint is satisfied. Second, it is difficult to choose a good $\lambda$ that works well for all architectures. By contrast, we set $\gamma$ by analyzing the first-order approximation mentioned above, and find the same $\gamma$ works well for different architectures. The results supporting these two points are given in Table 2.
+
+Table 2: Time cost and accuracy (average of 4 runs) for running one epoch of regularization/constrained form of GradInit.   
+
+<table><tr><td>Model</td><td>VGG-19 w/o BN</td><td>VGG-19 W/BN</td><td>ResNet-110 ResNet-110 w/o BN w/BN</td></tr><tr><td>Time (s)</td><td>82 vs.56</td><td>100 vs. 62</td><td>169 vs.103 269vs.195</td></tr><tr><td>入=10-4</td><td>32.3,94.6</td><td>10.6,93.1</td><td>33.7,93.9 32.4,95.2</td></tr><tr><td>入=10-2</td><td>30.4,94.5</td><td>10.4,93.0</td><td>36.7,94.1 32.6,95.3</td></tr><tr><td>入=1</td><td>18.2, 74.7</td><td>38.5,95.1</td><td>30.7,94.2 36.5,95.3</td></tr><tr><td>γ=1</td><td>29.3,94.7</td><td>47.8, 95.1</td><td>36.2,94.6 38.2, 95.4</td></tr></table>
+
+# 4 Experiments
+
+We evaluate GradInit on benchmark datasets for image classification and machine translation tasks. For image classification, five different architectures are evaluated for CIFAR10 [26], and ResNet-50 is evaluated for ImageNet [27]. For machine translation, we use GradInit to find good initializations for a Post-LN Transformer without any change to its original architecture on IWSLT-14 De-En [28]. We observe that the method can remove the necessity of any form of learning rate warmup for both Adam and SGD.
+
+We conduct our experiments in PyTorch. We use the fairseq library for machine translation $\mathbb { \left[ \left[ 2 9 \right] \right] }$ . All the experiments on CIFAR-10 and IWSLT-14 DE-EN can run with one single NVIDIA RTX 2080 Ti GPU with 11GB of RAM.
+
+GradInit first initializes the weights using Kaiming initialization [2] for all the Conv and FC layers for image classification. For machine translation, we use the default Xavier initialization [1]. We optimize the scale factors $\left\{ \alpha _ { i } \right\}$ with Adam $\pmb { \mathbb { B } } 0 \|$ using the default momentum parameters.
+
+# 4.1 Image Datasets with Various Architectures
+
+The introduction of Batch Normalization (BN) $\mathbb { \lVert 1 9 \rVert }$ and skip connections makes it relatively easy to train common CNNs for image classification to achieve high accuracy. Despite this, we show that
+
+when the network is very deep, the network is unstable even when both BN and skip connections are used, and GradInit can significantly improve the stability. The results on CIFAR-10 are given in Table 3 and results on ImageNet are given in Table 6.
+
+# 4.1.1 Settings
+
+Architectures. On CIFAR-10, we focus on the feedforward VGG net and the prevalent and powerful ResNet, with and without BN layers. For networks without BN, we use learnable biases in all layers. For ResNet, we additionally evaluate a deep 1202-layer version. We give results for other architectures (Wide ResNet, DenseNet) in Appendix E due to space limits. We compare with four different methods/settings: 1) Kaiming Initialization [2]; 2) First train the network for one epoch with a constant learning rate equal to the starting learning rate, labelled as $^ { 6 } { + } 1$ epoch (Const. LR)" in Table 3; 3) First train the network for one epoch with a linear warmup learning rate, labbeled as $^ { 6 6 } { + 1 }$ epoch (Warmup)" in Table 3; 4) MetaInit [16].
+
+On ImageNet, we use the ResNet-50 model $\scriptstyle { \left[ \left[ 2 1 \right] \right] }$ . We compare with Kaiming Initialization, FixUp initialization $[ [ 9 $ and MetaInit. For the ResNet-50 without BN, we follow the architecture of FixUp for fair comparisons, but we still use the original Kaiming initialization as the starting point of GradInit.
+
+Hyperparameters. We set $\mathcal { A }$ to SGD and $\eta = 0 . 1$ (the same as the base learning rate) for GradInit in all image classification experiments. On CIFAR-10, we train networks with a batch size of 128. We find MetaInit often takes 2 to 3 times as much memory as GradInit. We run GradInit or MetaInit for one epoch on the data, which takes less than $1 \%$ of the total training time. For GradInit, according to our analysis in Section $^ { 3 . 3 , }$ we fix the gradient norm constraint $\gamma = 1$ in all these experiments. Therefore, as in MetaInit, the only hyperparameter that needs to be tuned is the learning rate $\tau$ of the scale factors. We do a grid search on $\tau$ in the range $[ 1 0 ^ { - 3 } , 1 0 ^ { - 1 } ]$ , and report the results with the best average final test accuracy on 4 runs. After GradInit initialization, we use a learning rate of 0.1 and the cosine annealing learning rate schedule without restart $\pmb { \mathbb { B } } \mathbf { \mathbb { 1 } }$ to train the model for 200 epochs, where the learning rate decays after each iteration and decays to 0 in the last iteration. Due to their high initial gradient variance (see Figure $^ { 6 ) }$ , we have applied gradient clipping (maximum norm is 1) to all non-BN networks so that they converge without GradInit under the same schedule.
+
+On ImageNet, we train the ResNet-50 model for 90 epochs with a total batch size of 256 on 4 GPUs. Due to the difference in the library for training and the number of GPUs used, which affects the BN statistics, our baseline top-1 accuracy of ResNet-50 (w/ BN) on ImageNet is $0 . 7 9 \%$ lower than $\mathbb { \lVert 3 2 \rVert }$ . We use SGD with a starting learning rate of 0.1 and decay the learning rate by 10 after the $3 0 \mathrm { t h }$ and 60th epoch. We provide additional details in Appendix A.
+
+# 4.1.2 Results and Analysis
+
+Table 3: First epoch $( A c c _ { 1 } )$ and best test accuracy over all epochs $( A c c _ { b e s t } )$ for models on CIFAR-10. We report the mean and standard error of the test accuracies in 4 experiments with different random seeds. Best results in each group are in bold.   
+
+<table><tr><td colspan="2">Model (#Params)</td><td>VGG-19 w/o BN (20.03M)</td><td>VGG-19 w/BN (20.04M)</td><td>ResNet-110 w/o BN (1.72M)</td><td>ResNet-110 w/BN (1.73M)</td><td>ResNet-1202 w/BN (19.42M)</td></tr><tr><td rowspan="2">Kaiming</td><td>AcC1</td><td>29.1 ± 1.5</td><td>12.6 ± 0.6</td><td>16.1 ± 2.1</td><td>23.2 ± 0.9</td><td>12.9 ± 2.8</td></tr><tr><td>AcCbest</td><td>94.5 ± 0.1</td><td>94.4 ± 0.1</td><td>94.2 ± 0.1</td><td>95.0± 0.2</td><td>94.4 ± 0.6</td></tr><tr><td rowspan="2">+1 epoch (Const. LR)</td><td>Acc1</td><td>37.2 ± 1.1</td><td>19.6 ± 4.0</td><td>21.0 ± 3.8</td><td>32.5 ±3.8</td><td>12.6 ± 2.8</td></tr><tr><td>Accbest</td><td>94.4± 0.1</td><td>94.5 ± 0.1</td><td>93.9 ± 0.4</td><td>94.7 ± 0.3</td><td>94.0 ± 0.4</td></tr><tr><td rowspan="2">+1 epoch (Warmup)</td><td>Acc1</td><td>37.4 ±1.2</td><td>53.5 ± 2.9</td><td>19.8 ± 0.5</td><td>48.7 ± 1.1</td><td>28.1 ± 1.3</td></tr><tr><td>AcCbest</td><td>94.4 ± 0.1</td><td>94.7 ± 0.1</td><td>94.1 ± 0.1</td><td>95.1 ± 0.1</td><td>95.4± 0.2</td></tr><tr><td rowspan="2">MetaInit</td><td>AcC1</td><td>30.5± 0.9</td><td>35.1 ± 0.6</td><td>14.6 ± 2.2</td><td>29.0 ± 1.5</td><td>11.7 ± 1.6</td></tr><tr><td>AcCbest</td><td>94.6 ± 0.1</td><td>94.6 ± 0.1</td><td>94.2 ± 0.1</td><td>94.8 ± 0.1</td><td>95.0 ± 0.5</td></tr><tr><td rowspan="2">GradInit</td><td>AcC1</td><td>29.3±0.6</td><td>47.8 ± 1.8</td><td>36.2 ±0.8</td><td>38.2 ± 0.9</td><td>29.0 ± 1.1</td></tr><tr><td>Accbest</td><td>94.7 ± 0.1</td><td>95.1 ± 0.1</td><td>94.6 ± 0.1</td><td>95.4± 0.1</td><td>96.2 ± 0.1</td></tr></table>
+
+GradInit further stabilizes feedforward nets with BN. BN does stabilize VGG-19 and allows training without gradient clipping, but with an average first-epoch test accuracy of only 12.57 and an average final test accuracy lower than the version without BN (see Table $\textcircled{3}$ , it does not seem to eliminate the instability of Kaiming initialization. As shown in Figure $\bigtriangledown ,$ its initial gradient variance is still relatively high compared with GradInit. BN could magnify the gradient variance when the variance of its input features (in the forward pass) is smaller than 1 (see Appendix $\boxed { \mathbf { C } }$ . GradInit reduces the gradient variance by 4 orders of magnitude compared to Kaiming initialization , resulting in significantly higher test accuracy after the first epoch $( 4 7 . 7 9 \%$ vs. $1 2 . 5 7 \%$ ), which also has an impact on the final test accuracy $( 9 5 . 1 3 \%$ vs. $9 4 . 4 1 \%$ ). The reduction in gradient variance is achieved mainly by scaling down the weights of the final FC layer and the last 2 BN layers, so that the variance of the activations is reduced in the forward pass. This learned behavior is consistent with the strategy of FixUp, where the final FC layer is initialized to 0. Another source of gradient variance reduction is achieved by increasing the weight norms of the remaining Conv and BN layers, so that the variance of the inputs to the BN layers is increased and the gradient magnifying effect of BN is alleviated in the backward pass. This reduced the ratio $\sigma ( \pmb { g } _ { 1 } ) / \bar { \sigma } ( \pmb { g } _ { 1 6 } )$ from 204.9 to 164.8 for the Conv layers in Figure 4. By contrast, FixUp only reduces the weight norms, which may not always be the best solution for networks with normalization layers.
+
+![](images/b1c7d4d91bac8e66a991e0f50cbde8c33271da8b1f33abfd97bece26ad451b27.jpg)  
+Figure 1: Top row: results of ResNet-110 on CIFAR-10. Bottom row: results of ResNet-50 on ImageNet. Left two columns: compare the relative cross-batch gradient variance on the training set for the BN and Conv/FC layers before and after GradInit. Right two columns: weight norms before and after GradInit. Ratio between points in the same layer reflects the scale factor. Note each of the residual blocks has 2 and 3 Conv and BN layers for the ResNet-110 and ResNet-50, respectively. The initial relative gradient variance are reduced for all layers except the final linear layer in both settings. The strategies are similar on two different datasets. Within each residual block, the last BN layer has the smallest scaling factors, and the scales of all Conv layers are surprisingly increased. Best viewed in color.
+
+![](images/68982e2c5ddf39fc5a9aa28acb3eeeb208468a65c714c3beb3e000e0d69d317f.jpg)  
+Figure 2: Comparing the convergence of Kaiming Initialization and GradInit on CIFAR-10, for models trained with SGD (left three) and Adam (right).
+
+Deep residual networks still need better initializations. We also gain significant improvements from GradInit for ResNet-110 and ResNet-1202. In ResNets, the skip connections cause the variance of activations to accumulate as the ResNet goes deeper, even for the version with BN $\mathbb { m }$ . This issue is more significant when the ResNet scales to 1202 layers, from which we can see that with Kaiming initialization, the first-epoch accuracy of ResNet-1202 is quite low, and the final test accuracy is even worse than the shallower ResNet-110, matching the observations of He et al. $\left[ \left[ 2 1 \right] \right]$ . Warmup is even more effective than MetaInit at accelerating the convergence and improving the final test accuracy of ResNet-1202, but GradInit still outperforms its final test accuracy by $0 . 8 \%$ , and the resulting ResNet-1202 finally achieved higher accuracy than ResNet-110.
+
+The learned layer-wise rescaling patterns of GradInit are even more interesting for ResNets with BN. For ResNets with BN, recall that we have two Conv layers and two BN layers in each residual block. As shown in Figure 1, GradInit learns to increase the weight norms of all the linear layers except for the final FC layer, instead of decreasing as for the case without BN (see Figure $6 )$ . A more unique pattern is the collaborative behavior of the BN weights, where the second BN in each residual block is usually scaled down while the first BN is always scaled up. In deeper layers, the joint effect of these two BN weights is to downscale the activations and reduce their variance in the forward pass, with a more significant reducing effect as the layers get deeper. Intuitively, the marginal utility of adding a new layer decreases with depth. Therefore, for deeper layers, GradInit learns to further downscale the residual branch, and prevents the variance from increasing too much in the forward pass. Inside each residual block, increasing the scale factors of the first BN helps to reduce the magnification effect of the second BN on the gradient; forcing the input activations to the second convolution to have variance larger than 1 ensures its variance after the following convolution layer does not go below 1, avoiding the magnification effect that the second BN has on the gradient variance. See Appendix C for more discussions about the magnifying effect.
+
+Table 4: Comparing the results of GradInit with fixed BN scale parameters (Fix BN) and only rescale the BN parameters (Only BN).   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Kaiming</td><td colspan="2">GradInit</td><td colspan="2">GradInit (Fix BN)</td><td rowspan="2">GradInit (Only BN) Accbest</td></tr><tr><td>Acco</td><td>Accbest</td><td>Acco</td><td>Accbest</td><td>Acco Accbest</td><td>Acco</td></tr><tr><td>VGG-19 (w/ BN)</td><td>12.6 ±0.6 94.4 ± 0.1 47.8 ± 1.8 95.1 ± 0.1 13.1 ± 0.9 94.6 ±0.1 14.4 ± 2.1 94.4 ± 0.1</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ResNet-110(w/BN) 23.2±0.9 95.0 ±0.2 38.2 ±0.9 95.4 ± 0.1 24.7±3.1 94.7±0.3 25.4±3.1 94.6± 0.3</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 5: Comparing the results with multiplying each weight matrix with a learnable scaler (Learning Scalars) on CIFAR10. The VGG-19 model is not able to converge unless we reduce the initial learning rate to 0.01, which obtained worse final accuracy. The ResNet-110 model’s $A c c _ { 0 }$ was $10 \%$ for 2 of the 4 runs.   
+
+<table><tr><td>Model</td><td colspan="2">Learning Scalars</td><td colspan="2">GradInit</td></tr><tr><td></td><td>Acco</td><td>Accbest</td><td>Acco</td><td>AcCbest</td></tr><tr><td>VGG-19 (w/BN,Ir=0.1)</td><td>10.0±0.0</td><td></td><td>10.0±0.0 47.8±1.8 95.1±0.1</td><td></td></tr><tr><td>VGG-19 (w/BN,Ir=0.01) 50.6±0.8</td><td></td><td>93.4 ±0.1</td><td></td><td>=</td></tr><tr><td>ResNet-110 (w/BN)</td><td>21.5 ± 6.9</td><td></td><td>94.7 ± 0.1 38.2 ± 0.9 95.4 ± 0.1</td><td></td></tr></table>
+
+Generalizing to Adam. Models in previous experiments are trained with SGD. We also consider the case when $\mathcal { A }$ is Adam and use AdamW $\pmb { \Vert 3 3 \Vert }$ to train the ResNet-110 (w/ BN) model on CIFAR-10. Following $\pmb { \mathbb { B 4 } }$ , we use a cosine annealing learning rate schedule with initial learning rate $3 \times 1 0 ^ { - 3 }$ and weight decay 0.2. For GradInit, we set $\gamma = 2 5$ . The $A c c _ { 1 }$ and $A c c _ { b e s t }$ of Kaiming initialization and GradInit are $( 3 6 . 6 \pm 4 . 7$ , $9 4 . 9 \pm 0 . 1 )$ and $( 4 0 . 2 \pm 0 . 2$ , $9 5 . 3 \pm 0 . 1 )$ , respectively. We also show the per-epoch test accuracy in Figure 2.
+
+The importance of rescaling BN layers. The scale parameters of BN layers usually controls the variance of activations and gradients in the forward and backward passes, while the linear layers right before the BN layers are scale-invariant. Although changing the magnitudes of the scale-invariant layers affect their learning dynamics $\mathbb { \left| \sum 3 \right| \left| \sum 4 \right| }$ , we find it important for GradInit to rescale both BN and other linear layers, as shown in Table 4.
+
+The importance of GradInit’s objective. GradInit is designed to rescale the layers to solve the constrained optimization problem in Eq. $\mathbb { L }$ Simply letting the model to learn to rescale the layers cannot improve the results, and sometimes further causes instability, as shown in Table $5 .$ We hypothesize that the bad results with VGG are due to a mismatch between the scales/norms of the gradients of the scalars and the weights. To make this alternative work, we may need to set different learning rates for the scalars and the weights, which adds to the difficulty of hyperparameter tuning. Note we do not learn the scalars when training networks initialized by GradInit.
+
+Table 6: $A c c _ { 1 } / A c c _ { b e s t }$ of ResNet-50 models on ImageNet. Result of MetaInit comes from Dauphin and Schoenholz $\mathbb { I } \mathbb { 6 } \mathbb { I }$ and we reimplemented the rest.   
+
+<table><tr><td></td><td>Kaiming</td><td>FixUp</td><td>MetaInit</td><td>GradInit</td></tr><tr><td>w/BN</td><td>14.6/75.9</td><td>1</td><td>-</td><td>19.2/76.2</td></tr><tr><td>w/o BN</td><td>1</td><td>18.0/75.7</td><td>-/75.4</td><td>19.2/75.8</td></tr></table>
+
+GradInit scales to ImageNet. As shown in Table $6 ,$ GradInit also accelerates convergence and improves test accuracy of ResNet-50 on ImageNet, with or without BN layers, despite having to use a smaller batch size for GradInit than training due to our GPU memory limit. The acceleration achieved by GradInit is even more significant than FixUp, even on the network with the architecture designed for the initialization.
+
+# 4.2 Training the Original Transformer Model without Warmup
+
+For a Transformer model to converge, either an explicit or implicit learning rate warmup stage is needed, especially for the original Transformer architecture. It is observed that this Post-LN architecture tends to outperform the Pre-LN model $\textcircled { 6 }$ while having higher gradient variance at initialization [4]. Is it believed that this high variance makes a warmup stage inevitable. Previous works that removes the warmup stage often involves architectural changes, e.g., removing Layer Normalizations, since it can surprisingly cause instability [4]. Here, we show that with a proper initialization, we can do away with the warmup stage for the original Post-LN Transformer without any modification to the architecture. Table 7 summarizes the architectural changes and best results of methods for improving the initialization of Post-LN Transformers. We compare the stability of the GradInit and Admin initialization methods without warmup in Figure 3.
+
+Table 7: A comparison of GradInit with with the results from the papers (top 4 rows), and our reimplementation of Admin for training the Post-LN Transformer model on the IWSLT-14 De-EN dataset. “Standard" refers to training with standard initialization and warmup.   
+
+<table><tr><td>Method</td><td>Remove LN</td><td>Wskip</td><td>Warmup</td><td>Optimizer</td><td>BLEU</td></tr><tr><td>Standard [6</td><td></td><td></td><td>√</td><td>RAdam</td><td>35.6</td></tr><tr><td>FixUp 回</td><td>√</td><td></td><td>√</td><td>Adam</td><td>34.5</td></tr><tr><td>T-FixUp[5]</td><td></td><td></td><td></td><td>Adam</td><td>35.5</td></tr><tr><td>Admin 回</td><td></td><td>√</td><td></td><td>RAdam</td><td>35.7</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>SGD</td><td>33.7</td></tr><tr><td>GradInit</td><td></td><td>√</td><td></td><td>Adam</td><td>36.0</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>SGD</td><td>35.6</td></tr></table>
+
+# Dataset, Architecture, & Hyperparameters.
+
+IWSLT’14 DE-EN $\left[ \left[ 2 8 \right] \right]$ is a German to English translation dataset that has $1 6 0 \mathrm { k }$ training examples. Our Transformer model is inherited from $\mathbf { \widehat { \mathbb { B } } }$ , which is a Post-LN Transformer placing its Layer Normalization after the summation of the skip connection and the residual branch. It has a 512- dimensional word embedding layer and 1024 dimensions in its hidden FFN layer. We also apply GradInit to the variant from Admin $\pmb { \Vert 6 \Vert }$ , where a learnable vector ${ { \pmb w } _ { s k i p } }$ is element-wise multiplied with each dimension of the skip connection, but we initialize it to 1 for GradInit. Please refer to $\dot { \left. \left[ 6 \right] \right. }$ for how Admin initializes these weights. Following $\pmb { \Vert 6 \Vert }$ , we use a linearly decaying learning rate schedule that decays from the maximum learning rate $\eta _ { \mathrm { m a x } }$ to 0 as the model trains for 100K iterations. For training with SGD, we set the prescribed learning rate $\eta _ { \mathrm { m a x } } = 0 . 1 5$ , and use $\eta = 0 . 1 5 , \gamma = 1$ for GradInit. We do a grid search on $\eta _ { \mathrm { m a x } }$ for Admin and report its best result in Table $\perp$ For training with Adam, we set $\dot { \eta } = 5 \times 1 0 ^ { - 4 } , \dot { \gamma } = 1 0 ^ { 3 }$ for the objective of GradInit, so that $\eta \gamma$ is $O ( 1 0 ^ { - 1 } )$ as discussed in Section 3.3. We train the initialized model $\eta _ { \mathrm { m a x } }$ and $\beta _ { 2 }$ as listed in Figure $3 .$ We evaluate the BLEU score every epoch, and report the best BLEU scores throughout training for each run. For GradInit, we set the maximum number of iterations $T$ to 780. By comparison, the warmup stage usually takes 4000 iterations, and we find that if we use 780 steps for warmup, the model does not converge with $\eta _ { \mathrm { m a x } } \ge 3 \times 1 0 ^ { - 4 }$ . For $\eta _ { \mathrm { m a x } } = 2 \times 1 0 ^ { - 4 }$ with 780-step warmup, the BLEU score is 35.4, worse than GradInit’s 36.0, showing the advantage of GradInit against warmup.
+
+Stability after removing warmup for Adam. In Figure $^ { 3 , }$ , the training process becomes more unstable as $\beta _ { 2 }$ grows larger. From the analysis of RAdam $[ \overbrace { 3 5 } ] ]$ , this is because the variance of the gradient has a stronger impact on the adaptive learning rate when $\beta _ { 2 }$ is closer to 1. Therefore, the largest $\beta _ { 2 } < 1$ that maintains the performance of the trained model reflects the stability of the initialization. We can see GradInit results in more stable models than Admin in general, though their best performance numbers are almost the same. In addition, we find ${ { \pmb w } _ { s k i p } }$ can help stabilize training in extreme hyper parameter settings, e.g., at $\eta _ { \mathrm { m a x } } = 5 \times 1 0 ^ { - 4 }$ and $\beta _ { 2 } = 0 . 9 9 5$ in Figure $\bigtriangledown _ { \ b { \lambda } }$ GradInit with ${ { \pmb w } _ { s k i p } }$ obtains a good average BLEU score of 36.0, while without ${ { \pmb w } _ { s k i p } }$ only succeeded in obtaining a BLEU score $> 3 5$ for one out of four experiments, resulting in an average BLEU score of 8.9.
+
+We also find the network is unable to be trained without learning rate warmup if we just fix ${ { \pmb w } _ { s k i p } }$ to its initial value given by Admin and leave the initialization of other parameters unchanged. Nevertheless, with GradInit, we do not need to modify the architecture of Post-LN Transformer to obtain the same good result as Admin. For a closer look at the stabilization mechanism, we show the weight norms and gradient variance at initialization of the original Post-LN architecture using GradInit and Xavier initialization in Figure 9 of the Appendix. For Xavier initialization, the gradient variance is relatively higher for all encoder layers, so GradInit downscales the encoder layer weights more in general. For the LN weights, GradInit only
+
+![](images/54b16b400c864897eac4effa71200cc1009e90a3c1eecd924677164f4aecc148.jpg)  
+Figure 3: BLEU scores for the Post-LN Transformer without learning rate warmup using Adam on IWSLT-14 DE-EN under different learning rates $\eta _ { \mathrm { m a x } }$ ( $y$ axis) and $\beta _ { 2 }$ $x$ axis). Each result is averaged over 4 experiments.
+
+downscales the final LN of both the encoder and decoder, which reduces the variance of the encoder and decoder during the forward pass. Another strategy GradInit learns is to downscale the weights of the output projection and the FFN layers, so that the residual branch is relatively down-weighted compared with the skip connection, similar to Admin.
+
+Removing warmup without architectural change. Another widely observed phenomenon is that adaptive methods such as Adam seem to be much better than SGD for training Transformer-based language models [13]. Table 7 shows that, with GradInit, we can find a good initialization for the Post-LN Transformer on IWSLT-14 DE-EN that trains using SGD without learning rate warmup nor gradient clipping, and achieves performance close to Adam trained using the same type of learning rate schedule. By comparison, Admin also makes the Transformer trainable with SGD, but the BLEU score is lower than the one initialized with GradInit. By comparing Figures 9 and $\bigstar$ in the Appendix, we find GradInit for Adam and SGD adopts different rescaling patterns, with the Adam version depending more on downscaling the residual branches through the FFN and output projection layers than the SGD version, and the SGD version downscaling more in the final FFN block of the decoder. This highlights the importance of considering the optimization algorithm $\mathcal { A }$ in GradInit, and also indicates the presence of different ways to reduce the initial gradient variance.
+
+# 5 Conclusion
+
+In this paper, we propose GradInit, a gradient-based initialization scheme for any architecture. GradInit reinitializes a network by learning a scale factor for each randomly initialized parameter block of a network, so that the training loss evaluated on a different minibatch after one gradient step of a specific stochastic optimizer is minimized. Such a design takes the stochasticity, the learning rate, and the direction of the optimizer into account, allowing us to find better initializations tailored for the optimizer. The initialization learned by GradInit often decreases the gradient variance for most of the parameter blocks. We show that GradInit accelerates the convergence and improves the test performance of a variety of architectures on image classification. It also enables training the Post-LN Transformer without any form of learning rate warmup, even for SGD. GradInit can be a useful tool in the future discovery of better neural architectures that are otherwise discarded due to poor initializations. By analyzing the learned scaling coefficients and their impact on gradient variance, it can also serve a guide to design better initialization schemes for complex architectures to shorten the training schedule and save energy.
+
+# 6 Acknowledgement
+
+This project was supported by the Office of Naval Research, AFOSR MURI program, the DARPA Young Faculty Award, and the National Science Foundation Division of Mathematical Sciences. Additional support was provided by Capital One Bank and JP Morgan Chase.
+
+References   
+[1] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In AISTATS, 2010.   
+[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In CVPR, 2015.   
+[3] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, pages 5998–6008, 2017.   
+[4] Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In ICML, 2020.   
+[5] Xiao Shi Huang, Felipe Perez, Jimmy Ba, and Maksims Volkovs. Improving transformer optimization through better initialization. In ICML, 2020.   
+[6] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. EMNLP, 2020.   
+[7] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   
+[8] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. NeurIPS, 2020.   
+[9] Hongyi Zhang, Yann N Dauphin, and Tengyu Ma. Fixup initialization: Residual learning without normalization. In ICLR, 2019.   
+[10] Soham De and Sam Smith. Batch normalization biases residual blocks towards the identity function in deep networks. NeurIPS, 2020.   
+[11] Andrew Brock, Soham De, and Samuel L Smith. Characterizing signal propagation to close the performance gap in unnormalized resnets. ICLR, 2021.   
+[12] Andrew Brock, Soham De, Samuel L. Smith, and Karen Simonyan. High-performance largescale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   
+[13] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why are adaptive methods good for attention models? NeurIPS, 2020.   
+[14] Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. ICLR, 2014.   
+[15] Dmytro Mishkin and Jiri Matas. All you need is a good init. ICLR, 2016.   
+[16] Yann N Dauphin and Samuel Schoenholz. Metainit: Initializing learning by learning to initialize. In NeurIPS, pages 12645–12657, 2019.   
+[17] Mert Gurbuzbalaban and Yuanhan Hu. Fractional moment-preserving initialization schemes for training deep neural networks. In International Conference on Artificial Intelligence and Statistics, pages 2233–2241. PMLR, 2021.   
+[18] Charles H Martin and Michael W Mahoney. Traditional and heavy-tailed self regularization in neural network models. arXiv preprint arXiv:1901.08276, 2019.   
+[19] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pages 448–456, 2015.   
+[20] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   
+[21] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016.   
+[22] Thomas Bachlechner, Bodhisattwa Prasad Majumder, Huanru Henry Mao, Garrison W Cottrell, and Julian McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   
+[23] Sanjeev Arora, Zhiyuan Li, and Kaifeng Lyu. Theoretical analysis of auto rate-tuning by batch normalization. In International Conference on Learning Representations, 2019.   
+[24] Ruosi Wan, Zhanxing Zhu, Xiangyu Zhang, and Jian Sun. Spherical motion dynamics of deep neural networks with batch normalization and weight decay. arXiv preprint arXiv:2006.08419, 2020.   
+[25] Lukas Balles and Philipp Hennig. Dissecting adam: The sign, magnitude and variance of stochastic gradients. In ICML, pages 404–413, 2018.   
+[26] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   
+[27] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR, 2009.   
+[28] Mauro Cettolo, Jan Niehues, Sebastian Stüker, Luisa Bentivogli, and Marcello Federico. Report on the 11th iwslt evaluation campaign, iwslt 2014. In IWSLT, volume 57, 2014.   
+[29] Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In NAACL-HLT (Demonstrations), 2019.   
+[30] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.   
+[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   
+[32] Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   
+[33] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2018.   
+[34] Chen Zhu, Yu Cheng, Zhe Gan, Furong Huang, Jingjing Liu, and Tom Goldstein. Maxva: Fast adaptation of step sizes by maximizing observed variance of gradients. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 628–643. Springer, 2021.   
+[35] Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. ICLR, 2020.   
+[36] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   
+[37] Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+[38] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.   
+[39] Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   
+[40] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ICLR, 2018.   
+[41] Jeremy Bernstein, Yu-Xiang Wang, Kamyar Azizzadenesheli, and Animashree Anandkumar. signsgd: Compressed optimisation for non-convex problems. In ICML, 2018.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] One limitation of our current work is we have not checked whether GradInit can improve the training of models from other domains such as speech.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [Yes]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/03x6x6qNwJ3/03x6x6qNwJ3_content_list.json

@@ -0,0 +1,1208 @@
+[
+    {
+        "type": "text",
+        "text": "GradInit: Learning to Initialize Neural Networks for Stable and Efficient Training ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            122,
+            818,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chen Zhu University of Maryland chenzhu@cs.umd.edu ",
+        "bbox": [
+            217,
+            226,
+            372,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Renkun Ni University of Maryland rn9zm@cs.umd.edu ",
+        "bbox": [
+            419,
+            226,
+            576,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zheng Xu Google Research xuzheng@google.com ",
+        "bbox": [
+            624,
+            226,
+            782,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kezhi Kong University of Maryland kong@cs.umd.edu ",
+        "bbox": [
+            223,
+            289,
+            380,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "W. Ronny Huang Google Research wrh@google.com ",
+        "bbox": [
+            437,
+            289,
+            562,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tom Goldstein University of Maryland tomg@cs.umd.edu ",
+        "bbox": [
+            617,
+            289,
+            774,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Innovations in neural architectures have fostered significant breakthroughs in language modeling and computer vision. Unfortunately, novel architectures often result in challenging hyper-parameter choices and training instability if the network parameters are not properly initialized. A number of architecture-specific initialization schemes have been proposed, but these schemes are not always portable to new architectures. This paper presents GradInit, an automated and architecture agnostic method for initializing neural networks. GradInit is based on a simple heuristic; the norm of each network layer is adjusted so that a single step of SGD or Adam with prescribed hyperparameters results in the smallest possible loss value. This adjustment is done by introducing a scalar multiplier variable in front of each parameter block, and then optimizing these variables using a simple numerical scheme. GradInit accelerates the convergence and test performance of many convolutional architectures, both with or without skip connections, and even without normalization layers. It also improves the stability of the original Transformer architecture for machine translation, enabling training it without learning rate warmup using either Adam or SGD under a wide range of learning rates and momentum coefficients. Code is available at https://github.com/zhuchen03/gradinit. ",
+        "bbox": [
+            232,
+            397,
+            766,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            310,
+            674
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The initialization of network parameters has a strong impact on the training stability and performance of deep neural networks. Initializations that prevent gradient explosion/vanishing in back propagation played a key role in early successes with feed-forward networks [1, 2]. Even with cleverly designed initialization rules, complex models with many layers or multiple branches can still suffer from instability. For example, the original Transformer model [3] does not converge without learning rate warmup using the default initialization [4–6]; RoBERTa [7] and GPT-3 $\\pmb { \\| \\widetilde { \\ 8 } \\| }$ have to tune the $\\beta _ { 2 }$ parameter of Adam for stability when the batch size is large. Recent innovations have shown that architecture-specific initializations, which are carefully derived to maintain stability, can promote convergence without needing normalization layers [5, 9–12]. Unfortunately, the reliance on analytically derived initializations makes it difficult to realize the benefits of these methods when performing architecture search, training networks with branched or heterogeneous components, or proposing altogether new architectures. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a simple method for learning the initialization of a network with any architecture. Typically, initialization schemes draw parameters independently from a zero-mean distribution, with the variance of each distribution set to pre-determined values depending on the dimensions of the layers [1, 2]. Rather than deriving a closed-form expression for the these distribution parameters, our method re-scales each random weight tensor (e.g. convolution kernels) directly by a learned scalar coefficient. This small set of coefficients is optimized to make the first step of a stochastic optimizer (e.g. SGD or Adam) as effective as possible at minimizing the training loss, while preventing the initial gradient norm from exploding. In addition, this process is designed to take into account the direction, step size, and stochasticity of the optimizer. Finally, after the variance has been learned for each parameter tensor, the random network parameters are re-scaled and optimization proceeds as normal. We empirically find that our methods can make the initialization fall into a smooth loss region, reduce the inter-sample gradient variance, and accelerates training. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposed method, GradInit, is architecture agnostic, and works with both Adam and SGD optimizers. In the vision domain, we show it accelerates the convergence and test performance of a variety of deep architectures, from the vanilla feed-forward VGG net to ResNet, with or without Batch Normalization. It is efficient and scalable, finding good initializations using less than $1 \\%$ of the total training time in our experiments, and it improves the initialization of ResNet-50 on ImageNet to obtain better final test accuracy. In the language domain, GradInit enables training the original Transformer model $\\pmb { \\mathbb { B } }$ using either Adam or SGD without learning rate warmup for machine translation, which is commonly acknowledged to be difficult [4, 13]. As an extreme example of the capabilities of GradInit, we use it to initialize and train a 1202-layer ResNet that achieves significantly higher test accuracy than ResNet-110, which other initialization methods have failed to achieve. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, by visualizing the initial norms and gradient variances of the weights before and after GradInit is applied, we show that GradInit is a useful tool for identifying potential causes for instability at initialization, such as those imposed by normalization layers, and we summarize interesting scale patterns learned by GradInit that can be helpful for designing better initialization rules. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            443,
+            321,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Controlling the norms of network parameters at initialization has proven to be an effective approach for speeding up and stabilizing training. Glorot and Bengio $\\mathbb { M }$ studied how the variance of features evolves with depth in feed-forward linear neural networks by assuming both activations and weight tensors are independent and identical random variables. They developed a technique in which the variance of each filter scales with its fan-in (the number of input neurons). This style of analysis was later generalized to the case of ReLU networks $\\pmb { \\mathbb { Z } } ] \\mathbf { l }$ . These two analyses are most effective for feed-forward networks without skip connections or normalization layers. Based on the orthogonal initialization scheme $\\pmb { \\mathbb { I } }$ , Mishkin and Matas $[ \\overline { { 1 5 } } ]$ proposed an iterative procedure to rescale the orthogonally initialized weights of each layer in feedforward networks so that the activations of that layer have unit variance. However, this method fails to prevent the blowup of activations with depth for ResNets [16]. Recently, Gurbuzbalaban and Hu $[ \\textcircled { 1 7 } ]$ proposed initialization schemes such that the network can provably preserve any given moment of order $s \\in ( 0 , 2 ]$ for the output of each layer. The motivation is that the stochastic gradient updates can result in heavy-tailedness in the distribution of the network weights with a potentially infinite variance, but finite $s$ -order moment $\\mathbb { \\lVert \\rVert }$ . Again, these initialization schemes can only be applied for feed-forward neural networks. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For more complex architectures, normalization layers $\\mathbb { n m }$ and skip connections $\\scriptstyle { \\left\\| { \\overline { { 2 1 } } } \\right\\| }$ stabilized training dynamics and improved the state-of-the-art. Similarly, learning rate warmup is a common trick for training large Transformers $\\pmb { \\mathbb { B } } \\|$ . These methods make training tractable for some models, but do not eliminate the high initial gradient variance that destabilizes training when the network is deep [9–11] or when the normalization layers are not carefully positioned [4]. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            760
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Several authors have proposed better initializations for networks with skip connections. This is often achieved by replacing the normalization layers with simpler scaling or bias operations, and scaling the weight matrices in each layer so that the variance of activations does not increase with depth [9– 12]. Similar analysis has been applied to self attention in Transformers [5]. Without removing the normalization layers, it is possbile to stabilize the initial parameter updates by introducing carefully initialized learnable scale factors to the skip connections $\\pmb { \\Vert 6 \\Vert }$ or the residual branches $\\pmb { \\left. 2 2 \\right. }$ . However, such techniques are often restricted to one specific architecture such as ResNets. ",
+        "bbox": [
+            173,
+            766,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, Dauphin and Schoenholz $\\mathbb { \\left[ \\left[ 1 6 \\right] \\right] }$ proposed a task-agnostic and automatic initialization method, MetaInit, for any neural network achitecture. MetaInit optimized the norms of weight tensors to minimize the “gradient quotient”, which measures the effect of curvature near the initial parameters, on minibatches of random Gaussian samples. However, as training data is usually accessible for most tasks of interest, it is simpler and potentially more efficient to use the training data for initialization. MetaInit also involves the gradient of a Hessian-vector product that requires computing a “gradient of the gradient” multiple times in tandem, which is very computationally intensive. Our proposed method distinguishes itself from MetaInit in the following ways: (i) Our method is more computationally efficient. MetaInit involves computing third-order derivatives, results in long computing times and high memory usage. The memory overhead of MetaInit is more of an issue for networks with normalization layers. For the relatively small-scale CIFAR-10 problem with batch size 64, MetaInit requires three GPUs (RTX 2080Ti), while the proposed GradInit needs just one. (ii) Our method takes the stochasticity of minibatches into consideration. MetaInit uses the local curvature evaluated on a single minibatch, which fails to capture the variance of the loss/gradient between two different stochastic minibatches. (iii) Our method considers the training dynamics of different optimization algorithms including the learning rate and the direction of the gradient step, and effectively handles different optimizers including SGD and Adam. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            271,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We aim to develop an initialization scheme applicable to arbitrary network architectures. Since previous works [1, 2, 9, 16, 10, 12] have shown that the initial weight norms effectively control the initial gradient norm on average, our method rescales the randomly initialized weight matrices using learnable scale factors.1 ",
+        "bbox": [
+            174,
+            335,
+            825,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using a small number of gradient descent steps on these scale factors, the proposed GradInit method chooses the initialization scalars so that the loss after the first gradient step taken by a stochastic optimizer (SGD or Adam) is as low as possible. The process of learning initialization coefficients accounts for the chosen learning rate, optimizer, and other parameters. To prevent gradient explosion, our method enforces a constraint that the gradient norm is no larger than a constant $\\gamma$ . ",
+        "bbox": [
+            174,
+            397,
+            825,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that for scale-invariant weights, e.g., convolution kernels before BN layers, rescaling still changes their learning dynamics by changing their effective learning rate $\\pm \\sqrt { 2 3 } \\sqrt { 2 4 } ]$ . Empirically, GradInit goes beyond simply preventing exploding or vanishing gradients; it also reduces the gradient variance, making the initialization fall into a smooth loss region with small gradient variance so that training is fast, see discussion about Figure $^ 1$ and comparisons in Figure $2 .$ ",
+        "bbox": [
+            174,
+            473,
+            825,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Efficient Learning-based Initialization via Constrained Optimization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            691,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We begin by filling all the weight matrices $\\{ W _ { 1 } , \\hdots , W _ { M } \\}$ of the network with values drawn from independent zero-mean Gaussian distributions, except for the scales and biases of the normalization layers (if any), which are initialized to 1 and 0 respectively. During the initialization process, we keep $\\{ W _ { 1 } , \\hdots , W _ { M } \\}$ constant, but we multiply each $W _ { i }$ with a learnable non-negative scale factor $\\alpha _ { i }$ (initialized to 1). After initialization, we rescale the weights by the learned scale factors, and start training without the learnable scale factors just as normal. We use $\\pmb { m } = \\{ \\alpha _ { 1 } , . . . , \\alpha _ { M } \\}$ to denote the set of scale factors, and $\\pmb { \\theta } _ { m } = \\{ \\alpha _ { 1 } \\pmb { W } _ { 1 } , \\ldots , \\alpha _ { M } \\pmb { W } _ { M } \\}$ is the set of rescaled weight matrices. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\begin{array} { r } { L ( S ; \\pmb { \\theta } ) = \\frac { 1 } { | S | } \\sum _ { x \\in S } \\ell ( x ; \\pmb { \\theta } ) } \\end{array}$ be the average loss of the model parameterized by $\\pmb \\theta$ on a minibatch of samples $S$ , where $| S |$ is the number of samples in the minibatch. We use $\\pmb { g } _ { S , \\pmb { \\theta } } = \\nabla _ { \\pmb { \\theta } } L ( S ; \\pmb { \\theta } )$ as a shorthand for the gradient of $\\pmb { \\theta }$ . During standard training, this gradient is preprocessed/preconditioned by the optimization algorithm $\\mathcal { A }$ , and then used to update the network parameters. GradInit solves the following constrained optimization problem: ",
+        "bbox": [
+            174,
+            685,
+            825,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2487a7d56698ad132194476b7617b22526001fe6abbdc781d205ff09630abc2f.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { m } { \\mathrm { m i n i m i z e } } } & { L ( \\tilde { S } ; \\pmb { \\theta } _ { m } - \\eta \\mathcal { A } [ \\pmb { g } _ { S , \\pmb { \\theta } _ { m } } ] ) , } \\\\ { \\mathrm { s u b j e c t ~ t o ~ } } & { \\| \\pmb { g } _ { S , \\pmb { \\theta } _ { m } } \\| _ { p , s } \\le \\gamma , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            766,
+            622,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $S$ and $\\tilde { S }$ are two different minibatches, $\\eta$ is a prescribed learning rate for the optimization algorithm $\\mathcal { A }$ , $p _ { \\mathcal { A } }$ is the $\\ell _ { p }$ -norm associated with $\\mathcal { A }$ , and $\\gamma$ is the upper bound for the norm. For the first gradient step, Adam uses $\\mathcal { A } [ g _ { S , \\theta _ { m } } ] = \\mathrm { s i g n } ( g _ { S , \\theta _ { m } } ) \\left[ \\left[ 2 5 \\right] \\right]$ , while SGD uses $\\mathcal { A } [ g ( S ; \\theta _ { m } ) ] =$ ",
+        "bbox": [
+            174,
+            819,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\gamma \\pmb { g } ( S ; \\pmb { \\theta } _ { m } ) / \\| \\pmb { g } ( S ; \\pmb { \\theta } _ { m } ) \\| _ { 2 }$ . We show how to choose $\\gamma$ and $p _ { \\cal A }$ without tuning in Section 3.3. We discuss the formulation of this problem and how to solve it below. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Solving the Constrained Problem ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            140,
+            442,
+            155
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The problem $( 1 )$ is solved using a stochastic gradient descent method in which we sample new mini-batches on each iteration. Since the proposed method uses gradient updates to compute the initialization, we dub it GradInit. We propose a simple solver to optimize objective $( 1 )$ in Algorithm 1 A key feature of our method is that is makes a simple approximation: after $g _ { S , \\theta _ { m } }$ is computed on the forward pass of an iteration, we treat $\\mathcal { A } [ \\pmb { g } _ { S } , \\pmb { \\theta } _ { m } ]$ as a constant and do not back-propagate through $\\mathcal { A } [ \\pmb { g } _ { S } , \\pmb { \\theta } _ { m } ]$ on the backward pass. We make this choice to keep computing costs low, and because it is not possible to back-propagate through the non-differentiable sign function for Adam. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/37d2f1f6ff2fc475153ce55d1616a350bf22027fc6624ecec645f1eeab46d211.jpg",
+        "table_caption": [
+            "Algorithm 1 GradInit for learning the initialization of neural networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>1: Input: Target optimization algorithm Aand learning raten for model training, initial model parameters 0o, learningrateTof the GradInit scales m,total iterations T,upper boundof the gradienty,lower bound for</td><td></td></tr><tr><td>2:mi←1</td><td>the initialization scalars α= O.01.</td><td></td></tr><tr><td></td><td>3: for t = 1 to T do</td><td></td></tr><tr><td>4:</td><td>Sample St from training set.</td><td></td></tr><tr><td>5:</td><td>Lt←S l(xk;0mt)，gt←VθLt</td><td></td></tr><tr><td>6:</td><td>if |lgtllpA &gt;γ then</td><td></td></tr><tr><td>7:</td><td>mt+1 ← mt -TVmtllgtllpA</td><td></td></tr><tr><td>8:</td><td>else</td><td></td></tr><tr><td>9:</td><td>Sample St from training set.</td><td></td></tr><tr><td>10:</td><td>Lt+1←s∑x∈ste(xk;Omt-nAlgt]）</td><td></td></tr><tr><td>11: 12:</td><td>mt+1←mt-TVmtLt+1</td><td></td></tr></table>",
+        "bbox": [
+            176,
+            301,
+            826,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To enforce the constraint in $( 1 )$ , we test whether the constraint is satisfied after computing $\\pmb { g } ( S ; \\pmb { \\theta } _ { m } )$ . If not, we take a gradient descent step to minimize $\\| \\pmb { g } ( S ; \\pmb { \\theta } _ { m } ) \\| _ { p _ { A } }$ , which involves computing second A order derivatives. If the constraint is satisfied, then we instead compute a gradient descent step for the loss. In addition, we set a lower bound $\\underline { { \\alpha } } = 0 . 0 1$ for all $\\alpha _ { i }$ . We find that this prevents scalars from landing on small values during minimization and keeps the GradInit optimizer stable. In our experiments, we find the only layer that ever hit this lower bound is the final FC layer on some networks (see the figures in Section $4 . 1 )$ . We find this procedure converges reliably within 2000 iterations for ImageNet, and fewer than 400 iterations for CIFAR-10, taking less than $1 \\%$ of the total training time on both problems. We also find it works well to set the step size $\\tau$ to values within the range between $1 0 ^ { - 3 }$ and $1 0 ^ { - 1 }$ . During initialization, the gradient norm constraint is satisfied for the majority of iterations. The choice of $\\gamma , p _ { \\mathcal { A } }$ will be discussed in Section $3 . 3 .$ ",
+        "bbox": [
+            173,
+            511,
+            826,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Stochasticity of mini-batching. The objective in $\\mathbb { \\underline { { ( 1 ) } } }$ uses two different mini-batches; $S$ is used to compute the gradient, and $\\tilde { S }$ is used to compute the loss. Ideally, $S$ and $\\tilde { S }$ should be independently sampled from the training set to capture the randomness of the stochastic optimizer. However, when the network has large initial gradient variance, the gradients on $S$ and $\\tilde { S }$ usually differ a lot, and for $\\tilde { S }$ , the gradient update step $\\theta _ { m } - \\eta \\mathcal { A } \\left[ g _ { S , \\theta _ { m } } \\right]$ becomes more similar to adding random perturbations to the parameters. We find our objective less effective at accelerating convergence in this case, as shown by the first-epoch accuracy $( A c c _ { 1 } )$ in Table $\\nsupseteq$ On the other hand, the randomness is not captured if $S = \\tilde { S }$ , and we find empirically that $\\theta _ { m }$ can exploit the loss by increasing the gradient norm and destabilize training in this case (see Table $\\textcircled{8}$ . Without excessive tuning, we find that we get more reliable behavior for different architectures when $\\tilde { S }$ is a mixture of $50 \\%$ samples from $S$ and $50 \\%$ re-sampled training data, and use this setting by default unless otherwise stated. ",
+        "bbox": [
+            174,
+            683,
+            553,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/99c5b717a3e991056b4ebb5839d9fc6f39eea1063d0888677697a47d53e9ba89.jpg",
+        "table_caption": [
+            "Table 1: Accuracies on CIFAR-10 using different overlapping ratios of $\\tilde { S }$ and $S$ for GradInit. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Sns |S]</td><td>Acc1</td><td>AcCbest</td></tr><tr><td>VGG-19</td><td>0</td><td>21.9 ± 4.4</td><td>94.5 ± 0.1</td></tr><tr><td>w/o BN</td><td>0.5</td><td>29.3 ± 0.6</td><td>94.7± 0.02</td></tr><tr><td>(20.03 M)</td><td>1</td><td>28.7 ± 1.0</td><td>94.5 ± 0.1</td></tr></table>",
+        "bbox": [
+            566,
+            746,
+            821,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            825,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Setting and Enforcing the Constraint ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            90,
+            470,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The constraint in $( 1 )$ is included to prevent the network from minimizing the loss in a trivial way by blowing up the initial gradient. In other words, we want the optimizer to achieve small loss by choosing an effective search direction rather than by taking an extremely large step in a sub-optimal direction. ",
+        "bbox": [
+            174,
+            116,
+            825,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Setting $p _ { \\cal A }$ and $\\gamma$ through first-order approximation. We show that $p _ { \\mathcal { A } }$ and $\\gamma$ can be set easily with a rule of thumb and without a parameter search. From the first-order approximation, we expect the first gradient step to result in a change in the loss on $S$ as following: ",
+        "bbox": [
+            174,
+            188,
+            823,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0feceaf154e60bd08891f0234c7af53f813f0c6c744fe1227cca2cc2fb3b60c8.jpg",
+        "text": "$$\nL ( S ; \\theta _ { m } - \\eta \\mathcal { A } [ g _ { S , \\theta _ { m } } ] ) - L ( S ; \\theta _ { m } ) \\approx - \\eta \\mathcal { A } [ g _ { S , \\theta _ { m } } ] ^ { T } g _ { S , \\theta _ { m } } = \\left\\{ \\begin{array} { l l } { - \\eta \\| g _ { S , \\theta _ { m } } \\| _ { 2 } ^ { 2 } , } & { \\mathrm { i f ~ } \\mathcal { A } \\mathrm { ~ i s ~ S G D } , } \\\\ { - \\eta \\| g _ { S , \\theta _ { m } } \\| _ { 1 } , } & { \\mathrm { i f ~ } \\mathcal { A } \\mathrm { ~ i s ~ A d a m } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            238,
+            795,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To effectively bound the approximated change in Eq. $\\bigtriangledown$ we choose $\\ell _ { p _ { A } }$ to be the $\\ell _ { 2 }$ and $\\ell _ { 1 }$ norm for ASGD and Adam respectively, so when the constraint is satisifed, the maximum change in the loss, according to our local approximation, is $\\eta \\gamma ^ { 2 }$ for SGD and $\\eta \\gamma$ for Adam. We recommend setting $\\gamma$ such that $\\eta \\gamma ^ { 2 } = 0 . 1$ for SGD and $\\eta \\gamma = 0 . 1$ for Adam. According to the linear approximations, this limits the gradient magnitude so that the first step of SGD can decrease the loss by at most 0.1. This simple rule was used across all vision and language experiments. ",
+        "bbox": [
+            173,
+            280,
+            826,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Why a constraint and not a penalty? Instead of formulating GradInit as a constrained optimization, one can alternatively formulate it as minimizing the objective with a gradient penalty: minimize $L ( \\tilde { S } ; \\theta _ { m } - \\eta A \\left[ \\pmb { g } _ { S , \\theta _ { m } } \\right] ) + \\lambda \\Vert \\pmb { g } _ { S ; \\theta _ { m } } \\Vert _ { p _ { A } }$ , where $\\lambda > 0$ is the penalty strength. ",
+        "bbox": [
+            173,
+            381,
+            826,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The penalized objective has two drawbacks compared to the constrained one in Eq. $^ { 1 . }$ First, every gradient descent step on the penalized objective involves second-order gradients due to the gradient regularization, while the constrained form does not need second-order gradients when the constraint is satisfied. Second, it is difficult to choose a good $\\lambda$ that works well for all architectures. By contrast, we set $\\gamma$ by analyzing the first-order approximation mentioned above, and find the same $\\gamma$ works well for different architectures. The results supporting these two points are given in Table 2. ",
+        "bbox": [
+            174,
+            429,
+            485,
+            609
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b457567bd8d4c3aa8a065e849d6c7fd5ebacb1b9c41b7229d211fcc45292250b.jpg",
+        "table_caption": [
+            "Table 2: Time cost and accuracy (average of 4 runs) for running one epoch of regularization/constrained form of GradInit. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>VGG-19 w/o BN</td><td>VGG-19 W/BN</td><td>ResNet-110 ResNet-110 w/o BN w/BN</td></tr><tr><td>Time (s)</td><td>82 vs.56</td><td>100 vs. 62</td><td>169 vs.103 269vs.195</td></tr><tr><td>入=10-4</td><td>32.3,94.6</td><td>10.6,93.1</td><td>33.7,93.9 32.4,95.2</td></tr><tr><td>入=10-2</td><td>30.4,94.5</td><td>10.4,93.0</td><td>36.7,94.1 32.6,95.3</td></tr><tr><td>入=1</td><td>18.2, 74.7</td><td>38.5,95.1</td><td>30.7,94.2 36.5,95.3</td></tr><tr><td>γ=1</td><td>29.3,94.7</td><td>47.8, 95.1</td><td>36.2,94.6 38.2, 95.4</td></tr></table>",
+        "bbox": [
+            500,
+            478,
+            821,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            628,
+            312,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate GradInit on benchmark datasets for image classification and machine translation tasks. For image classification, five different architectures are evaluated for CIFAR10 [26], and ResNet-50 is evaluated for ImageNet [27]. For machine translation, we use GradInit to find good initializations for a Post-LN Transformer without any change to its original architecture on IWSLT-14 De-En [28]. We observe that the method can remove the necessity of any form of learning rate warmup for both Adam and SGD. ",
+        "bbox": [
+            173,
+            660,
+            826,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conduct our experiments in PyTorch. We use the fairseq library for machine translation $\\mathbb { \\left[ \\left[ 2 9 \\right] \\right] }$ . All the experiments on CIFAR-10 and IWSLT-14 DE-EN can run with one single NVIDIA RTX 2080 Ti GPU with 11GB of RAM. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GradInit first initializes the weights using Kaiming initialization [2] for all the Conv and FC layers for image classification. For machine translation, we use the default Xavier initialization [1]. We optimize the scale factors $\\left\\{ \\alpha _ { i } \\right\\}$ with Adam $\\pmb { \\mathbb { B } } 0 \\|$ using the default momentum parameters. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Image Datasets with Various Architectures ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            511,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The introduction of Batch Normalization (BN) $\\mathbb { \\lVert 1 9 \\rVert }$ and skip connections makes it relatively easy to train common CNNs for image classification to achieve high accuracy. Despite this, we show that ",
+        "bbox": [
+            176,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "when the network is very deep, the network is unstable even when both BN and skip connections are used, and GradInit can significantly improve the stability. The results on CIFAR-10 are given in Table 3 and results on ImageNet are given in Table 6. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            135
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            281,
+            164
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Architectures. On CIFAR-10, we focus on the feedforward VGG net and the prevalent and powerful ResNet, with and without BN layers. For networks without BN, we use learnable biases in all layers. For ResNet, we additionally evaluate a deep 1202-layer version. We give results for other architectures (Wide ResNet, DenseNet) in Appendix E due to space limits. We compare with four different methods/settings: 1) Kaiming Initialization [2]; 2) First train the network for one epoch with a constant learning rate equal to the starting learning rate, labelled as $^ { 6 } { + } 1$ epoch (Const. LR)\" in Table 3; 3) First train the network for one epoch with a linear warmup learning rate, labbeled as $^ { 6 6 } { + 1 }$ epoch (Warmup)\" in Table 3; 4) MetaInit [16]. ",
+        "bbox": [
+            173,
+            174,
+            825,
+            286
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet, we use the ResNet-50 model $\\scriptstyle { \\left[ \\left[ 2 1 \\right] \\right] }$ . We compare with Kaiming Initialization, FixUp initialization $[ [ 9 $ and MetaInit. For the ResNet-50 without BN, we follow the architecture of FixUp for fair comparisons, but we still use the original Kaiming initialization as the starting point of GradInit. ",
+        "bbox": [
+            176,
+            290,
+            823,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters. We set $\\mathcal { A }$ to SGD and $\\eta = 0 . 1$ (the same as the base learning rate) for GradInit in all image classification experiments. On CIFAR-10, we train networks with a batch size of 128. We find MetaInit often takes 2 to 3 times as much memory as GradInit. We run GradInit or MetaInit for one epoch on the data, which takes less than $1 \\%$ of the total training time. For GradInit, according to our analysis in Section $^ { 3 . 3 , }$ we fix the gradient norm constraint $\\gamma = 1$ in all these experiments. Therefore, as in MetaInit, the only hyperparameter that needs to be tuned is the learning rate $\\tau$ of the scale factors. We do a grid search on $\\tau$ in the range $[ 1 0 ^ { - 3 } , 1 0 ^ { - 1 } ]$ , and report the results with the best average final test accuracy on 4 runs. After GradInit initialization, we use a learning rate of 0.1 and the cosine annealing learning rate schedule without restart $\\pmb { \\mathbb { B } } \\mathbf { \\mathbb { 1 } }$ to train the model for 200 epochs, where the learning rate decays after each iteration and decays to 0 in the last iteration. Due to their high initial gradient variance (see Figure $^ { 6 ) }$ , we have applied gradient clipping (maximum norm is 1) to all non-BN networks so that they converge without GradInit under the same schedule. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            505
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet, we train the ResNet-50 model for 90 epochs with a total batch size of 256 on 4 GPUs. Due to the difference in the library for training and the number of GPUs used, which affects the BN statistics, our baseline top-1 accuracy of ResNet-50 (w/ BN) on ImageNet is $0 . 7 9 \\%$ lower than $\\mathbb { \\lVert 3 2 \\rVert }$ . We use SGD with a starting learning rate of 0.1 and decay the learning rate by 10 after the $3 0 \\mathrm { t h }$ and 60th epoch. We provide additional details in Appendix A. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 Results and Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            369,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/50a4c47abcd983072ed8704ae0cbb47dca42929bbd5db005f7bb97b8fc00e0b0.jpg",
+        "table_caption": [
+            "Table 3: First epoch $( A c c _ { 1 } )$ and best test accuracy over all epochs $( A c c _ { b e s t } )$ for models on CIFAR-10. We report the mean and standard error of the test accuracies in 4 experiments with different random seeds. Best results in each group are in bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Model (#Params)</td><td>VGG-19 w/o BN (20.03M)</td><td>VGG-19 w/BN (20.04M)</td><td>ResNet-110 w/o BN (1.72M)</td><td>ResNet-110 w/BN (1.73M)</td><td>ResNet-1202 w/BN (19.42M)</td></tr><tr><td rowspan=\"2\">Kaiming</td><td>AcC1</td><td>29.1 ± 1.5</td><td>12.6 ± 0.6</td><td>16.1 ± 2.1</td><td>23.2 ± 0.9</td><td>12.9 ± 2.8</td></tr><tr><td>AcCbest</td><td>94.5 ± 0.1</td><td>94.4 ± 0.1</td><td>94.2 ± 0.1</td><td>95.0± 0.2</td><td>94.4 ± 0.6</td></tr><tr><td rowspan=\"2\">+1 epoch (Const. LR)</td><td>Acc1</td><td>37.2 ± 1.1</td><td>19.6 ± 4.0</td><td>21.0 ± 3.8</td><td>32.5 ±3.8</td><td>12.6 ± 2.8</td></tr><tr><td>Accbest</td><td>94.4± 0.1</td><td>94.5 ± 0.1</td><td>93.9 ± 0.4</td><td>94.7 ± 0.3</td><td>94.0 ± 0.4</td></tr><tr><td rowspan=\"2\">+1 epoch (Warmup)</td><td>Acc1</td><td>37.4 ±1.2</td><td>53.5 ± 2.9</td><td>19.8 ± 0.5</td><td>48.7 ± 1.1</td><td>28.1 ± 1.3</td></tr><tr><td>AcCbest</td><td>94.4 ± 0.1</td><td>94.7 ± 0.1</td><td>94.1 ± 0.1</td><td>95.1 ± 0.1</td><td>95.4± 0.2</td></tr><tr><td rowspan=\"2\">MetaInit</td><td>AcC1</td><td>30.5± 0.9</td><td>35.1 ± 0.6</td><td>14.6 ± 2.2</td><td>29.0 ± 1.5</td><td>11.7 ± 1.6</td></tr><tr><td>AcCbest</td><td>94.6 ± 0.1</td><td>94.6 ± 0.1</td><td>94.2 ± 0.1</td><td>94.8 ± 0.1</td><td>95.0 ± 0.5</td></tr><tr><td rowspan=\"2\">GradInit</td><td>AcC1</td><td>29.3±0.6</td><td>47.8 ± 1.8</td><td>36.2 ±0.8</td><td>38.2 ± 0.9</td><td>29.0 ± 1.1</td></tr><tr><td>Accbest</td><td>94.7 ± 0.1</td><td>95.1 ± 0.1</td><td>94.6 ± 0.1</td><td>95.4± 0.1</td><td>96.2 ± 0.1</td></tr></table>",
+        "bbox": [
+            236,
+            676,
+            756,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "GradInit further stabilizes feedforward nets with BN. BN does stabilize VGG-19 and allows training without gradient clipping, but with an average first-epoch test accuracy of only 12.57 and an average final test accuracy lower than the version without BN (see Table $\\textcircled{3}$ , it does not seem to eliminate the instability of Kaiming initialization. As shown in Figure $\\bigtriangledown ,$ its initial gradient variance is still relatively high compared with GradInit. BN could magnify the gradient variance when the variance of its input features (in the forward pass) is smaller than 1 (see Appendix $\\boxed { \\mathbf { C } }$ . GradInit reduces the gradient variance by 4 orders of magnitude compared to Kaiming initialization , resulting in significantly higher test accuracy after the first epoch $( 4 7 . 7 9 \\%$ vs. $1 2 . 5 7 \\%$ ), which also has an impact on the final test accuracy $( 9 5 . 1 3 \\%$ vs. $9 4 . 4 1 \\%$ ). The reduction in gradient variance is achieved mainly by scaling down the weights of the final FC layer and the last 2 BN layers, so that the variance of the activations is reduced in the forward pass. This learned behavior is consistent with the strategy of FixUp, where the final FC layer is initialized to 0. Another source of gradient variance reduction is achieved by increasing the weight norms of the remaining Conv and BN layers, so that the variance of the inputs to the BN layers is increased and the gradient magnifying effect of BN is alleviated in the backward pass. This reduced the ratio $\\sigma ( \\pmb { g } _ { 1 } ) / \\bar { \\sigma } ( \\pmb { g } _ { 1 6 } )$ from 204.9 to 164.8 for the Conv layers in Figure 4. By contrast, FixUp only reduces the weight norms, which may not always be the best solution for networks with normalization layers. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b1c7d4d91bac8e66a991e0f50cbde8c33271da8b1f33abfd97bece26ad451b27.jpg",
+        "image_caption": [
+            "Figure 1: Top row: results of ResNet-110 on CIFAR-10. Bottom row: results of ResNet-50 on ImageNet. Left two columns: compare the relative cross-batch gradient variance on the training set for the BN and Conv/FC layers before and after GradInit. Right two columns: weight norms before and after GradInit. Ratio between points in the same layer reflects the scale factor. Note each of the residual blocks has 2 and 3 Conv and BN layers for the ResNet-110 and ResNet-50, respectively. The initial relative gradient variance are reduced for all layers except the final linear layer in both settings. The strategies are similar on two different datasets. Within each residual block, the last BN layer has the smallest scaling factors, and the scales of all Conv layers are surprisingly increased. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            825,
+            289
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/68982e2c5ddf39fc5a9aa28acb3eeeb208468a65c714c3beb3e000e0d69d317f.jpg",
+        "image_caption": [
+            "Figure 2: Comparing the convergence of Kaiming Initialization and GradInit on CIFAR-10, for models trained with SGD (left three) and Adam (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            395,
+            825,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            537,
+            825,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Deep residual networks still need better initializations. We also gain significant improvements from GradInit for ResNet-110 and ResNet-1202. In ResNets, the skip connections cause the variance of activations to accumulate as the ResNet goes deeper, even for the version with BN $\\mathbb { m }$ . This issue is more significant when the ResNet scales to 1202 layers, from which we can see that with Kaiming initialization, the first-epoch accuracy of ResNet-1202 is quite low, and the final test accuracy is even worse than the shallower ResNet-110, matching the observations of He et al. $\\left[ \\left[ 2 1 \\right] \\right]$ . Warmup is even more effective than MetaInit at accelerating the convergence and improving the final test accuracy of ResNet-1202, but GradInit still outperforms its final test accuracy by $0 . 8 \\%$ , and the resulting ResNet-1202 finally achieved higher accuracy than ResNet-110. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The learned layer-wise rescaling patterns of GradInit are even more interesting for ResNets with BN. For ResNets with BN, recall that we have two Conv layers and two BN layers in each residual block. As shown in Figure 1, GradInit learns to increase the weight norms of all the linear layers except for the final FC layer, instead of decreasing as for the case without BN (see Figure $6 )$ . A more unique pattern is the collaborative behavior of the BN weights, where the second BN in each residual block is usually scaled down while the first BN is always scaled up. In deeper layers, the joint effect of these two BN weights is to downscale the activations and reduce their variance in the forward pass, with a more significant reducing effect as the layers get deeper. Intuitively, the marginal utility of adding a new layer decreases with depth. Therefore, for deeper layers, GradInit learns to further downscale the residual branch, and prevents the variance from increasing too much in the forward pass. Inside each residual block, increasing the scale factors of the first BN helps to reduce the magnification effect of the second BN on the gradient; forcing the input activations to the second convolution to have variance larger than 1 ensures its variance after the following convolution layer does not go below 1, avoiding the magnification effect that the second BN has on the gradient variance. See Appendix C for more discussions about the magnifying effect. ",
+        "bbox": [
+            174,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a7344c4efa23fb5c2e0f9c33166c671af5c5ac6208c65dc6caf1111ebd4c6b90.jpg",
+        "table_caption": [
+            "Table 4: Comparing the results of GradInit with fixed BN scale parameters (Fix BN) and only rescale the BN parameters (Only BN). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Kaiming</td><td colspan=\"2\">GradInit</td><td colspan=\"2\">GradInit (Fix BN)</td><td rowspan=\"2\">GradInit (Only BN) Accbest</td></tr><tr><td>Acco</td><td>Accbest</td><td>Acco</td><td>Accbest</td><td>Acco Accbest</td><td>Acco</td></tr><tr><td>VGG-19 (w/ BN)</td><td>12.6 ±0.6 94.4 ± 0.1 47.8 ± 1.8 95.1 ± 0.1 13.1 ± 0.9 94.6 ±0.1 14.4 ± 2.1 94.4 ± 0.1</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ResNet-110(w/BN) 23.2±0.9 95.0 ±0.2 38.2 ±0.9 95.4 ± 0.1 24.7±3.1 94.7±0.3 25.4±3.1 94.6± 0.3</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            303,
+            821,
+            364
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/29ec11160bd9a9835d5c21fe8e79599076b65032c2e6c83a982ce6b3aac72b07.jpg",
+        "table_caption": [
+            "Table 5: Comparing the results with multiplying each weight matrix with a learnable scaler (Learning Scalars) on CIFAR10. The VGG-19 model is not able to converge unless we reduce the initial learning rate to 0.01, which obtained worse final accuracy. The ResNet-110 model’s $A c c _ { 0 }$ was $10 \\%$ for 2 of the 4 runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"2\">Learning Scalars</td><td colspan=\"2\">GradInit</td></tr><tr><td></td><td>Acco</td><td>Accbest</td><td>Acco</td><td>AcCbest</td></tr><tr><td>VGG-19 (w/BN,Ir=0.1)</td><td>10.0±0.0</td><td></td><td>10.0±0.0 47.8±1.8 95.1±0.1</td><td></td></tr><tr><td>VGG-19 (w/BN,Ir=0.01) 50.6±0.8</td><td></td><td>93.4 ±0.1</td><td></td><td>=</td></tr><tr><td>ResNet-110 (w/BN)</td><td>21.5 ± 6.9</td><td></td><td>94.7 ± 0.1 38.2 ± 0.9 95.4 ± 0.1</td><td></td></tr></table>",
+        "bbox": [
+            285,
+            420,
+            707,
+            494
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generalizing to Adam. Models in previous experiments are trained with SGD. We also consider the case when $\\mathcal { A }$ is Adam and use AdamW $\\pmb { \\Vert 3 3 \\Vert }$ to train the ResNet-110 (w/ BN) model on CIFAR-10. Following $\\pmb { \\mathbb { B 4 } }$ , we use a cosine annealing learning rate schedule with initial learning rate $3 \\times 1 0 ^ { - 3 }$ and weight decay 0.2. For GradInit, we set $\\gamma = 2 5$ . The $A c c _ { 1 }$ and $A c c _ { b e s t }$ of Kaiming initialization and GradInit are $( 3 6 . 6 \\pm 4 . 7$ , $9 4 . 9 \\pm 0 . 1 )$ and $( 4 0 . 2 \\pm 0 . 2$ , $9 5 . 3 \\pm 0 . 1 )$ , respectively. We also show the per-epoch test accuracy in Figure 2. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            593
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The importance of rescaling BN layers. The scale parameters of BN layers usually controls the variance of activations and gradients in the forward and backward passes, while the linear layers right before the BN layers are scale-invariant. Although changing the magnitudes of the scale-invariant layers affect their learning dynamics $\\mathbb { \\left| \\sum 3 \\right| \\left| \\sum 4 \\right| }$ , we find it important for GradInit to rescale both BN and other linear layers, as shown in Table 4. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            667
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The importance of GradInit’s objective. GradInit is designed to rescale the layers to solve the constrained optimization problem in Eq. $\\mathbb { L }$ Simply letting the model to learn to rescale the layers cannot improve the results, and sometimes further causes instability, as shown in Table $5 .$ We hypothesize that the bad results with VGG are due to a mismatch between the scales/norms of the gradients of the scalars and the weights. To make this alternative work, we may need to set different learning rates for the scalars and the weights, which adds to the difficulty of hyperparameter tuning. Note we do not learn the scalars when training networks initialized by GradInit. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e627993923a4a1da1865e96757438d4905377349420a3104d24a2cad4ee3cb08.jpg",
+        "table_caption": [
+            "Table 6: $A c c _ { 1 } / A c c _ { b e s t }$ of ResNet-50 models on ImageNet. Result of MetaInit comes from Dauphin and Schoenholz $\\mathbb { I } \\mathbb { 6 } \\mathbb { I }$ and we reimplemented the rest. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Kaiming</td><td>FixUp</td><td>MetaInit</td><td>GradInit</td></tr><tr><td>w/BN</td><td>14.6/75.9</td><td>1</td><td>-</td><td>19.2/76.2</td></tr><tr><td>w/o BN</td><td>1</td><td>18.0/75.7</td><td>-/75.4</td><td>19.2/75.8</td></tr></table>",
+        "bbox": [
+            318,
+            816,
+            676,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "GradInit scales to ImageNet. As shown in Table $6 ,$ GradInit also accelerates convergence and improves test accuracy of ResNet-50 on ImageNet, with or without BN layers, despite having to use a smaller batch size for GradInit than training due to our GPU memory limit. The acceleration achieved by GradInit is even more significant than FixUp, even on the network with the architecture designed for the initialization. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Training the Original Transformer Model without Warmup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            154,
+            627,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For a Transformer model to converge, either an explicit or implicit learning rate warmup stage is needed, especially for the original Transformer architecture. It is observed that this Post-LN architecture tends to outperform the Pre-LN model $\\textcircled { 6 }$ while having higher gradient variance at initialization [4]. Is it believed that this high variance makes a warmup stage inevitable. Previous works that removes the warmup stage often involves architectural changes, e.g., removing Layer Normalizations, since it can surprisingly cause instability [4]. Here, we show that with a proper initialization, we can do away with the warmup stage for the original Post-LN Transformer without any modification to the architecture. Table 7 summarizes the architectural changes and best results of methods for improving the initialization of Post-LN Transformers. We compare the stability of the GradInit and Admin initialization methods without warmup in Figure 3. ",
+        "bbox": [
+            173,
+            181,
+            825,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4ba7083f0ada1dae6e6311735f433cdc22ee4666313066d623f76bf7b2dca4ce.jpg",
+        "table_caption": [
+            "Table 7: A comparison of GradInit with with the results from the papers (top 4 rows), and our reimplementation of Admin for training the Post-LN Transformer model on the IWSLT-14 De-EN dataset. “Standard\" refers to training with standard initialization and warmup. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Remove LN</td><td>Wskip</td><td>Warmup</td><td>Optimizer</td><td>BLEU</td></tr><tr><td>Standard [6</td><td></td><td></td><td>√</td><td>RAdam</td><td>35.6</td></tr><tr><td>FixUp 回</td><td>√</td><td></td><td>√</td><td>Adam</td><td>34.5</td></tr><tr><td>T-FixUp[5]</td><td></td><td></td><td></td><td>Adam</td><td>35.5</td></tr><tr><td>Admin 回</td><td></td><td>√</td><td></td><td>RAdam</td><td>35.7</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>SGD</td><td>33.7</td></tr><tr><td>GradInit</td><td></td><td>√</td><td></td><td>Adam</td><td>36.0</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>SGD</td><td>35.6</td></tr></table>",
+        "bbox": [
+            269,
+            382,
+            723,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset, Architecture, & Hyperparameters. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            478,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "IWSLT’14 DE-EN $\\left[ \\left[ 2 8 \\right] \\right]$ is a German to English translation dataset that has $1 6 0 \\mathrm { k }$ training examples. Our Transformer model is inherited from $\\mathbf { \\widehat { \\mathbb { B } } }$ , which is a Post-LN Transformer placing its Layer Normalization after the summation of the skip connection and the residual branch. It has a 512- dimensional word embedding layer and 1024 dimensions in its hidden FFN layer. We also apply GradInit to the variant from Admin $\\pmb { \\Vert 6 \\Vert }$ , where a learnable vector ${ { \\pmb w } _ { s k i p } }$ is element-wise multiplied with each dimension of the skip connection, but we initialize it to 1 for GradInit. Please refer to $\\dot { \\left. \\left[ 6 \\right] \\right. }$ for how Admin initializes these weights. Following $\\pmb { \\Vert 6 \\Vert }$ , we use a linearly decaying learning rate schedule that decays from the maximum learning rate $\\eta _ { \\mathrm { m a x } }$ to 0 as the model trains for 100K iterations. For training with SGD, we set the prescribed learning rate $\\eta _ { \\mathrm { m a x } } = 0 . 1 5$ , and use $\\eta = 0 . 1 5 , \\gamma = 1$ for GradInit. We do a grid search on $\\eta _ { \\mathrm { m a x } }$ for Admin and report its best result in Table $\\perp$ For training with Adam, we set $\\dot { \\eta } = 5 \\times 1 0 ^ { - 4 } , \\dot { \\gamma } = 1 0 ^ { 3 }$ for the objective of GradInit, so that $\\eta \\gamma$ is $O ( 1 0 ^ { - 1 } )$ as discussed in Section 3.3. We train the initialized model $\\eta _ { \\mathrm { m a x } }$ and $\\beta _ { 2 }$ as listed in Figure $3 .$ We evaluate the BLEU score every epoch, and report the best BLEU scores throughout training for each run. For GradInit, we set the maximum number of iterations $T$ to 780. By comparison, the warmup stage usually takes 4000 iterations, and we find that if we use 780 steps for warmup, the model does not converge with $\\eta _ { \\mathrm { m a x } } \\ge 3 \\times 1 0 ^ { - 4 }$ . For $\\eta _ { \\mathrm { m a x } } = 2 \\times 1 0 ^ { - 4 }$ with 780-step warmup, the BLEU score is 35.4, worse than GradInit’s 36.0, showing the advantage of GradInit against warmup. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stability after removing warmup for Adam. In Figure $^ { 3 , }$ , the training process becomes more unstable as $\\beta _ { 2 }$ grows larger. From the analysis of RAdam $[ \\overbrace { 3 5 } ] ]$ , this is because the variance of the gradient has a stronger impact on the adaptive learning rate when $\\beta _ { 2 }$ is closer to 1. Therefore, the largest $\\beta _ { 2 } < 1$ that maintains the performance of the trained model reflects the stability of the initialization. We can see GradInit results in more stable models than Admin in general, though their best performance numbers are almost the same. In addition, we find ${ { \\pmb w } _ { s k i p } }$ can help stabilize training in extreme hyper parameter settings, e.g., at $\\eta _ { \\mathrm { m a x } } = 5 \\times 1 0 ^ { - 4 }$ and $\\beta _ { 2 } = 0 . 9 9 5$ in Figure $\\bigtriangledown _ { \\ b { \\lambda } }$ GradInit with ${ { \\pmb w } _ { s k i p } }$ obtains a good average BLEU score of 36.0, while without ${ { \\pmb w } _ { s k i p } }$ only succeeded in obtaining a BLEU score $> 3 5$ for one out of four experiments, resulting in an average BLEU score of 8.9. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also find the network is unable to be trained without learning rate warmup if we just fix ${ { \\pmb w } _ { s k i p } }$ to its initial value given by Admin and leave the initialization of other parameters unchanged. Nevertheless, with GradInit, we do not need to modify the architecture of Post-LN Transformer to obtain the same good result as Admin. For a closer look at the stabilization mechanism, we show the weight norms and gradient variance at initialization of the original Post-LN architecture using GradInit and Xavier initialization in Figure 9 of the Appendix. For Xavier initialization, the gradient variance is relatively higher for all encoder layers, so GradInit downscales the encoder layer weights more in general. For the LN weights, GradInit only ",
+        "bbox": [
+            174,
+            119,
+            485,
+            339
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/54b16b400c864897eac4effa71200cc1009e90a3c1eecd924677164f4aecc148.jpg",
+        "image_caption": [
+            "Figure 3: BLEU scores for the Post-LN Transformer without learning rate warmup using Adam on IWSLT-14 DE-EN under different learning rates $\\eta _ { \\mathrm { m a x } }$ ( $y$ axis) and $\\beta _ { 2 }$ $x$ axis). Each result is averaged over 4 experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            138,
+            820,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "downscales the final LN of both the encoder and decoder, which reduces the variance of the encoder and decoder during the forward pass. Another strategy GradInit learns is to downscale the weights of the output projection and the FFN layers, so that the residual branch is relatively down-weighted compared with the skip connection, similar to Admin. ",
+        "bbox": [
+            174,
+            339,
+            826,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Removing warmup without architectural change. Another widely observed phenomenon is that adaptive methods such as Adam seem to be much better than SGD for training Transformer-based language models [13]. Table 7 shows that, with GradInit, we can find a good initialization for the Post-LN Transformer on IWSLT-14 DE-EN that trains using SGD without learning rate warmup nor gradient clipping, and achieves performance close to Adam trained using the same type of learning rate schedule. By comparison, Admin also makes the Transformer trainable with SGD, but the BLEU score is lower than the one initialized with GradInit. By comparing Figures 9 and $\\bigstar$ in the Appendix, we find GradInit for Adam and SGD adopts different rescaling patterns, with the Adam version depending more on downscaling the residual branches through the FFN and output projection layers than the SGD version, and the SGD version downscaling more in the final FFN block of the decoder. This highlights the importance of considering the optimization algorithm $\\mathcal { A }$ in GradInit, and also indicates the presence of different ways to reduce the initial gradient variance. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            566
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            297,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose GradInit, a gradient-based initialization scheme for any architecture. GradInit reinitializes a network by learning a scale factor for each randomly initialized parameter block of a network, so that the training loss evaluated on a different minibatch after one gradient step of a specific stochastic optimizer is minimized. Such a design takes the stochasticity, the learning rate, and the direction of the optimizer into account, allowing us to find better initializations tailored for the optimizer. The initialization learned by GradInit often decreases the gradient variance for most of the parameter blocks. We show that GradInit accelerates the convergence and improves the test performance of a variety of architectures on image classification. It also enables training the Post-LN Transformer without any form of learning rate warmup, even for SGD. GradInit can be a useful tool in the future discovery of better neural architectures that are otherwise discarded due to poor initializations. By analyzing the learned scaling coefficients and their impact on gradient variance, it can also serve a guide to design better initialization schemes for complex architectures to shorten the training schedule and save energy. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            833,
+            357,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This project was supported by the Office of Naval Research, AFOSR MURI program, the DARPA Young Faculty Award, and the National Science Foundation Division of Mathematical Sciences. Additional support was provided by Capital One Bank and JP Morgan Chase. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In AISTATS, 2010.   \n[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In CVPR, 2015.   \n[3] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, pages 5998–6008, 2017.   \n[4] Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In ICML, 2020.   \n[5] Xiao Shi Huang, Felipe Perez, Jimmy Ba, and Maksims Volkovs. Improving transformer optimization through better initialization. In ICML, 2020.   \n[6] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. EMNLP, 2020.   \n[7] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   \n[8] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. NeurIPS, 2020.   \n[9] Hongyi Zhang, Yann N Dauphin, and Tengyu Ma. Fixup initialization: Residual learning without normalization. In ICLR, 2019.   \n[10] Soham De and Sam Smith. Batch normalization biases residual blocks towards the identity function in deep networks. NeurIPS, 2020.   \n[11] Andrew Brock, Soham De, and Samuel L Smith. Characterizing signal propagation to close the performance gap in unnormalized resnets. ICLR, 2021.   \n[12] Andrew Brock, Soham De, Samuel L. Smith, and Karen Simonyan. High-performance largescale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   \n[13] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why are adaptive methods good for attention models? NeurIPS, 2020.   \n[14] Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. ICLR, 2014.   \n[15] Dmytro Mishkin and Jiri Matas. All you need is a good init. ICLR, 2016.   \n[16] Yann N Dauphin and Samuel Schoenholz. Metainit: Initializing learning by learning to initialize. In NeurIPS, pages 12645–12657, 2019.   \n[17] Mert Gurbuzbalaban and Yuanhan Hu. Fractional moment-preserving initialization schemes for training deep neural networks. In International Conference on Artificial Intelligence and Statistics, pages 2233–2241. PMLR, 2021.   \n[18] Charles H Martin and Michael W Mahoney. Traditional and heavy-tailed self regularization in neural network models. arXiv preprint arXiv:1901.08276, 2019.   \n[19] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pages 448–456, 2015.   \n[20] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   \n[21] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016.   \n[22] Thomas Bachlechner, Bodhisattwa Prasad Majumder, Huanru Henry Mao, Garrison W Cottrell, and Julian McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   \n[23] Sanjeev Arora, Zhiyuan Li, and Kaifeng Lyu. Theoretical analysis of auto rate-tuning by batch normalization. In International Conference on Learning Representations, 2019.   \n[24] Ruosi Wan, Zhanxing Zhu, Xiangyu Zhang, and Jian Sun. Spherical motion dynamics of deep neural networks with batch normalization and weight decay. arXiv preprint arXiv:2006.08419, 2020.   \n[25] Lukas Balles and Philipp Hennig. Dissecting adam: The sign, magnitude and variance of stochastic gradients. In ICML, pages 404–413, 2018.   \n[26] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   \n[27] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR, 2009.   \n[28] Mauro Cettolo, Jan Niehues, Sebastian Stüker, Luisa Bentivogli, and Marcello Federico. Report on the 11th iwslt evaluation campaign, iwslt 2014. In IWSLT, volume 57, 2014.   \n[29] Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In NAACL-HLT (Demonstrations), 2019.   \n[30] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.   \n[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   \n[32] Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   \n[33] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2018.   \n[34] Chen Zhu, Yu Cheng, Zhe Gan, Furong Huang, Jingjing Liu, and Tom Goldstein. Maxva: Fast adaptation of step sizes by maximizing observed variance of gradients. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 628–643. Springer, 2021.   \n[35] Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. ICLR, 2020.   \n[36] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   \n[37] Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   \n[38] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.   \n[39] Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   \n[40] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ICLR, 2018.   \n[41] Jeremy Bernstein, Yu-Xiang Wang, Kamyar Azizzadenesheli, and Animashree Anandkumar. signsgd: Compressed optimisation for non-convex problems. In ICML, 2018. ",
+        "bbox": [
+            171,
+            80,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            71,
+            828,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] One limitation of our current work is we have not checked whether GradInit can improve the training of models from other domains such as speech.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            253
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            257,
+            493,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            276,
+            736,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            311,
+            393,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            330,
+            825,
+            449
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            453,
+            823,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [Yes]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            472,
+            825,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            598,
+            705,
+            612
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            616,
+            825,
+            705
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HkgsPhNYPS/HkgsPhNYPS.md

@@ -0,0 +1,349 @@
+# SELF: LEARNING TO FILTER NOISY LABELS WITH SELF-ENSEMBLING
+
+Duc Tam Nguyen ∗, Chaithanya Kumar Mummadi ∗†, Thi Phuong Nhung Ngo †, Thi Hoai Phuong Nguyen ‡, Laura Beggel †, Thomas Brox †
+
+# ABSTRACT
+
+Deep neural networks (DNNs) have been shown to over-fit a dataset when being trained with noisy labels for a long enough time. To overcome this problem, we present a simple and effective method self-ensemble label filtering (SELF) to progressively filter out the wrong labels during training. Our method improves the task performance by gradually allowing supervision only from the potentially non-noisy (clean) labels and stops learning on the filtered noisy labels. For the filtering, we form running averages of predictions over the entire training dataset using the network output at different training epochs. We show that these ensemble estimates yield more accurate identification of inconsistent predictions throughout training than the single estimates of the network at the most recent training epoch. While filtered samples are removed entirely from the supervised training loss, we dynamically leverage them via semi-supervised learning in the unsupervised loss. We demonstrate the positive effect of such an approach on various image classification tasks under both symmetric and asymmetric label noise and at different noise ratios. It substantially outperforms all previous works on noise-aware learning across different datasets and can be applied to a broad set of network architectures.
+
+# 1 INTRODUCTION
+
+The acquisition of large quantities of a high-quality human annotation is a frequent bottleneck in applying DNNs. There are two cheap but imperfect alternatives to collect annotation at large scale: crowdsourcing from non-experts and web annotations, particularly for image data where the tags and online query keywords are treated as valid labels. Both these alternatives typically introduce noisy (wrong) labels. While Rolnick et al. (2017) empirically demonstrated that DNNs can be surprisingly robust to label noise under certain conditions, Zhang et al. (2017) has shown that DNNs have the capacity to memorize the data and will do so eventually when being confronted with too many noisy labels. Consequently, training DNNs with traditional learning procedures on noisy data strongly deteriorates their ability to generalize – a severe problem. Hence, limiting the influence of label noise is of great practical importance.
+
+A common approach to mitigate the negative influence of noisy labels is to eliminate them from the training data and train deep learning models just with the clean labels (Frenay & Verleysen, 2013). ´ Employing semi-supervised learning can even counteract the noisy labels (Laine & Aila, 2016; Luo et al., 2018). However, the decision which labels are noisy and which are not is decisive for learning robust models. Otherwise, unfiltered noisy labels still influence the (supervised) loss and affect the task performance as in these previous works. They use the entire label set to compute the loss and severely lack a mechanism to identify and filter out the erroneous labels from the labels set.
+
+In this paper, we propose a self-ensemble label filtering (SELF) framework that identifies potentially noisy labels during training and keeps the network from receiving supervision from the filtered noisy labels. This allows DNNs to gradually focus on learning from undoubtedly correct samples even with an extreme level of noise in the labels (e.g., $80 \%$ noise ratio) and leads to improved performance as the supervision become less noisy. The key contribution of our work is progressive filtering, i.e., leverage the knowledge provided in the network’s output over different training iterations to form a consensus of predictions (self-ensemble predictions) to progressively identify and filter out the noisy labels from the labeled data.
+
+![](images/ac35fe607b3c36ca0223001826b8c7871c1b71d8f89c6ebaa811eba4547b70be.jpg)  
+Figure 1: Comparing the performance of $S E L F$ with previous works for learning under different (symmetric) label noise ratios on the (a) CIFAR-10 & (b) CIFAR-100 datasets. SELF retains higher robust classification accuracy at all noise levels.
+
+When learning under label noise, the network receives noisy updates and hence fluctuates strongly. Such conduct of training would impede to learn stable neural representations and further mislead the consensus of the predictions. Therefore, it is essential to incorporate a model with stable training behavior to obtain better estimates from the consensus. Concretely, we employ the semi-supervised technique as a backbone to our framework to stabilize the learning process of the model. Correctly, we maintain the running average model, such as proposed by Tarvainen & Valpola (2017), a.k.a. the Mean-Teacher model. This model ensemble learning provides a more stable supervisory signal than the noisy model snapshots and provides a stable ground for progressive filtering to filter out potential noisy labels. Note that this is different from just a mere combination of semi-supervised techniques with a noisy label filtering method.
+
+We call our approach self-ensemble label filtering (SELF) - that establishes model ensemble learning as a backbone to form a solid consensus of the self-ensemble predictions to filter out the noisy labels progressively. Our framework allows to compute supervised loss on cleaner subsets rather than the entire noisy labeled data as in previous works. It further leverages the entire dataset, including the filtered out erroneous samples in the unsupervised loss. To best of our knowledge, we are the first to identify and propose self-ensemble as a principled technique against learning under noisy labels.
+
+Our motivation stems from the observation that DNNs start to learn from easy samples in initial phases and gradually adapt to hard ones during training. When trained on wrongly labeled data, DNNs learn from clean labels at ease and receive inconsistent error signals from the noisy labels before over-fitting to the dataset. The network’s prediction is likely to be consistent on clean samples and inconsistent or oscillates strongly on wrongly labeled samples over different training iterations. Based on this observation, we record the outputs of a single network made on different training epochs and treat them as an ensemble of predictions obtained from different individual networks. We call these ensembles that are evolved from a single network self-ensemble predictions. Subsequently, we identify the correctly labeled samples via the agreement between the provided label set and our running average of self-ensemble predictions. The samples of ensemble predictions that agree with the provided labels are likely to be consistent and treated as clean samples.
+
+In summary, our SELF framework stabilizes the training process and improves the generalization ability of DNNs. We evaluate the proposed technique on image classification tasks using CIFAR10, CIFAR100 & ImageNet. We demonstrate that SELF consistently outperforms the existing approaches on asymmetric and symmetric noise at all noise levels, as shown in Fig. 1. Besides, SELF remains robust towards the choice of the network architecture. Our work is transferable to other tasks without the need to modify the architecture or the primary learning objective.
+
+![](images/c82ec7a9b9bc7f2c8f64612f41085d91d63bfe3b6a05a44da5aa554cea5822f8.jpg)  
+Figure 2: Overview of the self-ensemble label filtering (SELF) framework. The model starts in iteration 0 with training from the noisy label set. During training, the model maintains a selfensemble, a running average of itself (Tarvainen & Valpola, 2017) to provide a stable learning signal. Also, the model collects a self-ensemble prediction (moving-average) for the subsequent filtering. Once the best model is found, these predictions identify and filter out noisy labels using the original label set $L _ { 0 }$ . The model performs this progressive filtering until there is no more better model. For details see Algorithm 1.
+
+# 2 SELF-ENSEMBLE LABEL FILTERING
+
+# 2.1 OVERVIEW
+
+Fig. 2 shows an overview of our proposed approach. In the beginning, we assume that the labels of the training set are noisy. The model attempts to identify correct labels progressively using selfforming ensembles of models and predictions. Since wrong labels cause strong fluctuations in the model’s predictions, using ensembles is a natural way to counteract noisy labels.
+
+Concretely, in each iteration, the model learns from a detected set of potentially correct labels and maintains a running average of model snapshots (realized by the Mean Teacher model Tarvainen & Valpola (2017)). This ensemble model is evaluated on the entire dataset and provides an additional learning signal for training the single models. Additionally, our framework maintains the runningaverage of the model’s predictions for the filtering process. The model is trained until we find the best model w.r.t. the performance on the validation set (e.g., by early-stopping). The set of correct labels is detected based on the strategy defined in Sec. 2.2. In the next iteration, we again use all data and the new filtered label set as input for the model training. The iterative training procedure stops when no better model can be found. In the following, we give more details about the combination of this training and filtering procedure.
+
+# 2.2 PROGRESSIVE LABEL FILTERING
+
+Progressive detection of correctly labeled samples Our framework Self-Ensemble Label Filtering (Algorithm 1) focuses on the detection of certainly correct labels from the provided label set $L _ { 0 }$ . In each iteration $i$ , the model is trained using the label set of potentially correct labels $L _ { i }$ . At the end of each iteration, the model determines the next correct label set $L _ { i + 1 }$ using the filtering strategy described in 2.2 The model stops learning when no improvement was achieved after training on the refined label set $L _ { i + 1 }$ .
+
+In other words, in each iteration, the model attempts to learn from the easy, in some sense, obviously correct labels. However, learning from easy samples also affects similar but harder samples from the same classes. Therefore, by learning from these easy samples, the network can gradually distinguish between hard and wrongly-labeled samples.
+
+<table><tr><td colspan="2">Algorithm1 SELF:Self-EnsembleLabel Filtering pseudocode</td></tr><tr><td>Require: Dtrain = noisy labeled training set Require: Dual = noisy labeled validation set</td><td></td></tr><tr><td>Require:(x,y) = training stimuli and label</td><td></td></tr><tr><td colspan="2">Require: α = ensembling momentum,O ≤α≤1 counter to track iterations</td></tr><tr><td colspan="2">i←0</td></tr><tr><td colspan="2">Mi ← train(Dtrain,Dvat) √initial Mean-Teacher ensemble model training Mbest←Mi</td></tr><tr><td colspan="2">&gt; set initial model as best model ←0 &gt;initialize ensemble predictions of all samples</td></tr><tr><td colspan="2">(ignored sample index for simplicity) while acc(Mi,Dvat) ≥ acc(Mbest,Dval) do √iterate until no best model is found on Dual</td></tr><tr><td colspan="2">Mbest←Mi save the best model Dfilter ←Dtrain &gt;set filtered dataset as initial label set</td></tr><tr><td colspan="2">i←i+1 for (x,y) in Dfilter do</td></tr><tr><td colspan="2">←Mbest(x) &gt; evaluate model output 泛i</td></tr><tr><td colspan="2">←azi-1+(1-a)</td></tr><tr><td colspan="2" rowspan="2">if y ≠ argmax(zi) then y ←@inDfilter</td></tr><tr><td rowspan="4">V accumulate ensemble predictions Zi &gt; verify agreement of ensemble predictions &amp; label</td></tr><tr><td>&gt;identify it as noisy label&amp; remove from label set</td></tr><tr><td></td></tr><tr><td colspan="2">end for Mi ← train(Dfilter,Dval) &gt;train Mean-Teacher model on filtered label set end while</td></tr></table>
+
+Our framework does not focus on repairing all noisy labels. Although the detection of wrong labels is sometimes easy, finding their correct hidden label might be extremely challenging in case of having many classes. If the noise is sufficiently random, the set of correct labels will be representative to achieve high model performance. Further, in our framework, the label filtering is performed on the original label set $L _ { 0 }$ from iteration 0. Clean labels erroneously removed in an earlier iteration (e.g., labels of hard to classify samples) can be reconsidered for model training again in later iterations.
+
+Filtering strategy The model can determine the set of potentially correct labels $L _ { i }$ based on agreement between the label $y$ and its maximal likelihood prediction ${ \hat { y } } | x$ with $L _ { i } ~ = ~ \{ ( y , x ) ~ | ~ \bar { \hat { y } _ { x } } ~ =$ $y ; \forall ( y , x ) \in L _ { 0 } \}$ . $L _ { 0 }$ is the label set provided in the beginning, $( y , x )$ are the samples and their respective noisy labels in the iteration $i$ . In other words, the labels are only used for supervised training if in the current epoch, the model predicts the respective label to be the correct class with the highest likelihood. In practice, our framework does not use ${ \hat { y } } ( x )$ of model snapshots for filtering but a moving-average of the ensemble models and predictions to improve the filtering decision.
+
+# 2.3 SELF-ENSEMBLE LEARNING
+
+The model’s predictions for noisy samples tend to fluctuate. For example, take a cat wrongly labeled as a tiger. Other cat samples would encourage the model to predict the given cat image as a cat. Contrary, the wrong label tiger regularly pulls the model back to predict the cat as a tiger. Hence, using the model’s predictions gathered in one single training epoch for filtering is sub-optimal. Therefore, in our framework SELF, our model relies on ensembles of models and predictions.
+
+Model ensemble with Mean Teacher A natural way to form a model ensemble is by using an exponential running average of model snapshots (Fig. 3a). This idea was proposed in Tarvainen & Valpola (2017) for semi-supervised learning and is known as the Mean Teacher model. In our framework, both the mean teacher model and the normal model are evaluated on all data to preserve the consistency between both models. The consistency loss between student and teacher output distribution can be realized with Mean-Square-Error loss or Kullback-Leibler-divergence. More details for training with the model ensemble can be found in Appendix A.1
+
+Prediction ensemble Additionally, we propose to collect the sample predictions over multiple training epochs: $\overline { { z } } _ { j } = \alpha \overline { { z } } _ { j - 1 } + ( 1 - \alpha ) \hat { z } _ { j }$ , whereby $\overline { { z } } _ { j }$ depicts the moving-average prediction of sample $k$ at epoch $j$ , $\alpha$ is a momentum, $\hat { z } _ { j }$ is the model prediction for sample $k$ in epoch $j$ . This scheme is displayed in Fig. 3b. For each sample, we store the moving-average predictions, accumulated over the past iterations. Besides having a more stable basis for the filtering step, our proposed procedure also leads to negligible memory and computation overhead.
+
+![](images/6dcee7204caa2b910d919137fe49f2fc7911913716572159b2a3330ffbd08ca0.jpg)  
+Figure 3: Maintaining the (a) model and (b) predictions ensembles is very effective against noisy model updates. These ensembles are self-forming during the training process as a moving-average of (a) model snapshots or (b) class predictions from previous training steps.
+
+Further, due to continuous training of the best model from the previous model, computation time can be significantly reduced, compared to re-training the model from scratch. On the new filtered dataset, the model must only slowly adapt to the new noise ratio contained in the training set. Depending on the computation budget, a maximal number of iterations for filtering can be set to save time.
+
+# 3 RELATED WORKS
+
+Reed et al. (2014); Azadi et al. (2015) performed early works on learning robustly under label noise for deep neural networks. Recently, Rolnick et al. (2017) have shown for classification that deep neural networks come with natural robustness to label noise following a particular random distribution. No modification of the network or the training procedure is required to achieve this robustness. Following this insight, our framework SELF relies on this natural robustness to kickstart the self-ensemble filtering process to extend the robust behavior to more challenging scenarios.
+
+Laine & Aila (2016); Luo et al. (2018) proposed to apply semi-supervised techniques on the data to counteract noise. These and other semi-supervised learning techniques learn from a static, initial set of noisy labels and have no mechanisms to repair labels. Therefore, the supervised losses in their learning objective are typically high until the model strongly overfits to the label noise. Compared to these works, our framework performs a variant of self-supervised label corrections. The network learns from a dynamic, variable set of labels, which is determined by the network itself. Progressive filtering allows the network to (1) focus on a label set with a significantly lower noise ratio and (2) repair wrong decisions made by itself in an earlier iteration.
+
+Other works assign weights to potentially wrong labels to reduce the learning signal (Jiang et al., 2017; Ren et al., 2018; Jenni & Favaro, 2018). These approaches tend to assign less extreme weights or hyperparameters that are hard to set. Since the typical classification loss is highly non-linear, a lower weight might still lead to learning from wrong labels. Compared to these works, the samples in SELF only receive extreme weights: either they are zero or one. Further, SELF focuses only on self-detecting the correct samples, instead of repairing the wrong labels. Typically, the set of correct samples are much easier to detect and are sufficiently representative to achieve high performance.
+
+Han et al. (2018b); Jiang et al. (2017) employ two collaborating and simultaneously learning networks to determine which samples to learn from and which not. However, the second network is free in its predictions and hence hard to tune. Compared to these works, we use ensemble learning as a principled approach to counteract model fluctuations. In SELF, the second network is extremely restricted and is only composed of running averages of the first network. To realize the second network, we use the mean-teacher model (Tarvainen & Valpola, 2017) as a backbone. Compared to their work, our self-ensemble label filtering gradually detects the correct labels and learns from them, so the label set is variable. Further, we do use not only model ensembles but also an ensemble of predictions to detect correct labels.
+
+Other works modify the primary loss function of the classification tasks. Patrini et al. (2017) estimates the noise transition matrix to correct the loss, Han et al. (2018a) uses human-in-the-loop, Zhang & Sabuncu (2018); Thulasidasan et al. (2019) propose other forms of cross-entropy losses. The loss modification impedes the transfer of these ideas to other tasks than classification. Compared to these works, our framework SELF does not modify the primary loss. However, many tasks rely on the presence of clean labels such as anomaly detection (Nguyen et al., 2019a) or self-supervised and unsupervised learning (Nguyen et al., 2019b). The progressive filtering procedure and self-ensemble learning proposed are also applicable in these tasks to counteract noise effectively.
+
+Table 1: Comparison of classification accuracy when learning under uniform label noise on CIFAR10 and CIFAR-100. Following previous works, we compare two evaluation scenarios: with a noisy validation set (top) and with 1000 clean validation samples (bottom). The best model is marked in bold. Having a small clean validation set improves the model but is not necessary.   
+
+<table><tr><td rowspan="2">NOISE RATIO</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td></tr><tr><td>40%</td><td>60%</td><td>80%</td><td>40%</td><td>60%</td><td>80%</td></tr><tr><td colspan="7">USINGNOISYVALIDATIONSET</td></tr><tr><td>REED-HARD (REED ET AL.,2014)</td><td>69.66</td><td></td><td></td><td>51.34</td><td></td><td></td></tr><tr><td>S-MODEL(GOLDBERGER&amp; BEN-REUVEN,2016)</td><td>70.64</td><td></td><td></td><td>49.10</td><td></td><td></td></tr><tr><td>OPEN-SET WANG ET AL.(2018)</td><td>78.15</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RAND.WEIGHTS (REN ET AL.,2018)</td><td>86.06</td><td></td><td>=</td><td>58.01</td><td></td><td></td></tr><tr><td>BI-LEVEL-MODEL (JENNI &amp; FAVARO,2018)</td><td>89.00</td><td></td><td>20.00</td><td>61.00</td><td></td><td>13.00</td></tr><tr><td>MENTORNET (JIANG ET AL., 2017)</td><td>89.00</td><td></td><td>49.00</td><td>68.00</td><td></td><td>35.00</td></tr><tr><td>Lq (ZHANG &amp; SABUNCU,2018)</td><td>87.13</td><td>82.54</td><td>64.07</td><td>61.77</td><td>53.16</td><td>29.16</td></tr><tr><td>TRUNC Lq(ZHANG &amp; SABUNCU, 2018)</td><td>87.62</td><td>82.70</td><td>67.92</td><td>62.64</td><td>54.04</td><td>29.60</td></tr><tr><td>FORWARD T (PATRINI ET AL.,2017)</td><td>83.25</td><td>74.96</td><td>54.64</td><td>31.05</td><td>19.12</td><td>08.90</td></tr><tr><td>CO-TEACHING (HAN ET AL.,2018B)</td><td>81.85</td><td>74.04</td><td>29.22</td><td>55.95</td><td>47.98</td><td>23.22</td></tr><tr><td>D2L (MA ET AL., 2018)</td><td>83.36</td><td>72.84</td><td>-</td><td>52.01</td><td>42.27</td><td></td></tr><tr><td>SL (WANG ET AL., 2019)</td><td>85.34</td><td>80.07</td><td>53.81</td><td>53.69</td><td>41.47</td><td>15.00</td></tr><tr><td>JOINTOPT (TANAKA ET AL.,2018)</td><td>83.27</td><td>74.39</td><td>40.09</td><td>52.88</td><td>42.64</td><td>18.46</td></tr><tr><td>SELF (OURS)</td><td>93.70</td><td>93.15</td><td>69.91</td><td>71.98</td><td>66.21</td><td>42.09</td></tr><tr><td colspan="7">USING CLEANVALIDATION SET (1000 IMAGES)</td></tr><tr><td>DAC (THULASIDASAN ET AL.,2019)</td><td>90.93</td><td>87.58</td><td>70.80</td><td>68.20</td><td>59.44</td><td>34.06</td></tr><tr><td>MENTORNET (JIANG ET AL.,2017)</td><td>78.00</td><td></td><td></td><td>59.00</td><td></td><td></td></tr><tr><td>RAND.WEIGHTS (REN ET AL., 2018)</td><td>86.55</td><td></td><td></td><td>58.34</td><td></td><td></td></tr><tr><td>REN ET AL(REN ET AL.,2018)</td><td>86.92</td><td></td><td></td><td>61.31</td><td></td><td></td></tr><tr><td>SELF*(OURS)</td><td>95.10</td><td>93.77</td><td>79.93</td><td>74.76</td><td>68.35</td><td>46.43</td></tr></table>
+
+# 4 EVALUATION
+
+# 4.1 EXPERIMENTS DESCRIPTIONS
+
+# 4.1.1 STRUCTURE OF THE ANALYSIS
+
+We evaluate our approach on CIFAR-10, CIFAR-100, an ImageNet-ILSVRC on different noise scenarios. For CIFAR-10, CIFAR-100, and ImageNet, we consider the typical situation with symmetric and asymmetric label noise. In the case of the symmetric noise, a label is randomly flipped to another class with probability $p$ . Following previous works, we also consider label flips of semantically similar classes on CIFAR-10, and pair-wise label flips on CIFAR-100. Finally, we perform studies on the choice of the network architecture and the ablation of the components in our framework. Tab. 6 (Appendix) shows the in-deep analysis of semi-supervised learning strategies combined with recent works. Overall, the proposed framework SELF outperforms all these combinations.
+
+# 4.1.2 COMPARISONS TO PREVIOUS WORKS
+
+We compare our work to previous methods from Reed-Hard (Reed et al., 2014), S-model (Goldberger & Ben-Reuven, 2016), Wang et al. (2018), Rand. weights (Ren et al., 2018), Bi-level-model (Jenni & Favaro, 2018), D2L (Ma et al., 2018), SL (Wang et al., 2019), $L _ { q }$ (Zhang & Sabuncu, 2018), Trunc $L _ { q }$ (Zhang & Sabuncu, 2018), Forward $\hat { T }$ (Patrini et al., 2017), DAC (Thulasidasan et al., 2019), Random reweighting (Ren et al., 2018), and Learning to reweight (Ren et al., 2018). For co-teaching (Han et al., 2018b), MentorNet (Jiang et al., 2017), JointOpt (Tanaka et al., 2018), the source codes are available and hence used for evaluation.
+
+(Ren et al., 2018) and DAC (Thulasidasan et al., 2019) considered the setting of having a small clean validation set of 1000 and 5000 images respectively. For comparison purposes, we also experiment with a small clean set of 1000 images additionally. Further, we abandon oracle experiments or methods using additional information to keep the evaluation comparable. For instance, Forward $T$ (Patrini et al., 2017) uses the true underlying confusion matrix to correct the loss. This information is neither known in typical scenarios nor used by other methods.
+
+Table 2: Asymmetric noise on CIFAR-10, CIFAR-100. All methods use Resnet34. CIFAR-10: flip TRUCK AUTOMOBILE, BIRD AIRPLANE, DEER HORSE, $\mathrm { C A T }  \mathrm { D O G }$ with prob. $p$ . CIFAR-100: flip class $i$ to $( i + 1 ) \% 1 0 0$ with prob. p. SELF retains high performances across all noise ratios and outperforms all previous works.   
+
+<table><tr><td></td><td colspan="4">CIFAR-10</td><td colspan="4">CIFAR-100</td></tr><tr><td>NOISE RATIO</td><td>10%</td><td>20%</td><td>30%</td><td>40%</td><td>10%</td><td>20%</td><td>30%</td><td>40%</td></tr><tr><td>CCE</td><td>90.69</td><td>88.59</td><td>86.14</td><td>80.11</td><td>66.54</td><td>59.20</td><td>51.40</td><td>42.74</td></tr><tr><td>MAE</td><td>82.61</td><td>52.93</td><td>50.36</td><td>45.52</td><td>13.38</td><td>11.50</td><td>08.91</td><td>08.20</td></tr><tr><td>FORWARD T</td><td>90.52</td><td>89.09</td><td>86.79</td><td>83.55</td><td>45.96</td><td>42.46</td><td>38.13</td><td>34.44</td></tr><tr><td>Lq</td><td>90.91</td><td>89.33</td><td>85.45</td><td>76.74</td><td>68.36</td><td>66.59</td><td>61.45</td><td>47.22</td></tr><tr><td>TRUNC Lq</td><td>90.43</td><td>89.45</td><td>87.10</td><td>82.28</td><td>68.86</td><td>66.59</td><td>61.87</td><td>47.66</td></tr><tr><td>SL</td><td>88.24</td><td>85.36</td><td>80.64</td><td>=</td><td>65.58</td><td>65.14</td><td>63.10</td><td>=</td></tr><tr><td>JOINTOPT</td><td>90.12</td><td>89.45</td><td>87.18</td><td>87.97</td><td>69.61</td><td>68.94</td><td>63.99</td><td>53.71</td></tr><tr><td>SELF (OURS)</td><td>93.75</td><td>92.76</td><td>92.42</td><td>89.07</td><td>72.45</td><td>70.53</td><td>65.09</td><td>53.83</td></tr></table>
+
+Whenever possible, we adopt the reported performance from the corresponding publications. The testing scenarios are kept as similar as possible to enable a fair comparison. All tested scenarios use a noisy validation set with the same noise distribution as the training set unless stated otherwise. All model performances are reported on the clean test set.
+
+Table 3: Effect of the choice of network architecture on classification accuracy on CIFAR-10 & -100 with uniform label noise. SELF is compatible with all tested architectures. Here \* represents baseline accuracy of the architectures that are trained on fully supervised setting at $0 \%$ label noise.   
+
+<table><tr><td colspan="3">CIFAR-10</td><td colspan="2">CIFAR-100</td></tr><tr><td>RESNET34</td><td colspan="2">93.5*</td><td colspan="2">76.76*</td></tr><tr><td>NOISE</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>Lq</td><td>87.13</td><td>64.07</td><td>61.77</td><td>29.16</td></tr><tr><td>TRUNC Lq</td><td>87.62</td><td>67.92</td><td>62.64</td><td>29.60</td></tr><tr><td>FORWARD T</td><td>83.25</td><td>54.64</td><td>31.05</td><td>8.90</td></tr><tr><td>SELF</td><td>91.13</td><td>63.59</td><td>66.71</td><td>35.56</td></tr><tr><td></td><td>96.37*</td><td></td><td>81.20*</td><td></td></tr><tr><td>RESNET26</td><td></td><td></td><td></td><td></td></tr><tr><td>NOISE</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>Co-T.</td><td>81.85</td><td>29.22</td><td>55.95</td><td>23.22</td></tr><tr><td>SELF</td><td>93.70</td><td>69.91</td><td>71.98</td><td>42.09</td></tr></table>
+
+<table><tr><td colspan="3">CIFAR-10</td><td colspan="2">CIFAR-100</td></tr><tr><td>RESNET101</td><td colspan="2">93.89*</td><td colspan="2">81.14*</td></tr><tr><td>NOISE</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>MENTORNET</td><td>89.00</td><td>49.00</td><td>68.00</td><td>35.00</td></tr><tr><td>Co-T.</td><td>62.58</td><td>21.79</td><td>39.58</td><td>16.79</td></tr><tr><td>SELF</td><td>92.77</td><td>64.52</td><td>69.00</td><td>39.73</td></tr><tr><td></td><td>96.21*</td><td></td><td>81.02*</td><td></td></tr><tr><td>WRN 28-10</td><td></td><td>80%</td><td></td><td></td></tr><tr><td>NOISE</td><td>40%</td><td></td><td>40%</td><td>80%</td></tr><tr><td>MENTORNET REWEIGHT</td><td>88.7</td><td>46.30</td><td>67.50</td><td>30.10</td></tr><tr><td></td><td>86.02</td><td>1</td><td>58.01</td><td>1</td></tr><tr><td>SELF</td><td>93.34</td><td>67.41</td><td>72.48</td><td>42.06</td></tr></table>
+
+# 4.1.3 NETWORKS CONFIGURATION AND TRAINING
+
+For the basic training of self-ensemble model, we use the Mean Teacher model (Tarvainen & Valpola, 2017) available on GitHub 1 . The students and teacher networks are residual networks (He et al., 2016) with 26 layers with Shake-Shake-regularization (Gastaldi, 2017). We use the PyTorch (Paszke et al., 2017) implementation of the network and keep the training settings close to (Tarvainen & Valpola, 2017). The network is trained with Stochastic Gradient Descent. In each filtering iteration, the model is trained for a maximum of 300 epochs, with patience of 50 epochs. For more training details, see the appendix.
+
+# 4.2 EXPERIMENTS RESULTS
+
+# 4.2.1 SYMMETRIC LABEL NOISE
+
+CIFAR-10 and 100 Results for typical uniform noise scenarios with noise ratios on CIFAR-10 and CIFAR-100 are shown in Tab. 1. More results are visualized in Fig. 1a (CIFAR-10) and Fig. 1b (CIFAR-100). Our approach $S E L F$ performs robustly in the case of lower noise ratios with up to $60 \%$ and outperforms previous works. Although a strong performance loss occurs at $80 \%$ label noise,
+
+Table 4: Classification accuracy on clean ImageNet validation dataset. The models are trained at $40 \%$ label noise and the best model is picked based on the evaluation on noisy validation data. Mentornet shows the best previously reported results. Mentornet\* is based on Resnet-101. We chose the smaller Resnext50 model to reduce the run-time.   
+
+<table><tr><td>Accurracy</td><td>Resnext18 P@1 P@5</td><td>Resnext50 P@1 P@5</td></tr><tr><td>Mentornet*</td><td>=</td><td>65.10 85.90</td></tr><tr><td>ResNext</td><td>50.6 75.99</td><td>56.25 80.90</td></tr><tr><td>Mean-T.</td><td>58.04 81.82</td><td>62.96 85.72</td></tr><tr><td>SELF (Ours)</td><td>66.92 86.65</td><td>71.31 89.92</td></tr></table>
+
+Table 5: Ablation study on CIFAR-10 and CIFAR100. The Resnet baseline was trained on the full noisy label set. Adding progressive filtering improves over this baseline. The Mean Teacher maintains an ensemble of model snapshots, which helps counteract noise. Having progressive filtering and model ensembles (-MVA-pred.) makes the model more robust but still fails at $80 \%$ noise. The full SELF framework additionally uses the prediction ensemble for detection of correct labels.
+
+<table><tr><td colspan="3">CIFAR-10</td><td colspan="2">CIFAR-100</td></tr><tr><td>NOISE RATIO</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>RESNET26</td><td>83.20</td><td>41.37</td><td>53.18</td><td>19.92</td></tr><tr><td>FILTERING</td><td>87.35</td><td>49.58</td><td>61.40</td><td>23.42</td></tr><tr><td>MEAN-T.</td><td>93.70</td><td>52.50</td><td>65.85</td><td>26.31</td></tr><tr><td>- MVA-PRED.</td><td>93.77</td><td>57.40</td><td>71.69</td><td>38,61</td></tr><tr><td>SELF (OURS)</td><td>93.70</td><td>69.91</td><td>71.98</td><td>42.09</td></tr></table>
+
+SELF still outperforms most of the previous approaches. The experiment $S E L F ^ { * }$ using a 1000 clean validation images shows that the performance loss mostly originates from the progressive filtering relying too strongly on the extremely noisy validation set.
+
+ImageNet-ILSVRC Tab. 4 shows the precision $@ 1$ and $\textcircled { a } 5$ of various models, given $40 \%$ label noise in the training set. Our networks are based on ResNext18 and Resnext50. Note that MentorNet (Jiang et al., 2017) uses Resnet101 $( \mathrm { P } @ 1 : 7 8 . 2 5 )$ (Goyal et al., 2017), which has higher performance compared to Resnext50 $( \mathrm { P } @ 1 \colon 7 7 . 8 )$ (Xie et al., 2017) on the standard ImageNet validation set.
+
+Despite the weaker model, SELF (ResNext50) surpasses the best previously reported results by more than $5 \%$ absolute improvement. Even the significantly weaker model ResNext18 outperforms MentorNet, which is based on a more powerful ResNet101 network.
+
+# 4.2.2 ASYMMETRIC LABEL NOISE
+
+Tab. 2 shows more challenging noise scenarios when the noise is not class-symmetric and uniform. Concretely, labels are flipped among semantically similar classes such as CAT and DOG on CIFAR10. On CIFAR-100, each label is flipped to the next class with a probability $p$ . In these scenarios, our framework SELF also retains high performance and only shows a small performance drop at $40 \%$ noise. The high label noise resistance of our framework indicates that the proposed self-ensemble filtering process helps the network identify correct samples, even under extreme noise ratios.
+
+# 4.2.3 EFFECTS OF DIFFERENT ARCHITECTURES
+
+Previous works utilize a various set of different architectures, which hinders a fair comparison. Tab. 3 shows the performance of our framework $S E L F$ compared to previous approaches. $S E L F$ outperforms other works in all scenarios except for CIFAR-10 with $80 \%$ noise. Typical robust learning approaches lead to significant accuracy losses at $40 \%$ noise, while SELF still retains high performance. Further, note that SELF allows the network’s performance to remain consistent across the different underlying architectures.
+
+# 4.2.4 ABLATION STUDY
+
+Tab. 5 shows the importance of each component in our framework. See Fig. 4a, Fig. 4b for experiments on more noise ratios. As expected, the Resnet-baseline rapidly breaks down with increasing noise ratios. Adding self-supervised filtering increases the performance slightly in lower noise ratios. However, the model has to rely on extremely noisy snapshots. Contrary, using a model ensemble alone such as in Mean-Teacher can counteract noise on the noisy dataset CIFAR-10. On the more challenging CIFAR-100, however, the performance decreases strongly. With self-supervised filtering and model ensembles, SELF (without MVA-pred) is more robust and only impairs performance at $80 \%$ noise. The last performance boost is given by using moving-average predictions so that the network can reliably detect correctly labeled samples gradually.
+
+Fig. 4 shows the ablation experiments on more noise ratios. The analyses shows that each component in SELF is essential for the model to learn robustly.
+
+![](images/4bee4e5edf9dbc3105e46d17d67ce0bac334f01220c37af5b6a416ad7d31ced7.jpg)  
+Figure 4: Ablation study on the importance of the components in our framework SELF, evaluated on (a) Cifar-10 and (b) Cifar-100 with uniform noise. Please refer Tab. 5 for details of components.
+
+Table 6: Analysis of semi-supervised learning (SSL) strategies: entropy learning, mean-teacher combined with recent works. Our progressive filtering strategy is shown to be effective and performs well regardless of the choice of the semi-supervised learning backbone. Overall, the proposed method SELF outperforms all these combinations. Best model in each SSL-category is marked in bold. Running mean-teacher+ co-teaching using the same configuration is not possible due to memory constraints.   
+
+<table><tr><td>NOISE RATIO</td><td>40%</td><td>CIFAR-10 60%</td><td>80%</td><td>40%</td><td>CIFAR-100 60%</td><td>80%</td></tr><tr><td colspan="7">BASELINE MODELS</td></tr><tr><td>RESNET26 (GASTALDI, 2017)</td><td>83.20</td><td>72.35</td><td>41.37</td><td>53.18</td><td>44.31</td><td>19.92</td></tr><tr><td>CO-TEACHING (HAN ET AL.,2018B)</td><td>81.85</td><td>74.04</td><td>29.22</td><td>55.95</td><td>47.98</td><td>23.22</td></tr><tr><td>JOINTOPT(TANAKA ET AL.,2018)</td><td>83.27</td><td>74.39</td><td>40.09</td><td>52.88</td><td>42.64</td><td>18.46</td></tr><tr><td>PROGRESSIVE FILTERING (OURS)</td><td>87.35</td><td>75.47</td><td>49.58</td><td>61.40</td><td>50.60</td><td>23.42</td></tr><tr><td colspan="7">SEMI-SUPERVISED LEARNING WITH ENTROPY LEARNING</td></tr><tr><td>ENTROPY</td><td>79.13</td><td>85.98</td><td>46.93</td><td>54.65</td><td>41.34</td><td>21.29</td></tr><tr><td>ENTROPY + CO-TEACHING</td><td>84.94</td><td>74.28</td><td>35.16</td><td>55.68</td><td>43.52</td><td>20.5</td></tr><tr><td>ENTROPY + JOINT-OPT</td><td>84.44</td><td>75.86</td><td>39.16</td><td>56.73</td><td>43.27</td><td>17.24</td></tr><tr><td>ENTROPY+FILTERING (OURS)</td><td>90.04</td><td>83.88</td><td>52.46</td><td>59.97</td><td>46.45</td><td>23.53</td></tr><tr><td colspan="7">SEMI-SUPERVISED LEARNING WITH MEAN-TEACHER</td></tr><tr><td>MEAN TEACHER</td><td>93.70</td><td>90.40</td><td>52.5</td><td>65.85</td><td>54.48</td><td>26.31</td></tr><tr><td>MEAN-TEACHER + JOINTOPT</td><td>91.40</td><td>83.62</td><td>45.12</td><td>60.09</td><td>45.92</td><td>23.54</td></tr><tr><td>MEAN-TEACHER + FILTERING - SELF(OURS)</td><td>93.70</td><td>92.85</td><td>69.91</td><td>71.98</td><td>66.21</td><td>42.58</td></tr></table>
+
+# 4.2.5 SEMI-SUPERVISED LEARNING FOR PROGRESSIVE FILTERING
+
+Tab. 6 shows different semi-supervised learning strategies: entropy learning, mean-teacher combined with recent works. Note that Co-Teaching+Mean-Teacher cannot be implemented and run in the same configuration as other experiments, due to memory constraints.
+
+The analysis indicates the semi-supervised losses mostly stabilize the baselines, compared to the model without semi-supervised learning. However, Co-teaching and JointOpt sometimes perform worse than the purely semi-supervised model. This result indicates that their proposed frameworks are not always compatible with semi-supervised losses.
+
+The progressive filtering technique is seamlessly compatible with different semi-supervised losses. The filtering outperforms its counterparts when combined with Entropy Learning or Mean-teacher model. Overall, SELF outperforms all considered combinations.
+
+# 5 CONCLUSION
+
+We propose a simple and easy to implement a framework to train robust deep learning models under incorrect or noisy labels. We filter out the training samples that are hard to learn (possibly noisy labeled samples) by leveraging ensemble of predictions of the single network’s output over different training epochs. Subsequently, we allow clean supervision from the non-hard samples and further leverage additional unsupervised loss from the entire dataset. We show that our framework results in DNN models with superior generalization performance on CIFAR-10, CIFAR-100 & ImageNet and outperforms all previous works under symmetric (uniform) and asymmetric noises. Furthermore, our models remain robust despite the increasing noise ratio and change in network architectures.
+
+# REFERENCES
+
+Samaneh Azadi, Jiashi Feng, Stefanie Jegelka, and Trevor Darrell. Auxiliary image regularization for deep cnns with noisy labels. arXiv preprint arXiv:1511.07069, 2015.
+
+Benoˆıt Frenay and Michel Verleysen. Classification in the presence of label noise: a survey. ´ IEEE transactions on neural networks and learning systems, 25(5):845–869, 2013.
+
+Xavier Gastaldi. Shake-shake regularization. arXiv preprint arXiv:1705.07485, 2017.
+
+Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative Adversarial Nets. pp. 9.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+Bo Han, Jiangchao Yao, Gang Niu, Mingyuan Zhou, Ivor Tsang, Ya Zhang, and Masashi Sugiyama. Masking: A new perspective of noisy supervision. In Advances in Neural Information Processing Systems, pp. 5836–5846, 2018a.
+
+Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In NeurIPS, pp. 8535–8545, 2018b.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Simon Jenni and Paolo Favaro. Deep bilevel learning. In ECCV, 2018.
+
+Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. MentorNet: Learning DataDriven Curriculum for Very Deep Neural Networks on Corrupted Labels. arXiv:1712.05055 [cs], December 2017. URL http://arxiv.org/abs/1712.05055. arXiv: 1712.05055.
+
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.
+
+Yucen Luo, Jun Zhu, Mengxi Li, Yong Ren, and Bo Zhang. Smooth neighbors on teacher graphs for semi-supervised learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8896–8905, 2018.
+
+Xingjun Ma, Yisen Wang, Michael E Houle, Shuo Zhou, Sarah M Erfani, Shu-Tao Xia, Sudanthi Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. arXiv preprint arXiv:1806.02612, 2018.
+
+Duc Tam Nguyen, Zhongyu Lou, Michael Klar, and Thomas Brox. Anomaly detection with multiple-hypotheses predictions. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 4800–4809, Long Beach, California, USA, 09–15 Jun 2019a. PMLR. URL http://proceedings.mlr.press/v97/nguyen19b.html.
+
+Tam Nguyen, Maximilian Dax, Chaithanya Kumar Mummadi, Nhung Ngo, Thi Hoai Phuong Nguyen, Zhongyu Lou, and Thomas Brox. Deepusps: Deep robust unsupervised saliency prediction via self-supervision. In Advances in Neural Information Processing Systems, pp. 204–214, 2019b.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1944–1952, 2017.
+
+Scott Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. arXiv preprint arXiv:1412.6596, 2014.
+
+Mengye Ren, Wenyuan Zeng, Bin Yang, and Raquel Urtasun. Learning to Reweight Examples for Robust Deep Learning. arXiv:1803.09050 [cs, stat], March 2018. URL http://arxiv.org/ abs/1803.09050. arXiv: 1803.09050.
+
+David Rolnick, Andreas Veit, Serge Belongie, and Nir Shavit. Deep learning is robust to massive label noise. arXiv preprint arXiv:1705.10694, 2017.
+
+Ilya Sutskever, James Martens, George E Dahl, and Geoffrey E Hinton. On the importance of initialization and momentum in deep learning. ICML (3), 28(1139-1147):5, 2013.
+
+Daiki Tanaka, Daiki Ikami, Toshihiko Yamasaki, and Kiyoharu Aizawa. Joint optimization framework for learning with noisy labels. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5552–5560, 2018.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Advances in neural information processing systems, pp. 1195–1204, 2017.
+
+Sunil Thulasidasan, Tanmoy Bhattacharya, Jeff Bilmes, Gopinath Chennupati, and Jamal MohdYusof. Combating label noise in deep learning using abstention. arXiv preprint arXiv:1905.10964, 2019.
+
+Yisen Wang, Weiyang Liu, Xingjun Ma, James Bailey, Hongyuan Zha, Le Song, and Shu-Tao Xia. Iterative learning with open-set noisy labels. arXiv preprint arXiv:1804.00092, 2018.
+
+Yisen Wang, Xingjun Ma, Zaiyi Chen, Yuan Luo, Jinfeng Yi, and James Bailey. Symmetric cross entropy for robust learning with noisy labels. In Proceedings of the IEEE International Conference on Computer Vision, pp. 322–330, 2019.
+
+Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans- ´ formations for deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1492–1500, 2017.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations, 2017. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ Sy8gdB9xx.
+
+Zhilu Zhang and Mert Sabuncu. Generalized cross entropy loss for training deep neural networks with noisy labels. In Advances in Neural Information Processing Systems, pp. 8778–8788, 2018.
+
+# A APPENDIX
+
+A.1 MEAN TEACHER MODEL FOR ITERATIVE FILTERING
+
+We apply the Mean Teacher algorithm in each iteration $i$ in the train $\mathbf { \nabla } _ { \cdot } ( \mathcal { D } _ { f i l t e r } , \mathcal { D } _ { v a l } )$ procedure as follows.
+
+• Input: examples with potentially clean labels $D _ { f i l t e r }$ from the filtering procedure. In the beginning $\mathit { i } = 0 $ ), here $D _ { f i l t e r }$ refers to entire labeled dataset.   
+Initialize a supervised neural network as the student model $M _ { i } ^ { s }$ .   
+Initialize the Mean Teacher model $M _ { i } ^ { t }$ as a copy of the student model with all weights detached.   
+• Let the loss function be the sum of normal classification loss of $M _ { i } ^ { s }$ and the consistency loss between the outputs of $M _ { i } ^ { t }$ and $M _ { i } ^ { t }$
+
+• Select an optimizer • In each training iteration:
+
+– Update the weights of $M _ { i } ^ { s }$ using the selected optimizer – Update the weights of $M _ { i } ^ { t }$ as an exponential moving-average of the student weights – Evaluate performance of $M _ { i } ^ { s }$ and $M _ { i } ^ { t }$ over $\mathcal { D } _ { v a l }$ to verify the early stopping criteria.
+
+• Return the best $M _ { i } ^ { t }$
+
+# A.2 ASSUMPTIONS DICUSSIONS
+
+Our method performs best when the following assumptions are hold.
+
+Natural robustness assumption of deep networks (Rolnick et al., 2017): The networks attempt to learn the easiest way to explain most of the data. SELF uses this assumption to kickstart the learning process.
+
+Correct samples dominate over wrongly labeled samples At $80 \%$ noise on CIFAR-10, the correctly labeled cats $20 \%$ out of all cat images) still dominates over samples wrongly labeled as cat $8 . { \overline { { 8 } } } { \dot { \% } }$ for each class).
+
+Independence results in less overfitting SELF performs best if the noises on the validation set and training set are i.i.d. . SELF uses the validation data for early stopping. Hence, a high correlation of label noise between train and valid increases the chance of model overfitting.
+
+Sufficient label randomness assumption The subset of all correctly labeled samples capture all samples clusters. In fact, many works from the active learning literature show that less than 100 $\%$ of the labeled samples are required to achieve the highest model performance. SELF performs progressive expansion of the correct labels sets. At larger noise ratios, not all clusters are covered by the identified samples. Therefore on task containing many classes, e.g., CIFAR-100, the model performance decreases faster than on CIFAR-10.
+
+The model performance reduces when these assumptions are strongly violated. Each assumption should have its own ”critical” threshold for violation. A future in-depth analysis to challenge the assumptions is an interesting future research direction.
+
+# A.3 TRAINING DETAILS
+
+# A.3.1 CIFAR-10 AND CIFAR-100
+
+Dataset Tab. 7 shows the details of CIFAR-10 and 100 datasets in our evaluation pipeline. The validation set is contaminated with the same noise ratio as the training data unless stated otherwise.
+
+Network training For the training our model SELF, we use the standard configuration provided by Tarvainen & Valpola (2017) 2. Concretely, we use the SGD-optimizer with Nesterov Sutskever et al. (2013) momentum, a learning rate of 0.05 with cosine learning rate annealing Loshchilov & Hutter (2016), a weight decay of 2e-4, max iteration per filtering step of 300, patience of 50 epochs, total epochs count of 600.
+
+Table 7: Dataset description. Classification tasks on CIFAR-10 and CIFAR-100 with uniform noise. Note that the noise on the training and validation set is not correlated. Hence, maximizing the accuracy on the noisy set provides a useful (but noisy) estimate for the generalization ability on unseen test data.   
+
+<table><tr><td></td><td>TYPE</td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>TASK RESOLUTION</td><td>CLASSIFICATION</td><td>10-WAY 32x32</td><td>100-WAY</td></tr><tr><td rowspan="3">DATA</td><td>TRAIN (NOISY)</td><td>45000</td><td>45000</td></tr><tr><td>VALID (NOISY)</td><td>5000</td><td>5000</td></tr><tr><td>TEST (CLEAN)</td><td>10000</td><td>10000</td></tr></table>
+
+For basic training of baselines models without semi-supervised learning, we had to set the learning rate to 0.01. In the case of higher learning rates, the loss typically explodes. Every other option is kept the same.
+
+Semi-supervised learning For the mean teacher training, additional hyperparameters are required. In both cases of CIFAR-10 and CIFAR-100, we again take the standard configuration with the consistency loss to mean-squared-error and a consistency weight: 100.0, logit distance cost: 0.01, consistency-ramp-up:5. The total batch-size is 512, with 124 samples being reserved for labeled samples, 388 for unlabeled data. Each epoch is defined as a complete processing of all unlabeled data. When training without semi-supervised-learning, the entire batch is used for labeled data.
+
+Data augmentation The data are normalized to zero-mean and standard-variance of one. Further, we use real-time data augmentation with random translation and reflection, subsequently random horizontal flip. The standard PyTorch-library provides these transformations.
+
+# A.3.2 IMAGENET-ILSVRC-2015
+
+Network Training The network used for evaluation were ResNet He et al. (2016) and Resnext Xie et al. (2017) for training. All ResNext variants use a cardinality of 32 and base width of 4 (32x4d). ResNext models follow the same structure as their Resnet counterparts, except for the cardinality and base width.
+
+All other configurations are kept as close as possible to Tarvainen & Valpola (2017). The initial learning rate to handle large batches Goyal et al. (2017) is set to 0.1; the base learning rate is 0.025 with a single cycle of cosine annealing.
+
+Semi-supervised learning Due to the large images, the batch size is set to 40 in total with 20/20 for labeled and unlabeled samples, respectively. We found the Kullback-divergence leads to no meaningful network training. Hence, we set the consistency loss to mean-squared-error, with a weight of 1000. We use consistency ramp up of 5 epochs to give the mean teacher more time in the beginning. Weight decay is set to 5e-5; patience is four epochs to stop training in the current filtering iteration.
+
+Filtering We filter noisy samples with the topk ${ \boldsymbol { \Xi } } 5$ strategy, instead of taking the maximumlikelihood (ML) prediction as on CIFAR-10 and CIFAR-100. That means the samples are kept for supervised training if their provided label lies within the top 5 predictions of the model. The main reason is that each image of ImageNet might contain multiple objects. Filtering with ML-predictions is too strict and would lead to a small recall of the detection of the correct sample.
+
+![](images/97cde72c1299198764476f784e7177f2db74d706d0a6c981d837434e544f1bae.jpg)  
+Figure 5: Simple training losses to counter label noise. (a) shows the prediction of a sample given a model. The red bar indicates the noisy label, blue the correct one. Arrows depict the magnitude of the gradients (b) Typical losses reweighting schemes are not wrong but suffer from the gradient vanishing problem. Non-linear losses such as Negative-log-likelihood are not designed for gradient ascent.
+
+Data Augmentation For all data, we normalize the RGB-images by the mean: (0.485, 0.456, 0.406) and the standard variance (0.229, 0.224, 0.225). For training data, we perform a random rotation of up to 10 degrees, randomly resize images to $2 2 4 \mathbf { x } 2 2 4$ , apply random horizontal flip and random color jittering. This noise is needed in regular mean-teacher training. The jittering setting are: brightness $_ { = 0 . 4 }$ , contras $= 0 . 4$ , saturation $= 0 . 4$ , hue $\scriptstyle = 0 . 1$ . The validation data are resized to $2 5 6 \mathrm { x } 2 5 6$ and randomly cropped to $2 2 4 \mathbf { x } 2 2 4$
+
+# A.3.3 SEMI-SUPERVISED LOSSES
+
+For the learning of wrongly labeled samples, Fig. 6 shows the relationship between the typical reweighting scheme and our baseline push-away-loss. Typically, reweighting is applied directly to the losses with samples weights $w ^ { ( k ) }$ for each sample $k$ as shown in Eq. 4
+
+$$
+\operatorname* { m i n } { w _ { i } ^ { ( k ) } N L L ( y _ { l a b e l } ^ { ( k ) } | x ^ { ( k ) } , D ) }
+$$
+
+$D$ is the dataset, $x ^ { ( k ) }$ and $y _ { l a b e l } ^ { ( k ) }$ are the samples $k$ and its noisy label. $w _ { i } ^ { ( k ) }$ is the samples weight for the sample $k$ at step $i$ . Negative samples weights $w _ { i } ^ { ( k ) }$ are often assigned to push the network away from the wrong labels. Let $w _ { i } ^ { ( k ) } = - c _ { i } ^ { ( k ) }$ with $c _ { i } ^ { ( k ) } > 0$ , then we have:
+
+$$
+\operatorname* { m i n } { - c _ { i } ^ { ( k ) } N L L ( y _ { l a b e l } ^ { ( k ) } | x ^ { ( k ) } , D ) }
+$$
+
+Which results in:
+
+$$
+\operatorname* { m a x } { c _ { i } ^ { ( k ) } N L L ( y _ { l a b e l } ^ { ( k ) } | x ^ { ( k ) } , D ) }
+$$
+
+In other words, we perform gradient ascent for wrongly labeled samples. However, the Negativelog-likelihood is not designed for gradient ascent. Hence the gradients of wrongly labeled samples vanish if the prediction is too close to the noisy label. This effect is similar to the training of Generative Adversarial Network (GAN) Goodfellow et al.. In the GAN-framework, the generator loss is not simply set to the negated version of the discriminator’s loss for the same reason.
+
+Therefore, to provide a fair comparison with our framework, we suggest the push-away-loss $L _ { P u s h - a w a y } ( y _ { l a b e l } ^ { ( k ) } , x ^ { ( k ) } , D )$ with improved gradients as follows:
+
+$$
+\operatorname* { m i n } \frac { 1 } { | Y | - 1 } \sum _ { y , y \ne y _ { l a b e l } ^ { ( k ) } } c _ { i } ^ { ( k ) } N L L ( y | x ^ { ( k ) } , D )
+$$
+
+Whereby $Y$ is the set of all classes in the training set. This loss has improved gradients to push the model away from the potentially wrong labels.
+
+![](images/219d42d1c63412854e7c7c4ab8eaee8f16ee72d3ec8db970bd1f0d680485c34e.jpg)  
+Figure 6: The entropy loss for semi-supervised learning. (a) Extreme predictions such as $[ 0 , 1 ]$ are encouraged by minimizing the entropy on each prediction. (b) Additionally, maximizing the entropy of the mean prediction on the entire dataset or a large batch forces the model to balance its predictions over multiple samples.
+
+Table 8: Accuracy of the complete removal of samples during iterative filtering on CIFAR-10 and CIFAR-100. The underlying model is the MeanTeacher based on Resnet26. When samples are completely removed from the training set, they are no longer used for either supervised-or-unsupervised learning. This common strategy from previous works leads to rapid performance breakdown.
+
+<table><tr><td></td><td colspan="2">CIFAR-10</td><td colspan="2">CIFAR-100</td></tr><tr><td>NOISE RATIO</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td colspan="5">USING NOISY I DATA ONLY</td></tr><tr><td>DATA REMOVAL</td><td>93.4</td><td>59.98</td><td>68.99</td><td>35.53</td></tr><tr><td>SELF (OURS)</td><td>93.7</td><td>69.91</td><td>71.98</td><td>42.09</td></tr><tr><td colspan="5">WITH( ICLEAN VALIDATION </td></tr><tr><td>COMPL.REMOVAL</td><td>94.39</td><td>70.93</td><td>71.86</td><td>36.61</td></tr><tr><td>SELF (OURS)</td><td>95.1</td><td>79.93</td><td>74.76</td><td>46.43</td></tr></table>
+
+Entropy minimization The typical entropy loss for semi-supervised learning is shown in Fig. 6. It encourages the model to provide extreme predictions (such as 0 or 1) for each sample. Over a large number of samples, the model should balance its predictions over all classes.
+
+The entropy loss can easily be applied to all samples to express the uncertainty about the provided labels. Alternatively, the loss can be combined with a strict filtering strategy, as in our work, which removes the labels of potentially wrongly labeled samples.
+
+For a large noise ratio, predictions of wrongly labeled samples fluctuate strongly over previous training iterations. Amplifying these network decisions could lead to even noisier models model. Combined with iterative filtering, the framework will have to rely on a single noisy model snapshot. In the case of an unsuitable snapshot, the filtering step will make many wrong decisions.
+
+# A.4 MORE EXPERIMENTS RESULTS
+
+# A.4.1 COMPLETE REMOVAL OF SAMPLES
+
+Tab. 8 shows the results of deleting samples from the training set. It leads to significant performances gaps compared to our strategy $( S E L F )$ , which considers the removed samples as unlabeled data. In case of a considerable label noise of $80 \%$ , the gap is close to $9 \%$ .
+
+Continuously using the filtered samples lead to significantly better results. The unsupervised-loss provides meaningful learning signals, which should be used for better model training.
+
+![](images/a8216754da77c295546c5ce60acf3b24db2f0b32c94325291b32baa29691c798.jpg)  
+Figure 7: Sample training curves of our approach SELF on CIFAR-100 with (a) $60 \%$ and (b) $80 \%$ noise, using noisy validation data. Note that with our approach, the training loss remains close to 0. Further, note that the mean-teacher continously outperforms the noisy student models. This shows the positive effect of temporal emsembling to counter label noise.
+
+# A.4.2 SAMPLE TRAINING PROCESS
+
+Fig. 7 shows the sample training processes of $S E L F$ under $60 \%$ and $80 \%$ noise on CIFAR-100. The mean-teacher always outperform the student models. Further, note that regular training leads to rapid over-fitting to label noise.
+
+Contrary, with our effective filtering strategy, both models slowly increase their performance while the training accuracy approaches $100 \%$ . Hence, by using progressive filtering, our model could erase the inconsistency in the provided labels set.

parse/train/HkgsPhNYPS/HkgsPhNYPS_content_list.json

@@ -0,0 +1,1903 @@
+[
+    {
+        "type": "text",
+        "text": "SELF: LEARNING TO FILTER NOISY LABELS WITH SELF-ENSEMBLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Duc Tam Nguyen ∗, Chaithanya Kumar Mummadi ∗†, Thi Phuong Nhung Ngo †, Thi Hoai Phuong Nguyen ‡, Laura Beggel †, Thomas Brox † ",
+        "bbox": [
+            181,
+            169,
+            728,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have been shown to over-fit a dataset when being trained with noisy labels for a long enough time. To overcome this problem, we present a simple and effective method self-ensemble label filtering (SELF) to progressively filter out the wrong labels during training. Our method improves the task performance by gradually allowing supervision only from the potentially non-noisy (clean) labels and stops learning on the filtered noisy labels. For the filtering, we form running averages of predictions over the entire training dataset using the network output at different training epochs. We show that these ensemble estimates yield more accurate identification of inconsistent predictions throughout training than the single estimates of the network at the most recent training epoch. While filtered samples are removed entirely from the supervised training loss, we dynamically leverage them via semi-supervised learning in the unsupervised loss. We demonstrate the positive effect of such an approach on various image classification tasks under both symmetric and asymmetric label noise and at different noise ratios. It substantially outperforms all previous works on noise-aware learning across different datasets and can be applied to a broad set of network architectures. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            525,
+            336,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The acquisition of large quantities of a high-quality human annotation is a frequent bottleneck in applying DNNs. There are two cheap but imperfect alternatives to collect annotation at large scale: crowdsourcing from non-experts and web annotations, particularly for image data where the tags and online query keywords are treated as valid labels. Both these alternatives typically introduce noisy (wrong) labels. While Rolnick et al. (2017) empirically demonstrated that DNNs can be surprisingly robust to label noise under certain conditions, Zhang et al. (2017) has shown that DNNs have the capacity to memorize the data and will do so eventually when being confronted with too many noisy labels. Consequently, training DNNs with traditional learning procedures on noisy data strongly deteriorates their ability to generalize – a severe problem. Hence, limiting the influence of label noise is of great practical importance. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            693
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A common approach to mitigate the negative influence of noisy labels is to eliminate them from the training data and train deep learning models just with the clean labels (Frenay & Verleysen, 2013). ´ Employing semi-supervised learning can even counteract the noisy labels (Laine & Aila, 2016; Luo et al., 2018). However, the decision which labels are noisy and which are not is decisive for learning robust models. Otherwise, unfiltered noisy labels still influence the (supervised) loss and affect the task performance as in these previous works. They use the entire label set to compute the loss and severely lack a mechanism to identify and filter out the erroneous labels from the labels set. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            796
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a self-ensemble label filtering (SELF) framework that identifies potentially noisy labels during training and keeps the network from receiving supervision from the filtered noisy labels. This allows DNNs to gradually focus on learning from undoubtedly correct samples even with an extreme level of noise in the labels (e.g., $80 \\%$ noise ratio) and leads to improved performance as the supervision become less noisy. The key contribution of our work is progressive filtering, i.e., leverage the knowledge provided in the network’s output over different training iterations to form a consensus of predictions (self-ensemble predictions) to progressively identify and filter out the noisy labels from the labeled data. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ac35fe607b3c36ca0223001826b8c7871c1b71d8f89c6ebaa811eba4547b70be.jpg",
+        "image_caption": [
+            "Figure 1: Comparing the performance of $S E L F$ with previous works for learning under different (symmetric) label noise ratios on the (a) CIFAR-10 & (b) CIFAR-100 datasets. SELF retains higher robust classification accuracy at all noise levels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            99,
+            812,
+            304
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            402,
+            820,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When learning under label noise, the network receives noisy updates and hence fluctuates strongly. Such conduct of training would impede to learn stable neural representations and further mislead the consensus of the predictions. Therefore, it is essential to incorporate a model with stable training behavior to obtain better estimates from the consensus. Concretely, we employ the semi-supervised technique as a backbone to our framework to stabilize the learning process of the model. Correctly, we maintain the running average model, such as proposed by Tarvainen & Valpola (2017), a.k.a. the Mean-Teacher model. This model ensemble learning provides a more stable supervisory signal than the noisy model snapshots and provides a stable ground for progressive filtering to filter out potential noisy labels. Note that this is different from just a mere combination of semi-supervised techniques with a noisy label filtering method. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We call our approach self-ensemble label filtering (SELF) - that establishes model ensemble learning as a backbone to form a solid consensus of the self-ensemble predictions to filter out the noisy labels progressively. Our framework allows to compute supervised loss on cleaner subsets rather than the entire noisy labeled data as in previous works. It further leverages the entire dataset, including the filtered out erroneous samples in the unsupervised loss. To best of our knowledge, we are the first to identify and propose self-ensemble as a principled technique against learning under noisy labels. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our motivation stems from the observation that DNNs start to learn from easy samples in initial phases and gradually adapt to hard ones during training. When trained on wrongly labeled data, DNNs learn from clean labels at ease and receive inconsistent error signals from the noisy labels before over-fitting to the dataset. The network’s prediction is likely to be consistent on clean samples and inconsistent or oscillates strongly on wrongly labeled samples over different training iterations. Based on this observation, we record the outputs of a single network made on different training epochs and treat them as an ensemble of predictions obtained from different individual networks. We call these ensembles that are evolved from a single network self-ensemble predictions. Subsequently, we identify the correctly labeled samples via the agreement between the provided label set and our running average of self-ensemble predictions. The samples of ensemble predictions that agree with the provided labels are likely to be consistent and treated as clean samples. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, our SELF framework stabilizes the training process and improves the generalization ability of DNNs. We evaluate the proposed technique on image classification tasks using CIFAR10, CIFAR100 & ImageNet. We demonstrate that SELF consistently outperforms the existing approaches on asymmetric and symmetric noise at all noise levels, as shown in Fig. 1. Besides, SELF remains robust towards the choice of the network architecture. Our work is transferable to other tasks without the need to modify the architecture or the primary learning objective. ",
+        "bbox": [
+            174,
+            848,
+            823,
+            933
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c82ec7a9b9bc7f2c8f64612f41085d91d63bfe3b6a05a44da5aa554cea5822f8.jpg",
+        "image_caption": [
+            "Figure 2: Overview of the self-ensemble label filtering (SELF) framework. The model starts in iteration 0 with training from the noisy label set. During training, the model maintains a selfensemble, a running average of itself (Tarvainen & Valpola, 2017) to provide a stable learning signal. Also, the model collects a self-ensemble prediction (moving-average) for the subsequent filtering. Once the best model is found, these predictions identify and filter out noisy labels using the original label set $L _ { 0 }$ . The model performs this progressive filtering until there is no more better model. For details see Algorithm 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            826,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 SELF-ENSEMBLE LABEL FILTERING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            482,
+            500,
+            497
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            511,
+            290,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fig. 2 shows an overview of our proposed approach. In the beginning, we assume that the labels of the training set are noisy. The model attempts to identify correct labels progressively using selfforming ensembles of models and predictions. Since wrong labels cause strong fluctuations in the model’s predictions, using ensembles is a natural way to counteract noisy labels. ",
+        "bbox": [
+            174,
+            534,
+            823,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concretely, in each iteration, the model learns from a detected set of potentially correct labels and maintains a running average of model snapshots (realized by the Mean Teacher model Tarvainen & Valpola (2017)). This ensemble model is evaluated on the entire dataset and provides an additional learning signal for training the single models. Additionally, our framework maintains the runningaverage of the model’s predictions for the filtering process. The model is trained until we find the best model w.r.t. the performance on the validation set (e.g., by early-stopping). The set of correct labels is detected based on the strategy defined in Sec. 2.2. In the next iteration, we again use all data and the new filtered label set as input for the model training. The iterative training procedure stops when no better model can be found. In the following, we give more details about the combination of this training and filtering procedure. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 PROGRESSIVE LABEL FILTERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            755,
+            439,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Progressive detection of correctly labeled samples Our framework Self-Ensemble Label Filtering (Algorithm 1) focuses on the detection of certainly correct labels from the provided label set $L _ { 0 }$ . In each iteration $i$ , the model is trained using the label set of potentially correct labels $L _ { i }$ . At the end of each iteration, the model determines the next correct label set $L _ { i + 1 }$ using the filtering strategy described in 2.2 The model stops learning when no improvement was achieved after training on the refined label set $L _ { i + 1 }$ . ",
+        "bbox": [
+            174,
+            777,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In other words, in each iteration, the model attempts to learn from the easy, in some sense, obviously correct labels. However, learning from easy samples also affects similar but harder samples from the same classes. Therefore, by learning from these easy samples, the network can gradually distinguish between hard and wrongly-labeled samples. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/087c2d7b8195d7f31991f4859d5441e3a21afb85587ebef782684cf21eeb1aa0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm1 SELF:Self-EnsembleLabel Filtering pseudocode</td></tr><tr><td>Require: Dtrain = noisy labeled training set Require: Dual = noisy labeled validation set</td><td></td></tr><tr><td>Require:(x,y) = training stimuli and label</td><td></td></tr><tr><td colspan=\"2\">Require: α = ensembling momentum,O ≤α≤1 counter to track iterations</td></tr><tr><td colspan=\"2\">i←0</td></tr><tr><td colspan=\"2\">Mi ← train(Dtrain,Dvat) √initial Mean-Teacher ensemble model training Mbest←Mi</td></tr><tr><td colspan=\"2\">&gt; set initial model as best model ←0 &gt;initialize ensemble predictions of all samples</td></tr><tr><td colspan=\"2\">(ignored sample index for simplicity) while acc(Mi,Dvat) ≥ acc(Mbest,Dval) do √iterate until no best model is found on Dual</td></tr><tr><td colspan=\"2\">Mbest←Mi save the best model Dfilter ←Dtrain &gt;set filtered dataset as initial label set</td></tr><tr><td colspan=\"2\">i←i+1 for (x,y) in Dfilter do</td></tr><tr><td colspan=\"2\">←Mbest(x) &gt; evaluate model output 泛i</td></tr><tr><td colspan=\"2\">←azi-1+(1-a)</td></tr><tr><td colspan=\"2\" rowspan=\"2\">if y ≠ argmax(zi) then y ←@inDfilter</td></tr><tr><td rowspan=\"4\">V accumulate ensemble predictions Zi &gt; verify agreement of ensemble predictions &amp; label</td></tr><tr><td>&gt;identify it as noisy label&amp; remove from label set</td></tr><tr><td></td></tr><tr><td colspan=\"2\">end for Mi ← train(Dfilter,Dval) &gt;train Mean-Teacher model on filtered label set end while</td></tr></table>",
+        "bbox": [
+            171,
+            103,
+            797,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our framework does not focus on repairing all noisy labels. Although the detection of wrong labels is sometimes easy, finding their correct hidden label might be extremely challenging in case of having many classes. If the noise is sufficiently random, the set of correct labels will be representative to achieve high model performance. Further, in our framework, the label filtering is performed on the original label set $L _ { 0 }$ from iteration 0. Clean labels erroneously removed in an earlier iteration (e.g., labels of hard to classify samples) can be reconsidered for model training again in later iterations. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Filtering strategy The model can determine the set of potentially correct labels $L _ { i }$ based on agreement between the label $y$ and its maximal likelihood prediction ${ \\hat { y } } | x$ with $L _ { i } ~ = ~ \\{ ( y , x ) ~ | ~ \\bar { \\hat { y } _ { x } } ~ =$ $y ; \\forall ( y , x ) \\in L _ { 0 } \\}$ . $L _ { 0 }$ is the label set provided in the beginning, $( y , x )$ are the samples and their respective noisy labels in the iteration $i$ . In other words, the labels are only used for supervised training if in the current epoch, the model predicts the respective label to be the correct class with the highest likelihood. In practice, our framework does not use ${ \\hat { y } } ( x )$ of model snapshots for filtering but a moving-average of the ensemble models and predictions to improve the filtering decision. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 SELF-ENSEMBLE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            643,
+            408,
+            657
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The model’s predictions for noisy samples tend to fluctuate. For example, take a cat wrongly labeled as a tiger. Other cat samples would encourage the model to predict the given cat image as a cat. Contrary, the wrong label tiger regularly pulls the model back to predict the cat as a tiger. Hence, using the model’s predictions gathered in one single training epoch for filtering is sub-optimal. Therefore, in our framework SELF, our model relies on ensembles of models and predictions. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Model ensemble with Mean Teacher A natural way to form a model ensemble is by using an exponential running average of model snapshots (Fig. 3a). This idea was proposed in Tarvainen & Valpola (2017) for semi-supervised learning and is known as the Mean Teacher model. In our framework, both the mean teacher model and the normal model are evaluated on all data to preserve the consistency between both models. The consistency loss between student and teacher output distribution can be realized with Mean-Square-Error loss or Kullback-Leibler-divergence. More details for training with the model ensemble can be found in Appendix A.1 ",
+        "bbox": [
+            174,
+            737,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Prediction ensemble Additionally, we propose to collect the sample predictions over multiple training epochs: $\\overline { { z } } _ { j } = \\alpha \\overline { { z } } _ { j - 1 } + ( 1 - \\alpha ) \\hat { z } _ { j }$ , whereby $\\overline { { z } } _ { j }$ depicts the moving-average prediction of sample $k$ at epoch $j$ , $\\alpha$ is a momentum, $\\hat { z } _ { j }$ is the model prediction for sample $k$ in epoch $j$ . This scheme is displayed in Fig. 3b. For each sample, we store the moving-average predictions, accumulated over the past iterations. Besides having a more stable basis for the filtering step, our proposed procedure also leads to negligible memory and computation overhead. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6dcee7204caa2b910d919137fe49f2fc7911913716572159b2a3330ffbd08ca0.jpg",
+        "image_caption": [
+            "Figure 3: Maintaining the (a) model and (b) predictions ensembles is very effective against noisy model updates. These ensembles are self-forming during the training process as a moving-average of (a) model snapshots or (b) class predictions from previous training steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            85,
+            789,
+            165
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Further, due to continuous training of the best model from the previous model, computation time can be significantly reduced, compared to re-training the model from scratch. On the new filtered dataset, the model must only slowly adapt to the new noise ratio contained in the training set. Depending on the computation budget, a maximal number of iterations for filtering can be set to save time. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            354,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Reed et al. (2014); Azadi et al. (2015) performed early works on learning robustly under label noise for deep neural networks. Recently, Rolnick et al. (2017) have shown for classification that deep neural networks come with natural robustness to label noise following a particular random distribution. No modification of the network or the training procedure is required to achieve this robustness. Following this insight, our framework SELF relies on this natural robustness to kickstart the self-ensemble filtering process to extend the robust behavior to more challenging scenarios. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Laine & Aila (2016); Luo et al. (2018) proposed to apply semi-supervised techniques on the data to counteract noise. These and other semi-supervised learning techniques learn from a static, initial set of noisy labels and have no mechanisms to repair labels. Therefore, the supervised losses in their learning objective are typically high until the model strongly overfits to the label noise. Compared to these works, our framework performs a variant of self-supervised label corrections. The network learns from a dynamic, variable set of labels, which is determined by the network itself. Progressive filtering allows the network to (1) focus on a label set with a significantly lower noise ratio and (2) repair wrong decisions made by itself in an earlier iteration. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Other works assign weights to potentially wrong labels to reduce the learning signal (Jiang et al., 2017; Ren et al., 2018; Jenni & Favaro, 2018). These approaches tend to assign less extreme weights or hyperparameters that are hard to set. Since the typical classification loss is highly non-linear, a lower weight might still lead to learning from wrong labels. Compared to these works, the samples in SELF only receive extreme weights: either they are zero or one. Further, SELF focuses only on self-detecting the correct samples, instead of repairing the wrong labels. Typically, the set of correct samples are much easier to detect and are sufficiently representative to achieve high performance. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Han et al. (2018b); Jiang et al. (2017) employ two collaborating and simultaneously learning networks to determine which samples to learn from and which not. However, the second network is free in its predictions and hence hard to tune. Compared to these works, we use ensemble learning as a principled approach to counteract model fluctuations. In SELF, the second network is extremely restricted and is only composed of running averages of the first network. To realize the second network, we use the mean-teacher model (Tarvainen & Valpola, 2017) as a backbone. Compared to their work, our self-ensemble label filtering gradually detects the correct labels and learns from them, so the label set is variable. Further, we do use not only model ensembles but also an ensemble of predictions to detect correct labels. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            813
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Other works modify the primary loss function of the classification tasks. Patrini et al. (2017) estimates the noise transition matrix to correct the loss, Han et al. (2018a) uses human-in-the-loop, Zhang & Sabuncu (2018); Thulasidasan et al. (2019) propose other forms of cross-entropy losses. The loss modification impedes the transfer of these ideas to other tasks than classification. Compared to these works, our framework SELF does not modify the primary loss. However, many tasks rely on the presence of clean labels such as anomaly detection (Nguyen et al., 2019a) or self-supervised and unsupervised learning (Nguyen et al., 2019b). The progressive filtering procedure and self-ensemble learning proposed are also applicable in these tasks to counteract noise effectively. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            931
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f290e77427f506b01e3c509fd29c79d11fb1a55274dcb714e375d7ff4f73f385.jpg",
+        "table_caption": [
+            "Table 1: Comparison of classification accuracy when learning under uniform label noise on CIFAR10 and CIFAR-100. Following previous works, we compare two evaluation scenarios: with a noisy validation set (top) and with 1000 clean validation samples (bottom). The best model is marked in bold. Having a small clean validation set improves the model but is not necessary. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">NOISE RATIO</td><td colspan=\"3\">CIFAR-10</td><td colspan=\"3\">CIFAR-100</td></tr><tr><td>40%</td><td>60%</td><td>80%</td><td>40%</td><td>60%</td><td>80%</td></tr><tr><td colspan=\"7\">USINGNOISYVALIDATIONSET</td></tr><tr><td>REED-HARD (REED ET AL.,2014)</td><td>69.66</td><td></td><td></td><td>51.34</td><td></td><td></td></tr><tr><td>S-MODEL(GOLDBERGER&amp; BEN-REUVEN,2016)</td><td>70.64</td><td></td><td></td><td>49.10</td><td></td><td></td></tr><tr><td>OPEN-SET WANG ET AL.(2018)</td><td>78.15</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RAND.WEIGHTS (REN ET AL.,2018)</td><td>86.06</td><td></td><td>=</td><td>58.01</td><td></td><td></td></tr><tr><td>BI-LEVEL-MODEL (JENNI &amp; FAVARO,2018)</td><td>89.00</td><td></td><td>20.00</td><td>61.00</td><td></td><td>13.00</td></tr><tr><td>MENTORNET (JIANG ET AL., 2017)</td><td>89.00</td><td></td><td>49.00</td><td>68.00</td><td></td><td>35.00</td></tr><tr><td>Lq (ZHANG &amp; SABUNCU,2018)</td><td>87.13</td><td>82.54</td><td>64.07</td><td>61.77</td><td>53.16</td><td>29.16</td></tr><tr><td>TRUNC Lq(ZHANG &amp; SABUNCU, 2018)</td><td>87.62</td><td>82.70</td><td>67.92</td><td>62.64</td><td>54.04</td><td>29.60</td></tr><tr><td>FORWARD T (PATRINI ET AL.,2017)</td><td>83.25</td><td>74.96</td><td>54.64</td><td>31.05</td><td>19.12</td><td>08.90</td></tr><tr><td>CO-TEACHING (HAN ET AL.,2018B)</td><td>81.85</td><td>74.04</td><td>29.22</td><td>55.95</td><td>47.98</td><td>23.22</td></tr><tr><td>D2L (MA ET AL., 2018)</td><td>83.36</td><td>72.84</td><td>-</td><td>52.01</td><td>42.27</td><td></td></tr><tr><td>SL (WANG ET AL., 2019)</td><td>85.34</td><td>80.07</td><td>53.81</td><td>53.69</td><td>41.47</td><td>15.00</td></tr><tr><td>JOINTOPT (TANAKA ET AL.,2018)</td><td>83.27</td><td>74.39</td><td>40.09</td><td>52.88</td><td>42.64</td><td>18.46</td></tr><tr><td>SELF (OURS)</td><td>93.70</td><td>93.15</td><td>69.91</td><td>71.98</td><td>66.21</td><td>42.09</td></tr><tr><td colspan=\"7\">USING CLEANVALIDATION SET (1000 IMAGES)</td></tr><tr><td>DAC (THULASIDASAN ET AL.,2019)</td><td>90.93</td><td>87.58</td><td>70.80</td><td>68.20</td><td>59.44</td><td>34.06</td></tr><tr><td>MENTORNET (JIANG ET AL.,2017)</td><td>78.00</td><td></td><td></td><td>59.00</td><td></td><td></td></tr><tr><td>RAND.WEIGHTS (REN ET AL., 2018)</td><td>86.55</td><td></td><td></td><td>58.34</td><td></td><td></td></tr><tr><td>REN ET AL(REN ET AL.,2018)</td><td>86.92</td><td></td><td></td><td>61.31</td><td></td><td></td></tr><tr><td>SELF*(OURS)</td><td>95.10</td><td>93.77</td><td>79.93</td><td>74.76</td><td>68.35</td><td>46.43</td></tr></table>",
+        "bbox": [
+            173,
+            162,
+            823,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            315,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTS DESCRIPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            421,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 STRUCTURE OF THE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            561,
+            441,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our approach on CIFAR-10, CIFAR-100, an ImageNet-ILSVRC on different noise scenarios. For CIFAR-10, CIFAR-100, and ImageNet, we consider the typical situation with symmetric and asymmetric label noise. In the case of the symmetric noise, a label is randomly flipped to another class with probability $p$ . Following previous works, we also consider label flips of semantically similar classes on CIFAR-10, and pair-wise label flips on CIFAR-100. Finally, we perform studies on the choice of the network architecture and the ablation of the components in our framework. Tab. 6 (Appendix) shows the in-deep analysis of semi-supervised learning strategies combined with recent works. Overall, the proposed framework SELF outperforms all these combinations. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 COMPARISONS TO PREVIOUS WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            709,
+            482,
+            723
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our work to previous methods from Reed-Hard (Reed et al., 2014), S-model (Goldberger & Ben-Reuven, 2016), Wang et al. (2018), Rand. weights (Ren et al., 2018), Bi-level-model (Jenni & Favaro, 2018), D2L (Ma et al., 2018), SL (Wang et al., 2019), $L _ { q }$ (Zhang & Sabuncu, 2018), Trunc $L _ { q }$ (Zhang & Sabuncu, 2018), Forward $\\hat { T }$ (Patrini et al., 2017), DAC (Thulasidasan et al., 2019), Random reweighting (Ren et al., 2018), and Learning to reweight (Ren et al., 2018). For co-teaching (Han et al., 2018b), MentorNet (Jiang et al., 2017), JointOpt (Tanaka et al., 2018), the source codes are available and hence used for evaluation. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(Ren et al., 2018) and DAC (Thulasidasan et al., 2019) considered the setting of having a small clean validation set of 1000 and 5000 images respectively. For comparison purposes, we also experiment with a small clean set of 1000 images additionally. Further, we abandon oracle experiments or methods using additional information to keep the evaluation comparable. For instance, Forward $T$ (Patrini et al., 2017) uses the true underlying confusion matrix to correct the loss. This information is neither known in typical scenarios nor used by other methods. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0080c852377dcb82ac16e10dcf9920e3b8e8c0a85647d1ea537b0bf8444bcd7.jpg",
+        "table_caption": [
+            "Table 2: Asymmetric noise on CIFAR-10, CIFAR-100. All methods use Resnet34. CIFAR-10: flip TRUCK AUTOMOBILE, BIRD AIRPLANE, DEER HORSE, $\\mathrm { C A T }  \\mathrm { D O G }$ with prob. $p$ . CIFAR-100: flip class $i$ to $( i + 1 ) \\% 1 0 0$ with prob. p. SELF retains high performances across all noise ratios and outperforms all previous works. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">CIFAR-10</td><td colspan=\"4\">CIFAR-100</td></tr><tr><td>NOISE RATIO</td><td>10%</td><td>20%</td><td>30%</td><td>40%</td><td>10%</td><td>20%</td><td>30%</td><td>40%</td></tr><tr><td>CCE</td><td>90.69</td><td>88.59</td><td>86.14</td><td>80.11</td><td>66.54</td><td>59.20</td><td>51.40</td><td>42.74</td></tr><tr><td>MAE</td><td>82.61</td><td>52.93</td><td>50.36</td><td>45.52</td><td>13.38</td><td>11.50</td><td>08.91</td><td>08.20</td></tr><tr><td>FORWARD T</td><td>90.52</td><td>89.09</td><td>86.79</td><td>83.55</td><td>45.96</td><td>42.46</td><td>38.13</td><td>34.44</td></tr><tr><td>Lq</td><td>90.91</td><td>89.33</td><td>85.45</td><td>76.74</td><td>68.36</td><td>66.59</td><td>61.45</td><td>47.22</td></tr><tr><td>TRUNC Lq</td><td>90.43</td><td>89.45</td><td>87.10</td><td>82.28</td><td>68.86</td><td>66.59</td><td>61.87</td><td>47.66</td></tr><tr><td>SL</td><td>88.24</td><td>85.36</td><td>80.64</td><td>=</td><td>65.58</td><td>65.14</td><td>63.10</td><td>=</td></tr><tr><td>JOINTOPT</td><td>90.12</td><td>89.45</td><td>87.18</td><td>87.97</td><td>69.61</td><td>68.94</td><td>63.99</td><td>53.71</td></tr><tr><td>SELF (OURS)</td><td>93.75</td><td>92.76</td><td>92.42</td><td>89.07</td><td>72.45</td><td>70.53</td><td>65.09</td><td>53.83</td></tr></table>",
+        "bbox": [
+            204,
+            161,
+            785,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Whenever possible, we adopt the reported performance from the corresponding publications. The testing scenarios are kept as similar as possible to enable a fair comparison. All tested scenarios use a noisy validation set with the same noise distribution as the training set unless stated otherwise. All model performances are reported on the clean test set. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            393
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b4c980cafcdf6c0401a0ed8f9b239ff3ea8059c266a9b10d67a2dda52483e1d6.jpg",
+        "table_caption": [
+            "Table 3: Effect of the choice of network architecture on classification accuracy on CIFAR-10 & -100 with uniform label noise. SELF is compatible with all tested architectures. Here \\* represents baseline accuracy of the architectures that are trained on fully supervised setting at $0 \\%$ label noise. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">CIFAR-10</td><td colspan=\"2\">CIFAR-100</td></tr><tr><td>RESNET34</td><td colspan=\"2\">93.5*</td><td colspan=\"2\">76.76*</td></tr><tr><td>NOISE</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>Lq</td><td>87.13</td><td>64.07</td><td>61.77</td><td>29.16</td></tr><tr><td>TRUNC Lq</td><td>87.62</td><td>67.92</td><td>62.64</td><td>29.60</td></tr><tr><td>FORWARD T</td><td>83.25</td><td>54.64</td><td>31.05</td><td>8.90</td></tr><tr><td>SELF</td><td>91.13</td><td>63.59</td><td>66.71</td><td>35.56</td></tr><tr><td></td><td>96.37*</td><td></td><td>81.20*</td><td></td></tr><tr><td>RESNET26</td><td></td><td></td><td></td><td></td></tr><tr><td>NOISE</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>Co-T.</td><td>81.85</td><td>29.22</td><td>55.95</td><td>23.22</td></tr><tr><td>SELF</td><td>93.70</td><td>69.91</td><td>71.98</td><td>42.09</td></tr></table>",
+        "bbox": [
+            490,
+            450,
+            802,
+            656
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/5b10fbc1daf1becd1ab649984cc4f1ec45c423b0f36fd7af610c7652fc28165f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">CIFAR-10</td><td colspan=\"2\">CIFAR-100</td></tr><tr><td>RESNET101</td><td colspan=\"2\">93.89*</td><td colspan=\"2\">81.14*</td></tr><tr><td>NOISE</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>MENTORNET</td><td>89.00</td><td>49.00</td><td>68.00</td><td>35.00</td></tr><tr><td>Co-T.</td><td>62.58</td><td>21.79</td><td>39.58</td><td>16.79</td></tr><tr><td>SELF</td><td>92.77</td><td>64.52</td><td>69.00</td><td>39.73</td></tr><tr><td></td><td>96.21*</td><td></td><td>81.02*</td><td></td></tr><tr><td>WRN 28-10</td><td></td><td>80%</td><td></td><td></td></tr><tr><td>NOISE</td><td>40%</td><td></td><td>40%</td><td>80%</td></tr><tr><td>MENTORNET REWEIGHT</td><td>88.7</td><td>46.30</td><td>67.50</td><td>30.10</td></tr><tr><td></td><td>86.02</td><td>1</td><td>58.01</td><td>1</td></tr><tr><td>SELF</td><td>93.34</td><td>67.41</td><td>72.48</td><td>42.06</td></tr></table>",
+        "bbox": [
+            173,
+            452,
+            483,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 NETWORKS CONFIGURATION AND TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            672,
+            539,
+            686
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the basic training of self-ensemble model, we use the Mean Teacher model (Tarvainen & Valpola, 2017) available on GitHub 1 . The students and teacher networks are residual networks (He et al., 2016) with 26 layers with Shake-Shake-regularization (Gastaldi, 2017). We use the PyTorch (Paszke et al., 2017) implementation of the network and keep the training settings close to (Tarvainen & Valpola, 2017). The network is trained with Stochastic Gradient Descent. In each filtering iteration, the model is trained for a maximum of 300 epochs, with patience of 50 epochs. For more training details, see the appendix. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTS RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            380,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 SYMMETRIC LABEL NOISE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            411,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 and 100 Results for typical uniform noise scenarios with noise ratios on CIFAR-10 and CIFAR-100 are shown in Tab. 1. More results are visualized in Fig. 1a (CIFAR-10) and Fig. 1b (CIFAR-100). Our approach $S E L F$ performs robustly in the case of lower noise ratios with up to $60 \\%$ and outperforms previous works. Although a strong performance loss occurs at $80 \\%$ label noise, ",
+        "bbox": [
+            174,
+            843,
+            825,
+            900
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bc52607d0f46373064dea3aec19637928631ff58380dfbd6334f76b5b57d5950.jpg",
+        "table_caption": [
+            "Table 4: Classification accuracy on clean ImageNet validation dataset. The models are trained at $40 \\%$ label noise and the best model is picked based on the evaluation on noisy validation data. Mentornet shows the best previously reported results. Mentornet\\* is based on Resnet-101. We chose the smaller Resnext50 model to reduce the run-time. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Accurracy</td><td>Resnext18 P@1 P@5</td><td>Resnext50 P@1 P@5</td></tr><tr><td>Mentornet*</td><td>=</td><td>65.10 85.90</td></tr><tr><td>ResNext</td><td>50.6 75.99</td><td>56.25 80.90</td></tr><tr><td>Mean-T.</td><td>58.04 81.82</td><td>62.96 85.72</td></tr><tr><td>SELF (Ours)</td><td>66.92 86.65</td><td>71.31 89.92</td></tr></table>",
+        "bbox": [
+            173,
+            241,
+            459,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Ablation study on CIFAR-10 and CIFAR100. The Resnet baseline was trained on the full noisy label set. Adding progressive filtering improves over this baseline. The Mean Teacher maintains an ensemble of model snapshots, which helps counteract noise. Having progressive filtering and model ensembles (-MVA-pred.) makes the model more robust but still fails at $80 \\%$ noise. The full SELF framework additionally uses the prediction ensemble for detection of correct labels. ",
+        "bbox": [
+            480,
+            101,
+            820,
+            239
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/099f7ba70f4031e584bad62e9511670cb7b8d6de712cf6fb9b9992844899d024.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">CIFAR-10</td><td colspan=\"2\">CIFAR-100</td></tr><tr><td>NOISE RATIO</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td>RESNET26</td><td>83.20</td><td>41.37</td><td>53.18</td><td>19.92</td></tr><tr><td>FILTERING</td><td>87.35</td><td>49.58</td><td>61.40</td><td>23.42</td></tr><tr><td>MEAN-T.</td><td>93.70</td><td>52.50</td><td>65.85</td><td>26.31</td></tr><tr><td>- MVA-PRED.</td><td>93.77</td><td>57.40</td><td>71.69</td><td>38,61</td></tr><tr><td>SELF (OURS)</td><td>93.70</td><td>69.91</td><td>71.98</td><td>42.09</td></tr></table>",
+        "bbox": [
+            485,
+            244,
+            807,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "SELF still outperforms most of the previous approaches. The experiment $S E L F ^ { * }$ using a 1000 clean validation images shows that the performance loss mostly originates from the progressive filtering relying too strongly on the extremely noisy validation set. ",
+        "bbox": [
+            174,
+            363,
+            823,
+            405
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ImageNet-ILSVRC Tab. 4 shows the precision $@ 1$ and $\\textcircled { a } 5$ of various models, given $40 \\%$ label noise in the training set. Our networks are based on ResNext18 and Resnext50. Note that MentorNet (Jiang et al., 2017) uses Resnet101 $( \\mathrm { P } @ 1 : 7 8 . 2 5 )$ (Goyal et al., 2017), which has higher performance compared to Resnext50 $( \\mathrm { P } @ 1 \\colon 7 7 . 8 )$ (Xie et al., 2017) on the standard ImageNet validation set. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Despite the weaker model, SELF (ResNext50) surpasses the best previously reported results by more than $5 \\%$ absolute improvement. Even the significantly weaker model ResNext18 outperforms MentorNet, which is based on a more powerful ResNet101 network. ",
+        "bbox": [
+            176,
+            477,
+            821,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 ASYMMETRIC LABEL NOISE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            423,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tab. 2 shows more challenging noise scenarios when the noise is not class-symmetric and uniform. Concretely, labels are flipped among semantically similar classes such as CAT and DOG on CIFAR10. On CIFAR-100, each label is flipped to the next class with a probability $p$ . In these scenarios, our framework SELF also retains high performance and only shows a small performance drop at $40 \\%$ noise. The high label noise resistance of our framework indicates that the proposed self-ensemble filtering process helps the network identify correct samples, even under extreme noise ratios. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2.3 EFFECTS OF DIFFERENT ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            514,
+            651
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Previous works utilize a various set of different architectures, which hinders a fair comparison. Tab. 3 shows the performance of our framework $S E L F$ compared to previous approaches. $S E L F$ outperforms other works in all scenarios except for CIFAR-10 with $80 \\%$ noise. Typical robust learning approaches lead to significant accuracy losses at $40 \\%$ noise, while SELF still retains high performance. Further, note that SELF allows the network’s performance to remain consistent across the different underlying architectures. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2.4 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            352,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tab. 5 shows the importance of each component in our framework. See Fig. 4a, Fig. 4b for experiments on more noise ratios. As expected, the Resnet-baseline rapidly breaks down with increasing noise ratios. Adding self-supervised filtering increases the performance slightly in lower noise ratios. However, the model has to rely on extremely noisy snapshots. Contrary, using a model ensemble alone such as in Mean-Teacher can counteract noise on the noisy dataset CIFAR-10. On the more challenging CIFAR-100, however, the performance decreases strongly. With self-supervised filtering and model ensembles, SELF (without MVA-pred) is more robust and only impairs performance at $80 \\%$ noise. The last performance boost is given by using moving-average predictions so that the network can reliably detect correctly labeled samples gradually. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 shows the ablation experiments on more noise ratios. The analyses shows that each component in SELF is essential for the model to learn robustly. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4bee4e5edf9dbc3105e46d17d67ce0bac334f01220c37af5b6a416ad7d31ced7.jpg",
+        "image_caption": [
+            "Figure 4: Ablation study on the importance of the components in our framework SELF, evaluated on (a) Cifar-10 and (b) Cifar-100 with uniform noise. Please refer Tab. 5 for details of components. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            99,
+            759,
+            271
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a21860815326bde5dd8134ef70ada85c6f20a4088041b0c202dc2982af9d510f.jpg",
+        "table_caption": [
+            "Table 6: Analysis of semi-supervised learning (SSL) strategies: entropy learning, mean-teacher combined with recent works. Our progressive filtering strategy is shown to be effective and performs well regardless of the choice of the semi-supervised learning backbone. Overall, the proposed method SELF outperforms all these combinations. Best model in each SSL-category is marked in bold. Running mean-teacher+ co-teaching using the same configuration is not possible due to memory constraints. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>NOISE RATIO</td><td>40%</td><td>CIFAR-10 60%</td><td>80%</td><td>40%</td><td>CIFAR-100 60%</td><td>80%</td></tr><tr><td colspan=\"7\">BASELINE MODELS</td></tr><tr><td>RESNET26 (GASTALDI, 2017)</td><td>83.20</td><td>72.35</td><td>41.37</td><td>53.18</td><td>44.31</td><td>19.92</td></tr><tr><td>CO-TEACHING (HAN ET AL.,2018B)</td><td>81.85</td><td>74.04</td><td>29.22</td><td>55.95</td><td>47.98</td><td>23.22</td></tr><tr><td>JOINTOPT(TANAKA ET AL.,2018)</td><td>83.27</td><td>74.39</td><td>40.09</td><td>52.88</td><td>42.64</td><td>18.46</td></tr><tr><td>PROGRESSIVE FILTERING (OURS)</td><td>87.35</td><td>75.47</td><td>49.58</td><td>61.40</td><td>50.60</td><td>23.42</td></tr><tr><td colspan=\"7\">SEMI-SUPERVISED LEARNING WITH ENTROPY LEARNING</td></tr><tr><td>ENTROPY</td><td>79.13</td><td>85.98</td><td>46.93</td><td>54.65</td><td>41.34</td><td>21.29</td></tr><tr><td>ENTROPY + CO-TEACHING</td><td>84.94</td><td>74.28</td><td>35.16</td><td>55.68</td><td>43.52</td><td>20.5</td></tr><tr><td>ENTROPY + JOINT-OPT</td><td>84.44</td><td>75.86</td><td>39.16</td><td>56.73</td><td>43.27</td><td>17.24</td></tr><tr><td>ENTROPY+FILTERING (OURS)</td><td>90.04</td><td>83.88</td><td>52.46</td><td>59.97</td><td>46.45</td><td>23.53</td></tr><tr><td colspan=\"7\">SEMI-SUPERVISED LEARNING WITH MEAN-TEACHER</td></tr><tr><td>MEAN TEACHER</td><td>93.70</td><td>90.40</td><td>52.5</td><td>65.85</td><td>54.48</td><td>26.31</td></tr><tr><td>MEAN-TEACHER + JOINTOPT</td><td>91.40</td><td>83.62</td><td>45.12</td><td>60.09</td><td>45.92</td><td>23.54</td></tr><tr><td>MEAN-TEACHER + FILTERING - SELF(OURS)</td><td>93.70</td><td>92.85</td><td>69.91</td><td>71.98</td><td>66.21</td><td>42.58</td></tr></table>",
+        "bbox": [
+            174,
+            443,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2.5 SEMI-SUPERVISED LEARNING FOR PROGRESSIVE FILTERING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            642,
+            761
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tab. 6 shows different semi-supervised learning strategies: entropy learning, mean-teacher combined with recent works. Note that Co-Teaching+Mean-Teacher cannot be implemented and run in the same configuration as other experiments, due to memory constraints. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            824
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The analysis indicates the semi-supervised losses mostly stabilize the baselines, compared to the model without semi-supervised learning. However, Co-teaching and JointOpt sometimes perform worse than the purely semi-supervised model. This result indicates that their proposed frameworks are not always compatible with semi-supervised losses. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The progressive filtering technique is seamlessly compatible with different semi-supervised losses. The filtering outperforms its counterparts when combined with Entropy Learning or Mean-teacher model. Overall, SELF outperforms all considered combinations. ",
+        "bbox": [
+            176,
+            893,
+            825,
+            935
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose a simple and easy to implement a framework to train robust deep learning models under incorrect or noisy labels. We filter out the training samples that are hard to learn (possibly noisy labeled samples) by leveraging ensemble of predictions of the single network’s output over different training epochs. Subsequently, we allow clean supervision from the non-hard samples and further leverage additional unsupervised loss from the entire dataset. We show that our framework results in DNN models with superior generalization performance on CIFAR-10, CIFAR-100 & ImageNet and outperforms all previous works under symmetric (uniform) and asymmetric noises. Furthermore, our models remain robust despite the increasing noise ratio and change in network architectures. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            260,
+            285,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samaneh Azadi, Jiashi Feng, Stefanie Jegelka, and Trevor Darrell. Auxiliary image regularization for deep cnns with noisy labels. arXiv preprint arXiv:1511.07069, 2015. ",
+        "bbox": [
+            174,
+            284,
+            823,
+            311
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benoˆıt Frenay and Michel Verleysen. Classification in the presence of label noise: a survey. ´ IEEE transactions on neural networks and learning systems, 25(5):845��869, 2013. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            351
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xavier Gastaldi. Shake-shake regularization. arXiv preprint arXiv:1705.07485, 2017. ",
+        "bbox": [
+            174,
+            359,
+            736,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. 2016. ",
+        "bbox": [
+            174,
+            386,
+            823,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative Adversarial Nets. pp. 9. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            506
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bo Han, Jiangchao Yao, Gang Niu, Mingyuan Zhou, Ivor Tsang, Ya Zhang, and Masashi Sugiyama. Masking: A new perspective of noisy supervision. In Advances in Neural Information Processing Systems, pp. 5836–5846, 2018a. ",
+        "bbox": [
+            176,
+            515,
+            825,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In NeurIPS, pp. 8535–8545, 2018b. ",
+        "bbox": [
+            176,
+            568,
+            823,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Simon Jenni and Paolo Favaro. Deep bilevel learning. In ECCV, 2018. ",
+        "bbox": [
+            173,
+            672,
+            637,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. MentorNet: Learning DataDriven Curriculum for Very Deep Neural Networks on Corrupted Labels. arXiv:1712.05055 [cs], December 2017. URL http://arxiv.org/abs/1712.05055. arXiv: 1712.05055. ",
+        "bbox": [
+            173,
+            698,
+            825,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016. ",
+        "bbox": [
+            169,
+            751,
+            825,
+            780
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016. ",
+        "bbox": [
+            169,
+            790,
+            825,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yucen Luo, Jun Zhu, Mengxi Li, Yong Ren, and Bo Zhang. Smooth neighbors on teacher graphs for semi-supervised learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8896–8905, 2018. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xingjun Ma, Yisen Wang, Michael E Houle, Shuo Zhou, Sarah M Erfani, Shu-Tao Xia, Sudanthi Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. arXiv preprint arXiv:1806.02612, 2018. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Duc Tam Nguyen, Zhongyu Lou, Michael Klar, and Thomas Brox. Anomaly detection with multiple-hypotheses predictions. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 4800–4809, Long Beach, California, USA, 09–15 Jun 2019a. PMLR. URL http://proceedings.mlr.press/v97/nguyen19b.html. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tam Nguyen, Maximilian Dax, Chaithanya Kumar Mummadi, Nhung Ngo, Thi Hoai Phuong Nguyen, Zhongyu Lou, and Thomas Brox. Deepusps: Deep robust unsupervised saliency prediction via self-supervision. In Advances in Neural Information Processing Systems, pp. 204–214, 2019b. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            290
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1944–1952, 2017. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. arXiv preprint arXiv:1412.6596, 2014. ",
+        "bbox": [
+            173,
+            351,
+            823,
+            393
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren, Wenyuan Zeng, Bin Yang, and Raquel Urtasun. Learning to Reweight Examples for Robust Deep Learning. arXiv:1803.09050 [cs, stat], March 2018. URL http://arxiv.org/ abs/1803.09050. arXiv: 1803.09050. ",
+        "bbox": [
+            173,
+            402,
+            825,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Rolnick, Andreas Veit, Serge Belongie, and Nir Shavit. Deep learning is robust to massive label noise. arXiv preprint arXiv:1705.10694, 2017. ",
+        "bbox": [
+            169,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, James Martens, George E Dahl, and Geoffrey E Hinton. On the importance of initialization and momentum in deep learning. ICML (3), 28(1139-1147):5, 2013. ",
+        "bbox": [
+            171,
+            491,
+            823,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daiki Tanaka, Daiki Ikami, Toshihiko Yamasaki, and Kiyoharu Aizawa. Joint optimization framework for learning with noisy labels. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5552–5560, 2018. ",
+        "bbox": [
+            174,
+            530,
+            823,
+            573
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Advances in neural information processing systems, pp. 1195–1204, 2017. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sunil Thulasidasan, Tanmoy Bhattacharya, Jeff Bilmes, Gopinath Chennupati, and Jamal MohdYusof. Combating label noise in deep learning using abstention. arXiv preprint arXiv:1905.10964, 2019. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            675
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yisen Wang, Weiyang Liu, Xingjun Ma, James Bailey, Hongyuan Zha, Le Song, and Shu-Tao Xia. Iterative learning with open-set noisy labels. arXiv preprint arXiv:1804.00092, 2018. ",
+        "bbox": [
+            173,
+            684,
+            821,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yisen Wang, Xingjun Ma, Zaiyi Chen, Yuan Luo, Jinfeng Yi, and James Bailey. Symmetric cross entropy for robust learning with noisy labels. In Proceedings of the IEEE International Conference on Computer Vision, pp. 322–330, 2019. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans- ´ formations for deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1492–1500, 2017. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            816
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations, 2017. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ Sy8gdB9xx. ",
+        "bbox": [
+            176,
+            825,
+            823,
+            868
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhilu Zhang and Mert Sabuncu. Generalized cross entropy loss for training deep neural networks with noisy labels. In Advances in Neural Information Processing Systems, pp. 8778–8788, 2018. ",
+        "bbox": [
+            173,
+            877,
+            823,
+            906
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 MEAN TEACHER MODEL FOR ITERATIVE FILTERING ",
+        "bbox": [
+            174,
+            136,
+            575,
+            150
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We apply the Mean Teacher algorithm in each iteration $i$ in the train $\\mathbf { \\nabla } _ { \\cdot } ( \\mathcal { D } _ { f i l t e r } , \\mathcal { D } _ { v a l } )$ procedure as follows. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            190
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Input: examples with potentially clean labels $D _ { f i l t e r }$ from the filtering procedure. In the beginning $\\mathit { i } = 0 $ ), here $D _ { f i l t e r }$ refers to entire labeled dataset.   \nInitialize a supervised neural network as the student model $M _ { i } ^ { s }$ .   \nInitialize the Mean Teacher model $M _ { i } ^ { t }$ as a copy of the student model with all weights detached.   \n• Let the loss function be the sum of normal classification loss of $M _ { i } ^ { s }$ and the consistency loss between the outputs of $M _ { i } ^ { t }$ and $M _ { i } ^ { t }$ ",
+        "bbox": [
+            215,
+            204,
+            825,
+            315
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Select an optimizer • In each training iteration: ",
+        "bbox": [
+            217,
+            318,
+            361,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            217,
+            335,
+            398,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "– Update the weights of $M _ { i } ^ { s }$ using the selected optimizer – Update the weights of $M _ { i } ^ { t }$ as an exponential moving-average of the student weights – Evaluate performance of $M _ { i } ^ { s }$ and $M _ { i } ^ { t }$ over $\\mathcal { D } _ { v a l }$ to verify the early stopping criteria. ",
+        "bbox": [
+            246,
+            358,
+            813,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• Return the best $M _ { i } ^ { t }$ ",
+        "bbox": [
+            217,
+            412,
+            361,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 ASSUMPTIONS DICUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            448,
+            410,
+            462
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our method performs best when the following assumptions are hold. ",
+        "bbox": [
+            174,
+            474,
+            622,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Natural robustness assumption of deep networks (Rolnick et al., 2017): The networks attempt to learn the easiest way to explain most of the data. SELF uses this assumption to kickstart the learning process. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            550
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Correct samples dominate over wrongly labeled samples At $80 \\%$ noise on CIFAR-10, the correctly labeled cats $20 \\%$ out of all cat images) still dominates over samples wrongly labeled as cat $8 . { \\overline { { 8 } } } { \\dot { \\% } }$ for each class). ",
+        "bbox": [
+            174,
+            569,
+            825,
+            611
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Independence results in less overfitting SELF performs best if the noises on the validation set and training set are i.i.d. . SELF uses the validation data for early stopping. Hence, a high correlation of label noise between train and valid increases the chance of model overfitting. ",
+        "bbox": [
+            176,
+            628,
+            823,
+            671
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sufficient label randomness assumption The subset of all correctly labeled samples capture all samples clusters. In fact, many works from the active learning literature show that less than 100 $\\%$ of the labeled samples are required to achieve the highest model performance. SELF performs progressive expansion of the correct labels sets. At larger noise ratios, not all clusters are covered by the identified samples. Therefore on task containing many classes, e.g., CIFAR-100, the model performance decreases faster than on CIFAR-10. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            772
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The model performance reduces when these assumptions are strongly violated. Each assumption should have its own ”critical” threshold for violation. A future in-depth analysis to challenge the assumptions is an interesting future research direction. ",
+        "bbox": [
+            176,
+            780,
+            823,
+            823
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            352,
+            857
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3.1 CIFAR-10 AND CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            431,
+            883
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dataset Tab. 7 shows the details of CIFAR-10 and 100 datasets in our evaluation pipeline. The validation set is contaminated with the same noise ratio as the training data unless stated otherwise. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Network training For the training our model SELF, we use the standard configuration provided by Tarvainen & Valpola (2017) 2. Concretely, we use the SGD-optimizer with Nesterov Sutskever et al. (2013) momentum, a learning rate of 0.05 with cosine learning rate annealing Loshchilov & Hutter (2016), a weight decay of 2e-4, max iteration per filtering step of 300, patience of 50 epochs, total epochs count of 600. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc3d9a10c6f2be6aac43612bd4cf7086c2236a8d0f4833ac19771a117a3a74f2.jpg",
+        "table_caption": [
+            "Table 7: Dataset description. Classification tasks on CIFAR-10 and CIFAR-100 with uniform noise. Note that the noise on the training and validation set is not correlated. Hence, maximizing the accuracy on the noisy set provides a useful (but noisy) estimate for the generalization ability on unseen test data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>TYPE</td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>TASK RESOLUTION</td><td>CLASSIFICATION</td><td>10-WAY 32x32</td><td>100-WAY</td></tr><tr><td rowspan=\"3\">DATA</td><td>TRAIN (NOISY)</td><td>45000</td><td>45000</td></tr><tr><td>VALID (NOISY)</td><td>5000</td><td>5000</td></tr><tr><td>TEST (CLEAN)</td><td>10000</td><td>10000</td></tr></table>",
+        "bbox": [
+            290,
+            262,
+            702,
+            366
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For basic training of baselines models without semi-supervised learning, we had to set the learning rate to 0.01. In the case of higher learning rates, the loss typically explodes. Every other option is kept the same. ",
+        "bbox": [
+            176,
+            388,
+            823,
+            430
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning For the mean teacher training, additional hyperparameters are required. In both cases of CIFAR-10 and CIFAR-100, we again take the standard configuration with the consistency loss to mean-squared-error and a consistency weight: 100.0, logit distance cost: 0.01, consistency-ramp-up:5. The total batch-size is 512, with 124 samples being reserved for labeled samples, 388 for unlabeled data. Each epoch is defined as a complete processing of all unlabeled data. When training without semi-supervised-learning, the entire batch is used for labeled data. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            531
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation The data are normalized to zero-mean and standard-variance of one. Further, we use real-time data augmentation with random translation and reflection, subsequently random horizontal flip. The standard PyTorch-library provides these transformations. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3.2 IMAGENET-ILSVRC-2015 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            607,
+            419,
+            621
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Network Training The network used for evaluation were ResNet He et al. (2016) and Resnext Xie et al. (2017) for training. All ResNext variants use a cardinality of 32 and base width of 4 (32x4d). ResNext models follow the same structure as their Resnet counterparts, except for the cardinality and base width. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            688
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "All other configurations are kept as close as possible to Tarvainen & Valpola (2017). The initial learning rate to handle large batches Goyal et al. (2017) is set to 0.1; the base learning rate is 0.025 with a single cycle of cosine annealing. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            737
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning Due to the large images, the batch size is set to 40 in total with 20/20 for labeled and unlabeled samples, respectively. We found the Kullback-divergence leads to no meaningful network training. Hence, we set the consistency loss to mean-squared-error, with a weight of 1000. We use consistency ramp up of 5 epochs to give the mean teacher more time in the beginning. Weight decay is set to 5e-5; patience is four epochs to stop training in the current filtering iteration. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            838
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Filtering We filter noisy samples with the topk ${ \\boldsymbol { \\Xi } } 5$ strategy, instead of taking the maximumlikelihood (ML) prediction as on CIFAR-10 and CIFAR-100. That means the samples are kept for supervised training if their provided label lies within the top 5 predictions of the model. The main reason is that each image of ImageNet might contain multiple objects. Filtering with ML-predictions is too strict and would lead to a small recall of the detection of the correct sample. ",
+        "bbox": [
+            176,
+            854,
+            821,
+            897
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/97cde72c1299198764476f784e7177f2db74d706d0a6c981d837434e544f1bae.jpg",
+        "image_caption": [
+            "Figure 5: Simple training losses to counter label noise. (a) shows the prediction of a sample given a model. The red bar indicates the noisy label, blue the correct one. Arrows depict the magnitude of the gradients (b) Typical losses reweighting schemes are not wrong but suffer from the gradient vanishing problem. Non-linear losses such as Negative-log-likelihood are not designed for gradient ascent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            103,
+            684,
+            231
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            340,
+            823,
+            369
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Data Augmentation For all data, we normalize the RGB-images by the mean: (0.485, 0.456, 0.406) and the standard variance (0.229, 0.224, 0.225). For training data, we perform a random rotation of up to 10 degrees, randomly resize images to $2 2 4 \\mathbf { x } 2 2 4$ , apply random horizontal flip and random color jittering. This noise is needed in regular mean-teacher training. The jittering setting are: brightness $_ { = 0 . 4 }$ , contras $= 0 . 4$ , saturation $= 0 . 4$ , hue $\\scriptstyle = 0 . 1$ . The validation data are resized to $2 5 6 \\mathrm { x } 2 5 6$ and randomly cropped to $2 2 4 \\mathbf { x } 2 2 4$ ",
+        "bbox": [
+            173,
+            383,
+            825,
+            468
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3.3 SEMI-SUPERVISED LOSSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            416,
+            498
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the learning of wrongly labeled samples, Fig. 6 shows the relationship between the typical reweighting scheme and our baseline push-away-loss. Typically, reweighting is applied directly to the losses with samples weights $w ^ { ( k ) }$ for each sample $k$ as shown in Eq. 4 ",
+        "bbox": [
+            174,
+            507,
+            825,
+            553
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43280897e071c14540883e980bab65d14b72e7d12174ca367d4c936a2a695f1d.jpg",
+        "text": "$$\n\\operatorname* { m i n } { w _ { i } ^ { ( k ) } N L L ( y _ { l a b e l } ^ { ( k ) } | x ^ { ( k ) } , D ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            568,
+            602,
+            589
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "$D$ is the dataset, $x ^ { ( k ) }$ and $y _ { l a b e l } ^ { ( k ) }$ are the samples $k$ and its noisy label. $w _ { i } ^ { ( k ) }$ is the samples weight for the sample $k$ at step $i$ . Negative samples weights $w _ { i } ^ { ( k ) }$ are often assigned to push the network away from the wrong labels. Let $w _ { i } ^ { ( k ) } = - c _ { i } ^ { ( k ) }$ with $c _ { i } ^ { ( k ) } > 0$ , then we have: ",
+        "bbox": [
+            174,
+            593,
+            825,
+            648
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8eb6ad9b8399835d1522b0ea6e2517867a28dee86d2035e0f2e46c461c30003a.jpg",
+        "text": "$$\n\\operatorname* { m i n } { - c _ { i } ^ { ( k ) } N L L ( y _ { l a b e l } ^ { ( k ) } | x ^ { ( k ) } , D ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            655,
+            606,
+            676
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Which results in: ",
+        "bbox": [
+            174,
+            690,
+            287,
+            704
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8dfcf2693c45d6509802dd24dcc3f2f41147d501e8388fb106ad773792fd18e.jpg",
+        "text": "$$\n\\operatorname* { m a x } { c _ { i } ^ { ( k ) } N L L ( y _ { l a b e l } ^ { ( k ) } | x ^ { ( k ) } , D ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            700,
+            601,
+            720
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In other words, we perform gradient ascent for wrongly labeled samples. However, the Negativelog-likelihood is not designed for gradient ascent. Hence the gradients of wrongly labeled samples vanish if the prediction is too close to the noisy label. This effect is similar to the training of Generative Adversarial Network (GAN) Goodfellow et al.. In the GAN-framework, the generator loss is not simply set to the negated version of the discriminator’s loss for the same reason. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            794
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Therefore, to provide a fair comparison with our framework, we suggest the push-away-loss $L _ { P u s h - a w a y } ( y _ { l a b e l } ^ { ( k ) } , x ^ { ( k ) } , D )$ with improved gradients as follows: ",
+        "bbox": [
+            174,
+            799,
+            823,
+            833
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ccf6e872a5f81b714e05ed414d7f59bb0385879b7b73465e71fa71543620214.jpg",
+        "text": "$$\n\\operatorname* { m i n } \\frac { 1 } { | Y | - 1 } \\sum _ { y , y \\ne y _ { l a b e l } ^ { ( k ) } } c _ { i } ^ { ( k ) } N L L ( y | x ^ { ( k ) } , D )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            848,
+            642,
+            892
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Whereby $Y$ is the set of all classes in the training set. This loss has improved gradients to push the model away from the potentially wrong labels. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/219d42d1c63412854e7c7c4ab8eaee8f16ee72d3ec8db970bd1f0d680485c34e.jpg",
+        "image_caption": [
+            "Figure 6: The entropy loss for semi-supervised learning. (a) Extreme predictions such as $[ 0 , 1 ]$ are encouraged by minimizing the entropy on each prediction. (b) Additionally, maximizing the entropy of the mean prediction on the entire dataset or a large batch forces the model to balance its predictions over multiple samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            359,
+            95,
+            625,
+            237
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 8: Accuracy of the complete removal of samples during iterative filtering on CIFAR-10 and CIFAR-100. The underlying model is the MeanTeacher based on Resnet26. When samples are completely removed from the training set, they are no longer used for either supervised-or-unsupervised learning. This common strategy from previous works leads to rapid performance breakdown. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            390
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0d14010f17e08db9a64be0e93ebaf45e8d2d6de736881574dc20976077e7809.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">CIFAR-10</td><td colspan=\"2\">CIFAR-100</td></tr><tr><td>NOISE RATIO</td><td>40%</td><td>80%</td><td>40%</td><td>80%</td></tr><tr><td colspan=\"5\">USING NOISY I DATA ONLY</td></tr><tr><td>DATA REMOVAL</td><td>93.4</td><td>59.98</td><td>68.99</td><td>35.53</td></tr><tr><td>SELF (OURS)</td><td>93.7</td><td>69.91</td><td>71.98</td><td>42.09</td></tr><tr><td colspan=\"5\">WITH( ICLEAN VALIDATION </td></tr><tr><td>COMPL.REMOVAL</td><td>94.39</td><td>70.93</td><td>71.86</td><td>36.61</td></tr><tr><td>SELF (OURS)</td><td>95.1</td><td>79.93</td><td>74.76</td><td>46.43</td></tr></table>",
+        "bbox": [
+            312,
+            415,
+            678,
+            560
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Entropy minimization The typical entropy loss for semi-supervised learning is shown in Fig. 6. It encourages the model to provide extreme predictions (such as 0 or 1) for each sample. Over a large number of samples, the model should balance its predictions over all classes. ",
+        "bbox": [
+            176,
+            598,
+            823,
+            640
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The entropy loss can easily be applied to all samples to express the uncertainty about the provided labels. Alternatively, the loss can be combined with a strict filtering strategy, as in our work, which removes the labels of potentially wrongly labeled samples. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            690
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For a large noise ratio, predictions of wrongly labeled samples fluctuate strongly over previous training iterations. Amplifying these network decisions could lead to even noisier models model. Combined with iterative filtering, the framework will have to rely on a single noisy model snapshot. In the case of an unsuitable snapshot, the filtering step will make many wrong decisions. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            753
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 MORE EXPERIMENTS RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            784,
+            431,
+            799
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4.1 COMPLETE REMOVAL OF SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            816,
+            470,
+            830
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Tab. 8 shows the results of deleting samples from the training set. It leads to significant performances gaps compared to our strategy $( S E L F )$ , which considers the removed samples as unlabeled data. In case of a considerable label noise of $80 \\%$ , the gap is close to $9 \\%$ . ",
+        "bbox": [
+            176,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Continuously using the filtered samples lead to significantly better results. The unsupervised-loss provides meaningful learning signals, which should be used for better model training. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8216754da77c295546c5ce60acf3b24db2f0b32c94325291b32baa29691c798.jpg",
+        "image_caption": [
+            "Figure 7: Sample training curves of our approach SELF on CIFAR-100 with (a) $60 \\%$ and (b) $80 \\%$ noise, using noisy validation data. Note that with our approach, the training loss remains close to 0. Further, note that the mean-teacher continously outperforms the noisy student models. This shows the positive effect of temporal emsembling to counter label noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            101,
+            794,
+            285
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.4.2 SAMPLE TRAINING PROCESS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            381,
+            429,
+            395
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Fig. 7 shows the sample training processes of $S E L F$ under $60 \\%$ and $80 \\%$ noise on CIFAR-100. The mean-teacher always outperform the student models. Further, note that regular training leads to rapid over-fitting to label noise. ",
+        "bbox": [
+            174,
+            405,
+            821,
+            446
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Contrary, with our effective filtering strategy, both models slowly increase their performance while the training accuracy approaches $100 \\%$ . Hence, by using progressive filtering, our model could erase the inconsistency in the provided labels set. ",
+        "bbox": [
+            176,
+            454,
+            823,
+            496
+        ],
+        "page_idx": 15
+    }
+]

parse/train/S1DWPP1A-/S1DWPP1A-.md

@@ -0,0 +1,538 @@
+# UNSUPERVISED LEARNING OF GOAL SPACES FORINTRINSICALLY MOTIVATED GOAL EXPLORATION
+
+# Alexandre Péré
+
+Flowers Team Inria and Ensta-ParisTech, France alexandre.pere@inria.fr
+
+Sebastien Forestier   
+Flowers Team   
+Inria and Ensta-ParisTech, France   
+sebastien.forestier@inria.fr
+
+# Olivier Sigaud
+
+# Pierre-Yves Oudeyer
+
+Flowers Team Inria, Ensta-ParisTech and UPMC, France Olivier.Sigaud@upmc.fr
+
+Flowers Team Inria and Ensta-ParisTech, France pierre-yves.oudeyer@inria.fr
+
+# ABSTRACT
+
+Intrinsically motivated goal exploration algorithms enable machines to discover repertoires of policies that produce a diversity of effects in complex environments. These exploration algorithms have been shown to allow real world robots to acquire skills such as tool use in high-dimensional continuous state and action spaces. However, they have so far assumed that self-generated goals are sampled in a specifically engineered feature space, limiting their autonomy. In this work, we propose to use deep representation learning algorithms to learn an adequate goal space. This is a developmental 2-stage approach: first, in a perceptual learning stage, deep learning algorithms use passive raw sensor observations of world changes to learn a corresponding latent space; then goal exploration happens in a second stage by sampling goals in this latent space. We present experiments where a simulated robot arm interacts with an object, and we show that exploration algorithms using such learned representations can match the performance obtained using engineered representations.
+
+Keywords: exploration; autonomous goal setting; diversity; unsupervised learning; deep neural network
+
+# 1 INTRODUCTION
+
+Spontaneous exploration plays a key role in the development of knowledge and skills in human children. For example, young children spend a large amount of time exploring what they can do with their body and external objects, independently of external objectives such as finding food or following instructions from adults. Such intrinsically motivated exploration (Berlyne, 1966; Gopnik et al., 1999; Oudeyer & Smith, 2016) leads them to make ratcheting discoveries, such as learning to locomote or climb in various styles and on various surfaces, or learning to stack and use objects as tools. Equipping machines with similar intrinsically motivated exploration capabilities should also be an essential dimension for lifelong open-ended learning and artificial intelligence.
+
+In the last two decades, several families of computational models have both contributed to a better understanding of such exploration processes in infants, and how to apply them efficiently for autonomous lifelong machine learning (Oudeyer et al., 2016). One general approach taken by several research groups (Baldassarre et al., 2013; Oudeyer et al., 2007; Barto, 2013; Friston et al., 2017) has been to model the child as intrinsically motivated to make sense of the world, exploring like a scientist that imagines, selects and runs experiments to gain knowledge and control over the world. These models have focused in particular on three kinds of mechanisms argued to be essential and complementary to enable machines and animals to efficiently explore and discover skill repertoires in the real world (Oudeyer et al., 2013; Cangelosi et al., 2015): embodiment 1, intrinsic motivation2 and social guidance3. This article focuses on challenges related to learning goal representations for intrinsically motivated exploration, but also leverages models of embodiment, through the use of parameterized Dynamic Movement Primitives controllers (Ijspeert et al., 2013) and social guidance, through the use of observations of another agent.
+
+Given an embodiment, intrinsically motivated exploration4 consists in automatically and spontaneously conducting experiments with the body to discover both the world dynamics and how it can be controlled through actions. Computational models have framed intrinsic motivation as a family of mechanisms that self-organize agents exploration curriculum, in particular through generating and selecting experiments that maximize measures such as novelty (Andreae & Andreae, 1978; Sutton, 1990), predictive information gain (Little & Sommer, 2013), learning progress (Schmidhuber, 1991; Kaplan & Oudeyer, 2003), compression progress (Schmidhuber, 2013), competence progress (Baranes & Oudeyer, 2013), predictive information (Martius et al., 2013) or empowerment (Salge et al., 2014). When used in the Reinforcement Learning (RL) framework (e.g. (Sutton, 1990; Schmidhuber, 1991; Kaplan & Oudeyer, 2003; Barto, 2013)), these measures have been called intrinsic rewards, and they are often applied to reward the "interestingness" of actions or states that are explored. They have been consistently shown to enable artificial agents or robots to make discoveries and solve problems that would have been difficult to learn using a classical optimization or RL approach based only on the target reward (which is often rare or deceptive) (Chentanez et al., 2005; Baranes & Oudeyer, 2013; Stanley & Lehman, 2015). Recently, they have been similarly used to guide exploration in difficult deep RL problems with sparse rewards, e.g. (Bellemare et al., 2016; Houthooft et al., 2016; Tang et al., 2017; Pathak et al., 2017).
+
+However, many of these computational approaches have considered intrinsically motivated exploration at the level of micro-actions and states (e.g. considering low-level actions and pixel level perception). Yet, children’s intrinsically motivated exploration leverages abstractions of the environments, such as objects and qualitative properties of the way they may move or sound, and explore by setting self-generated goals (Von Hofsten, 2004), ranging from objects to be reached, toy towers to be built, or paper planes to be flown. A computational framework proposed to address this higher-level form of exploration has been Intrinsically Motivated Goal Exploration Processes (IMGEPs) (Baranes & Oudeyer, 2009; Forestier et al., 2017), which is closely related to the idea of goal babbling (Rolf et al., 2010). Within this approach, agents are equipped with a mechanism enabling them to sample a goal in a space of parameterized goals5, before they try to reach it by executing an experiment. Each time they sample a goal, they dedicate a certain budget of experiments time to improve the solution to reach this goal, using lower-level optimization or RL methods for example. Most importantly, in the same time, they take advantage of information gathered during this exploration to discover other outcomes and improve solutions to other goals6.
+
+This property of cross-goal learning often enables efficient exploration even if goals are sampled randomly (Baranes & Oudeyer, 2013) in goal spaces containing many unachievable goals. Indeed, generating random goals (including unachievable ones) will very often produce goals that are outside the convex hull of already discovered outcomes, which in turn leads to exploration of variants of known corresponding policies, pushing the convex hull further. Thus, this fosters exploration of policies that have a high probability to produce novel outcomes without the need to explicitly measure novelty. This explains why forms of random goal exploration are a form of intrinsically motivated exploration. However, more powerful goal sampling strategies exist. A particular one consists in using meta-learning algorithms to monitor the evolution of competences over the space of goals and to select the next goal to try, according to the expected competence progress resulting from practicing it (Baranes & Oudeyer, 2013). This enables to automate curriculum sequences of goals of progressively increasing complexity, which has been shown to allow high-dimensional real world robots to acquire efficiently repertoires of locomotion skills or soft object manipulation (Baranes & Oudeyer, 2013), or advanced forms of nested tool use (Forestier et al., 2017). Similar ideas have been recently applied in the context of multi-goal deep RL, where architectures closely related to intrinsically motivated goal exploration are used by procedurally generating goals and sampling them randomly (Cabi et al., 2017; Najnin & Banerjee, 2017) or adaptively (Florensa et al., 2017).
+
+Yet, a current limit of existing algorithms within the family of Intrinsically Motivated Goal Exploration Processes is that they have assumed that the designer7 provides a representation allowing the autonomous agent to generate goals, together with formal tools used to measure the achievement of these goals (e.g. cost functions). For example, the designer could provide a representation that enables the agent to imagine goals as potential continuous target trajectories of objects (Forestier et al., 2017), or reach an end-state starting from various initial states defined in Euclidean space (Florensa et al., 2017), or realize one of several discrete relative configurations of objects (Cabi et al., 2017), which are high-level abstractions from the pixels. While this has allowed to show the power of intrinsically motivated goal exploration architectures, designing IMGEPs that sample goals from a learned goal representation remains an open question. There are several difficulties. One concerns the question of how an agent can learn in an unsupervised manner a representation for hypothetical goals that are relevant to their world before knowing whether and how it is possible to achieve them with the agent’s own action system. Another challenge is how to sample "interesting" goals using a learned goal representation, in order to remain in regions of the learned goal parameters that are not too exotic from the underlying physical possibilities of the world. Finally, a third challenge consists in understanding which properties of unsupervised representation learning methods enable an efficient use within an IMGEP architecture so as to lead to efficient discovery of controllable effects in the environment.
+
+In this paper, we present one possible approach named IMGEP-UGL where aspects of these difficulties are addressed within a 2-stage developmental approach, combining deep representation learning and goal exploration processes:
+
+Unsupervised Goal space Learning stage (UGL): In the first phase, we assume the learner can passively observe a distribution of world changes (e.g. different ways in which objects can move), perceived through raw sensors (e.g. camera pixels or other forms of low-level sensors in other modalities). Then, an unsupervised representation learning algorithm is used to learn a lower-dimensional latent space representation (also called embedding) of these world configurations. After training, a Kernel Density Estimator (KDE) is used to estimate the distribution of these observations in the latent space.
+
+Intrinsically Motivated Goal Exploration Process stage (IMGEP): In the second phase, the embedding representation and the corresponding density estimation learned during the first stage are reused in a standard IMGEP. Here, goals are iteratively sampled in the embedding as target outcomes. Each time a goal is sampled, the current knowledge (forward model and meta-policy, see below) enables to guess the parameters of a corresponding policy, used to initialize a time-bounded optimization process to improve the cost of this policy for this goal. Crucially, each time a policy is executed, the observed outcome is not only used to improve knowledge for the currently selected goal, but for all goals in the embedding. This process enables the learner to incrementally discover new policy parameters and their associated outcomes, and aims at learning a repertoire of policies that produce a maximally diverse set of outcomes.
+
+A potential limit of this approach, as it is implemented and studied in this article, is that representations learned in the first stage are frozen and do not evolve in the second stage. However, we consider here this decomposition for two reasons. First, it corresponds to a well-known developmental progression in infant development: in their first few weeks, motor exploration in infants is very limited (due to multiple factors), while they spend a considerable amount of time observing what is happening in the outside world with their eyes (e.g. observing images of social peers producing varieties of effects on objects). During this phase, a lot of perceptual learning happens, and this is reused later on for motor learning (infant perceptual development often happens ahead of motor development in several important ways). Here, passive perceptual learning from a database of visual effects observed in the world in the first phase can be seen as a model of this stage where infants learn by passively observing what is happening around them8. A second reason for this decomposition is methodological: given the complexity of the underlying algorithmic components, analyzing the dynamics of the architecture is facilitated when one decomposes learning in these two phases (representation learning, then exploration).
+
+Main contribution of this article. Prior to this work, and to our knowledge, all existing goal exploration process architectures used a goal space representation that was hand designed by the engineer, limiting the autonomy of the system. Here, the main contribution is to show that representation learning algorithms can discover goal spaces that lead to exploration dynamics close to the one obtained using an engineered goal representation space. The proposed algorithmic architecture is tested in two environments where a simulated robot learns to discover how to move and rotate an object with its arm to various places (the object scene being perceived as a raw pixel map). The objective measure we consider, called KL-coverage, characterizes the diversity of discovered outcomes during exploration by comparing their distribution with the uniform distribution over the space of outcomes that are physically possible (which is unknown to the learner). We even show that the use of particular representation learning algorithms such as VAEs in the IMGEP-UGL architecture can produce exploration dynamics that match the one using engineered representations.
+
+# Secondary contributions of this article:
+
+• We show that the IMGEP-UGL architecture can be successfully implemented (in terms of exploration efficiency) using various unsupervised learning algorithms for the goal space learning component: AutoEncoders (AEs) (Bourlard & Kamp, 1988), Variational AE (VAE) (Rezende et al., 2014; Kingma & Ba, 2015), VAE with Normalizing Flow (Rezende & Mohamed, 2015), Isomap (Tenenbaum et al., 2000), PCA (Pearson, 1901), and we quantitatively compare their performances in terms of exploration dynamics of the associated IMGEP-UGL architecture.   
+We show that specifying more embedding dimensions than needed to capture the phenomenon manifold does not deteriorate the performance of these unsupervised learning algorithms.   
+We show examples of unsupervised learning algorithms (Radial Flow VAEs) which produce less efficient exploration dynamics than other algorithms in our experiments, and suggest hypotheses to explain this difference.
+
+# 2 GOALS REPRESENTATION LEARNING FOR EXPLORATION ALGORITHMS
+
+In this section, we first present an outline of intrinsically motivated goal exploration algorithmic architectures (IMGEPs) as originally developed and used in the field of developmental robotics, and where goal spaces are typically hand crafted. Then, we present a new version of this architecture (IMGEP-UGL) that includes a first phase of passive perceptual learning where goal spaces are learned using a combination of representation learning and density estimation. Finally, we outline a list of representation learning algorithms that can be used in this first phase, as done in the experimental section.
+
+# 2.1 INTRINSICALLY MOTIVATED GOAL EXPLORATION ALGORITHMS
+
+Intrinsically Motivated Goal Exploration Processes (IMGEPs), are powerful algorithmic architectures which were initially introduced in Baranes & Oudeyer (2009) and formalized in Forestier et al. (2017). They can be used as heuristics to drive the exploration of high-dimensional continuous action spaces so as to learn forward and inverse control models in difficult robotic problems. To clearly understand the essence of IMGEPs, we must envision the robotic agent as an experimenter seeking information about an unknown physical phenomenon through sequential experiments. In this perspective, the main elements of an exploration process are:
+
+• A context c, element of a Context Space $\mathcal { C }$ . This context represents the initial experimental factors that are not under the robotic agent control. In most cases, the context is considered fully observable (e.g. state of the world as measured by sensors).
+
+• A parameterization $\theta$ , element of a Parameterization Space $\Theta$ . This parameterization represents the experimental factors that can be controlled by the robotic agent (e.g. parameters of a policy). • An outcome o, element of an Outcome Space $\mathcal { O }$ . The outcome contains information qualifying properties of the phenomenon during the execution of the experiment (e.g. measures characterizing the trajectory of raw sensor observations during the experiment). • A phenomenon dynamics $D : { \mathcal { C } } , \Theta \mapsto \mathcal { O }$ , which in most interesting cases is unknown.
+
+If we take the example of the Arm-Ball problem9 in which a multi-joint robotic arm can interact with a ball, the context could be the initial state of the robot and the ball, the parameterization could be the parameters of a policy that generate a sequence of motor torque commands for $N$ time steps, and the outcome could be the position of the ball at the last time step. Developmental roboticists are interested in developing autonomous agents that learn two models, the forward model $\tilde { D } : \mathcal { C } \times \Theta \mapsto $ $\mathcal { O }$ which approximates the phenomenon dynamics, and the inverse model $\tilde { I } : \mathcal { C } \times \mathcal { O } \mapsto \Theta$ which allows to produce desired outcomes under given context by properly setting the parameterization. Using the aforementioned elements, one could imagine a simple strategy that would allow the agent to gather tuples $\{ c , \theta , o \}$ to train those models, by uniformly sampling a random parameterization $\theta \stackrel { - } { \sim } \mathcal { U } ( \theta )$ and executing the experiment. We refer to this strategy as Random Parameterization Exploration. The problem for most interesting applications in robotics, is that only a small subspace of $\Theta$ is likely to produce interesting outcomes. Indeed, considering again the Arm-Ball problem with time-bounded action sequences as parameterizations, very few of those will lead the arm to touch the object and move it. In this case, a random sampling in $\Theta$ would be a terrible strategy to yield interesting samples allowing to learn useful forward and inverse models for moving the ball.
+
+To overcome this difficulty, one must come up with a better approach to sample parameterizations that lead to informative samples. Intrinsically Motivated Goal Exploration Strategies propose a way to address this issue by giving the agent a set of tools to handle this situation:
+
+• A Goal Space $\tau$ whose elements $\tau$ represent parameterized goals that can be targeted by the autonomous agent. In the context of this article, and of the IMGEP-UGL architecture, we consider the simple but important case where the Goal Space is equated with the Outcome space. Thus, goals are simply vectors in the outcome space that describe target properties of the phenomenon that the learner tries to achieve through actions.   
+A Goal Policy $\gamma ( \tau )$ , which is a probability distribution over the Goal Space used for sampling goals (see Algorithmic Architecture 2). It can be stationary, but in most cases, it will be updated over time following an intrinsic motivation strategy. Note that in some cases, this Goal Policy can be conditioned on the context $\gamma ( \tau \vert c )$ .   
+• A set of Goal-parameterized Cost Functions $C _ { \tau } : \mathcal { O } \mapsto \mathbb { R }$ defined over all $\mathcal { O }$ , which maps every outcome with a real number representing the goodness-of-fit of the outcome $o$ regarding the goal $\tau$ . As these cost functions are defined over $\mathcal { O }$ , this enables to compute the cost of a policy for a given goal even if the goal is imagined after the policy roll-out. Thus, as IMGEPs typically memorize the population of all executed policies and their outcomes, this enables reuse of experimentations across multiple goals.   
+A Meta-Policy $\Pi : \tau , \mathcal { C } \mapsto \Theta$ which is a mechanism to approximately solve the minimization problem $\Pi ( \tau , c ) = \arg \operatorname* { m i n } _ { \theta } C _ { \tau } ( \tilde { D } ( \theta , c ) )$ , where $\bar { \tilde { D } }$ is a running forward model (approximating $D$ ), trained on-line during exploration.
+
+In some applications, a de-facto ensemble of such tools can be used. For example, in the case where $\mathcal { O }$ is an Euclidean space, we can allow the agent to set goals in the Outcome Space $\mathcal { T } = \mathcal { O }$ , in which case for every goal $\tau$ we can consider a Goal-parameterized cost function $C _ { \tau } ( o ) = \| \tau - o \|$ where $\left. . \right.$ is a similarity metric. In the case of the Arm-Ball problem, the final position of the ball can be used as Outcome Space, hence the Euclidean distance between the goal position and the final ball position at the end of the episode can be used as Goal-parameterized cost function (but one could equally choose the full trajectories of the ball as outcomes and goals, and an associated similarity metric).
+
+Algorithmic architecture 2 describes the main steps of Intrinsically Motivated Goal Exploration Processes using these tools10:
+
+Bootstrapping phase: Sampling a few policy parameters (called Random Parametrization Exploration, RPE), observing the starting context and the resulting outcome, to initialize a memory of experiments $( \mathcal { H } = \{ ( c _ { i } , \theta _ { i } , o _ { i } ) \} )$ and a regressor $\tilde { D } _ { r u n n i n g }$ approximating the phenomenon dynamics.
+
+Goal exploration phase: Stochastically mixing random policy exploration with goal exploration. In goal exploration, one first observes the context $c$ and then samples a goal $\tau$ using goal policy $\gamma$ (this goal policy can be a random stationary distribution, as in experiments below, or a contextual multi-armed bandit maximizing information gain or competence progress, see (Baranes & Oudeyer, 2013)). Then, a meta-policy algorithm $\Pi$ is used to search the parameterization $\theta$ minimizing the Goal-parameterized cost function $C _ { \tau }$ , i.e. it computes $\bar { \theta } = \arg \operatorname* { m i n } _ { \theta } C _ { \tau } ( \tilde { D } _ { r u n n i n g } ( \bar { \theta } , c ) )$ . This process is typically initialized by searching the parameter $\theta _ { i n i t }$ in $\mathcal { H }$ such that the corresponding $c _ { i n i t }$ is in the neighborhood of $c$ and $C _ { \tau } ( o _ { i n i t } )$ is minimized. Then, this initial guess is improved using an optimization algorithm (e.g. L-BFGS) over the regressor $\tilde { D } _ { r u n n i n g }$ . The resulting policy $\theta$ is executed, and the outcome $o$ is observed. The observation $( c , \theta , o )$ is then used to update $\mathcal { H }$ and $\tilde { D } _ { r u n n i n g }$ .
+
+This procedure has been experimentally shown to enable sample efficient exploration in highdimensional continuous action robotic setups, enabling in turn to learn repertoires of skills in complex physical setups with object manipulations using tools (Forestier $\&$ Oudeyer, 2016; Forestier et al., 2017) or soft deformable objects (Nguyen & Oudeyer, 2014).
+
+Nevertheless, two issues arise when it comes to using these algorithms in real-life setups, and within a fully autonomous learning approach. First, there are many real world cases where providing an Outcome Space (in which to make observations and sample goals, so this is also the Goal Space) to the agent is difficult, since the designer may not himself understand well the space that the robot is learning about. The approach taken until now (Forestier et al., 2017), was to create an external program which extracted information out of images, such as tracking all objects positions. This information was presented to the agent as a point in $[ 0 , 1 ] ^ { n }$ , which was hence considered as an Outcome Space. In such complex environments, the designer may not know what is actually feasible or not for the robot, and the Outcome space may contain many unfeasible goals. This is the reason why advanced mechanisms for sampling goals and discovering which ones are actually feasible have been designed (Baranes & Oudeyer, 2013; Forestier et al., 2017). Second, a system where the engineer designs the representation of an Outcome Space space is limited in its autonomy. A question arising from this is: can we design a mechanism that allows the agent to construct an Outcome Space that leads to efficient exploration by the mean of examples? Representation Learning methods, in particular Deep Learning algorithms, constitute a natural approach to this problem as it has shown outstanding performances in learning representations for images. In the next two sections, we present an update of the IMGEP architecture that includes a goal space representation learning stage, as well as various Deep Representation Learning algorithms tested: Autoencoders along with their more recent Variational counter-parts.
+
+# 2.2 UNSUPERVISED GOAL REPRESENTATION LEARNING FOR IMGEP
+
+In order to enable goal space representation learning within the IMGEP framework, we propose to add a first stage of unsupervised perceptual learning (called UGL) before the goal exploration stage, leading to the new IMGEP-UGL architecture described in Algorithmic Architecture 1. In the passive perceptual learning stage (UGL, lines 2-8), the learner passively observes the unknown phenomenon by collecting samples $x _ { i }$ of raw sensor values as the world changes. The architecture is neutral with regards to how these world changes are produced, but as argued in the introduction, one can see them as coming from actions of other agents in the environment. Then, this database of $x _ { i }$ observations is used to train an unsupervised learning algorithm (e.g. VAE, Isomap) to learn an embedding function $\tilde { \mathcal { R } }$ which maps the high-dimensional raw sensor observations onto a lowerdimensional representation $o$ . Also, a kernel density estimator $K D E$ estimates the distribution $p _ { k d e } ( o )$ of observed world changes projected in the embedding. Then, in the goal exploration stage (lines 9-26), this lower-dimensional representation $o$ is used as the outcome and goal space, and the distribution $p _ { k d e } ( o )$ is used as a stochastic goal policy, within a standard IMGEP process (see above).
+
+# Algorithmic Architecture 1: Intrinsically Motivated Goal Exploration Process with Unsupervised Goal Representation Learning (IMGEP-UGL)
+
+#
+
+Regressor $\tilde { D } _ { r u n n i n g }$ , Goal Policy $\gamma$ , Parameterized cost function $C _ { \tau }$ , Meta-Policy algorithm Π,   
+Unsupervised representation learning algorithm $\mathcal { A }$ (e.g. AE, VAE, Isomap), Kernel Density   
+Estimator algorithm $K D E$ ,   
+History $\mathcal { H }$ , Random exploration ratio $\Gamma _ { e }$
+
+# 1 begin
+
+# Passive perceptual learning stage (UGL):
+
+for A fixed number of Observation iterations $n _ { r }$ do
+
+Learn an embedding function ${ \tilde { R } } : { \mathrm { ~ } } x \to o$ using algorithm $\mathcal { A }$ on data $\mathcal { D }$ Set $\mathcal { O } = \mathcal { T } = \tilde { R } ( x )$
+
+Estimate the outcome distribution $p _ { k d e } ( o )$ from $\{ \tilde { R } ( x _ { i } ) \} _ { i \in [ 0 , 1 0 0 0 0 ] }$ using algorithm $K D E$ Set the Goal Policy $\gamma = p _ { k d e }$ to be the estimated outcome distribution
+
+# Goal exploration stage (IMGEP):
+
+or A fixed number of Bootstrapping iterations do Observe context $c$ Sample $\theta \sim \mathcal { U } ( \theta )$ Perform experiment and retrieve outcome from raw sensor signal $o = \tilde { R } ( x )$ Update Regressor $\tilde { D } _ { r u n n i n g }$ with tuple $\{ c , \theta , o \}$ $\mathcal { \bar { H } } = \mathcal { H } \cup \{ c , \theta , o \}$
+
+Perform experiment and retrieve outcome from raw sensor signal $o = \tilde { R } ( x )$ Update Regressor $\tilde { D } _ { r u n n i n g }$ with a tuple $\{ c , \theta , o \}$ Update Goal Policy $\gamma$ , according to Intrinsic Motivation strategy $\mathcal { \bar { H } } = \mathcal { H } \cup \{ c , \theta , o \}$
+
+28 return The forward model $\tilde { D } _ { r u n n i n g }$ , the history $\mathcal { H }$ and the embedding $\tilde { R }$
+
+2.3 REPRESENTATION LEARNING ALGORITHMS AND DENSITY ESTIMATION FOR THE UGL STAGE
+
+As IMGEP-UGL is an algorithmic architecture, it can be implemented with several algorithmic variants depending on which unsupervised learning algorithm is used in the UGL phase. We experimented over different deep and classical Representation Learning algorithms for the UGL phase. We rapidly outline these algorithms here. For a more in-depth introduction to those models, the reader can refer to Appendix B which contains details on the derivations of the different Cost Functions and Architectures of the Deep Neural Networks based models.
+
+Auto-Encoders (AEs) are a particular type of Feed-Forward Neural Networks that were introduced in the early hours of neural networks (Bourlard & Kamp, 1988). They are trained to output a reconstruction $\tilde { \bf x }$ of the input vector $\mathbf { x }$ of dimension $D$ , through a representation layer of size $d < D$ . They can be trained in an unsupervised manner using a large dataset of unlabeled samples $\mathcal { D } = \{ \mathbf { x } ^ { ( i ) } \} _ { i \in \{ 0 \ldots N \} }$ . Their main interest lies in their ability to model the statistical regularities existing in the data. Indeed, during training, the network learns the regularities allowing to encode most of the information existing in the input in a more compact representation. Put differently, AEs can be seen as learning a non-linear compression for data coming from an unknown distribution. Those models can be trained using different algorithms, the most simple being Stochastic Gradient Descent (SGD), to minimize a loss function $\mathcal { I } ( \mathcal { D } )$ that penalizes differences between $\tilde { \bf x }$ and $\mathbf { x }$ for all samples in $\mathcal { D }$ .
+
+Variational Auto-Encoders (VAEs) are a recent alternative to classic AEs (Rezende et al., 2014; Kingma & Ba, 2015), that can be seen as an extension to a stochastic encoding. The argument underlying this model is slightly more involved than the simple approach taken for AEs, and relies on a statistical standpoint presented in Appendix B. In practice, this model simplifies to an architecture very similar to an AE, differing only in the fact that the encoder $f _ { \theta }$ outputs the parameters $\mu$ and $\sigma$ of a multivariate Gaussian distribution ${ \mathcal { N } } ( \mu , d i a g ( \sigma ^ { 2 } ) )$ with diagonal covariance matrix, from which the representation $\mathbf { z }$ is sampled. Moreover, an extra term is added to the Cost Function, to condition the distribution of $\mathbf { z }$ in the representation space. Under the restriction that a factorial Gaussian is used, the neural network can be made fully differentiable thanks to a reparameterization trick, making it possible to use SGD for training.
+
+In practice VAEs tend to yield smooth representations of the data, and are faster to converge than AEs from our experiments. Despite these interesting properties, the derivation of the actual cost function relies mostly on the assumption that the factors can be described by a factorial Gaussian distribution. This hypothesis can be largely erroneous, for example if one of the factors is periodic, multi-modal, or discrete. In practice our experiments showed that even if training could converge for non-Gaussian factors, it tends to be slower and to yield poorly conditioned representations.
+
+Normalizing Flow proposes a way to overcome this restriction on distribution, by allowing more expressive ones (Rezende & Mohamed, 2015). It uses the classic rule of change of variables for random variables, which states that considering a random variable ${ \bf z } _ { 0 } \sim { \boldsymbol q } ( { \bf z } _ { 0 } )$ , and an invertible transformation $t : \mathbb { R } ^ { d } \mapsto \mathbb { R } ^ { d }$ , if ${ \bf z } = t ( { \bf z } _ { 0 } )$ then $q ( \mathbf { z } ) = q ( \mathbf { z } _ { 0 } ) \lvert \operatorname* { d e t } \partial t / \partial \mathbf { z } _ { 0 } \rvert ^ { - 1 }$ . Using this, we can chain multiple transformations $t _ { 1 } , t _ { 2 } , \dots , t _ { K }$ to produce a new random variable $\mathbf { z } _ { K } = t _ { K } \circ \cdot \cdot \cdot \circ$ $t _ { 2 } \circ t _ { 1 } ( \mathbf { z } _ { 0 } )$ . One particularly interesting transformation is the Radial Flow, which allows to radially contract and expand a distribution as can be seen in Figure 5 in Appendix. This transformation seems to give the required flexibility to encode periodic factors.
+
+Isomap is a classical approach of Multi-Dimensional Scaling (Kruskal, 1964) a procedure allowing to embed a set of $N$ -dimensional points in a $n$ dimensional space, with $N > n$ , minimizing the Kruskal Stress, which measures the distortion induced by the embedding in the pairwise Euclidean distances. This algorithm results in an embedding whose pairwise distances are roughly the same as in the initial space. Isomap (Tenenbaum et al., 2000) goes further by assuming that the data lies in the vicinity of a lower dimensional manifold. Hence, it replaces the pairwise Euclidean distances in the input space by an approximate pairwise geodesic distance, computed by the Dijkstra’s Shortest Path algorithm on a $\kappa$ nearest-neighbors graph.
+
+Principal Component Analysis is an ubiquitous procedure (Pearson, 1901) which, for a set of data points, allows to find the orthogonal transformation that yields linearly uncorrelated data. This transformation is found by taking the principal axis of the covariance matrix of the data, leading to a representation whose variance is in decreasing order along dimensions. This procedure can be used to reduce dimensionality, by taking only the first $n$ dimensions of the transformed data.
+
+Estimation of sampling distribution: Since the Outcome Space $\mathcal { O }$ was learned by the agent, it had no prior knowledge of $p ( o )$ for $o \in \mathcal { O }$ . We used a Gaussian Kernel Density Estimation (KDE) (Parzen, 1962; Rosenblatt, 1956) to estimate this distribution from the projection of the images observed by the agent, into the learned goal space representation. Kernel Density Estimation allows to estimate the continuous density function (cdf) $f ( o )$ out of a discrete set of samples $\{ o _ { i } \} _ { i \in \{ 1 , . . . , n \} }$ drown from distribution $p ( o )$ . The estimated cdf is computed using the following equation:
+
+$$
+{ \hat { f } } _ { \mathbf { H } } ( o ) = { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } K _ { \mathbf { H } } ( o - o _ { i } ) ,
+$$
+
+with $K ( \cdot )$ a kernel function and $\mathbf { H }$ a bandwidth $d \times d$ matrix (d the dimension of $\mathcal { O }$ ). In our case, we used a Gaussian Kernel:
+
+$$
+K _ { \mathbf { H } } ( o ) = ( 2 \pi ) ^ { - \frac { d } { 2 } } | \mathbf { H } | ^ { - \frac { 1 } { 2 } } e ^ { - \frac { 1 } { 2 } o ^ { T } \mathbf { H } ^ { - 1 } o } ,
+$$
+
+with the bandwidth matrix $\mathbf { H }$ equaling the covariance matrix of the set of points, rescaled by factor $n ^ { - \frac { 1 } { d + 4 } }$ , with $n$ the number of samples, as proposed in Scott (1992).
+
+# 3 EXPERIMENTS
+
+We conducted experiments to address the following questions in the context of two simulated environments:
+
+• Is it possible for an IMGEP-UGL implementation to produce a Goal Space representation yielding an exploration dynamics as efficient as the dynamics produced by an IMGEP implementation using engineered goal space representations? Here, the dynamics of exploration is measured through the KL Coverage defined thereafter.   
+• What is the impact of the target embedding dimensionality provided to these algorithms?   
+• Are there differences in exploration dynamics when one uses different unsupervised learning algorithms (Isomap-KDE, PCA-KDE, AE-KDE, VAE-KDE, VAE-GP, RFVAE-GP, RFVAE-KDE) as various UGL component of IMGEP-UGL?
+
+We now present in depth the experimental campaign we performed11.
+
+Environments: We experimented on two different Simulated Environments derived from the Arm-Ball benchmark represented in Figure 1, namely the Arm-Ball and the Arm-Arrow environments, in which a 7-joint arm, controlled by a 21 continuous dimension Dynamic Movement Primitives (DMP) (Ijspeert et al., 2013) controller, evolves in an environment containing an object it can handle and move around in the scene. In the case of IMGEP-UGL learners, the scene is perceived as a $7 0 \mathrm { x } 7 0$ pixel image. For the UGL phase, we used the following mechanism to generate the distribution of samples $x _ { i }$ : the object was moved randomly uniformly over $[ - 1 , 1 ] ^ { 2 }$ for ArmBall, and over $[ - 1 , 1 ] ^ { 2 } \times \mathbf { \bar { [ 0 , 2 \pi ] } }$ for ArmArrow, and the corresponding images were generated and provided as an observable sample to IMGEP-UGL learners. Note that the physically reachable space (i.e. the largest space the arm can move the object to) is the disk centered on 0 and of radius 1: this means that the distribution of object movements observed by the learner is slightly larger than the actual space of moves that learners can produce themselves (and learners have no knowledge of which subspace corresponds to physically feasible outcomes). The environments are presented in depth in Appendix C.
+
+Algorithmic Instantiation of the IMGEP-UGL Architecture: We experimented over the following Representation Learning Algorithms for the UGL component: Auto-Encoders with $K D E$ (RGE-AE), Variational Auto-Encoders with $K D E$ (RGE-VAE), Variational Auto-Encoders using the associated Gaussian prior for sampling goal instead of $K D E$ (RGE-VAE-GP), Radial Flow Variational Auto-Encoders with $K D E$ (RGE-RFVAE), Radial Flow Variational Auto-Encoders using the associated Gaussian prior for sampling goal (RGE-RFVAE-GP), Isomap (RGE-Isomap) (Tenenbaum et al., 2000) and Principal Component Analysis (RGE-Isomap).
+
+Regarding the classical IMGEP components, we considered the following elements:
+
+• Context Space $\boldsymbol { \mathcal { C } } = \boldsymbol { \mathcal { D } }$ : In the implemented environments, the initial positions of the arm and the object were reset at each episode12. Consequently, the context was not observed nor accounted for by the agent.
+
+![](images/e8bf17f9ff9892deff429576211799baeccfc98b162b4d0f8e28b61a30b6c6d0.jpg)  
+Figure 1: Left: The Arm-Ball environment with a 7 DOF arm, controlled by a 21D continuous actions DMP controller, that can stick and move the ball if the arm tip touches it (on the left). Right: rendered $7 0 \mathrm { x } 7 0$ images used as raw signals representing the end position of the objects for Arm-Ball (on the center) and Arm-Arrow (on the right) environments. The arm is not visible to learners.
+
+• Parameterization Space $\Theta = [ 0 , 1 ] ^ { 2 1 }$ : During the experiments, we used DMP controllers as parameterized policies to generate time-bounded motor actions sequences. Since the DMP controller was parameterized by 3 basis functions for each joint of the arm (7), the parameterization of the controller was represented by a point in $[ 0 , \bar { 1 } ] ^ { 3 \times 7 }$ .
+
+Outcome Space $\mathcal { O } \subset \mathbb { R } ^ { l }$ : The Outcome Space is the subspace of $\bar { \mathbb { R } ^ { l } }$ spanned by the embedding representations of the ensemble of images observed in the first phase of learning. For the RGE-EFR algorithm, $l = 2$ in ArmBall and $l = 3$ in ArmArrow. For IMGEPUGL algorithms, as the representation learning algorithms used in the UGL stage require a parameter specifying the maximum dimensionality of the target embedding, we considered two cases in experiments: 1) $l = 1 0$ , which is 5 times larger than the true manifold dimension for ArmBall, and 3.3 times larger for ArmArrow (the algorithm is not supposed to know this, so testing the performance with larger embedding dimension is key); 2) $l = 2$ for ArmBall, and $l = 3$ for ArmArrow, which is the same dimensionality as the true dimensions of these manifolds. Goal Space $\tau = \mathcal { O }$ : The Goal Space was taken to equate the Outcome Space. • Goal-Parameterized Cost function $C _ { \tau } ( \cdot ) = \| \tau - \cdot \| _ { 2 }$ : Sampling goals in the Outcome Space allows us to use the Euclidean distance as Goal-parameterized cost function.
+
+Considering those elements, we used the instantiation of the IMGEP architecture represented in Appendix $\mathbf { D }$ in Algorithm 3. We implemented a goal sampling strategy known as Random Goal Exploration (RGE), which consists, given a stationary distribution over the Outcome Space $p ( o )$ , in sampling a random goal $o \sim p ( o )$ each time (note that this stationary distribution $p ( o )$ is learnt in the UGL stage for IMGEP-UGL implementations). We used a simple $k$ -neighbors regressor to implement the running forward model $\tilde { D }$ , and the Meta-Policy mechanism consisted in returning the nearest achieved outcome in the outcome space, and taking the same parameterization perturbed by an exploration noise (which has proved to be a very strong baseline in IMGEP architectures in previous works (Baranes & Oudeyer, 2013; Forestier & Oudeyer, 2016)).
+
+Exploration Performance Measure: In this article, the central property we are interested in is the dynamics and quality of exploration of the outcome space, characterizing the evolution of the distribution of discovered outcomes, i.e. the diversity of effects that the learner discovers how to produce. In order to characterize this exploration dynamics quantitatively, we monitored a measure which we refer to as Kullback-Leibler Coverage (KLC). At a given point in time during exploration, this measure computes the KL-divergence between the distribution of the outcomes produced so far, with a uniform distribution of outcomes in the space of physically possible outcomes (which is known by the experimenter, but unknown by the learner). To compute it, we use a normalized histogram of the explored outcomes, with 30 bins per dimension, which we refer to as $E$ , and we compute its Kullback Leibler Divergence with the normalized histogram of attainable points which
+
+we refer to as $A$
+
+$$
+K L C = \mathbb { D } _ { K L } [ E \| A ] = \sum _ { i = 1 } ^ { 3 0 } E ( i ) \log { \frac { E ( i ) } { A ( i ) } } .
+$$
+
+We emphasize that, when computed against a uniform distribution, the KLC measure is a proxy for the (opposite) Entropy of the $E$ distribution. Nevertheless, we prefer to keep it under the divergence form, as the $A$ distribution allows to define what the experimenter considers to be a good exploration distribution. In the case of this study, we consider a uniform distribution of explored locations over the attainable domain, to be the best exploration distribution achievable.
+
+Baseline algorithms: We are using two natural baseline algorithms for evaluating the exploration dynamics of our IMGEP-UGL algorithmic implementations :
+
+• Random Goal Exploration with Engineered Features Representations (RGE-EFR): This is an IMGEP implementation using a goal/outcome space with handcrafted features that directly encode the underlying structure of environments: for Arm-Ball, this is the 2D position of the ball in $[ 0 , 1 ] ^ { 2 }$ , and for Arm-Arrow this is the 2D position and the 1D orientation of the arrow in $[ 0 , \dot { 1 } ] ^ { 3 }$ . This algorithm is also given the prior knowledge of $p ( o ) = \mathcal { U } ( O )$ . All other aspects of the IMGEP (regressor, meta-policy, other parameters) are identical to IMGEP-UGL implementations. This algorithm is known to provide highly efficient exploration dynamics in these environments (Forestier & Oudeyer, 2016). Random Parameterization Exploration (RPE): The Random Parameterization Exploration approach does not use an Outcome Space, nor a Goal Policy, and only samples a random parameterization $\theta \sim \mathcal { U } ( \Theta )$ at each episode. We expected this algorithm to lower bound the performances of our novel architecture.
+
+# 4 RESULTS
+
+We first study the exploration dynamics of all IMGEP-UGL algorithms, comparing them to the baselines and among themselves. Then, we study specifically the impact of the target embedding dimension (latent space) for the UGL implementations, by observing what exploration dynamics is produced in two cases:
+
+• Using a target dimension larger than the true dimension $( l = 1 0 )$ ) • Providing the true embedding dimension to the UGL implementations $( l = 2 , 3$
+
+Finally, we specifically study RGE-VAE, using the intrinsic Gaussian prior of these algorithms to replace the $K D E$ estimator of $p ( O )$ in the UGL part.
+
+Exploration Performances: In Figure 2, we can see the evolution of the KLC through exploration epochs (one exploration epoch is defined as one experimentation/roll-out of a parameter $\theta$ ). We can see that for both environments, and all values of latent spaces, all IMGEP-UGL algorithms, except RGE-RFVAE, achieve similar or better performance (both in terms of asymptotic KLC and speed to reach it) than the RGE-EFR algorithm using engineered Goal Space features, and much better performance than the RPE algorithm.
+
+Figure 3 (see also Figure 8 and 9 in Appendix) show details of the evolution of discovered outcomes in ArmBall (final ball positions after the end of a policy roll-out) and corresponding KLC measures for individual runs with various algorithms. It also shows the evolution of the number of times learners managed to move the ball, which is considered in the KLC measure but not easily visible in the displayed set of outcomes in Figure 3. For instance, we observe that both RPE (Figure 3(a)) and RGE-RFVAE (Figure 3(c)) algorithms perform poorly: they discover very few policies moving the ball at all (pink curves), and these discovered ball moves cover only a small part of the physically possible outcome space. On the contrary, both RGE-EFR (handcrafted features) and RGE-VAE (learned goal space representation with VAE) perform very well, and the KLC of RGE-VAE is even better than the KLC of RGE-EFR, due to the fact that RGE-VAE has discovered more policies (around 2400) that move the ball than RGE-EFR (around 1600, pink curve).
+
+![](images/d68e5afba4b30dbeda7df4c891ba804a889a2678d22aa3e991fd2b16f86e0776.jpg)  
+Figure 2: KL Coverage through epochs for different algorithms on ArmBall and ArmArrow environments. The exploration performance was assessed for both an over-complete representation (10 latent dimensions), and a complete representation (2 and 3 latent dimensions). The shaded area represent a $90 \%$ confidence interval estimated from 5 run of the different algorithms.
+
+Impact of target latent space size in IMGEP-UGL algorithms On the ArmBall problem, we observe that if one provides the true target embedding dimension $\mathit { l } = 2 \mathit { \Pi }$ ) to IMGEP-UGL implementations, RGE-Isomap is slightly improving (getting quasi-identical to RGE-EFR), RGE-AE does not change (remains quasi-identical to RGE-EFR), but the performance of RGE-PCA and RGE-VAE is degraded. For ArmArrow, the effect is similar: IMGEP-UGL algorithms with a larger target embedding dimension $\left( l = 1 0 \right)$ ) than the true dimensionality all perform better than RGE-EFR (except RGE-RFVAE which is worse in all cases), while when $l = 2$ only RGE-VAE is significantly better than RGE-EFR. In Appendix F, more examples of exploration curves with attached exploration scatters are shown. For most example runs, increasing the target embedding dimension enables learners to discover more policies moving the ball and, in these cases, the discovered outcomes are more concentrated towards the external boundary of the discus of physically possible outcomes. This behavior, where increasing the target embedding dimension improves the KLC while biasing the discovered outcome towards the boundary the feasible goals, can be understood as a consequence of the following well-known general property of IMGEPs: if goals are sampled outside the convex hull of outcomes already discovered, this has the side-effect of biasing exploration towards policies that will produce outcomes beyond this convex hull (until the boundary of feasible outcomes is reached). Here, as observations in the UGL phase were generated by uniformly moving the objects on the square $[ - 1 , 1 ] ^ { 2 }$ , while the feasible outcome space was the smaller discus of radius 1, goal sampling happened in a distribution of outcomes larger than the feasible outcome space. As one increases the embedding space dimensionality, the ratio between the volume of the corresponding hyper-cube and hyper-discus increases, in turn increasing the probability to sample goals outside the feasible space, which has the side effect of fostering the discovery of novel outcomes and biasing exploration towards the boundaries.
+
+![](images/ad28206a8c259ade0c5bcf33c47ddebcf1fd777ae7fab0f24c675f2b86bd186c.jpg)  
+(a) Rpe
+
+![](images/e5d4c2562b2c8f9a3ee3265822c1af8300826dad666c6ba08756833f0a1f1168.jpg)  
+(b) Rge-Efr
+
+![](images/069a9595806ccd9a443408e2db17cbae8e389c5074cf8fa1a52e1e9a1ec9e684.jpg)  
+(c) Rge-Rfvae - 10 Latents
+
+![](images/8791895103570b29d655a7eb5599620d4eb7ab2e20259d41fc3e2541a311c574.jpg)  
+Figure 3: Examples of achieved outcomes related with the evolution of KL-Coverage in the ArmBall environments. The number of times the ball was effectively handled is also represented.
+
+![](images/76c87457fe99340adaae2eeb85b019731d4c58c9097609757b3148ad261ca681.jpg)  
+Figure 4: Evolution of the Exploration Ratio for RGE-VAE using KDE or Isotropic Gaussian prior. The curves show the mean and standard deviation over 5 independent runs of each condition.
+
+Impact of Sampling Kernel Density Estimation Another factor impacting the exploration assessed during our experiments was the importance of the distribution used as stationary Goal Policy. If, in most cases, the representation algorithm gives no particular prior knowledge of $p ( o )$ , in the case of Variational Auto-Encoders, it is assumed in the derivation that $p ( o ) = \mathbf { \bar { \mathcal { N } } } ( 0 , \bar { I } )$ . Hence, the isotropic Gaussian distribution is a better candidate stationary Goal Policy than Kernel Density Estimation. Figure 4 shows a comparison between exploration performances achieved with RGEVAE using a KDE distribution or an isotropic Gaussian as Goal Policy. The performance is not significantly different from the isotropic Gaussian case. Our experiments showed that convergence on the KL term of the loss can be more or less quick depending on the initialization. Since we used a number of iterations as stopping criterion for training (based on early experiments), we found that sometimes, at stop, the divergence was still pretty high despite achieving a low reconstruction error. In those cases the representation was not be perfectly matching an isotropic Gaussian, which could lead to a goal sampling bias when using the isotropic Gaussian Goal Policy.
+
+# 5 CONCLUSION
+
+In this paper, we proposed a new Intrinsically Motivated Goal Exploration architecture with Unsupervised Learning of Goal spaces (IMGEP-UGL). Here, the Outcome Space (also used as Goal Space) representation is learned using passive observations of world changes through low-level raw sensors (e.g. movements of objects caused by another agent and perceived at the pixel level). Within the perspective of research on Intrinsically Motivated Goal Exploration started a decade ago (Oudeyer & Kaplan, 2007; Baranes & Oudeyer, 2013), and considering the fundamental problem of how AI agents can autonomously explore environments and skills by setting their own goals, this new architecture constitutes a milestone as it is to our knowledge the first goal exploration architecture where the goal space representation is learned, as opposed to hand-crafted.
+
+Furthermore, we have shown in two simulated environments (involving a high-dimensional continuous action arm) that this new architecture can be successfully implemented using multiple kinds of unsupervised learning algorithms, including recent advanced deep neural network algorithms like Variational Auto-Encoders. This flexibility opens the possibility to benefit from future advances in unsupervised representation learning research. Yet, our experiments have shown that all algorithms we tried (except RGE-RFVAE) can compete with an IMGEP implementation using engineered feature representations. We also showed, in the context of our test environments, that providing to IMGEP-UGL algorithms a target embedding dimension larger than the true dimensionality of the phenomenon can be beneficial through leveraging exploration dynamics properties of IMGEPs. Though we must investigate more systematically the extent of this effect, this is encouraging from an autonomous learning perspective, as one should not assume that the learner initially knows the target dimensionality.
+
+Limits and future work. The experiments presented here were limited to a fairly restricted set of environments. Experimenting over a larger set of environments would improve our understanding of IMGEP-UGL algorithms in general. In particular, a potential challenge is to consider environments where multiple objects/entities can be independently controlled, or where some objects/entities are not controllable (e.g. animate entities). In these cases, previous work on IMGEPs has shown that random Goal Policies should be either replaced by modular Goal Policies (considering a modular goal space representation, see Forestier et al. (2017)), or by active Goal Policies which adaptively focus the sampling of goals in subregions of the Goal Space where the competence progress is maximal (Baranes & Oudeyer, 2013). For learning modular representations of Goal Spaces, an interesting avenue of investigations could be the use of the Independently Controllable Factors approach proposed in (Thomas et al., 2017).
+
+Finally, in this paper, we only studied a learning scenario where representation learning happens first in a passive perceptual learning stage, and is then fixed during a second stage of autonomous goal exploration. While this was here motivated both by analogies to infant development and to facilitate evaluation, the ability to incrementally and jointly learn an outcome space representation and explore the world is a stimulating topic for future work.
+
+# REFERENCES
+
+Peter M Andreae and John H. Andreae. A teachable machine in the real world. International Journal of Man-Machine Studies, 10(3):301–312, 1978.
+
+Gianluca Baldassarre, Marco Mirolli, and Andrew G. Barto. Intrinsically motivated learning in natural and artificial systems. Springer, 2013.
+
+Adrien Baranes and Pierre-Yves Oudeyer. R-IAC: Robust intrinsically motivated exploration and active learning. IEEE Transactions on Autonomous Mental Development, 1(3):155–169, 2009. doi: 10.1109/TAMD.2009.2037513.
+
+Adrien Baranes and Pierre-Yves Oudeyer. Active learning of inverse models with intrinsically motivated goal exploration in robots. Robotics and Autonomous Systems, 61(1), 2013.
+
+Andrew G. Barto. Intrinsic motivation and reinforcement learning. In Intrinsically motivated learning in natural and artificial systems, pp. 17–47. Springer, 2013.
+
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016.
+
+Daniel E. Berlyne. Curiosity and exploration. Science, 153(3731):25–33, 1966.
+
+Leon Bottou. Online Algorithms and Stochastic Approximations. In Online Learning and Neural Networks, pp. 1–34. 1998. ISBN 978-0521117913.
+
+Hervé Bourlard and Yves Kamp. Auto-association by multilayer perceptrons and singular value decomposition. Biological Cybernetics, 59(4-5):291–294, 1988. ISSN 03401200. doi: 10.1007/ BF00332918.
+
+Serkan Cabi, Sergio G. Colmenarejo, Matthew W. Hoffman, Misha Denil, Ziyu Wang, and Nando De Freitas. The intentional unintentional agent: Learning to solve many continuous control tasks simultaneously. CoRR, abs/1707.03300, 2017.
+
+Angelo Cangelosi, Matthew Schlesinger, and Linda B. Smith. Developmental robotics: From babies to robots. MIT Press, 2015.
+
+Nuttapong Chentanez, Andrew G Barto, and Satinder P. Singh. Intrinsically motivated reinforcement learning. In Advances in neural information processing systems, pp. 1281–1288, 2005.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive Subgradient Methods for Online Learning and Stochastic Optimization. Journal of Machine Learning Research, 12:2121–2159, 2011. ISSN 15324435. doi: 10.1109/CDC.2012.6426698. URL http://jmlr.org/papers/ v12/duchi11a.html.
+
+Carlos Florensa, David Held, Markus Wulfmeier, and Pieter Abbeel. Reverse curriculum generation for reinforcement learning. arXiv preprint arXiv:1707.05300, 2017.
+
+Sébastien Forestier and Pierre-Yves Oudeyer. Modular active curiosity-driven discovery of tool use. In IEEE International Conference on Intelligent Robots and Systems, volume 2016-November, pp. 3965–3972, 2016. ISBN 9781509037629. doi: 10.1109/IROS.2016.7759584.
+
+Sébastien Forestier, Yoan Mollard, and Pierre-Yves Oudeyer. Intrinsically motivated goal exploration processes with automatic curriculum learning. CoRR, abs/1708.02190, 2017.
+
+Karl J. Friston, Marco Lin, Christopher D. Frith, Giovanni Pezzulo, J. Allan Hobson, and Sasha Ondobaka. Active inference, curiosity and insight. Neural Computation, 2017.
+
+Alison Gopnik, Andrew N. Meltzoff, and Patricia K. Kuhl. The scientist in the crib: Minds, brains, and how children learn. William Morrow & Co, 1999.
+
+Irina Higgins, Loic Matthey, Xavier Glorot, Arka Pal, Benigno Uria, Charles Blundell, Shakir Mohamed, and Alexander Lerchner. Early visual concept learning with unsupervised deep learning. CoRR, abs/1606.05579, 2016.
+
+Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. Vime: Variational information maximizing exploration. In Advances in Neural Information Processing Systems, pp. 1109–1117, 2016.
+
+Auke Jan Ijspeert, Jun Nakanishi, Heiko Hoffmann, Peter Pastor, and Stefan Schaal. Dynamical movement primitives: learning attractor models for motor behaviors. Neural computation, 25(2): 328–73, 2013. ISSN 1530-888X. doi: 10.1162/NECO_a_00393. URL http://www.ncbi. nlm.nih.gov/pubmed/23148415.
+
+Frederic Kaplan and Pierre-Yves Oudeyer. Motivational principles for visual know-how development. 2003.
+
+Diederik P. Kingma and Jimmy Lei Ba. Adam: a Method for Stochastic Optimization. International Conference on Learning Representations 2015, pp. 1–15, 2015. ISSN 09252312. doi: http: //doi.acm.org.ezproxy.lib.ucf.edu/10.1145/1830483.1830503.
+
+Diederik P. Kingma and Max Welling. Auto-encoding variational bayes, 2013. URL http:// arxiv.org/abs/1312.6114.
+
+Joseph B. Kruskal. Multidimensional scaling by optimizing goodness of fit to a nonmetric hypothesis. Psychometrika, 29(1):1–27, 1964. ISSN 00333123. doi: 10.1007/BF02289565.
+
+Daniel Y Little and Friedrich T Sommer. Learning and exploration in action-perception loops. Frontiers in neural circuits, 7, 2013.
+
+Georg Martius, Ralf Der, and Nihat Ay. Information driven self-organization of complex robotic behaviors. PloS one, 8(5):e63400, 2013.
+
+Shamima Najnin and Bonny Banerjee. A predictive coding framework for a developmental agent: Speech motor skill acquisition and speech production. Speech Communication, 2017.
+
+Sao M. Nguyen and Pierre-Yves Oudeyer. Socially guided intrinsic motivation for robot learning of motor skills. Autonomous Robots, 36(3):273–294, 2014. doi: 10.1007/s10514-013-9339-y.
+
+P-Y Oudeyer, Jacqueline Gottlieb, and Manuel Lopes. Intrinsic motivation, curiosity, and learning: Theory and applications in educational technologies. In Progress in brain research, volume 229, pp. 257–284. Elsevier, 2016.
+
+Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? A typology of computational approaches. Frontiers in Neurorobotics, 3(NOV), 2007. ISSN 16625218. doi: 10.3389/neuro.12.006.2007.
+
+Pierre-Yves Oudeyer and Linda B. Smith. How evolution may work through curiosity-driven developmental process. Topics in Cognitive Science, 8(2):492–502, 2016.
+
+Pierre-Yves Oudeyer, Frederic Kaplan, and Verena V. Hafner. Intrinsic motivation systems for autonomous mental development. IEEE Transactions on Evolutionary Computation, 11(2):265– 286, 2007. ISSN 1089778X. doi: 10.1109/TEVC.2006.890271.
+
+Pierre-Yves Oudeyer, Adrien Baranes, and Frederic Kaplan. Intrinsically motivated learning of realworld sensorimotor skills with developmental constraints. In Intrinsically motivated learning in natural and artificial systems, pp. 303–365. Springer, 2013.
+
+Emanuel Parzen. On Estimation of a Probability Density Function and Mode. The Annals of Mathematical Statistics, 33(3):1065–1076, 1962. ISSN 0003-4851. doi: 10.1214/aoms/1177704472. URL http://projecteuclid.org/euclid.aoms/1177704472.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In Proceedings of the seventh international conference on machine learning, 2017.
+
+Karl Pearson. On lines and planes of closest fit to systems of points in space. Philosophical Magazine Series 6, 2(11):559–572, 1901. ISSN 1941-5982. doi: 10.1080/14786440109462720. URL http://www.tandfonline.com/doi/abs/10.1080/14786440109462720.
+
+Danilo J. Rezende and Shakir Mohamed. Variational inference with normalizing flows. In ICML, 2015.
+
+Danilo J. Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In ICML, volume 32 of JMLR Workshop and Conference Proceedings, pp. 1278–1286. JMLR.org, 2014. URL http://dblp.uni-trier.de/ db/conf/icml/icml2014.html#RezendeMW14.
+
+M. Rolf, Jochen J. Steil, and Michael Gienger. Goal babbling permits direct learning of inverse kinematics. IEEE Transactions on Autonomous Mental Development, 2(3), 2010.
+
+Murray Rosenblatt. Remarks on Some Nonparametric Estimates of a Density Function. The Annals of Mathematical Statistics, 27(3):832–837, 1956. ISSN 0003-4851. doi: 10.1214/aoms/ 1177728190. URL http://projecteuclid.org/euclid.aoms/1177728190.
+
+Christoph Salge, Cornelius Glackin, and Daniel Polani. Changing the environment based on empowerment as intrinsic motivation. Entropy, 16(5):2789–2819, 2014.
+
+Stefan Schaal, Auke Ijspeert, and Aude Billard. Computational approaches to motor learning by imitation. Philosophical Transactions of the Royal Society of London B: Biological Sciences, 358 (1431):537–547, 2003.
+
+Jurgen Schmidhuber. A possibility for implementing curiosity and boredom in model-building neural controllers. In From animals to animats: Proceedings of the first international conference on simulation of adaptive behavior, pp. 15–21, 1991.
+
+Jurgen Schmidhuber. Powerplay: Training an increasingly general problem solver by continually searching for the simplest still unsolvable problem. Frontiers in psychology, 4, 2013.
+
+David W. Scott. Multivariate Density Estimation: Theory, Practice, and Visualization, volume 156. 1992. ISBN 0471547700. doi: 10.1002/9780470316849.fmatter. URL http://www.jstor. org/stable/2983087?origin $=$ crossref.
+
+Casper K. Sonderby, Tapani Raiko, Lars MaalÃÿe, Soren K. Sonderby, and Ole Winther. Ladder variational autoencoders. Feb 2016. URL http://arxiv.org/abs/1602.02282v3.
+
+Kenneth O. Stanley and Joel Lehman. Why greatness cannot be planned: The myth of the objective. Springer, 2015.
+
+Richard S. Sutton. Integrated architectures for learning, planning, and reacting based on approximating dynamic programming. In Proceedings of the seventh international conference on machine learning, pp. 216–224, 1990.
+
+Haoran Tang, Rein Houthooft, Davis Foote, Adam Stooke, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. # exploration: A study of count-based exploration for deep reinforcement learning. In Advances in Neural Information Processing Systems, 2017.
+
+Joshua B. Tenenbaum, Veronica De Silva, and John C. Langford. A global geometric framework for nonlinear dimensionality reduction. Science, 290 5500:2319–23, 2000.
+
+Valentin Thomas, Jules Pondard, Emmanuel Bengio, Marc Sarfati, Philippe Beaudoin, Marie-Jean Meurs, Joelle Pineau, Doina Precup, and Yoshua Bengio. Independently controllable factors. arXiv preprint arXiv:1708.01289, 2017.
+
+Jakub M. Tomczak and Max Welling. Improving variational auto-encoders using householder flow. Dec 2016. URL http://arxiv.org/abs/1611.09630v4.
+
+Claes Von Hofsten. An action perspective on motor development. Trends in cognitive sciences, 8 (6):266–272, 2004.
+
+# Appendix
+
+# A INTRINSICALLY MOTIVATED GOAL EXPLORATION PROCESS
+
+Intrinsically Motivated Goal Exploration Processes are algorithmic architectures that can be instantiated into different exploration algorithms depending on the problem to explore. The general architecture is represented in Algorithm 2.
+
+# Algorithmic Architecture 2: Intrinsically Motivated Goal Exploration Strategy
+
+# Input:
+
+![](images/e787ca75cdd120e26f00528370b16f396f1bc7a454ea0cae42cd8f0427e5d730.jpg)  
+19 return The forward model $\tilde { D } _ { r u n n i n g }$ and the history $\mathcal { H }$
+
+# B DEEP REPRESENTATION LEARNING ALGORITHMS
+
+The cost functions used to train the different Deep Representation Learning algorithms used in this paper can be motivated by a few theoretical arguments summarized below.
+
+Auto-Encoders (AEs) The choice of the cost function can be motivated by considering the network as composed of:
+
+• An encoder network parameterized by weights $\theta$ that maps an input $\mathbf { x }$ to its deterministic representation $\mathbf { z } = f _ { \boldsymbol { \theta } } ( \mathbf { x } )$ .   
+• A decoder network parameterized by weights $\phi$ that maps a representation $\mathbf { z }$ to a vector $\xi$ parameterizing a distribution $p _ { \xi } ( \mathbf { x } | \mathbf { z } )$ with $\xi = g _ { \phi } ( \mathbf { z } )$ .
+
+Under this stochastic decoding assumption, the Maximum Likelihood principle is used to train the model, i.e. AEs can maximize the likelihood of data under the model. In the case of Auto-Encoders, this principle is compatible with gradient descent, and we can use the negative log-likelihood as a cost function to be minimized. If input $\mathbf { x }$ is binary valued, $p ( \mathbf { x } | \mathbf { z } )$ is assumed to follow a multivariate
+
+Bernouilli distribution of $\xi$ parameters 13, and the log likelihood of the dataset $\mathcal { D }$ is expressed as:
+
+$$
+\log \mathfrak { L } ( \mathcal { D } ) = \sum _ { i = 1 } ^ { N } \log p ( \mathbf { x } ^ { ( i ) } | \xi ^ { ( i ) } ) = \sum _ { i = 1 } ^ { N } \sum _ { k = 1 } ^ { D } \big [ x _ { k } ^ { ( i ) } \log \xi _ { k } ^ { ( i ) } + ( 1 - x _ { k } ^ { ( i ) } ) \log ( 1 - \xi _ { k } ^ { ( i ) } ) \big ] ,
+$$
+
+with $\xi ^ { ( i ) } = g _ { \phi } ( f _ { \theta } ( \mathbf { x } ^ { ( i ) } ) )$ . For a binary valued input vector $\mathbf { x } ^ { ( i ) }$ , the unitary Cost Function to minimize is:
+
+$$
+\mathcal { I } ( \theta , \phi , \mathbf { x } ^ { ( i ) } ) = - \sum _ { d = 1 } ^ { D } \big [ x _ { d } ^ { ( i ) } \log ( g _ { \phi } ( f _ { \theta } ( \mathbf { x } ^ { ( i ) } ) ) _ { d } ) + ( 1 - x _ { d } ^ { ( i ) } ) \log ( 1 - g _ { \phi } ( f _ { \theta } ( \mathbf { x } ^ { ( i ) } ) ) _ { d } ) \big ] ,
+$$
+
+provided that $f _ { \theta }$ is the encoder part of the architecture and $g _ { \phi }$ is the decoding part of the architecture. This Cost Function can be minimized using Stochastic Gradient Descent (Bottou, 1998), or more advanced optimizers such as Adagrad (Duchi et al., 2011) or Adam (Kingma & Ba, 2015).
+
+Depending on the depth of the network14, those architectures can prove difficult to train using vanilla Stochastic Gradient Descent. A particularly successful procedure to overcome this difficulty is to greedily train each pairs of encoding-decoding layers and stacking those to sequentially form the complete network. This procedure, known as stacked AEs, accelerates convergence. But it has shown bad results with our problem, and thus was discarded for the sake of clarity.
+
+Variational Auto-Encoders (VAEs) If we assume that the observed data are realizations of a random variable $\mathbf { x } \sim p ( \mathbf { x } | \psi )$ , we can hypothesize that they are conditioned by a random vector of independent factors $\mathbf { z } \sim p ( \mathbf { z } | \psi )$ . In this setting, learning the model would amount to searching the parameters $\psi$ of both distributions. We might use the same principle of maximum likelihood as before to find the best parameters by computing the likelihood $\begin{array} { r } { \log \mathfrak { L } ( \mathcal { D } ) = \sum _ { i = 1 } ^ { N } \log p ( \mathbf { x } ^ { ( i ) } | \psi ) } \end{array}$ by using the fact that $\begin{array} { r } { p ( { \mathbf x } | \psi ) = \int p ( { \mathbf x } , { \mathbf z } | \psi ) d { \mathbf z } = \int p ( { \mathbf x } | { \mathbf z } , \psi ) p ( { \mathbf z } | \psi ) d { \mathbf z } . } \end{array}$ . Unfortunately, in most cases, this integral is intractable and cannot be approximated by Monte-Carlo sampling in reasonable time. To overcome this problem, we can introduce an arbitrary distribution $q ( \mathbf { z } | \mathbf { x } , \chi )$ and remark that the following holds:
+
+$$
+\log p ( \mathbf { x } | \psi ) = \mathcal { L } ( q , \psi ) + \mathbb { D } _ { K L } [ q ( \mathbf { z } | \mathbf { x } , \chi ) \| p ( \mathbf { z } | \mathbf { x } , \psi ) ,
+$$
+
+with the Evidence Lower Bound being:
+
+$$
+\begin{array} { r } { \mathcal { L } ( q , \psi ) = \underbrace { \mathbb { E } _ { \mathbf { z } \sim q ( \mathbf { z } | \mathbf { x } , \psi ) } [ \log p ( \mathbf { x } | \mathbf { z } , \psi ) ] } _ { a } - \underbrace { \mathbb { D } _ { K L } [ q ( \mathbf { z } | \mathbf { x } , \chi ) \| p ( \mathbf { z } , \psi ) ] } _ { b } . } \end{array}
+$$
+
+Looking at Equation (5), we can see that since the KL divergence is non-negative, $\begin{array} { r } { \mathcal { L } ( q , \psi ) ~ \leq } \end{array}$ $\log p ( \mathbf { x } \mathbf { \bar { | } } \psi ) - \mathbb { D } _ { K L } \big ( [ q ( \mathbf { z } | \mathbf { x } , \chi ) ] | p ( \mathbf { z } | \mathbf { x } , \psi ) \big ]$ whatever the $q$ distribution, hence the name of Evidence Lower Bound (ELBO). Consequently, maximizing the ELBO have the effect to maximize the log likelihood, while minimizing the KL-Divergence between the approximate $q ( \mathbf { z } | \mathbf { x } )$ distribution, and the true unknown posterior $p ( \mathbf { z } | \mathbf { x } , \psi )$ . The approach taken by VAEs is to learn the parameters of both conditional distributions $p ( \mathbf { x } | \mathbf { z } , \psi )$ and $q ( \mathbf { z } | \mathbf { x } , \chi )$ as non-linear functions. Under some restricted conditions, Equation (6) can be turned into a valid cost function to train a neural network. First, we hypothesize that $q ( \mathbf { z } | \mathbf { x } , \chi )$ and $p ( \mathbf { z } | \boldsymbol { \psi } )$ follow Multivariate Gaussian distributions with diagonal covariances, which allows us to compute the $b$ term in closed form. Second, using the Gaussian assumption on $q$ , we can reparameterize the inner sampling operation by $\mathbf { z } = \mu \dot { + } \sigma ^ { 2 } \odot \epsilon$ with $\epsilon \sim \bar { \mathcal { N } } ( 0 , I )$ . Using this trick, the Path-wise Derivative estimator can be used for the $a$ member of the ELBO. Under those conditions, and assuming that $p ( \mathbf { x } | \boldsymbol { \psi } )$ follows a Multivariate Bernouilli distribution, we can write the cost function used to train the neural network as:
+
+$$
+\begin{array} { r l } & { \mathcal { I } ( \psi , \chi , \mathbf { x } ^ { ( i ) } ) = - \displaystyle \frac { 1 } { 2 } \sum _ { j = 1 } ^ { J } ( 1 + \log ( \sigma ( \mathbf { x } ^ { ( i ) } ) _ { j } ^ { 2 } ) - \mu ( \mathbf { x } ^ { ( i ) } ) _ { j } ^ { 2 } - \sigma ( \mathbf { x } ^ { ( i ) } ) _ { j } ^ { 2 } ) } \\ & { \quad \quad \quad - \displaystyle \sum _ { k = 1 } ^ { D } \big [ x _ { k } ^ { ( i ) } \log ( g _ { \psi } ( f _ { \chi } ( \mathbf { x } ^ { ( i ) } ) ) _ { k } ) + ( 1 - x _ { k } ^ { ( i ) } ) \log ( 1 - g _ { \psi } ( f _ { \chi } ( \mathbf { x } ^ { ( i ) } ) ) _ { k } ) \big ] , } \end{array}
+$$
+
+where $f _ { \chi }$ represents the encoding and sampling part of the architecture and $g _ { \psi }$ represents the decoding part of the architecture. In essence, this derivation simplifies to the initial cost function used in AEs augmented by a term penalizing the divergence between $q ( \mathbf { z } | \mathbf { x } , \chi )$ and the assumed prior that $p ( \mathbf { x } | \psi ) \overset { \mathbf { \bar { \alpha } } } { = } \mathcal { N } ( 0 , I )$ .
+
+Normalizing Flow overcomes the problem stated earlier, by permitting more expressive prior distributions (Rezende & Mohamed, 2015). It is based on the classic rule of change of variables for random variables. Considering a random variable ${ \bf z } _ { 0 } \sim { \boldsymbol q } ( { \bf z } _ { 0 } )$ , and an invertible transformation $t : \mathbb { R } ^ { d } \mapsto \mathbb { R } ^ { d }$ , if ${ \bf z } = t ( { \bf z } _ { 0 } )$ , then:
+
+$$
+q ( \mathbf { z } ) = q ( \mathbf { z } _ { 0 } ) { \bigg | } \operatorname* { d e t } { \frac { \partial t ^ { - 1 } } { \partial \mathbf { z } _ { 0 } } } { \bigg | } = q ( \mathbf { z } _ { 0 } ) { \bigg | } \operatorname* { d e t } { \frac { \partial t } { \partial \mathbf { z } _ { 0 } } } { \bigg | } ^ { - 1 } .
+$$
+
+We can then directly chain different invertible transformations $t _ { 1 } , t _ { 2 } , \dots , t _ { K }$ to produce a new random variable $\mathbf { z } _ { K } = t _ { K } \circ \cdot \cdot \cdot \circ t _ { 2 } \circ t _ { 1 } ( \mathbf { z } _ { 0 } )$ . In this case, we have:
+
+$$
+\log q ( \mathbf { z } _ { k } ) = \log \left( q ( \mathbf { z } _ { 0 } ) \prod _ { k = 1 } ^ { K } \left| \operatorname* { d e t } { \frac { \partial t _ { k } } { \partial \mathbf { z } _ { k - 1 } } } \right| ^ { - 1 } \right) = \log q ( \mathbf { z } _ { 0 } ) - \sum _ { k = 1 } ^ { K } \log \left| \operatorname* { d e t } { \frac { \partial t _ { k } } { \partial \mathbf { z } _ { k - 1 } } } \right| .
+$$
+
+This formulation is interesting because the Law Of The Unconscious Statistician allows us to compute expectations over $q ( \mathbf { z } _ { k } )$ without having a precise knowledge of it:
+
+$$
+\begin{array} { r } { \mathbb { E } _ { \mathbf { z } _ { k } \sim q ( \mathbf { z } _ { k } ) } [ h ( \mathbf { z } _ { k } ) ] = \mathbb { E } _ { \mathbf { z } _ { 0 } \sim q ( \mathbf { z } _ { 0 } ) } [ h ( t _ { k } \circ . . . t _ { 2 } \circ t _ { 1 } ( \mathbf { z } _ { 0 } ) ) ] , } \end{array}
+$$
+
+provided that $h$ does not depends on $q ( \mathbf { z } _ { k } )$ . Using this principle on the ELBO allows us to derive the following:
+
+$$
+\begin{array} { l } { { \displaystyle \mathcal { L } ( q , \theta , \phi ) = \mathbb { E } _ { { \bf z } _ { 0 } \sim q ( { \bf z } _ { 0 } | { \bf x } ) } [ \log p ( { \bf x } | t _ { K } \circ . . . t _ { 2 } \circ t _ { 1 } ( { \bf z } _ { 0 } ) ) ] } } \\ { { \displaystyle - \mathbb { D } _ { K L } [ q ( { \bf z } _ { 0 } | { \bf x } ) \| p ( { \bf z } _ { 0 } ) ] } } \\ { { \displaystyle + 2 \mathbb { E } _ { { \bf z } _ { 0 } \sim q ( { \bf z } _ { 0 } | { \bf x } ) } \left[ \sum _ { k = 1 } ^ { K } \log \left| \operatorname* { d e t } \frac { \partial t _ { k } } { \partial { \bf z } _ { k - 1 } } \right| \right] } } \end{array}
+$$
+
+This is nothing more than the regular ELBO with an additional term concerning the log-determinant of the transformations. In practice, as before, we use $p ( \mathbf { z } _ { 0 } ) ~ = ~ \mathcal { N } ( \mathbf { z } _ { 0 } ; \mathbf { 0 } , \mathbf { I } )$ , and $q ( \mathbf { z } _ { 0 } | x ) \ =$ $\mathcal { N } ( \mathbf { z } _ { 0 } ; \mu ( x ) , d i a g ( \sigma ( x ) ^ { 2 } ) )$ . We only have to find out parameterized transformations $t$ , whose parameters can be learned and have a defined log-determinant. Using radial flow, which is expressed as:
+
+$$
+t ( \mathbf { z } ) = \mathbf { z } + \beta h ( \alpha , \mathbf { r } ) ( \mathbf { z } - \mathbf { c } ) ,
+$$
+
+where $\mathbf { r } = | \mathbf { z } - \mathbf { c } |$ , $\textstyle h ( \alpha , \mathbf { r } ) = { \frac { 1 } { \alpha + \mathbf { r } } }$ and $\alpha , \beta , { \bf c }$ are learnable parameters of the transformation, our cost function can be written as:
+
+$$
+\begin{array} { l l l } { \displaystyle \mathcal { I } ( \psi , \chi , \mathbf { x } ^ { ( i ) } ) = - \frac { 1 } { 2 } \sum _ { j = 1 } ^ { J } ( 1 + \log ( \sigma ( \mathbf { x } ^ { ( i ) } ) _ { j } ^ { 2 } ) - \mu ( \mathbf { x } ^ { ( i ) } ) _ { j } ^ { 2 } - \sigma ( \mathbf { x } ^ { ( i ) } ) _ { j } ^ { 2 } ) } \\ { \displaystyle \qquad - \sum _ { d = 1 } ^ { D } [ x _ { d } ^ { ( i ) } \log ( g _ { \psi } ( f _ { \chi } ( \mathbf { x } ^ { ( i ) } ) ) _ { d } ) + ( 1 - x _ { d } ^ { ( i ) } ) \log ( 1 - g _ { \psi } ( f _ { \chi } ( \mathbf { x } ^ { ( i ) } ) ) _ { d } ) ] } \\ { \displaystyle \qquad \quad - 2 \sum _ { k = 1 } ^ { K } \log [ 1 + \beta _ { k } h ( \alpha _ { k } , \mathbf { r } ) ) ] ^ { D - 1 } [ 1 + \beta _ { k } h ( \alpha , \mathbf { r } ) ) + \beta _ { k } h ^ { \prime } ( \alpha , r ) r ] , } \end{array}
+$$
+
+provided that $f _ { \chi }$ represents the encoding, sampling ad transforming part of the architecture, $g _ { \psi }$ represents the decoding part of the architecture, and $\beta _ { k } , \alpha _ { k } , c _ { k }$ are the parameters of the different transformations. Other types of transformations have been proposed lately. The Householder flow (Tomczak & Welling, 2016) is a volume preserving transformation, meaning that its log determinant equals 1, with the consequence that it can be used with no modifications of the loss function. A more convoluted type of transformations based on a masked autoregressive auto-encoder, the Inverse Autoregressive Flow, was proposed in Kingma & Welling (2013). We did not explore those two last approaches.
+
+![](images/32f0916280aec0049b1513491f736f23f35e5d5a75ac52b2c6fc5df185af113e.jpg)  
+Figure 5: Effect of a Radial Flow transformation on an Isotropic Gaussian Distribution.
+
+![](images/715541dcd4b68908b5450acb1957efa92eaa7c782b086309478582bdee08df86.jpg)  
+Figure 6: A DMP executed on the Arm-Ball environment.
+
+# C EXPERIMENTAL ENVIRONMENTS
+
+The following environments were considered:
+
+• Arm-Ball: A 7 joints arm, controlled in angular position, can move around in an environment containing a ball. The environment state is perceived visually as a $5 0 \mathrm { x } 5 0$ pixels image. The arm has a sticky arm tip: if the tip of the arm touches the ball, the ball sticks to the arm until the end of the movement. The underlying state of the environment is hence parameterized by two bounded continuous factors which represent the coordinates of the ball. A situation can be sampled by the experimenter by taking a random point in $[ 0 , 1 ] ^ { 2 }$ .
+
+• Arm-Arrow: The same arm can manipulate an arrow in a plane, an arrow being considered as an object with a single symmetry that can be oriented in space. Consequently, the underlying state of the environment is parameterized by two bounded continuous factors representing the coordinates of the arrow , and one periodic continuous factor representing its orientation. A particular situation can hence be sampled by taking a random point in $[ 0 , 1 ] ^ { 3 }$ .
+
+The physical situations were represented by small $7 0 \mathrm { x } 7 0$ images very similar to the dSprites dataset proposed by Higgins et al. $( 2 0 \dot { 1 } 6 ) ^ { 1 5 }$ . The arm was not depicted in the field of view of the (virtual) camera used to gather images for representation learning. We used a robotic arm composed of 7 joints, whose motions were parameterized by DMPs using 3 basis functions (hence action policies have 21 continuous parameters), during 50 time-steps. An example of such a DMP executed in the environment is represented in Figure 6. The first phase, where the learner observes changes of the environment $\left( = \right.$ ball moves) caused by another agent, is modeled by a process which samples iteratively a random state in the underlying state space, e.g. in the case of Arm-Ball $s \sim \mathcal { U } ( [ 0 , \bar { 1 } ] ^ { 2 } )$ , and then generating the corresponding image $x = f ( s )$ that is observed by the learner.
+
+# D ALGORITHMIC IMPLEMENTATION
+
+For the experiments, we instantiated the Algorithmic Architecture 1 into Algorithm 3.
+
+In the text, Algorithm 3 is denoted (RGE- $\star$ ), where $\star$ denotes any representation learning algorithm: (RGE-AE) for Auto-Encoders, (RGE-VAE) for Variational Auto-Encoders, (RGE-RFVAE)
+
+for Radial Flow Variational Auto-Encoders, (RGE-ISOMAP) for Isomap, (RGE-PCA) for Principal Component Analysis and (RGE-FI) for Full Information.
+
+Algorithm 3: Random Goal Exploration with Unsupervised Goal Space Learning
+
+# Input:
+
+$k$ -neighbors regressor $\tilde { D }$ , History $\mathcal { H }$ , Meta-Policy $\Pi$ is a tabular minimization over $\mathcal { H }$ ,   
+Unsupervised representation learning algorithm $\mathcal { A }$ (e.g. AE, VAE, Isomap), Kernel Density   
+Estimator algorithm $\kappa D \mathcal { E }$ , Random exploration noise $\gamma _ { m }$ , Random exploration ratio $\Gamma _ { e }$   
+1 begin   
+2 for 10000 Observation Iterations do   
+3 Observe a random environment image $x _ { i }$   
+4 Add this image to a database $\mathcal { D } = \{ x _ { i } \} _ { i \in [ 0 , 1 0 0 0 0 ] }$ 1   
+5 Learn an embedding function ${ \tilde { R } } : { \mathrm { ~ } } x \to o$ using algorithm $\mathcal { A }$ on data $\mathcal { D }$   
+6 Estimate the outcome distribution $p _ { k d e } ( o )$ from $\{ \tilde { R } ( x _ { i } ) \} _ { i \in [ 0 , 1 0 0 0 0 ] }$ using algorithm $\kappa D \mathcal { E }$   
+7 Set the Goal Policy $\gamma = p _ { k d e }$ to be the estimated outcome distribution   
+8 for 100 Bootstrapping iterations do   
+9 Sample a random parameterization $\theta _ { i } \sim p ( \theta )$   
+10 Execute the experiment $\theta _ { i }$ $\stackrel {  } { = }$ run a controller with parameters $\theta _ { i }$ )   
+11 Retrieve the outcome from raw image $o _ { i } = \tilde { R } ( x _ { i } )$   
+12 Update the forward model with ${ \tilde { D } } ( \theta _ { i } ) \triangleq o _ { i }$   
+13 ${ \mathcal { H } } = { \mathcal { H } } \cup \{ \theta , o \}$   
+14 for 5000 Exploration iterations do   
+15 if $u \sim \mathcal { U } ( 0 , 1 ) < \Gamma _ { e }$ then   
+16 Sample a random parameterization $\theta _ { i } \sim p ( \theta )$   
+17 else   
+18 Sample a goal $g _ { i } \sim \gamma$   
+19 Sample an exploration noise $\epsilon \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$   
+20 Execute $\Pi$ to find $\begin{array} { r } { \theta _ { i } = \arg \operatorname* { m i n } _ { \theta \in \mathcal { H } } C _ { \tau } \big ( D _ { r u n n i n g } ( \theta ) \big ) } \end{array}$   
+21 $\theta _ { i } = \theta _ { i } + \epsilon$   
+22 Execute the experiment $\theta _ { i }$   
+23 Retrieve the outcome from raw image $o _ { i } = \tilde { R } ( x _ { i } )$   
+24 Update the forward model with ${ \tilde { D } } ( \theta _ { i } ) \triangleq o _ { i }$   
+25 ${ \mathcal { H } } = { \mathcal { H } } \cup \{ \theta , o \}$
+
+26 return The forward model $\tilde { D }$ , the history $\mathcal { H }$ and the embedding $\tilde { R }$
+
+# E DETAILS OF NEURAL ARCHITECTURES
+
+Fig. 7 shows the neural networks architectures used for Deep Representation Learning algorithms.   
+Those architectures are based on the one proposed in Higgins et al. (2016).
+
+Auto-Encoder The architecture was trained directly without particular stacking. The AdaGrad optimizer was used, with initial learning rate of $1 e - 3$ , with batches of size 100, until convergence at $2 e 5$ epochs.
+
+Variational Auto-Encoder The architecture was trained with a deterministic warm-up of 1e4 epochs, as proposed in Sonderby et al. (2016), which shows improved convergence rate. The Adam optimizer was used, with initial learning rate of $1 e - 3$ , with batches of size 100, until convergence at 1e5 epochs.
+
+Radial Flow Variational Auto-Encoder The architecture was trained with a deterministic warm$u p$ of 1e4 epochs. The complete flow was made out of 10 planar flows as proposed in Rezende & Mohamed (2015), whose parameters were learned by the encoder. The Adam optimizer was used, with initial learning rate of $1 e - 3$ , with batches of size 100, until convergence at 5e4 epochs.
+
+![](images/3d04205b518ddbce21bf050d9a72e00b69013d3ebb1ba20c0ee65e8fdce3488d.jpg)  
+Figure 7: Layers of the different neural networks architectures.
+
+![](images/e1e2de9822475b327756186a9236031286ed902c55c8c78955e46dd4c03f4ce3.jpg)  
+(a) Rge-Ae - 10 Latents
+
+![](images/d5b6034fdf10b022e4355b93007688b21282fa5d8ddaaebce248187ff2c1df67.jpg)  
+(b) Rge-Ae - 2 Latents
+
+![](images/5f78d35d0ad91636510b2a53127ab1326a50698efd3b9c6286ef7f22c854aa0a.jpg)  
+(c) Rge-Pca - 10 Latents
+
+![](images/eb48dcbb3ab167186ff17e11cc9ee03a1a2bc73ec698cff3308faf17dabff23b.jpg)  
+Figure 8: Examples of achieved outcomes related with the evolution of KL-Coverage in the ArmBall environments. The number of times the ball was effectively handled is also represented.
+
+![](images/3a48435b62e816beaa1e7e70ba0fde73b9db96cb9e0422fc813fc22d3c700aee.jpg)  
+(a) Rge-Isomap - 10 Latents
+
+![](images/2e384b32eb85ab3528ffb4a86df2ef69e7ded3294767066c518ae62c4e7e3417.jpg)  
+(b) Rge-Isomap - 2 Latents
+
+![](images/46f646c6bc5a3f679e9a0c2cbef28b9d8ce6c8e9821be30ff72cf212d5ace7fb.jpg)  
+(c) Rge-Vae - 2 Latents
+
+![](images/055415f8f45f7ca7b517af3a52ab5a69317de60a2c65786378ef701f9ee9c33d.jpg)  
+Figure 9: Examples of achieved outcomes related with the evolution of KL-Coverage in the ArmBall environments. The number of times the ball was effectively handled is also represented.

parse/train/rye7knCqK7/rye7knCqK7.md

@@ -0,0 +1,336 @@
+# LEARNING WHEN TO COMMUNICATE AT SCALE INMULTIAGENT COOPERATIVE AND COMPETITIVETASKS
+
+Tushar Jain∗ New York University tushar@nyu.edu
+
+Amanpreet Singh∗ New York University Facebook AI Research† amanpreet@nyu.edu
+
+Sainbayar Sukhbaatar New York University Facebook AI Research† sainbar@cs.nyu.edu
+
+# ABSTRACT
+
+Learning when to communicate and doing that effectively is essential in multi-agent tasks. Recent works show that continuous communication allows efficient training with back-propagation in multiagent scenarios, but have been restricted to fullycooperative tasks. In this paper, we present Individualized Controlled Continuous Communication Model (IC3Net) which has better training efficiency than simple continuous communication model, and can be applied to semi-cooperative and competitive settings along with the cooperative settings. IC3Net controls continuous communication with a gating mechanism and uses individualized rewards for each agent to gain better performance and scalability while fixing credit assignment issues. Using variety of tasks including StarCraft BroodWarsTM explore and combat scenarios, we show that our network yields improved performance and convergence rates than the baselines as the scale increases. Our results convey that IC3Net agents learn when to communicate based on the scenario and profitability.
+
+# 1 INTRODUCTION
+
+Communication is an essential element of intelligence as it helps in learning from others experience, work better in teams and pass down knowledge. In multi-agent settings, communication allows agents to cooperate towards common goals. Particularly in partially observable environments, when the agents are observing different parts of the environment, they can share information and learnings from their observation through communication.
+
+Recently, there have been a lot of success in the field of reinforcement learning (RL) in playing Atari Games (Mnih et al., 2015) to playing Go (Silver et al., 2016), most of which have been limited to the single agent domain. However, the number of systems and applications having multi-agents have been growing (Lazaridou et al., 2017; Mordatch & Abbeel, 2018); where size can be from a team of robots working in manufacturing plants to a network of self-driving cars. Thus, it is crucial to successfully scale RL to multi-agent environments in order to build intelligent systems capable of higher productivity. Furthermore, scenarios other than cooperative, namely semi-cooperative (or mixed) and competitive scenarios have not even been studied as extensively for multi-agent systems.
+
+The mixed scenarios can be compared to most of the real life scenarios as humans are cooperative but not fully-cooperative in nature. Humans work towards their individual goals while cooperating with each other. In competitive scenarios, agents are essentially competing with each other for better rewards. In real life, humans always have an option to communicate but can choose when to actually communicate. For example, in a sports match two teams which can communicate, can choose to not communicate at all (to prevent sharing strategies) or use dishonest signaling (to misdirect opponents) (Lehman et al., 2018) in order to optimize their own reward and handicap opponents; making it important to learn when to communicate.
+
+Teaching agents how to communicate makes it is unnecessary to hand code the communication protocol with expert knowledge (Sukhbaatar et al., 2016)(Kottur et al., 2017). While the content of communication is important, it is also important to know when to communicate either to increase scalability and performance or to increase competitive edge. For example, a prey needs to learn when to communicate to avoid communicating its location with predators.
+
+Sukhbaatar et al. (2016) showed that agents communicating through a continuous vector are easier to train and have a higher information throughput than communication based on discrete symbols. Their continuous communication is differentiable, so it can be trained efficiently with back-propagation. However, their model assumes full-cooperation between agents and uses average global rewards. This restricts the model from being used in mixed or competitive scenarios as full-cooperation involves sharing hidden states to everyone; exposing everything and leading to poor performance by all agents as shown by our results. Furthermore, the average global reward for all agents makes the credit assignment problem even harder and difficult to scale as agents don’t know their individual contributions in mixed or competitive scenarios where they want themselves to succeed before others.
+
+To solve above mentioned issues, we make the following contributions:
+
+1. We propose Individualized Controlled Continuous Communication Model (IC3Net), in which each agent is trained with its individualized reward and can be applied to any scenario whether cooperative or not.   
+2. We empirically show that based on the given scenario–using the gating mechanism–our model can learn when to communicate. The gating mechanism allows agents to block their communication; which is useful in competitive scenarios.   
+3. We conduct experiments on different scales in three chosen environments including StarCraft and show that IC3Net outperforms the baselines with performance gaps that increase with scale. The results show that individual rewards converge faster and better than global rewards.
+
+# 2 RELATED WORK
+
+The simplest approach in multi-agent reinforcement learning (MARL) settings is to use an independent controller for each agent. This was attempted with Q-learning in Tan (1993). However, in practice it performs poorly (Matignon et al., 2012), which we also show in comparison with our model. The major issue with this approach is that due to multiple agents, the stationarity of the environment is lost and naïve application of experience replay doesn’t work well.
+
+The nature of interaction between agents can either be cooperative, competitive, or a mix of both. Most algorithms are designed only for a particular nature of interaction, mainly cooperative settings (Omidshafiei et al., 2017; Lauer & Riedmiller, 2000; Matignon et al., 2007), with strategies which indirectly arrive at cooperation via sharing policy parameters (Gupta et al., 2017). These algorithms are generally not applicable in competitive or mixed settings. See Busoniu et al. (2008) for survey of MARL in general and Panait & Luke (2005) for survey of cooperative multi-agent learning.
+
+Our work can be considered as an all-scenario extension of Sukhbaatar et al. (2016)’s CommNet for collaboration among multiple agents using continuous communication; usable only in cooperative settings as stated in their work and shown by our experiments. Due to continuous communication, the controller can be learned via backpropagation. However, this model is restricted to fully cooperative tasks as hidden states are fully communicated to others which exposes everything about agent. On the other hand, due to global reward for all agents, CommNet also suffers from credit assignment issue.
+
+The Multi-Agent Deep Deterministic Policy Gradient (MADDPG) model presented by Lowe et al. (2017) also tries to achieve similar goals. However, they differ in the way of providing the coordination signal. In their case, there is no direct communication among agents (actors with different policy per agent), instead a different centralized critic per agent – which can access the actions of all the agents – provides the signal. Concurrently, a similar model using centralized critic and decentralized actors with additional counterfactual reward, COMA by Foerster et al. (2018) was proposed to tackle the challenge of multiagent credit assignment by letting agents know their individual contributions.
+
+Vertex Attention Interaction Networks (VAIN) (Hoshen, 2017) also models multi-agent communication through the use of Interaction Networks (Battaglia et al., 2016) with attention mechanism (Bahdanau et al., 2015) for predictive modelling using supervised settings. The work by Foerster et al. (2016b) also learns a communication protocol where agents communicate in a discrete manner through their actions. This contrasts with our model where multiple continuous communication cycles can be used at each time step to decide the actions of all agents. Furthermore, our approach is amenable to dynamic number of agents. Peng et al. (2017) also attempts to solve micromanagement tasks in StarCraft using communication. However, they have non-symmetric addition of agents in communication channel and are restricted to only cooperative scenarios.
+
+In contrast, a lot of work has focused on understanding agents’ communication content; mostly in discrete settings with two agents (Wang et al., 2016; Havrylov & Titov, 2017; Kottur et al., 2017; Lazaridou et al., 2017; Lee et al., 2018). Lazaridou et al. (2017) showed that given two neural network agents and a referential game, the agents learn to coordinate. Havrylov & Titov (2017) extended this by grounding communication protocol to a symbols’s sequence while Kottur et al. (2017) showed that this language can be made more human-like by placing certain restrictions. Lee et al. (2018) demonstrated that agents speaking different languages can learn to translate in referential games.
+
+# 3 MODEL
+
+![](images/64d6af336cb2cedd34597f69a28af258797e370061c9367795362f1eb99ac896.jpg)  
+Figure 1: An overview of IC3Net. (Left) In-depth view of a single communication step. LSTM gets hidden state, $h _ { t }$ and cell state, $s _ { t }$ (not shown) from previous time-step. Hidden state $h _ { t }$ is passed to Communication-Action module $f _ { g }$ for a communication binary action $g _ { t }$ . Finally, communication vector $c _ { t }$ is calculated by averaging hidden states of other active agents gated by their communication action $a c _ { t }$ and is passed through a linear transformation C before fed to LSTM along with the observation. (Right) High-level view of IC3Net which optimizes individual rewards $r ^ { t }$ for each agent based on observation $o ^ { t }$ .
+
+In this section, we introduce our model Individualized Controlled Continuous Communication Model (IC3Net) as shown in Figure 1 to work in multi-agent cooperative, competitive and mixed settings where agents learn what to communicate as well as when to communicate.
+
+First, let us describe an independent controller model where each agent is controlled by an individual LSTM. For the j-th agent, its policy takes the form of:
+
+$$
+\begin{array} { r c l } { { h _ { j } ^ { t + 1 } , s _ { j } ^ { t + 1 } } } & { { = } } & { { L S T M ( e ( o _ { j } ^ { t } ) , h _ { j } ^ { t } , s _ { j } ^ { t } ) } } \\ { { a _ { j } ^ { t } } } & { { = } } & { { \pi ( h _ { j } ^ { t } ) , } } \end{array}
+$$
+
+where $o _ { j } ^ { t }$ is the observation of the ${ \bf j }$ -th agent at time $t$ , $e ( \cdot )$ is an encoder function parameterized by a fully-connected neural network and $\pi$ is an agent’s action policy. Also, ${ \mathit { h } } _ { { j } } ^ { t }$ and $s _ { j } ^ { t }$ are the hidden and cell states of the LSTM. We use the same LSTM model for all agents, sharing their parameters. This way, the model is invariant to permutations of the agents.
+
+IC3Net extends this independent controller model by allowing agents to communicate their internal state, gated by a discrete action. The policy of the j-th agent in a IC3Net is given by
+
+$$
+\begin{array} { r c l } { { g _ { j } ^ { t + 1 } } } & { { = } } & { { f ^ { g } ( h _ { j } ^ { t } ) } } \\ { { h _ { j } ^ { t + 1 } , s _ { j } ^ { t + 1 } } } & { { = } } & { { L S T M ( e ( o _ { j } ^ { t } ) + c _ { j } ^ { t } , h _ { j } ^ { t } , s _ { j } ^ { t } ) } } \\ { { c _ { j } ^ { t + 1 } } } & { { = } } & { { \displaystyle \frac { 1 } { J - 1 } C \sum _ { j ^ { \prime } \neq j } h _ { j ^ { \prime } } ^ { t + 1 } \odot g _ { j ^ { \prime } } ^ { t + 1 } } } \\ { { a _ { j } ^ { t } } } & { { = } } & { { \pi ( h _ { j } ^ { t } ) , } } \end{array}
+$$
+
+where $c _ { j } ^ { t }$ is the communication vector for the $j$ -th agent, $C$ is a linear transformation matrix for transforming gated average hidden state to a communication tensor, $J$ is the number of alive agents currently present in the system and $f ^ { g } ( . )$ is a simple network containing a soft-max layer for 2 actions (communicate or not) on top of a linear layer with non-linearity. The binary action $g _ { j } ^ { t }$ specifies whether agent $j$ wants to communicate with others, and act as a gating function when calculating the communication vector. Note that the gating action for next time-step is calculated at current time-step. We train both the action policy $\pi$ and the gating function $f ^ { g }$ with REINFORCE (Williams, 1992).
+
+In Sukhbaatar et al. (2016), individual networks controlling agents were interconnected, and they as a whole were considered as a single big neural network. This single big network controller approach required a definition of an unified loss function during training, thus making it impossible to train agents with different rewards.
+
+In this work, however, we move away from the single big network controller approach. Instead, we consider multiple big networks with shared parameters each controlling a single agent separately. Each big network consists of multiple LSTM networks, each processing an observation of a single agent. However, only one of the LSTMs need to output an action because the big network is only controlling a single agent. Although this view has a little effect on the implementation (we can still use a single big network in practice), it allows us to train each agent to maximize its individual reward instead of a single global reward. This has two benefits: (i) it allows the model to be applied to both cooperative and competitive scenarios, (ii) it also helps resolve the credit assignment issue faced by many multi-agent (Sukhbaatar et al., 2016; Foerster et al., 2016a) algorithms while improving performance with scalability and is coherent with the findings in Chang et al. (2003).
+
+# 4 EXPERIMENTS1
+
+We study our network in multi-agent cooperative, mixed and competitive scenarios to understand its workings. We perform experiments to answer following questions:
+
+1. Can our network learn the gating mechanism to communicate only when needed according to the given scenario? Essentially, is it possible to learn when to communicate?   
+2. Does our network using individual rewards scales better and faster than the baselines? This would clarify, whether or not, individual rewards perform better than global rewards in multi-agent communication based settings.
+
+We first analyze gating action’s $\left( g _ { t } \right)$ working. Later, we train our network in three chosen environments with variations in difficulty and coordination to ensure scalability and performance.
+
+# 4.1 ENVIRONMENTS
+
+We consider three environments for our analysis and experiments. (i) a predator-prey environment $( \mathbf { P P } )$ where predators with limited vision look for a prey on a square grid. (ii) a traffic junction environment (TJ) similar to Sukhbaatar et al. (2016) where agents with limited vision must learn to communicate in order to avoid collisions. (iii) StarCraft BroodWars2 (SC) explore and combat tasks which test control on multiple agents in various scenarios where agent needs to understand and decouple observations for multiple opposing units.
+
+![](images/fc7a299164b5d74fb63d2721ff4d4579e2cbafdc52cc40a4d272a39b6e223b46.jpg)  
+Figure 2: Environments’ Visualizations. (Left) $1 0 \times 1 0$ version of predator-prey task where 5 predators(red circles) with limited vision of size 1 (blue region) try to catch a randomly initialized fixed prey (green circle). (Center and Right) Easy and medium versions of traffic junction task where cars have to cross the the whole path minimizing collisions using two actions, gas and brake respectively. Agents have zero vision and can only observe their own location. (Right) In medium version, chances of collision are increased due to more possible routes and increased number of cars.
+
+# 4.1.1 PREDATOR PREY
+
+In this task, we have $n$ predators (agents) with limited vision trying to find a stationary prey. Once a predator reaches a prey, it stays there and always gets a positive reward, until end of episode (rest of the predators reach prey, or maximum number of steps). In case of zero vision, agents don’t have a direct way of knowing prey’s location unless they jump on it.
+
+We design three cooperation settings (competitive, mixed and cooperative) for this task with different reward structures to test our network. See Appendix 6.3 for details on grid, reward structure, observation and action space. There is no loss or benefit from communicating in mixed scenario. In competitive setting, agents get lower rewards if other agents reach the prey and in cooperative setting, reward increases as more agents reach the prey. We compare with baselines using mixed settings in subsection 4.3.2 while explicitly learning and analyzing gating action’s working in subsection 4.2.
+
+We create three levels for this environment – as mentioned in Appendix $6 . 3 \textrm { -- }$ to compare our network’s performance with increasing number of agents and grid size. $1 0 \times 1 0$ grid version with 5 agents is shown in Figure 2 (left). All agents are randomly placed in the grid at start of an episode.
+
+# 4.1.2 TRAFFIC JUNCTION
+
+Following Sukhbaatar et al. (2016), we test our model on the traffic junction task as it is a good proxy for testing whether communication is working. This task also helps in supporting our claim that IC3Net provides good performance and faster convergence in fully-cooperative scenarios similar to mixed ones. In the traffic junction, cars enter a junction from all entry points with a probability $p _ { a r r }$ . The maximum number of cars at any given time in the junction is limited. Cars can take two actions at each time-step, gas and brake respectively. The task has three difficulty levels (see Figure 2) which vary in the number of possible routes, entry points and junctions. We make this task harder by always setting vision to zero in all the three difficulty levels to ensure that task is not solvable without communication. See Appendix 6.4 for details on reward structure, observation and training.
+
+# 4.1.3 STARCRAFT: BROODWARS
+
+To fully understand the scalability of our architecture in more realistic and complex scenarios, we test it on StarCraft combat and exploration micro-management tasks in partially observable settings. StarCraft is a challenging environment for RL because it has a large observation-action space, many different unit types and stochasticity. We train our network on Combat and Explore task. The task’s difficulty can be altered by changing the number of our units, enemy units and the map size.
+
+![](images/a7686b7a8eee149a51ca08e31963b08150082506f691da658f318fb992ba134b.jpg)  
+Figure 3: Learning the Gating Action: Plots show gating action $g _ { t }$ for predators and prey averaged over each epoch in PP. In cooperative setting (a, e) agent almost always communicate to increase their own reward. In $\mathbf { ( b ) }$ mixed setting and (c) competitive setting, predators only communicate when necessary and profitable. As is evident from (f), they stop communicating once they reach prey. In all cases, prey almost never communicates with predators as it is not profitable for it. Similarly, in competitive scenario (d) for SC, team agents learn to communicate only when necessary due to the division of reward when near enemy, while enemy agent learns not to communicate as in PP.
+
+By default, the game has macro-actions which allow a player to directly target an enemy unit which makes player’s unit find the best possible path using the game’s in-built path-finding system, move towards the target and attack when it is in a range. However, we make the task harder by (i) removing macro-actions making exploration harder (ii) limiting vision making environment partially observable(iii) unlike previous works (Wender & Watson, 2012; Ontanón et al., 2013; Usunier et al., 2017; Peng et al., 2017), initializing enemy and our units at random locations in a fixed size square on the map, which makes it challenging to find enemy units. Refer to Appendix 6.5.1 for reward, action, observation and task details. We consider two types of tasks in StarCraft:
+
+Explore: In this task, we have $n$ agents trying to explore the map and find an enemy unit. This is a direct scale-up of the PP but with more realistic and stochastic situations.
+
+Combat: We test an agent’s capability to execute a complex task of combat in StarCraft which require coordination between teammates, exploration of a terrain, understanding of enemy units and formalism of complex strategies. We specifically test a team of $n$ agents trying to find and kill a team of $m$ enemies in a partially observable environment similar to the explore task. The agents, with their limited vision, must find the enemy units and kill all of them to score a win. More information on reward structure, observation and setup can be found in Appendix 6.5.1 and 6.5.2.
+
+# 4.2 ANALYSIS OF THE GATING MECHANISM
+
+We analyze working of gating action $\left( g _ { t } \right)$ in IC3Net by using cooperative, competitive and mixed settings in Predator-Prey (4.1.1) and StarCraft explore tasks (4.1.3). However, this time the enemy unit (prey) shares parameters with the predators and is trained with them. All of the enemy unit’s actions are noop which makes it stationary. The enemy unit gets a positive reward equivalent to $r _ { t i m e }$ $= 0 . 0 5$ per timestep until no predator/medic is captures it; after that it gets a reward of 0.
+
+For $5 \times 5$ grid in PP task, Figure 3 shows gating action (averaged per epoch) in all scenarios for (i) communication between predator and (ii) communication between prey and predators. We also test on $5 0 \times 5 0$ map size for competitive and cooperative StaraCraft explore task and found similar results (Fig. 3d). We can deduce following observations:
+
+• As can be observed in Figure 3a, 3b, 3c and 3d, in all the four cases, the prey learns not to communicate. If the prey communicates, predators will reach it faster. Since it will get 0 reward when an agent comes near or on top of it, it doesn’t communicate to achieve higher rewards.   
+• In cooperative setting (Figure 3a, 3e), the predators are openly communicating with $g$ close to 1. Even though the prey communicates with the predators at the start, it eventually learns not to communicate; so as not to share its location. As all agents are communicating in this setting, it takes more training time to adjust prey’s weights towards silence. Our preliminary tests suggest that in cooperative settings, it is beneficial to fix the gating action to 1.0 as communication is almost always needed and it helps in faster training by skipping the need to train the gating action.   
+• In the mixed setting (Figure 3b), agents don’t always communicate which corresponds to the fact that there is no benefit or loss by communicating in mixed scenario. The prey is easily able to learn not to communicate as the weights for predators are also adjusted towards non-cooperation from the start itself.   
+• As expected due to competition, predators rarely communicate in competitive setting (Figure 3c, 3d). Note that, this setting is not fully-adversarial as predators can initially explore faster if they communicate which can eventually lead to overall higher rewards. This can be observed as the agents only communicate while it’s profitable for them, i.e. before reaching the prey (Figure 3f)) as communicating afterwards can impact their future rewards.
+
+Experiments in this section, empirically suggest that agents can “learn to communicate when it is profitable”; thus allowing same network to be used in all settings.
+
+# 4.3 SCALABILITY AND GENERALIZATION EXPERIMENTS
+
+In this section, we look at bigger versions of our environments to understand scalability and generalization aspects of IC3Net.
+
+# 4.3.1 BASELINES
+
+For training details, refer to Appendix 6.1. We compare IC3Net with baselines specified below in all scenarios.
+
+Individual Reward Independent Controller (IRIC): In this controller, model is applied individually to all of the agents’ observations to produce the action to be taken. Essentially, this can be seen as IC3Net without any communication between agents; but with individualized reward for each agent. Note that no communication makes gating action $( g _ { t } )$ ineffective.
+
+Independent Controller (IC - IC3Net w/o Comm and IR): Like IRIC except the agents are trained with a global average reward instead of individual rewards. This will help us understand the credit assignment issue prevalent in CommNet.
+
+CommNet: Introduced in Sukhbaatar et al. (2016), CommNet allows communication between agents over a channel where an agent is provided with the average of hidden state representations of other agents as a communication signal. Like IC3Net, CommNet also uses continuous signals to communicate between the agents. Thus, CommNet can be considered as IC3Net without both the gating action $\left( g _ { t } \right)$ and individualized rewards.
+
+# 4.3.2 RESULTS
+
+We discuss major results for our experiments in this section and analyze particular behaviors/patterns of agents in Appendix 6.2.
+
+Predator Prey: Table 1 (left) shows average steps taken by the models to complete an episode i.e. find the prey in mixed setting (we found similar results for cooperative setting shown in appendix). IC3Net reaches prey faster than the baselines as we increase the number of agents as well as the size of the maze. In $2 0 \times 2 0$ version, the gap in average steps is almost 24 steps, which is a substantial improvement over baselines. Figure 4 (right) shows the scalability graph for IC3Net and CommNet which supports the claim that with the increasing number of agents, IC3Net converges faster at a better optimum than CommNet. Through these results on the PP task, we can see that compared to IC3Net, CommNet doesn’t work well in mixed scenarios. Finally, Figure 4 (left) shows the training plot of $2 0 \times 2 0$ grid with 10 agents trying to find a prey. The plot clearly shows the faster performance improvement of IC3Net in contrast to CommNet which takes long time to achieve a minor jump. We also find same pattern of the gating action values as in 4.2.
+
+![](images/707fd94f3ff80c5216e8f2bede5d69c635fd04667c5b7a65ee400ef6649652cf.jpg)  
+Figure 4: Result Plots for PP and TJ task. (Left) Average steps taken to complete an episode in $2 0 \times 2 0$ grid. (Center) IC3Net converges faster than CommNet as the number of predators (agents) increase in Predator-Prey environment. (Right) Success $\%$ in medium TJ task trained with curriculum. Performance and convergence of IC3Net is superior than baselines.
+
+Table 1: Predator Prey (Left): Avg. number of steps taken to complete the episode in three different environment sizes in mixed settings. IC3Net completes the episode faster than the baselines by finding the prey. Traffic Junction (Right): Success rate on various difficulty levels with zero vision for all. IC3Net provides better performance than baselines consistently especially as the scale increases.   
+
+<table><tr><td colspan="4">Predatory-Prey Mixed (Avg. Steps)</td><td colspan="4">Traffic Junction (Success %)</td></tr><tr><td>Model</td><td>5x5,n=3</td><td>10x10,n=5 20x20,n=10</td><td></td><td>Model</td><td>Easy</td><td>Medium</td><td>Hard</td></tr><tr><td>IRIC</td><td>16.5±0.1</td><td>28.1±0.2</td><td>75.0± 1.4</td><td>IRIC</td><td>29.8±0.7</td><td>3.4±0.5</td><td>35.0±0.6</td></tr><tr><td>IC</td><td>16.4± 0.49</td><td>28.0±0.74</td><td>77.4± 0.8</td><td>IC</td><td>30.2±0.4</td><td>3.4±0.5</td><td>47.0± 2.9</td></tr><tr><td>CommNet</td><td>9.1± 0.1</td><td>13.1±0.01</td><td>76.5± 1.3</td><td>CommNet</td><td>93.0± 4.2</td><td>54.3± 14.2</td><td>50.2±3.5</td></tr><tr><td>IC3Net</td><td>8.9± 0.02</td><td>13.0±0.02</td><td>52.4± 3.4</td><td>IC3Net</td><td>93.0± 3.7</td><td>89.3± 2.5</td><td>72.4± 9.6</td></tr></table>
+
+Traffic Junction: Table 1 (right) shows the success ratio for traffic junction. We fixed the gating action to 1 for TJ as discussed in 4.2. With zero vision, it is not possible to perform well without communication as evident by the results of IRIC and IC. Interestingly, IC performs better than IRIC in the hard case, as we believe without communication, the global reward in TJ acts as a better indicator of the overall performance. On the other hand, with communication and better knowledge of others, the global reward training face a credit assignment issue which is alleviated by IC3Net as evident by its superior performance compared to CommNet. In Sukhbaatar et al. (2016), well-performing agents in the medium and hard versions had vision $> 0$ . With zero vision, IC3Net is to CommNet and IRIC with a performance gap greater than $30 \%$ . This verifies that individualized rewards in IC3Net help achieve a better or similar performance than CommNet in fully-cooperative tasks with communication due to a better credit assignment.
+
+StarCraft: Table 2 displays win $\%$ and the average number of steps taken to complete an episode in StarCraft explore and combat tasks. We specifically test on (i) Explore task: 10 medics finding 1 enemy medic on $5 0 \times 5 0$ cell grid (ii) On $7 5 \times 7 5$ cell grid (iii) Combat task: 10 Marines vs 3 Zealots on $5 0 \mathrm { ~ x ~ } 5 0$ cell grid. Maximum steps in an episode are set to 60. The results on the explore task are similar to Predator-Prey as IC3Net outperforms the baselines. Moving to a bigger map size, we still see the performance gap even though performance drops for all the models.
+
+On the combat task, IC3Net performs comparably well to CommNet. A detailed analysis on IC3Net’s performance in StarCraft tasks is provided in Appendix 6.2.1. To confirm that 10 marines vs 3 zealots is hard to win, we run an experiment on reverse scenario where our agents control 3 Zealots initialized separately and enemies are 10 marines initialized together. We find that both IRIC and IC3Net reach a success percentage of $100 \%$ easily. We find that even in this case, IC3Net converges faster than IRIC.
+
+![](images/aabaafd3db9061a08fb600c175b8999ef12875c46df5546f71325121df48e5a9.jpg)  
+Figure 5: Average steps taken to complete an episode of StarCraft Explore10 Medic $5 0 \times 5 0$ task.
+
+Table 2: StarCraft Results: Win Ratio and average number of steps taken to complete episodes for explore (Exp) tasks with 10 Marines (M) on different grid sizes $( 5 0 \times 5 0$ and $7 5 \times 7 5$ ) and a combat (Cbt) task with 10 Marines (M) vs 3 Zealots $\mathrm { ( Z e ) }$ on a grid of size $5 0 \times 5 0$ . IC3Net beats the baselines with huge margin in case of exploration tasks, while it is as good as CommNet in case of 10 Marines vs 3 Zealots combat task.   
+
+<table><tr><td></td><td colspan="2">IRIC</td><td colspan="2">IC</td><td colspan="2">CommNet</td><td colspan="2">IC3Net</td></tr><tr><td>StarCraft task</td><td>Win %</td><td>Steps</td><td>Win %</td><td>Steps</td><td>Win %</td><td>Steps</td><td>Win %</td><td>Steps</td></tr><tr><td>Exp-10M 50 × 50</td><td>35.4± 1.7</td><td>52.7± 0.6</td><td>18.0± 1.63</td><td>55.5± 0.4</td><td>9.2± 3.12</td><td>58.4± 0.5</td><td>64.2± 17.7</td><td>41.2± 8.4</td></tr><tr><td>Exp-10M 75 × 75</td><td>9.0± 4.2</td><td>58.6±0.9</td><td>1.0±0.2</td><td>59.1±0.4</td><td>2.1±0.3</td><td>59.9± 0.1</td><td>17.0± 15.2</td><td>57.2±3.5</td></tr><tr><td>Cbt-10Mv3Ze</td><td>74.6± 5.1</td><td>35.0±0.8</td><td>51.8± 3.0</td><td>48.6± 0.4</td><td>88.0± 7.2</td><td>33.3± 1.2</td><td>87.4± 1.0</td><td>33.6±0.2</td></tr></table>
+
+# 5 CONCLUSIONS AND FUTURE WORK
+
+In this work, we introduced IC3Net which aims to solve multi-agent tasks in various cooperation settings by learning when to communicate. Its continuous communication enables efficient training by backpropagation, while the discrete gating trained by reinforcement learning along with individual rewards allows it to be used in all scenarios and on larger scale.
+
+Through our experiments, we show that IC3Net performs well in cooperative, mixed or competitive settings and learns to communicate only when necessary. Further, we show that agents learn to stop communication in competitive cases. We show scalability of our network by further experiments. In future, we would like to explore possibility of having multi-channel communication where agents can decide on which channel they want to put their information similar to communication groups but dynamic. It would be interesting to provide agents a choice of whether to listen to communication from a channel or not.
+
+Acknowledgements Authors would like to thank Zeming Lin for his consistent support and suggestions around StarCraft and TorchCraft.
+
+# REFERENCES
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. Proceedings of ICLR, 2015.
+
+Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. In Advances in neural information processing systems, pp. 4502–4510, 2016.
+
+Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning, ICML ’09, pp. 41–48, 2009.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Lucian Busoniu, Robert Babuska, and Bart De Schutter. A comprehensive survey of multiagent reinforcement learning. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 38(2):156–172, March 2008.
+
+Yu-Han Chang, Tracey Ho, and Leslie Pack Kaelbling. All learning is local: Multi-agent learning in global reward games. In Proceedings of the 16th International Conference on Neural Information Processing Systems, NIPS’03, pp. 807–814, 2003.
+
+Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems 29, pp. 2137–2145. 2016a.
+
+Jakob N Foerster, Yannis M Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate to solve riddles with deep distributed recurrent q-networks. arXiv preprint arXiv:1602.02672, 2016b.
+
+Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Jayesh K. Gupta, Maxim Egorov, and Mykel J. Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In Adaptive Learning Agents Workshop, 2017. doi: 10.1007/ 978-3-319-71682-4_5.
+
+Serhii Havrylov and Ivan Titov. Emergence of language with multi-agent games: learning to communicate with sequences of symbols. In Advances in Neural Information Processing Systems, pp. 2149–2159, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In Advances in Neural Information Processing Systems 30, pp. 2701–2711. 2017.
+
+Satwik Kottur, José Moura, Stefan Lee, and Dhruv Batra. Natural language does not emerge ‘naturally’in multi-agent dialog. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2962–2967, 2017.
+
+Martin Lauer and Martin Riedmiller. An algorithm for distributed reinforcement learning in cooperative multi-agent systems. In In Proceedings of the Seventeenth International Conference on Machine Learning, pp. 535–542. Morgan Kaufmann, 2000.
+
+Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In Proceedings of ICLR, 2017.
+
+Jason Lee, Kyunghyun Cho, Jason Weston, and Douwe Kiela. Emergent translation in multi-agent communication. In Proceedings of ICLR, 2018.
+
+Joel Lehman, Jeff Clune, Dusan Misevic, Christoph Adami, Julie Beaulieu, Peter J Bentley, Samuel Bernard, Guillaume Belson, David M Bryson, Nick Cheney, et al. The surprising creativity of digital evolution: A collection of anecdotes from the evolutionary computation and artificial life research communities. arXiv preprint arXiv:1803.03453, 2018.
+
+Ryan Lowe, YI WU, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems 30, pp. 6379–6390. 2017.
+
+L. Matignon, G. J. Laurent, and N. L. Fort-Piat. Hysteretic q-learning :an algorithm for decentralized reinforcement learning in cooperative multi-agent teams. In 2007 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 64–69, Oct 2007.
+
+Laetitia Matignon, Guillaume J Laurent, and Nadine Le Fort-Piat. Independent reinforcement learners in cooperative markov games: a survey regarding coordination problems. The Knowledge Engineering Review, 27(1):1–31, 2012.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518:529–533, 2015.
+
+Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Shayegan Omidshafiei, Jason Pazis, Christopher Amato, Jonathan P How, and John Vian. Deep decentralized multi-task multi-agent reinforcement learning under partial observability. pp. 2681– 2690, 2017.
+
+Santiago Ontanón, Gabriel Synnaeve, Alberto Uriarte, Florian Richoux, David Churchill, and Mike Preuss. A survey of real-time strategy game ai research and competition in starcraft. IEEE Transactions on Computational Intelligence and AI in games, 5(4):293–311, 2013.
+
+Liviu Panait and Sean Luke. Cooperative multi-agent learning: The state of the art. Autonomous agents and multi-agent systems, 11(3):387–434, 2005.
+
+Peng Peng, Quan Yuan, Ying Wen, Yaodong Yang, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent bidirectionally-coordinated nets for learning to play starcraft combat games. arXiv preprint arXiv:1703.10069, 2017.
+
+David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529:484–489, 2016.
+
+Sainbayar Sukhbaatar, Rob Fergus, et al. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems, pp. 2244–2252, 2016.
+
+Ming Tan. Multi-agent reinforcement learning: independent versus cooperative agents. In Proceedings of the Tenth International Conference on International Conference on Machine Learning, pp. 330– 337. Morgan Kaufmann Publishers Inc., 1993.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26–31, 2012.
+
+Nicolas Usunier, Gabriel Synnaeve, Zeming Lin, and Soumith Chintala. Episodic exploration for deep deterministic policies: An application to starcraft micromanagement tasks. In Proceedings of ICLR, 2017.
+
+Sida I Wang, Percy Liang, and Christopher D Manning. Learning language games through interaction. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 2368–2378, 2016.
+
+Stefan Wender and Ian Watson. Applying reinforcement learning to small scale combat in the real-time strategy game starcraft: Broodwar. In Computational Intelligence and Games (CIG), 2012 IEEE Conference on, pp. 402–408. IEEE, 2012.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+# 6 APPENDIX
+
+# 6.1 TRAINING DETAILS
+
+We set the hidden layer size to 128 units and we use LSTM (Hochreiter & Schmidhuber, 1997) with recurrence for all of the baselines and IC3Net. We use RMSProp (Tieleman & Hinton, 2012) with initial learning rate as a tuned hyper-parameter. All of the models use skip-connections (He et al., 2016). The training is distributed over 16 cores and each core runs a mini-batch till total episodes steps are 500 or more. We do 10 weight updates per epoch. We run predator-prey, StarCraft experiments for 1000 epochs, traffic junction experiment for 2000 epochs and report the final results. In mixed case, we report the mean score of all agents, while in cooperative case we report any agent’s score as they are same. We implement our model using PyTorch and environments using Gym (Brockman et al., 2016).We use REINFORCE (Williams, 1992) to train our setup. We conduct 5 runs on each of the tasks to compile our results. The training time for different tasks varies; StarCraft tasks usually takes more than a day (depends on number of agents and enemies), while predator-prey and traffic junction tasks complete under 12 hours.
+
+# 6.2 RESULTS ANALYSIS
+
+In this section, we analyze and discuss behaviors/patterns in the results on our experiments.
+
+# 6.2.1 IC3NET IN STARCRAFT-COMBAT TASK
+
+As observed in Table 2, IC3Net performs better than CommNet in explore task but doesn’t outperform it on Combat task. Our experiments and visualizations of actual strategy suggested that compared to exploration, combat can be solved far easily if the units learn to stay together. Focused firepower with more attack quantity in general results in quite good results on combat. We verify this hypothesis by running a heuristics baseline “attack closest” in which agents have full vision on map and have macro actions available3. By attacking the closest available enemy together the agents are able to kill zealots with success ratio of $7 6 . 6 \pm 8 $ calculated over 5 runs, even though initialized separately. Also, as described in Appendix 6.5.2, the global reward in case of win in Combat task is relatively huge compared to the individual rewards for killing other units. We believe that with coordination to stay together, huge global rewards and focus fire–which is achievable through simple cooperation–add up to CommNet’s performance in this task.
+
+Further, in exploration we have seen that agents go in separate direction and have individual rewards/sense of exploration which usually leads to faster exploration of an unexplored area. Thinking in simple terms, exploration of an house would be faster if different people handle different rooms. Achieving this is hard in CommNet because global rewards don’t exactly tell your individual contributions if you had explored separately. Also in CommNet, we have observed that agents follow a pattern where they get together at a point and explore together from that point which further signals that using CommNet, it is easy to get together for agents4.
+
+# 6.2.2 VARIANCE IN IC3NET
+
+In Figure 5, we have observed significant variance in IC3Net results for StarCraft. We performed a lot of experiments on StarCraft and can attribute the significant variance to stochasticity in the environment. There are a huge number of possible states in which agents can end up due to millions of possible interactions and their results in StarCraft. We believe it is hard to learn each one of them. This stochasticity variance can even be seen in simple heuristics baselines like “attack closest” (6.2.1) and is in-fact an indicator of how difficult is it to learn real-world scenarios which also have same amount of stochasticity. We believe that we don’t see similar variance in CommNet and other baselines because adding gating action increases the action-state-space combinations which yields better results while being difficult to learn sometimes. Further, this variance is only observed in higher Win $\%$ models which requires to learn more state spaces.
+
+# 6.2.3 COMMNET IN STARCRAFT-EXPLORE TASKS
+
+In Table 2, we can observe that CommNet performs worse than IRIC and IC in case of StarCraftExplore task. In this section, we provide a hypothesis for this result. First, we need to notice is that IRIC is better than IC also overall, which points to the fact that individualized reward are better than global rewards in case of exploration. This makes sense because if agents cover more area and know how much they covered through their own contribution (individual reward), it should lead to overall more coverage, compared to global rewards where agents can’t figure out their own coverage but instead overall one. Second, in case of CommNet, it is easy to communicate and get together. We observe this pattern in $\mathrm { C o m m N e t ^ { 4 } }$ where agents first get together at a point and then start exploring from there which leads to slow exploration, but IC is better in this respect because it is hard to gather at single point which inherently leads to faster exploration than CommNet. Third, the reward structure in the case of mixed scenario doesn’t appreciate searching together which is not directly visible to CommNet and IC due to global rewards.
+
+# 6.3 DETAILS OF PREDATOR PREY
+
+In all the three settings, cooperative, competitive and mixed, a predator agent gets a constant time-step penalty $r _ { e x p l o r e } = - 0 . 0 5$ , until it reaches the prey. This makes sure that agent doesn’t slack in finding the prey. In the mixed setting, once an agent reaches the prey, the agent always gets a positive reward $r _ { p r e y } = 0 . 0 5$ which doesn’t depend on the number of agents on prey. . Similarly, in the cooperative setting, an agent gets a positive reward of $r _ { c o o p } = r _ { p r e y } * n$ , and in the competitive setting, an agent gets a positive reward of $r _ { c o m p } = r _ { p r e y } / n$ after it reaches the prey, where $n$ is the number of agents on the prey. The total reward at time $t$ for an agent $i$ can be written as:
+
+$$
+r _ { i } ^ { p p } ( t ) = \delta _ { i } * r _ { e x p l o r e } + ( 1 - \delta _ { i } ) * n _ { t } ^ { \lambda } * r _ { p r e y } * | \lambda |
+$$
+
+where $\delta _ { i }$ denotes whether agent $i$ has found the prey or not, $n _ { t }$ is number of agents on prey at time-step $t$ and $\lambda$ is -1, 0 and 1 in the competitive, mixed and cooperative scenarios respectively. Maximum episode steps are set to 20, 40 and 80 for $5 \times 5$ , $1 0 \times 1 0$ and $2 0 \times 2 0$ grids respectively. The number of predators are 5, 10 and 20 in $5 { \times } 5$ , $1 0 \times 1 0$ and $2 0 \times 2 0$ grids respectively. Each predator can take one of the five basic movement actions i.e. up, down, lef t, right or stay. Predator, prey and all locations on grid are considered unique classes in vocabulary and are represented as one-hot binary vectors. Observation obs, at each point will be the sum of all one-hot binary vectors of location, predators and prey present at that point. With vision of 1, observation of each agent have dimension $\dot { 3 } ^ { 2 } \times | o b s |$ .
+
+# 6.3.1 EXTRA EXPERIMENTS
+
+<table><tr><td colspan="3">Predator Prey Cooperative (Avg. Rewards)</td></tr><tr><td>Model</td><td>5x5,n=3</td><td>10x10, n=5 20x20,n=10</td></tr><tr><td>IRIC</td><td>0.48±0.001 0.47± 0.009</td><td>4.08± 0.049 5.77± 0.130</td></tr><tr><td>IC</td><td>3.78± 0.082</td><td>4.99± 0.529</td></tr><tr><td>CommNet</td><td>1.56± 0.010 6.94± 0.020</td><td>19.99± 0.62</td></tr><tr><td>IC3Net</td><td>1.57± 0.008 6.85± 0.144</td><td>21.09± 0.579</td></tr></table>
+
+Table 3: Predator-Prey Cooperative: Avg. rewards in three difficulty levels of predator-prey environment in cooperative setting. IC3Net performs equivalently or better than baselines consistently.
+
+Table 3 shows the results for IC3Net and baselines in the cooperative scenario for the predator-prey environment. As the cooperative reward function provides more reward after a predator reaches the prey, the comparison is provided for rewards instead of average number of steps. IC3Net performs better or equal to CommNet and other baselines in all three difficulty levels. The performance gap closes in and increases as we move towards bigger grids which shows that IC3Net is more scalable due to individualized rewards. More importantly, even with the extra gating action training, IC3Net can perform comparably to CommNet which is designed for cooperative scenarios which suggests that IC3Net is a suitable choice for all cooperation settings.
+
+To analyze the effect of gating action on rewards in case of mixed scenario where individualized rewards alone can help a lot, we test Predator Prey mixed cooperation setting on $2 0 \mathbf { x } 2 0$ grid on a baseline in which we set gating action to 1 (global communication) and uses individual rewards $( \mathrm { I C 2 N e t / C o m m N e t + I R } )$ ). We find average max steps to be $5 0 . 2 4 \pm 3 . 4$ which is lower than IC3Net. This means that (i) individualized rewards help a lot in mixed scenarios by allowing agents to understand there contributions (ii) adding the gating action in this case has an overhead but allows the same model to work in all settings (even competitive) by “learning to communicate” which is more close to real-world humans with a negligible hit on the performance.
+
+# 6.4 DETAILS OF TRAFFIC JUNCTION
+
+Traffic junction’s observation vocabulary has one-hot vectors for all locations in the grid and car class. Each agent observes its previous action, route identifier and a vector specifying sum of one-hot vectors for all classes present at that agent’s location. Collision occurs when two cars are on same location. We set maximum number of steps to 20, 40 and 60 in easy, medium and hard difficulty respectively. Similar to Sukhbaatar et al. (2016), we provide a negative reward $r _ { c o l l } = - 1 0$ on collision. To cut off traffic jams, we provide a negative reward $\tau _ { i } r _ { t i m e } = - 0 . 0 1 \tau _ { i }$ where $\tau _ { i }$ is time spent by the agent in the junction at time-step $t$ . Reward for ith agent which is having $C _ { i } ^ { t }$ collisions at time-step $t$ can be written as:
+
+$$
+r _ { i } ^ { t j } ( t ) = r _ { c o l l } C _ { i } ^ { t } + r _ { t i m e } \tau _ { i }
+$$
+
+We utilized curriculum learning Bengio et al. (2009) to make the training process easier. The parrive is kept at the start value till the first 250 epochs and is then linearly increased till the end value during the course from 250th to 1250th epoch. The start and end values of $p _ { a r r i v e }$ for different difficulty levels are indicated in Table 4. Finally, training continues for another 750 epochs. The learning rate is fixed at 0.003 throughout. We also implemented three difficulty variations of the game explained as follows.
+
+<table><tr><td>Difficulty</td><td>P-arrive Start</td><td>End</td><td>N-total</td><td>Arrival Points</td><td>Routes per Entry Point</td><td>Two-Way</td><td> Junctions</td><td>Dimension</td></tr><tr><td>Easy</td><td>0.1</td><td>0.3</td><td>5</td><td>2</td><td>1</td><td>F</td><td>1</td><td>7×7</td></tr><tr><td>Medium</td><td>0.05</td><td>0.2</td><td>10</td><td>4</td><td>3</td><td>T</td><td>1</td><td>14×14</td></tr><tr><td>Hard</td><td>0.02</td><td>0.05</td><td>20</td><td>8</td><td>7</td><td>T</td><td>4</td><td>18×18</td></tr></table>
+
+Table 4: Traffic Junction: Variations in different traffic junction difficulty levels. T refers to True as in the difficulty level has 2-way roads and F refers to False as in the difficulty level has 1-way roads.
+
+The easy version is a junction of two one-way roads on a $7 \times 7$ grid. There are two arrival points, each with two possible routes and with a $N _ { t o t a l }$ value of 5.
+
+The medium version consists of two connected junctions of two-way roads in $1 4 \times 1 4$ as shown in Figure 2 (right). There are 4 arrival points and 3 different routes for each arrival point and have $N _ { t o t a l } = 2 0$ .
+
+The harder version consists of four connected junctions of two-way roads in $1 8 \times 1 8$ as shown in Figure 6. There are 8 arrival points and 7 different routes for each arrival point and have $N _ { t o t a l } = 2 0$
+
+# 6.4.1 IRIC AND IC PERFORMANCE
+
+In Table 1, we notice that IRIC and IC perform worst in medium level compared to the hard level. Our visualizations suggest that this is due to high final add-rate in case of medium version compared to hard version. Collisions happen much more often in medium version leading to less success rate (an episode is considered failure if a collision happens) compared to hard where initial add-rate is low to accommodate curriculum learning for hard version’s big grid size. The final add-rate in case of hard level is comparatively low to make sure that it is possible to pass a junction without a collision as with more entry points it is easy to collide even with a small add-rate.
+
+![](images/a0fd45cbb7d56cb27882def10fa95f27efdecc80600cb481d468e95f9a69b35e.jpg)  
+Figure 6: Hard difficulty level of traffic junction task. Level has four connected junctions, eight entry points and at each entry point there are 7 possible routes increasing chances of a collision. We use curriculum learning to successfully train our models on hard level.
+
+# 6.5 STARCRAFT DETAILS
+
+# 6.5.1 OBSERVATION AND ACTIONS
+
+Explore: To complete the explore task, agents must be within a particular range of enemy unit called explore vision. Once an agent is within explore vision of enemy unit, we noop further actions. The reward structure is same as the PP task with only difference being that an agent needs to be within the explore vision range of the enemy unit instead of being on same location to get a non-negative reward. We use medic units which don’t attack enemy units. This ensures that we can simulate our explore task without any of kind of combat happening and interfering with the goal of the task. Observation for each agent is its (absolute $x ,$ , absolute y) and enemy’s (relative x, relative y, visible) where visible, relative $x$ and relative $y$ are 0 when enemy is not in explore vision range. Agents have 9 actions to choose from which includes 8 basic directions and one stay action.
+
+Combat: Agent observes its own (absolute $x _ { i }$ , absolute y, healthpoints $^ +$ shield, weapon cooldown, previous action) and (relative $x ,$ relative y, visible, healthpoints $^ +$ shield, weapon cooldown) for each of the enemies. relative $x$ and relative $y$ are only observed when enemy is visible which is corresponded by visible flag. All of the observations are normalized to be in between $( 0 , 1 )$ . Agent has to choose from $9 + m$ actions which include 9 basic actions and 1 action for attacking each of the $m$ agents. Attack actions only work when the enemy is within the sight range of the agent, otherwise it is a noop. In combat, we don’t compare with prior work on StarCraft because our environment setting is much harder, restrictive, new and different, thus, not directly comparable.
+
+# 6.5.2 COMBAT REWARD
+
+To avoid slack in finding the enemy team, we provide a negative reward $r _ { t i m e } = - 0 . 0 1$ at each timestep when the agent is not involved in a combat. At each timestep, an agent gets as reward the difference between (i) its normalized health in current and previous timestep (ii) normalized health at previous timestep and current timestep for each of the enemies it has attacked till now. At the end of the episode, terminal reward for each agents consists of (i) all its remaining health $\ast _ { 3 }$ as negative reward (ii) $5 \ast m + \mathrm { a l l }$ its remaining health $\ast _ { 3 }$ as positive reward if agents win (iii) normalized remaining health $\ast _ { 3 }$ for all of the alive enemies as negative reward on lose. In this task, the group of enemies is initialized together randomly in one half of the map and our agents are initialized separately in other half which makes task even harder, thus requiring communication. For an automatic way of individualizing rewards, please refer to Foerster et al. (2018).
+
+# 6.5.3 EXAMPLE SEQUENCE OF STATES IN COOPERATIVE EXPLORE MOD
+
+We provide an example sequence of states in StarCraft cooperative explore mode in Figure 7. As soon as one of the agents finds the enemy unit, the other agents get the information about enemy’s location through communication and are able to reach it faster.
+
+![](images/54a6b0d9fecfd970701398e1e4c5c9cb733e24371e3b1eb71cfcb25d3c19ee1c.jpg)  
+Figure 7: State sequence in SC Cooperative Explore. We can see how agents which are randomly initialized communicate to reach the enemy faster. Once, some agents are near the prey and other reach very fast due to communication

parse/train/rye7knCqK7/rye7knCqK7_content_list.json

@@ -0,0 +1,1877 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING WHEN TO COMMUNICATE AT SCALE INMULTIAGENT COOPERATIVE AND COMPETITIVETASKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            823,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tushar Jain∗ New York University tushar@nyu.edu ",
+        "bbox": [
+            405,
+            219,
+            545,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Amanpreet Singh∗ New York University Facebook AI Research† amanpreet@nyu.edu ",
+        "bbox": [
+            183,
+            219,
+            352,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar New York University Facebook AI Research† sainbar@cs.nyu.edu ",
+        "bbox": [
+            598,
+            219,
+            777,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            314,
+            544,
+            329
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning when to communicate and doing that effectively is essential in multi-agent tasks. Recent works show that continuous communication allows efficient training with back-propagation in multiagent scenarios, but have been restricted to fullycooperative tasks. In this paper, we present Individualized Controlled Continuous Communication Model (IC3Net) which has better training efficiency than simple continuous communication model, and can be applied to semi-cooperative and competitive settings along with the cooperative settings. IC3Net controls continuous communication with a gating mechanism and uses individualized rewards for each agent to gain better performance and scalability while fixing credit assignment issues. Using variety of tasks including StarCraft BroodWarsTM explore and combat scenarios, we show that our network yields improved performance and convergence rates than the baselines as the scale increases. Our results convey that IC3Net agents learn when to communicate based on the scenario and profitability. ",
+        "bbox": [
+            233,
+            344,
+            766,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            336,
+            566
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Communication is an essential element of intelligence as it helps in learning from others experience, work better in teams and pass down knowledge. In multi-agent settings, communication allows agents to cooperate towards common goals. Particularly in partially observable environments, when the agents are observing different parts of the environment, they can share information and learnings from their observation through communication. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            651
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, there have been a lot of success in the field of reinforcement learning (RL) in playing Atari Games (Mnih et al., 2015) to playing Go (Silver et al., 2016), most of which have been limited to the single agent domain. However, the number of systems and applications having multi-agents have been growing (Lazaridou et al., 2017; Mordatch & Abbeel, 2018); where size can be from a team of robots working in manufacturing plants to a network of self-driving cars. Thus, it is crucial to successfully scale RL to multi-agent environments in order to build intelligent systems capable of higher productivity. Furthermore, scenarios other than cooperative, namely semi-cooperative (or mixed) and competitive scenarios have not even been studied as extensively for multi-agent systems. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The mixed scenarios can be compared to most of the real life scenarios as humans are cooperative but not fully-cooperative in nature. Humans work towards their individual goals while cooperating with each other. In competitive scenarios, agents are essentially competing with each other for better rewards. In real life, humans always have an option to communicate but can choose when to actually communicate. For example, in a sports match two teams which can communicate, can choose to not communicate at all (to prevent sharing strategies) or use dishonest signaling (to misdirect opponents) (Lehman et al., 2018) in order to optimize their own reward and handicap opponents; making it important to learn when to communicate. ",
+        "bbox": [
+            174,
+            776,
+            826,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Teaching agents how to communicate makes it is unnecessary to hand code the communication protocol with expert knowledge (Sukhbaatar et al., 2016)(Kottur et al., 2017). While the content of communication is important, it is also important to know when to communicate either to increase scalability and performance or to increase competitive edge. For example, a prey needs to learn when to communicate to avoid communicating its location with predators. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sukhbaatar et al. (2016) showed that agents communicating through a continuous vector are easier to train and have a higher information throughput than communication based on discrete symbols. Their continuous communication is differentiable, so it can be trained efficiently with back-propagation. However, their model assumes full-cooperation between agents and uses average global rewards. This restricts the model from being used in mixed or competitive scenarios as full-cooperation involves sharing hidden states to everyone; exposing everything and leading to poor performance by all agents as shown by our results. Furthermore, the average global reward for all agents makes the credit assignment problem even harder and difficult to scale as agents don’t know their individual contributions in mixed or competitive scenarios where they want themselves to succeed before others. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To solve above mentioned issues, we make the following contributions: ",
+        "bbox": [
+            174,
+            313,
+            640,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose Individualized Controlled Continuous Communication Model (IC3Net), in which each agent is trained with its individualized reward and can be applied to any scenario whether cooperative or not.   \n2. We empirically show that based on the given scenario–using the gating mechanism–our model can learn when to communicate. The gating mechanism allows agents to block their communication; which is useful in competitive scenarios.   \n3. We conduct experiments on different scales in three chosen environments including StarCraft and show that IC3Net outperforms the baselines with performance gaps that increase with scale. The results show that individual rewards converge faster and better than global rewards. ",
+        "bbox": [
+            176,
+            338,
+            825,
+            468
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            341,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The simplest approach in multi-agent reinforcement learning (MARL) settings is to use an independent controller for each agent. This was attempted with Q-learning in Tan (1993). However, in practice it performs poorly (Matignon et al., 2012), which we also show in comparison with our model. The major issue with this approach is that due to multiple agents, the stationarity of the environment is lost and naïve application of experience replay doesn’t work well. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The nature of interaction between agents can either be cooperative, competitive, or a mix of both. Most algorithms are designed only for a particular nature of interaction, mainly cooperative settings (Omidshafiei et al., 2017; Lauer & Riedmiller, 2000; Matignon et al., 2007), with strategies which indirectly arrive at cooperation via sharing policy parameters (Gupta et al., 2017). These algorithms are generally not applicable in competitive or mixed settings. See Busoniu et al. (2008) for survey of MARL in general and Panait & Luke (2005) for survey of cooperative multi-agent learning. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            680
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work can be considered as an all-scenario extension of Sukhbaatar et al. (2016)’s CommNet for collaboration among multiple agents using continuous communication; usable only in cooperative settings as stated in their work and shown by our experiments. Due to continuous communication, the controller can be learned via backpropagation. However, this model is restricted to fully cooperative tasks as hidden states are fully communicated to others which exposes everything about agent. On the other hand, due to global reward for all agents, CommNet also suffers from credit assignment issue. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Multi-Agent Deep Deterministic Policy Gradient (MADDPG) model presented by Lowe et al. (2017) also tries to achieve similar goals. However, they differ in the way of providing the coordination signal. In their case, there is no direct communication among agents (actors with different policy per agent), instead a different centralized critic per agent – which can access the actions of all the agents – provides the signal. Concurrently, a similar model using centralized critic and decentralized actors with additional counterfactual reward, COMA by Foerster et al. (2018) was proposed to tackle the challenge of multiagent credit assignment by letting agents know their individual contributions. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Vertex Attention Interaction Networks (VAIN) (Hoshen, 2017) also models multi-agent communication through the use of Interaction Networks (Battaglia et al., 2016) with attention mechanism (Bahdanau et al., 2015) for predictive modelling using supervised settings. The work by Foerster et al. (2016b) also learns a communication protocol where agents communicate in a discrete manner through their actions. This contrasts with our model where multiple continuous communication cycles can be used at each time step to decide the actions of all agents. Furthermore, our approach is amenable to dynamic number of agents. Peng et al. (2017) also attempts to solve micromanagement tasks in StarCraft using communication. However, they have non-symmetric addition of agents in communication channel and are restricted to only cooperative scenarios. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In contrast, a lot of work has focused on understanding agents’ communication content; mostly in discrete settings with two agents (Wang et al., 2016; Havrylov & Titov, 2017; Kottur et al., 2017; Lazaridou et al., 2017; Lee et al., 2018). Lazaridou et al. (2017) showed that given two neural network agents and a referential game, the agents learn to coordinate. Havrylov & Titov (2017) extended this by grounding communication protocol to a symbols’s sequence while Kottur et al. (2017) showed that this language can be made more human-like by placing certain restrictions. Lee et al. (2018) demonstrated that agents speaking different languages can learn to translate in referential games. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            292
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            320,
+            269,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/64d6af336cb2cedd34597f69a28af258797e370061c9367795362f1eb99ac896.jpg",
+        "image_caption": [
+            "Figure 1: An overview of IC3Net. (Left) In-depth view of a single communication step. LSTM gets hidden state, $h _ { t }$ and cell state, $s _ { t }$ (not shown) from previous time-step. Hidden state $h _ { t }$ is passed to Communication-Action module $f _ { g }$ for a communication binary action $g _ { t }$ . Finally, communication vector $c _ { t }$ is calculated by averaging hidden states of other active agents gated by their communication action $a c _ { t }$ and is passed through a linear transformation C before fed to LSTM along with the observation. (Right) High-level view of IC3Net which optimizes individual rewards $r ^ { t }$ for each agent based on observation $o ^ { t }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            366,
+            756,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce our model Individualized Controlled Continuous Communication Model (IC3Net) as shown in Figure 1 to work in multi-agent cooperative, competitive and mixed settings where agents learn what to communicate as well as when to communicate. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "First, let us describe an independent controller model where each agent is controlled by an individual LSTM. For the j-th agent, its policy takes the form of: ",
+        "bbox": [
+            173,
+            768,
+            821,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a9a960dda51dd5b8d8d6c0e86d77ccd3d078e153c3eebceef102555271bfa32.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { h _ { j } ^ { t + 1 } , s _ { j } ^ { t + 1 } } } & { { = } } & { { L S T M ( e ( o _ { j } ^ { t } ) , h _ { j } ^ { t } , s _ { j } ^ { t } ) } } \\\\ { { a _ { j } ^ { t } } } & { { = } } & { { \\pi ( h _ { j } ^ { t } ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            809,
+            630,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $o _ { j } ^ { t }$ is the observation of the ${ \\bf j }$ -th agent at time $t$ , $e ( \\cdot )$ is an encoder function parameterized by a fully-connected neural network and $\\pi$ is an agent’s action policy. Also, ${ \\mathit { h } } _ { { j } } ^ { t }$ and $s _ { j } ^ { t }$ are the hidden and cell states of the LSTM. We use the same LSTM model for all agents, sharing their parameters. This way, the model is invariant to permutations of the agents. ",
+        "bbox": [
+            174,
+            864,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "IC3Net extends this independent controller model by allowing agents to communicate their internal state, gated by a discrete action. The policy of the j-th agent in a IC3Net is given by ",
+        "bbox": [
+            169,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2146b3718612718f10344c7730fda4a4610d909276e7c0a7024eb7e31ab7a0d.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { g _ { j } ^ { t + 1 } } } & { { = } } & { { f ^ { g } ( h _ { j } ^ { t } ) } } \\\\ { { h _ { j } ^ { t + 1 } , s _ { j } ^ { t + 1 } } } & { { = } } & { { L S T M ( e ( o _ { j } ^ { t } ) + c _ { j } ^ { t } , h _ { j } ^ { t } , s _ { j } ^ { t } ) } } \\\\ { { c _ { j } ^ { t + 1 } } } & { { = } } & { { \\displaystyle \\frac { 1 } { J - 1 } C \\sum _ { j ^ { \\prime } \\neq j } h _ { j ^ { \\prime } } ^ { t + 1 } \\odot g _ { j ^ { \\prime } } ^ { t + 1 } } } \\\\ { { a _ { j } ^ { t } } } & { { = } } & { { \\pi ( h _ { j } ^ { t } ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            137,
+            648,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $c _ { j } ^ { t }$ is the communication vector for the $j$ -th agent, $C$ is a linear transformation matrix for transforming gated average hidden state to a communication tensor, $J$ is the number of alive agents currently present in the system and $f ^ { g } ( . )$ is a simple network containing a soft-max layer for 2 actions (communicate or not) on top of a linear layer with non-linearity. The binary action $g _ { j } ^ { t }$ specifies whether agent $j$ wants to communicate with others, and act as a gating function when calculating the communication vector. Note that the gating action for next time-step is calculated at current time-step. We train both the action policy $\\pi$ and the gating function $f ^ { g }$ with REINFORCE (Williams, 1992). ",
+        "bbox": [
+            173,
+            247,
+            825,
+            345
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Sukhbaatar et al. (2016), individual networks controlling agents were interconnected, and they as a whole were considered as a single big neural network. This single big network controller approach required a definition of an unified loss function during training, thus making it impossible to train agents with different rewards. ",
+        "bbox": [
+            174,
+            352,
+            825,
+            407
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, however, we move away from the single big network controller approach. Instead, we consider multiple big networks with shared parameters each controlling a single agent separately. Each big network consists of multiple LSTM networks, each processing an observation of a single agent. However, only one of the LSTMs need to output an action because the big network is only controlling a single agent. Although this view has a little effect on the implementation (we can still use a single big network in practice), it allows us to train each agent to maximize its individual reward instead of a single global reward. This has two benefits: (i) it allows the model to be applied to both cooperative and competitive scenarios, (ii) it also helps resolve the credit assignment issue faced by many multi-agent (Sukhbaatar et al., 2016; Foerster et al., 2016a) algorithms while improving performance with scalability and is coherent with the findings in Chang et al. (2003). ",
+        "bbox": [
+            173,
+            415,
+            825,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            331,
+            590
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We study our network in multi-agent cooperative, mixed and competitive scenarios to understand its workings. We perform experiments to answer following questions: ",
+        "bbox": [
+            173,
+            607,
+            823,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Can our network learn the gating mechanism to communicate only when needed according to the given scenario? Essentially, is it possible to learn when to communicate?   \n2. Does our network using individual rewards scales better and faster than the baselines? This would clarify, whether or not, individual rewards perform better than global rewards in multi-agent communication based settings. ",
+        "bbox": [
+            176,
+            647,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first analyze gating action’s $\\left( g _ { t } \\right)$ working. Later, we train our network in three chosen environments with variations in difficulty and coordination to ensure scalability and performance. ",
+        "bbox": [
+            173,
+            732,
+            823,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            777,
+            330,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider three environments for our analysis and experiments. (i) a predator-prey environment $( \\mathbf { P P } )$ where predators with limited vision look for a prey on a square grid. (ii) a traffic junction environment (TJ) similar to Sukhbaatar et al. (2016) where agents with limited vision must learn to communicate in order to avoid collisions. (iii) StarCraft BroodWars2 (SC) explore and combat tasks which test control on multiple agents in various scenarios where agent needs to understand and decouple observations for multiple opposing units. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc7a299164b5d74fb63d2721ff4d4579e2cbafdc52cc40a4d272a39b6e223b46.jpg",
+        "image_caption": [
+            "Figure 2: Environments’ Visualizations. (Left) $1 0 \\times 1 0$ version of predator-prey task where 5 predators(red circles) with limited vision of size 1 (blue region) try to catch a randomly initialized fixed prey (green circle). (Center and Right) Easy and medium versions of traffic junction task where cars have to cross the the whole path minimizing collisions using two actions, gas and brake respectively. Agents have zero vision and can only observe their own location. (Right) In medium version, chances of collision are increased due to more possible routes and increased number of cars. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            98,
+            818,
+            253
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            373,
+            823,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 PREDATOR PREY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            343,
+            434
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this task, we have $n$ predators (agents) with limited vision trying to find a stationary prey. Once a predator reaches a prey, it stays there and always gets a positive reward, until end of episode (rest of the predators reach prey, or maximum number of steps). In case of zero vision, agents don’t have a direct way of knowing prey’s location unless they jump on it. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We design three cooperation settings (competitive, mixed and cooperative) for this task with different reward structures to test our network. See Appendix 6.3 for details on grid, reward structure, observation and action space. There is no loss or benefit from communicating in mixed scenario. In competitive setting, agents get lower rewards if other agents reach the prey and in cooperative setting, reward increases as more agents reach the prey. We compare with baselines using mixed settings in subsection 4.3.2 while explicitly learning and analyzing gating action’s working in subsection 4.2. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We create three levels for this environment – as mentioned in Appendix $6 . 3 \\textrm { -- }$ to compare our network’s performance with increasing number of agents and grid size. $1 0 \\times 1 0$ grid version with 5 agents is shown in Figure 2 (left). All agents are randomly placed in the grid at start of an episode. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            641
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 TRAFFIC JUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            660,
+            361,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following Sukhbaatar et al. (2016), we test our model on the traffic junction task as it is a good proxy for testing whether communication is working. This task also helps in supporting our claim that IC3Net provides good performance and faster convergence in fully-cooperative scenarios similar to mixed ones. In the traffic junction, cars enter a junction from all entry points with a probability $p _ { a r r }$ . The maximum number of cars at any given time in the junction is limited. Cars can take two actions at each time-step, gas and brake respectively. The task has three difficulty levels (see Figure 2) which vary in the number of possible routes, entry points and junctions. We make this task harder by always setting vision to zero in all the three difficulty levels to ensure that task is not solvable without communication. See Appendix 6.4 for details on reward structure, observation and training. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 STARCRAFT: BROODWARS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            413,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To fully understand the scalability of our architecture in more realistic and complex scenarios, we test it on StarCraft combat and exploration micro-management tasks in partially observable settings. StarCraft is a challenging environment for RL because it has a large observation-action space, many different unit types and stochasticity. We train our network on Combat and Explore task. The task’s difficulty can be altered by changing the number of our units, enemy units and the map size. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7686b7a8eee149a51ca08e31963b08150082506f691da658f318fb992ba134b.jpg",
+        "image_caption": [
+            "Figure 3: Learning the Gating Action: Plots show gating action $g _ { t }$ for predators and prey averaged over each epoch in PP. In cooperative setting (a, e) agent almost always communicate to increase their own reward. In $\\mathbf { ( b ) }$ mixed setting and (c) competitive setting, predators only communicate when necessary and profitable. As is evident from (f), they stop communicating once they reach prey. In all cases, prey almost never communicates with predators as it is not profitable for it. Similarly, in competitive scenario (d) for SC, team agents learn to communicate only when necessary due to the division of reward when near enemy, while enemy agent learns not to communicate as in PP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            97,
+            828,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "By default, the game has macro-actions which allow a player to directly target an enemy unit which makes player’s unit find the best possible path using the game’s in-built path-finding system, move towards the target and attack when it is in a range. However, we make the task harder by (i) removing macro-actions making exploration harder (ii) limiting vision making environment partially observable(iii) unlike previous works (Wender & Watson, 2012; Ontanón et al., 2013; Usunier et al., 2017; Peng et al., 2017), initializing enemy and our units at random locations in a fixed size square on the map, which makes it challenging to find enemy units. Refer to Appendix 6.5.1 for reward, action, observation and task details. We consider two types of tasks in StarCraft: ",
+        "bbox": [
+            173,
+            530,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Explore: In this task, we have $n$ agents trying to explore the map and find an enemy unit. This is a direct scale-up of the PP but with more realistic and stochastic situations. ",
+        "bbox": [
+            173,
+            648,
+            821,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Combat: We test an agent’s capability to execute a complex task of combat in StarCraft which require coordination between teammates, exploration of a terrain, understanding of enemy units and formalism of complex strategies. We specifically test a team of $n$ agents trying to find and kill a team of $m$ enemies in a partially observable environment similar to the explore task. The agents, with their limited vision, must find the enemy units and kill all of them to score a win. More information on reward structure, observation and setup can be found in Appendix 6.5.1 and 6.5.2. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ANALYSIS OF THE GATING MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            488,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We analyze working of gating action $\\left( g _ { t } \\right)$ in IC3Net by using cooperative, competitive and mixed settings in Predator-Prey (4.1.1) and StarCraft explore tasks (4.1.3). However, this time the enemy unit (prey) shares parameters with the predators and is trained with them. All of the enemy unit’s actions are noop which makes it stationary. The enemy unit gets a positive reward equivalent to $r _ { t i m e }$ $= 0 . 0 5$ per timestep until no predator/medic is captures it; after that it gets a reward of 0. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For $5 \\times 5$ grid in PP task, Figure 3 shows gating action (averaged per epoch) in all scenarios for (i) communication between predator and (ii) communication between prey and predators. We also test on $5 0 \\times 5 0$ map size for competitive and cooperative StaraCraft explore task and found similar results (Fig. 3d). We can deduce following observations: ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• As can be observed in Figure 3a, 3b, 3c and 3d, in all the four cases, the prey learns not to communicate. If the prey communicates, predators will reach it faster. Since it will get 0 reward when an agent comes near or on top of it, it doesn’t communicate to achieve higher rewards.   \n• In cooperative setting (Figure 3a, 3e), the predators are openly communicating with $g$ close to 1. Even though the prey communicates with the predators at the start, it eventually learns not to communicate; so as not to share its location. As all agents are communicating in this setting, it takes more training time to adjust prey’s weights towards silence. Our preliminary tests suggest that in cooperative settings, it is beneficial to fix the gating action to 1.0 as communication is almost always needed and it helps in faster training by skipping the need to train the gating action.   \n• In the mixed setting (Figure 3b), agents don’t always communicate which corresponds to the fact that there is no benefit or loss by communicating in mixed scenario. The prey is easily able to learn not to communicate as the weights for predators are also adjusted towards non-cooperation from the start itself.   \n• As expected due to competition, predators rarely communicate in competitive setting (Figure 3c, 3d). Note that, this setting is not fully-adversarial as predators can initially explore faster if they communicate which can eventually lead to overall higher rewards. This can be observed as the agents only communicate while it’s profitable for them, i.e. before reaching the prey (Figure 3f)) as communicating afterwards can impact their future rewards. ",
+        "bbox": [
+            179,
+            141,
+            826,
+            400
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experiments in this section, empirically suggest that agents can “learn to communicate when it is profitable”; thus allowing same network to be used in all settings. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 SCALABILITY AND GENERALIZATION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            581,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we look at bigger versions of our environments to understand scalability and generalization aspects of IC3Net. ",
+        "bbox": [
+            173,
+            481,
+            825,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3.1 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            308,
+            539
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For training details, refer to Appendix 6.1. We compare IC3Net with baselines specified below in all scenarios. ",
+        "bbox": [
+            176,
+            549,
+            823,
+            577
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Individual Reward Independent Controller (IRIC): In this controller, model is applied individually to all of the agents’ observations to produce the action to be taken. Essentially, this can be seen as IC3Net without any communication between agents; but with individualized reward for each agent. Note that no communication makes gating action $( g _ { t } )$ ineffective. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Independent Controller (IC - IC3Net w/o Comm and IR): Like IRIC except the agents are trained with a global average reward instead of individual rewards. This will help us understand the credit assignment issue prevalent in CommNet. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            689
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CommNet: Introduced in Sukhbaatar et al. (2016), CommNet allows communication between agents over a channel where an agent is provided with the average of hidden state representations of other agents as a communication signal. Like IC3Net, CommNet also uses continuous signals to communicate between the agents. Thus, CommNet can be considered as IC3Net without both the gating action $\\left( g _ { t } \\right)$ and individualized rewards. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            765
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            292,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We discuss major results for our experiments in this section and analyze particular behaviors/patterns of agents in Appendix 6.2. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Predator Prey: Table 1 (left) shows average steps taken by the models to complete an episode i.e. find the prey in mixed setting (we found similar results for cooperative setting shown in appendix). IC3Net reaches prey faster than the baselines as we increase the number of agents as well as the size of the maze. In $2 0 \\times 2 0$ version, the gap in average steps is almost 24 steps, which is a substantial improvement over baselines. Figure 4 (right) shows the scalability graph for IC3Net and CommNet which supports the claim that with the increasing number of agents, IC3Net converges faster at a better optimum than CommNet. Through these results on the PP task, we can see that compared to IC3Net, CommNet doesn’t work well in mixed scenarios. Finally, Figure 4 (left) shows the training plot of $2 0 \\times 2 0$ grid with 10 agents trying to find a prey. The plot clearly shows the faster performance improvement of IC3Net in contrast to CommNet which takes long time to achieve a minor jump. We also find same pattern of the gating action values as in 4.2. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/707fd94f3ff80c5216e8f2bede5d69c635fd04667c5b7a65ee400ef6649652cf.jpg",
+        "image_caption": [
+            "Figure 4: Result Plots for PP and TJ task. (Left) Average steps taken to complete an episode in $2 0 \\times 2 0$ grid. (Center) IC3Net converges faster than CommNet as the number of predators (agents) increase in Predator-Prey environment. (Right) Success $\\%$ in medium TJ task trained with curriculum. Performance and convergence of IC3Net is superior than baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            98,
+            821,
+            207
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a1aeec42a61b66ed5f2e8c07674654e4c376f311caf835e43205f2f9aa014ac1.jpg",
+        "table_caption": [
+            "Table 1: Predator Prey (Left): Avg. number of steps taken to complete the episode in three different environment sizes in mixed settings. IC3Net completes the episode faster than the baselines by finding the prey. Traffic Junction (Right): Success rate on various difficulty levels with zero vision for all. IC3Net provides better performance than baselines consistently especially as the scale increases. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">Predatory-Prey Mixed (Avg. Steps)</td><td colspan=\"4\">Traffic Junction (Success %)</td></tr><tr><td>Model</td><td>5x5,n=3</td><td>10x10,n=5 20x20,n=10</td><td></td><td>Model</td><td>Easy</td><td>Medium</td><td>Hard</td></tr><tr><td>IRIC</td><td>16.5±0.1</td><td>28.1±0.2</td><td>75.0± 1.4</td><td>IRIC</td><td>29.8±0.7</td><td>3.4±0.5</td><td>35.0±0.6</td></tr><tr><td>IC</td><td>16.4± 0.49</td><td>28.0±0.74</td><td>77.4± 0.8</td><td>IC</td><td>30.2±0.4</td><td>3.4±0.5</td><td>47.0± 2.9</td></tr><tr><td>CommNet</td><td>9.1± 0.1</td><td>13.1±0.01</td><td>76.5± 1.3</td><td>CommNet</td><td>93.0± 4.2</td><td>54.3± 14.2</td><td>50.2±3.5</td></tr><tr><td>IC3Net</td><td>8.9± 0.02</td><td>13.0±0.02</td><td>52.4± 3.4</td><td>IC3Net</td><td>93.0± 3.7</td><td>89.3± 2.5</td><td>72.4± 9.6</td></tr></table>",
+        "bbox": [
+            199,
+            292,
+            800,
+            386
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            484,
+            825,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Traffic Junction: Table 1 (right) shows the success ratio for traffic junction. We fixed the gating action to 1 for TJ as discussed in 4.2. With zero vision, it is not possible to perform well without communication as evident by the results of IRIC and IC. Interestingly, IC performs better than IRIC in the hard case, as we believe without communication, the global reward in TJ acts as a better indicator of the overall performance. On the other hand, with communication and better knowledge of others, the global reward training face a credit assignment issue which is alleviated by IC3Net as evident by its superior performance compared to CommNet. In Sukhbaatar et al. (2016), well-performing agents in the medium and hard versions had vision $> 0$ . With zero vision, IC3Net is to CommNet and IRIC with a performance gap greater than $30 \\%$ . This verifies that individualized rewards in IC3Net help achieve a better or similar performance than CommNet in fully-cooperative tasks with communication due to a better credit assignment. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            714
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "StarCraft: Table 2 displays win $\\%$ and the average number of steps taken to complete an episode in StarCraft explore and combat tasks. We specifically test on (i) Explore task: 10 medics finding 1 enemy medic on $5 0 \\times 5 0$ cell grid (ii) On $7 5 \\times 7 5$ cell grid (iii) Combat task: 10 Marines vs 3 Zealots on $5 0 \\mathrm { ~ x ~ } 5 0$ cell grid. Maximum steps in an episode are set to 60. The results on the explore task are similar to Predator-Prey as IC3Net outperforms the baselines. Moving to a bigger map size, we still see the performance gap even though performance drops for all the models. ",
+        "bbox": [
+            174,
+            722,
+            562,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the combat task, IC3Net performs comparably well to CommNet. A detailed analysis on IC3Net’s performance in StarCraft tasks is provided in Appendix 6.2.1. To confirm that 10 marines vs 3 zealots is hard to win, we run an experiment on reverse scenario where our agents control 3 Zealots initialized separately and enemies are 10 marines initialized together. We find that both IRIC and IC3Net reach a success percentage of $100 \\%$ easily. We find that even in this case, IC3Net converges faster than IRIC. ",
+        "bbox": [
+            173,
+            868,
+            562,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/aabaafd3db9061a08fb600c175b8999ef12875c46df5546f71325121df48e5a9.jpg",
+        "image_caption": [
+            "Figure 5: Average steps taken to complete an episode of StarCraft Explore10 Medic $5 0 \\times 5 0$ task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            575,
+            744,
+            823,
+            867
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1cf954b36c73c22c2440b934bbff20fee277003c8ff8bacaf719dc4e5555d8e4.jpg",
+        "table_caption": [
+            "Table 2: StarCraft Results: Win Ratio and average number of steps taken to complete episodes for explore (Exp) tasks with 10 Marines (M) on different grid sizes $( 5 0 \\times 5 0$ and $7 5 \\times 7 5$ ) and a combat (Cbt) task with 10 Marines (M) vs 3 Zealots $\\mathrm { ( Z e ) }$ on a grid of size $5 0 \\times 5 0$ . IC3Net beats the baselines with huge margin in case of exploration tasks, while it is as good as CommNet in case of 10 Marines vs 3 Zealots combat task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">IRIC</td><td colspan=\"2\">IC</td><td colspan=\"2\">CommNet</td><td colspan=\"2\">IC3Net</td></tr><tr><td>StarCraft task</td><td>Win %</td><td>Steps</td><td>Win %</td><td>Steps</td><td>Win %</td><td>Steps</td><td>Win %</td><td>Steps</td></tr><tr><td>Exp-10M 50 × 50</td><td>35.4± 1.7</td><td>52.7± 0.6</td><td>18.0± 1.63</td><td>55.5± 0.4</td><td>9.2± 3.12</td><td>58.4± 0.5</td><td>64.2± 17.7</td><td>41.2± 8.4</td></tr><tr><td>Exp-10M 75 × 75</td><td>9.0± 4.2</td><td>58.6±0.9</td><td>1.0±0.2</td><td>59.1±0.4</td><td>2.1±0.3</td><td>59.9± 0.1</td><td>17.0± 15.2</td><td>57.2±3.5</td></tr><tr><td>Cbt-10Mv3Ze</td><td>74.6± 5.1</td><td>35.0±0.8</td><td>51.8± 3.0</td><td>48.6± 0.4</td><td>88.0± 7.2</td><td>33.3± 1.2</td><td>87.4± 1.0</td><td>33.6±0.2</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            821,
+            178
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            287,
+            825,
+            329
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            504,
+            368
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduced IC3Net which aims to solve multi-agent tasks in various cooperation settings by learning when to communicate. Its continuous communication enables efficient training by backpropagation, while the discrete gating trained by reinforcement learning along with individual rewards allows it to be used in all scenarios and on larger scale. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            440
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Through our experiments, we show that IC3Net performs well in cooperative, mixed or competitive settings and learns to communicate only when necessary. Further, we show that agents learn to stop communication in competitive cases. We show scalability of our network by further experiments. In future, we would like to explore possibility of having multi-channel communication where agents can decide on which channel they want to put their information similar to communication groups but dynamic. It would be interesting to provide agents a choice of whether to listen to communication from a channel or not. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            546
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements Authors would like to thank Zeming Lin for his consistent support and suggestions around StarCraft and TorchCraft. ",
+        "bbox": [
+            174,
+            553,
+            823,
+            580
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            285,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. Proceedings of ICLR, 2015. ",
+        "bbox": [
+            173,
+            630,
+            823,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. In Advances in neural information processing systems, pp. 4502–4510, 2016. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning, ICML ’09, pp. 41–48, 2009. ",
+        "bbox": [
+            174,
+            727,
+            823,
+            768
+        ],
+        "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": [
+            173,
+            784,
+            823,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lucian Busoniu, Robert Babuska, and Bart De Schutter. A comprehensive survey of multiagent reinforcement learning. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 38(2):156–172, March 2008. ",
+        "bbox": [
+            173,
+            824,
+            826,
+            867
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yu-Han Chang, Tracey Ho, and Leslie Pack Kaelbling. All learning is local: Multi-agent learning in global reward games. In Proceedings of the 16th International Conference on Neural Information Processing Systems, NIPS’03, pp. 807–814, 2003. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems 29, pp. 2137–2145. 2016a. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob N Foerster, Yannis M Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate to solve riddles with deep distributed recurrent q-networks. arXiv preprint arXiv:1602.02672, 2016b. ",
+        "bbox": [
+            173,
+            157,
+            826,
+            200
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            173,
+            212,
+            826,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jayesh K. Gupta, Maxim Egorov, and Mykel J. Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In Adaptive Learning Agents Workshop, 2017. doi: 10.1007/ 978-3-319-71682-4_5. ",
+        "bbox": [
+            171,
+            267,
+            826,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Serhii Havrylov and Ivan Titov. Emergence of language with multi-agent games: learning to communicate with sequences of symbols. In Advances in Neural Information Processing Systems, pp. 2149–2159, 2017. ",
+        "bbox": [
+            173,
+            321,
+            826,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            169,
+            431,
+            825,
+            460
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In Advances in Neural Information Processing Systems 30, pp. 2701–2711. 2017. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Satwik Kottur, José Moura, Stefan Lee, and Dhruv Batra. Natural language does not emerge ‘naturally’in multi-agent dialog. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2962–2967, 2017. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            556
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Lauer and Martin Riedmiller. An algorithm for distributed reinforcement learning in cooperative multi-agent systems. In In Proceedings of the Seventeenth International Conference on Machine Learning, pp. 535–542. Morgan Kaufmann, 2000. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In Proceedings of ICLR, 2017. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jason Lee, Kyunghyun Cho, Jason Weston, and Douwe Kiela. Emergent translation in multi-agent communication. In Proceedings of ICLR, 2018. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            691
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joel Lehman, Jeff Clune, Dusan Misevic, Christoph Adami, Julie Beaulieu, Peter J Bentley, Samuel Bernard, Guillaume Belson, David M Bryson, Nick Cheney, et al. The surprising creativity of digital evolution: A collection of anecdotes from the evolutionary computation and artificial life research communities. arXiv preprint arXiv:1803.03453, 2018. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe, YI WU, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems 30, pp. 6379–6390. 2017. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            815
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "L. Matignon, G. J. Laurent, and N. L. Fort-Piat. Hysteretic q-learning :an algorithm for decentralized reinforcement learning in cooperative multi-agent teams. In 2007 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 64–69, Oct 2007. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            869
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laetitia Matignon, Guillaume J Laurent, and Nadine Le Fort-Piat. Independent reinforcement learners in cooperative markov games: a survey regarding coordination problems. The Knowledge Engineering Review, 27(1):1–31, 2012. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518:529–533, 2015. ",
+        "bbox": [
+            176,
+            103,
+            826,
+            172
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            173,
+            183,
+            820,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shayegan Omidshafiei, Jason Pazis, Christopher Amato, Jonathan P How, and John Vian. Deep decentralized multi-task multi-agent reinforcement learning under partial observability. pp. 2681– 2690, 2017. ",
+        "bbox": [
+            174,
+            219,
+            826,
+            262
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Santiago Ontanón, Gabriel Synnaeve, Alberto Uriarte, Florian Richoux, David Churchill, and Mike Preuss. A survey of real-time strategy game ai research and competition in starcraft. IEEE Transactions on Computational Intelligence and AI in games, 5(4):293–311, 2013. ",
+        "bbox": [
+            174,
+            271,
+            826,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liviu Panait and Sean Luke. Cooperative multi-agent learning: The state of the art. Autonomous agents and multi-agent systems, 11(3):387–434, 2005. ",
+        "bbox": [
+            173,
+            323,
+            823,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peng Peng, Quan Yuan, Ying Wen, Yaodong Yang, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent bidirectionally-coordinated nets for learning to play starcraft combat games. arXiv preprint arXiv:1703.10069, 2017. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529:484–489, 2016. ",
+        "bbox": [
+            174,
+            412,
+            826,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Rob Fergus, et al. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems, pp. 2244–2252, 2016. ",
+        "bbox": [
+            171,
+            492,
+            825,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ming Tan. Multi-agent reinforcement learning: independent versus cooperative agents. In Proceedings of the Tenth International Conference on International Conference on Machine Learning, pp. 330– 337. Morgan Kaufmann Publishers Inc., 1993. ",
+        "bbox": [
+            178,
+            530,
+            823,
+            573
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26–31, 2012. ",
+        "bbox": [
+            174,
+            582,
+            826,
+            623
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Usunier, Gabriel Synnaeve, Zeming Lin, and Soumith Chintala. Episodic exploration for deep deterministic policies: An application to starcraft micromanagement tasks. In Proceedings of ICLR, 2017. ",
+        "bbox": [
+            174,
+            632,
+            826,
+            675
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sida I Wang, Percy Liang, and Christopher D Manning. Learning language games through interaction. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 2368–2378, 2016. ",
+        "bbox": [
+            174,
+            684,
+            826,
+            727
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stefan Wender and Ian Watson. Applying reinforcement learning to small scale combat in the real-time strategy game starcraft: Broodwar. In Computational Intelligence and Games (CIG), 2012 IEEE Conference on, pp. 402–408. IEEE, 2012. ",
+        "bbox": [
+            174,
+            736,
+            826,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            816
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            351,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We set the hidden layer size to 128 units and we use LSTM (Hochreiter & Schmidhuber, 1997) with recurrence for all of the baselines and IC3Net. We use RMSProp (Tieleman & Hinton, 2012) with initial learning rate as a tuned hyper-parameter. All of the models use skip-connections (He et al., 2016). The training is distributed over 16 cores and each core runs a mini-batch till total episodes steps are 500 or more. We do 10 weight updates per epoch. We run predator-prey, StarCraft experiments for 1000 epochs, traffic junction experiment for 2000 epochs and report the final results. In mixed case, we report the mean score of all agents, while in cooperative case we report any agent’s score as they are same. We implement our model using PyTorch and environments using Gym (Brockman et al., 2016).We use REINFORCE (Williams, 1992) to train our setup. We conduct 5 runs on each of the tasks to compile our results. The training time for different tasks varies; StarCraft tasks usually takes more than a day (depends on number of agents and enemies), while predator-prey and traffic junction tasks complete under 12 hours. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.2 RESULTS ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            345,
+            352,
+            359
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyze and discuss behaviors/patterns in the results on our experiments. ",
+        "bbox": [
+            171,
+            372,
+            769,
+            386
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.2.1 IC3NET IN STARCRAFT-COMBAT TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            402,
+            500,
+            416
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As observed in Table 2, IC3Net performs better than CommNet in explore task but doesn’t outperform it on Combat task. Our experiments and visualizations of actual strategy suggested that compared to exploration, combat can be solved far easily if the units learn to stay together. Focused firepower with more attack quantity in general results in quite good results on combat. We verify this hypothesis by running a heuristics baseline “attack closest” in which agents have full vision on map and have macro actions available3. By attacking the closest available enemy together the agents are able to kill zealots with success ratio of $7 6 . 6 \\pm 8 $ calculated over 5 runs, even though initialized separately. Also, as described in Appendix 6.5.2, the global reward in case of win in Combat task is relatively huge compared to the individual rewards for killing other units. We believe that with coordination to stay together, huge global rewards and focus fire–which is achievable through simple cooperation–add up to CommNet’s performance in this task. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            579
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Further, in exploration we have seen that agents go in separate direction and have individual rewards/sense of exploration which usually leads to faster exploration of an unexplored area. Thinking in simple terms, exploration of an house would be faster if different people handle different rooms. Achieving this is hard in CommNet because global rewards don’t exactly tell your individual contributions if you had explored separately. Also in CommNet, we have observed that agents follow a pattern where they get together at a point and explore together from that point which further signals that using CommNet, it is easy to get together for agents4. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.2.2 VARIANCE IN IC3NET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            383,
+            715
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, we have observed significant variance in IC3Net results for StarCraft. We performed a lot of experiments on StarCraft and can attribute the significant variance to stochasticity in the environment. There are a huge number of possible states in which agents can end up due to millions of possible interactions and their results in StarCraft. We believe it is hard to learn each one of them. This stochasticity variance can even be seen in simple heuristics baselines like “attack closest” (6.2.1) and is in-fact an indicator of how difficult is it to learn real-world scenarios which also have same amount of stochasticity. We believe that we don’t see similar variance in CommNet and other baselines because adding gating action increases the action-state-space combinations which yields better results while being difficult to learn sometimes. Further, this variance is only observed in higher Win $\\%$ models which requires to learn more state spaces. ",
+        "bbox": [
+            174,
+            726,
+            825,
+            809
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.2.3 COMMNET IN STARCRAFT-EXPLORE TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            174,
+            534,
+            189
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Table 2, we can observe that CommNet performs worse than IRIC and IC in case of StarCraftExplore task. In this section, we provide a hypothesis for this result. First, we need to notice is that IRIC is better than IC also overall, which points to the fact that individualized reward are better than global rewards in case of exploration. This makes sense because if agents cover more area and know how much they covered through their own contribution (individual reward), it should lead to overall more coverage, compared to global rewards where agents can’t figure out their own coverage but instead overall one. Second, in case of CommNet, it is easy to communicate and get together. We observe this pattern in $\\mathrm { C o m m N e t ^ { 4 } }$ where agents first get together at a point and then start exploring from there which leads to slow exploration, but IC is better in this respect because it is hard to gather at single point which inherently leads to faster exploration than CommNet. Third, the reward structure in the case of mixed scenario doesn’t appreciate searching together which is not directly visible to CommNet and IC due to global rewards. ",
+        "bbox": [
+            174,
+            199,
+            825,
+            366
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.3 DETAILS OF PREDATOR PREY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            382,
+            418,
+            397
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In all the three settings, cooperative, competitive and mixed, a predator agent gets a constant time-step penalty $r _ { e x p l o r e } = - 0 . 0 5$ , until it reaches the prey. This makes sure that agent doesn’t slack in finding the prey. In the mixed setting, once an agent reaches the prey, the agent always gets a positive reward $r _ { p r e y } = 0 . 0 5$ which doesn’t depend on the number of agents on prey. . Similarly, in the cooperative setting, an agent gets a positive reward of $r _ { c o o p } = r _ { p r e y } * n$ , and in the competitive setting, an agent gets a positive reward of $r _ { c o m p } = r _ { p r e y } / n$ after it reaches the prey, where $n$ is the number of agents on the prey. The total reward at time $t$ for an agent $i$ can be written as: ",
+        "bbox": [
+            173,
+            409,
+            825,
+            506
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1abec1f1e4b98eb62617b1dd713c67662da55fc64c3599bfd0b63f17c891d8e.jpg",
+        "text": "$$\nr _ { i } ^ { p p } ( t ) = \\delta _ { i } * r _ { e x p l o r e } + ( 1 - \\delta _ { i } ) * n _ { t } ^ { \\lambda } * r _ { p r e y } * | \\lambda |\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            512,
+            668,
+            531
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta _ { i }$ denotes whether agent $i$ has found the prey or not, $n _ { t }$ is number of agents on prey at time-step $t$ and $\\lambda$ is -1, 0 and 1 in the competitive, mixed and cooperative scenarios respectively. Maximum episode steps are set to 20, 40 and 80 for $5 \\times 5$ , $1 0 \\times 1 0$ and $2 0 \\times 2 0$ grids respectively. The number of predators are 5, 10 and 20 in $5 { \\times } 5$ , $1 0 \\times 1 0$ and $2 0 \\times 2 0$ grids respectively. Each predator can take one of the five basic movement actions i.e. up, down, lef t, right or stay. Predator, prey and all locations on grid are considered unique classes in vocabulary and are represented as one-hot binary vectors. Observation obs, at each point will be the sum of all one-hot binary vectors of location, predators and prey present at that point. With vision of 1, observation of each agent have dimension $\\dot { 3 } ^ { 2 } \\times | o b s |$ . ",
+        "bbox": [
+            174,
+            536,
+            826,
+            662
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.3.1 EXTRA EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            678,
+            383,
+            691
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/dec7f30a7ca6ae60da5d87d4bb4c0b21d86d5512ae7ae9f64c62333b18a9a7e2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Predator Prey Cooperative (Avg. Rewards)</td></tr><tr><td>Model</td><td>5x5,n=3</td><td>10x10, n=5 20x20,n=10</td></tr><tr><td>IRIC</td><td>0.48±0.001 0.47± 0.009</td><td>4.08± 0.049 5.77± 0.130</td></tr><tr><td>IC</td><td>3.78± 0.082</td><td>4.99± 0.529</td></tr><tr><td>CommNet</td><td>1.56± 0.010 6.94± 0.020</td><td>19.99± 0.62</td></tr><tr><td>IC3Net</td><td>1.57± 0.008 6.85± 0.144</td><td>21.09± 0.579</td></tr></table>",
+        "bbox": [
+            341,
+            704,
+            656,
+            797
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Predator-Prey Cooperative: Avg. rewards in three difficulty levels of predator-prey environment in cooperative setting. IC3Net performs equivalently or better than baselines consistently. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            837
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows the results for IC3Net and baselines in the cooperative scenario for the predator-prey environment. As the cooperative reward function provides more reward after a predator reaches the prey, the comparison is provided for rewards instead of average number of steps. IC3Net performs better or equal to CommNet and other baselines in all three difficulty levels. The performance gap closes in and increases as we move towards bigger grids which shows that IC3Net is more scalable due to individualized rewards. More importantly, even with the extra gating action training, IC3Net can perform comparably to CommNet which is designed for cooperative scenarios which suggests that IC3Net is a suitable choice for all cooperation settings. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To analyze the effect of gating action on rewards in case of mixed scenario where individualized rewards alone can help a lot, we test Predator Prey mixed cooperation setting on $2 0 \\mathbf { x } 2 0$ grid on a baseline in which we set gating action to 1 (global communication) and uses individual rewards $( \\mathrm { I C 2 N e t / C o m m N e t + I R } )$ ). We find average max steps to be $5 0 . 2 4 \\pm 3 . 4$ which is lower than IC3Net. This means that (i) individualized rewards help a lot in mixed scenarios by allowing agents to understand there contributions (ii) adding the gating action in this case has an overhead but allows the same model to work in all settings (even competitive) by “learning to communicate” which is more close to real-world humans with a negligible hit on the performance. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            265
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.4 DETAILS OF TRAFFIC JUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            281,
+            436,
+            295
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Traffic junction’s observation vocabulary has one-hot vectors for all locations in the grid and car class. Each agent observes its previous action, route identifier and a vector specifying sum of one-hot vectors for all classes present at that agent’s location. Collision occurs when two cars are on same location. We set maximum number of steps to 20, 40 and 60 in easy, medium and hard difficulty respectively. Similar to Sukhbaatar et al. (2016), we provide a negative reward $r _ { c o l l } = - 1 0$ on collision. To cut off traffic jams, we provide a negative reward $\\tau _ { i } r _ { t i m e } = - 0 . 0 1 \\tau _ { i }$ where $\\tau _ { i }$ is time spent by the agent in the junction at time-step $t$ . Reward for ith agent which is having $C _ { i } ^ { t }$ collisions at time-step $t$ can be written as: ",
+        "bbox": [
+            173,
+            306,
+            825,
+            417
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b878a3164075a133a14e13dce3ae0586f132f84a206d4ec0963b68489dfe56e.jpg",
+        "text": "$$\nr _ { i } ^ { t j } ( t ) = r _ { c o l l } C _ { i } ^ { t } + r _ { t i m e } \\tau _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            415,
+            588,
+            435
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We utilized curriculum learning Bengio et al. (2009) to make the training process easier. The parrive is kept at the start value till the first 250 epochs and is then linearly increased till the end value during the course from 250th to 1250th epoch. The start and end values of $p _ { a r r i v e }$ for different difficulty levels are indicated in Table 4. Finally, training continues for another 750 epochs. The learning rate is fixed at 0.003 throughout. We also implemented three difficulty variations of the game explained as follows. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            529
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e7eb9922972fb2afff4d76f30ed9a2e8b83b3bf607be2b6fd3acb6726a2295c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Difficulty</td><td>P-arrive Start</td><td>End</td><td>N-total</td><td>Arrival Points</td><td>Routes per Entry Point</td><td>Two-Way</td><td> Junctions</td><td>Dimension</td></tr><tr><td>Easy</td><td>0.1</td><td>0.3</td><td>5</td><td>2</td><td>1</td><td>F</td><td>1</td><td>7×7</td></tr><tr><td>Medium</td><td>0.05</td><td>0.2</td><td>10</td><td>4</td><td>3</td><td>T</td><td>1</td><td>14×14</td></tr><tr><td>Hard</td><td>0.02</td><td>0.05</td><td>20</td><td>8</td><td>7</td><td>T</td><td>4</td><td>18×18</td></tr></table>",
+        "bbox": [
+            220,
+            542,
+            777,
+            619
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Traffic Junction: Variations in different traffic junction difficulty levels. T refers to True as in the difficulty level has 2-way roads and F refers to False as in the difficulty level has 1-way roads. ",
+        "bbox": [
+            171,
+            630,
+            825,
+            657
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The easy version is a junction of two one-way roads on a $7 \\times 7$ grid. There are two arrival points, each with two possible routes and with a $N _ { t o t a l }$ value of 5. ",
+        "bbox": [
+            176,
+            674,
+            823,
+            702
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The medium version consists of two connected junctions of two-way roads in $1 4 \\times 1 4$ as shown in Figure 2 (right). There are 4 arrival points and 3 different routes for each arrival point and have $N _ { t o t a l } = 2 0$ . ",
+        "bbox": [
+            174,
+            709,
+            825,
+            751
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The harder version consists of four connected junctions of two-way roads in $1 8 \\times 1 8$ as shown in Figure 6. There are 8 arrival points and 7 different routes for each arrival point and have $N _ { t o t a l } = 2 0$ ",
+        "bbox": [
+            174,
+            757,
+            823,
+            786
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.4.1 IRIC AND IC PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            429,
+            815
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Table 1, we notice that IRIC and IC perform worst in medium level compared to the hard level. Our visualizations suggest that this is due to high final add-rate in case of medium version compared to hard version. Collisions happen much more often in medium version leading to less success rate (an episode is considered failure if a collision happens) compared to hard where initial add-rate is low to accommodate curriculum learning for hard version’s big grid size. The final add-rate in case of hard level is comparatively low to make sure that it is possible to pass a junction without a collision as with more entry points it is easy to collide even with a small add-rate. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a0fd45cbb7d56cb27882def10fa95f27efdecc80600cb481d468e95f9a69b35e.jpg",
+        "image_caption": [
+            "Figure 6: Hard difficulty level of traffic junction task. Level has four connected junctions, eight entry points and at each entry point there are 7 possible routes increasing chances of a collision. We use curriculum learning to successfully train our models on hard level. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            390,
+            98,
+            607,
+            265
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.5 STARCRAFT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            343,
+            364,
+            358
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.5.1 OBSERVATION AND ACTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            369,
+            429,
+            383
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Explore: To complete the explore task, agents must be within a particular range of enemy unit called explore vision. Once an agent is within explore vision of enemy unit, we noop further actions. The reward structure is same as the PP task with only difference being that an agent needs to be within the explore vision range of the enemy unit instead of being on same location to get a non-negative reward. We use medic units which don’t attack enemy units. This ensures that we can simulate our explore task without any of kind of combat happening and interfering with the goal of the task. Observation for each agent is its (absolute $x ,$ , absolute y) and enemy’s (relative x, relative y, visible) where visible, relative $x$ and relative $y$ are 0 when enemy is not in explore vision range. Agents have 9 actions to choose from which includes 8 basic directions and one stay action. ",
+        "bbox": [
+            173,
+            393,
+            826,
+            518
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Combat: Agent observes its own (absolute $x _ { i }$ , absolute y, healthpoints $^ +$ shield, weapon cooldown, previous action) and (relative $x ,$ relative y, visible, healthpoints $^ +$ shield, weapon cooldown) for each of the enemies. relative $x$ and relative $y$ are only observed when enemy is visible which is corresponded by visible flag. All of the observations are normalized to be in between $( 0 , 1 )$ . Agent has to choose from $9 + m$ actions which include 9 basic actions and 1 action for attacking each of the $m$ agents. Attack actions only work when the enemy is within the sight range of the agent, otherwise it is a noop. In combat, we don’t compare with prior work on StarCraft because our environment setting is much harder, restrictive, new and different, thus, not directly comparable. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            637
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.5.2 COMBAT REWARD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            354,
+            667
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To avoid slack in finding the enemy team, we provide a negative reward $r _ { t i m e } = - 0 . 0 1$ at each timestep when the agent is not involved in a combat. At each timestep, an agent gets as reward the difference between (i) its normalized health in current and previous timestep (ii) normalized health at previous timestep and current timestep for each of the enemies it has attacked till now. At the end of the episode, terminal reward for each agents consists of (i) all its remaining health $\\ast _ { 3 }$ as negative reward (ii) $5 \\ast m + \\mathrm { a l l }$ its remaining health $\\ast _ { 3 }$ as positive reward if agents win (iii) normalized remaining health $\\ast _ { 3 }$ for all of the alive enemies as negative reward on lose. In this task, the group of enemies is initialized together randomly in one half of the map and our agents are initialized separately in other half which makes task even harder, thus requiring communication. For an automatic way of individualizing rewards, please refer to Foerster et al. (2018). ",
+        "bbox": [
+            173,
+            676,
+            825,
+            816
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.5.3 EXAMPLE SEQUENCE OF STATES IN COOPERATIVE EXPLORE MOD",
+        "text_level": 1,
+        "bbox": [
+            179,
+            104,
+            678,
+            117
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We provide an example sequence of states in StarCraft cooperative explore mode in Figure 7. As soon as one of the agents finds the enemy unit, the other agents get the information about enemy’s location through communication and are able to reach it faster. ",
+        "bbox": [
+            176,
+            127,
+            825,
+            170
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/54a6b0d9fecfd970701398e1e4c5c9cb733e24371e3b1eb71cfcb25d3c19ee1c.jpg",
+        "image_caption": [
+            "Figure 7: State sequence in SC Cooperative Explore. We can see how agents which are randomly initialized communicate to reach the enemy faster. Once, some agents are near the prey and other reach very fast due to communication "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            183,
+            761,
+            452
+        ],
+        "page_idx": 15
+    }
+]

parse/train/vOchfRdvPy7/vOchfRdvPy7.md

@@ -0,0 +1,473 @@
+# TO BE ROBUST OR TO BE FAIR: TOWARDS FAIRNESS IN ADVERSARIAL TRAINING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Adversarial training algorithms have been proved to be reliable to improve machine learning models’ robustness against adversarial examples. However, we find that adversarial training algorithms tend to introduce severe disparity of accuracy and robustness between different groups of data. For instance, PGD adversarially trained ResNet18 model on CIFAR-10 has $93 \%$ clean accuracy and $67 \%$ PGD $l _ { \infty }$ - 8 adversarial accuracy1 on the class ”automobile” but only $59 \%$ and $17 \%$ on class ”cat”. This phenomenon happens in balanced datasets and does not exist in naturally trained models when only using clean samples. In this work, we theoretically show that this phenomenon can generally happen under adversarial training algorithms which minimize DNN models’ robust errors. Motivated by these findings, we propose a Fair-Robust-Learning (FRL) framework to mitigate this unfairness problem when doing adversarial defenses and experimental results validate the effectiveness of FRL.
+
+# 1 INTRODUCTION
+
+The existence of adversarial examples (Goodfellow et al., 2014; Szegedy et al., 2013) causes huge concerns when applying deep neural networks on safety-critical tasks, such as autonomous driving vehicles and face identification (Morgulis et al., 2019; Sharif et al., 2016). These adversarial examples are artificially crafted samples which do not change the semantic meaning of the natural samples, but can misguide the model to give wrong predictions. As countermeasures against the attack from adversarial examples, adversarial training algorithms aim to train classifier that can classify the input samples correctly even when they are adversarially perturbed. Namely, they optimize the model to have minimum adversarial risk of that a sample can be perturbed to be wrongly classified:
+
+$$
+\operatorname* { m i n } _ { f ~ x } \left[ \operatorname* { m a x } _ { | | \delta | \leq \epsilon } \mathcal { L } ( f ( x + \delta ) , y ) \right]
+$$
+
+These adversarial training methods (Kurakin et al., 2016; Madry et al., 2017; Zhang et al., 2019b) have been shown to be one type of the most effective and reliable ways to improve the model robustness against adversarial attacks. Although promising to improve model’s robustness, recent studies show side-effects of adversarial training: it usually degrades model’s clean accuracy (Tsipras et al., 2018).
+
+In our work, we find a new intriguing property about adversarial training algorithms: they usually result in a large disparity of accuracy and robustness between different classes. As a preliminary study in Section 2, we apply natural training and PGD adversarial training (Madry et al., 2017) on the CIFAR10 dataset (Krizhevsky et al., 2009) using a ResNet18 (He et al., 2016) architecture. For a naturally trained model, the model performance in each class is similar. However, in the adversarially trained model, there is a severe performance discrepancy (both accuracy and robustness) of the model for data in different classes. For example, the model has high clean accuracy and robust accuracy $93 \%$ and $67 \%$ successful rate, separately) on the samples from the class “car”, but much poorer performance on those “cat” images $5 9 \%$ and $17 \%$ successful rate). More preliminary results in Section 2 further show the similar “unfair” phenomenon from other datasets and models. Meanwhile, we find that this fairness issue does not appear in natural models which are trained on clean data. This fact demonstrates that adversarial training algorithms can indeed unequally help to improve model robustness for different data groups and unequally degrade their clean accuracy.
+
+In this work we first define this problem as the unfairness problem of adversarial training algorithms. If this phenomenon happens in real-world applications, it can raise huge concerns about safety or even social ethics. Imagine that an adversarially trained traffic sign recognizer has overall high robustness, but it is very inaccurate and vulnerable to perturbations for some specific signs such as stop signs. The safety of this autonomous driving car is still not guaranteed. In such case, the safety of this recognizer depends on the worst class performance. Therefore, in addition to achieving overall performance, it is also essential to achieve fair accuracy and robustness among different classes, which can guarantee the worst performance. Meanwhile, this problem may also lead to the issues from social ethics perspectives, which are similar to traditional ML fairness problems (Buolamwini & Gebru, 2018). For example, a robustly trained face identification system might provide different qualitative levels of service safety for different ethnic communities.
+
+In this paper, we first explore the potential reason which may cause this unfair accuracy / unfair robustness problem. In particular, we aim to answer the question - “Will adversarial training algorithms naturally cause unfairness problems, such as the disparity of clean accuracy and adversarial robustness between different classes?” To answer this question, we first propose a conceptual example under a mixture of two spherical Gaussian distributions which resembles to the previous work (Tsipras et al., 2018) but with different variances. In this setting, we hypothesize that adversarial training tends to only use robust features for model prediction, whose dimension is much lower than the non-robust feature space. In the lower dimensional space, an optimal linear model is more sensitive to the inherent data distributional difference and be biased when making predictions.
+
+Motivated by these empirical and theoretical findings, we then propose a Fair Robust Learning (FRL) framework to mitigate this unfairness issue, which is inspired from the traditional debiasing strategy to solve a series of cost-sensitive classification problems but we make specific effort to achieve the fairness goal in adversarial setting. Our main contributions can be summarized as following: (a) We discover the phenomenon of “unfairness” problem of adversarial training algorithms and implement empirical studies to present this problem can be general; (b) We build a conceptual example to theoretically investigate the main reasons that cause this unfairness problem; and (c) We propose a Fair Robust Learning (FRL) framework to mitigate the unfairness issue in adversarial setting.
+
+# 2 PRELIMINARY STUDIES
+
+CIFAR10 In this section, we present our preliminary studies to show that adversarial training algorithms usually present the unfairness issues, which are related to the strong disparity of clean accuracy and robustness among different classes. We implement algorithms including PGD adversarial training (Madry et al., 2017) and TRADES (Zhang et al., 2019b) on the CIFAR10 dataset (Krizhevsky et al., 2009). In CIFAR10, we both naturally and adversarially train ResNet18 (He & Garcia, 2009) models. In Figure 1, we present list the the model’s accuracy and robustness performance (under PGD attack by intensity $4 / 2 5 5$ and 8/255) for each individual class.
+
+![](images/87a9112a6a88af82672c79379c8f1e871b72902265671e092d7331d3685c0a14.jpg)  
+Figure 1: Clean and adversarial accuracy in each class of CIFAR10 dataset, from a naturally trained ResNet model (left), PGD-adversarially trained model (middle) and TRADES (right), against adversarial examples under $l _ { \infty }$ -norm by $\dot { 8 } / 2 5 5$ . The trained models’ robustness are evaluated by untargeted PGD attack under $l _ { \infty }$ -norm constrained by $8 / 2 5 5$ and $4 / 2 5 5$ .
+
+From the Figure 1, we can observe that – for the naturally trained models, every class has similar clean accuracy (around $9 0 \pm 5 \%$ ) and adversarial accuracy (close to $0 \%$ ) under the PGD attack. It suggests that naturally trained models do not have strong disparity of both clean and robustness performance among classes. However, for adversarially trained models (under PGD Adv. Training or TRADES), the disparity phenomenon becomes severe. For example, a PGD-adversarially trained model has $5 9 . 1 \%$ clean accuracy and $1 7 . 4 \%$ adversarial accuracy for the samples in the class “cat”, which are much lower than the model’s overall performance. This phenomenon demonstrates that adversarial training algorithms cannot provide the same help for the robustness for the samples in class “cat” as other classes, and unfairly degrades too much clean accuracy for “cat”. We list our empirical studies under more model architectures in Table 3 and more datasets (GTRSB (Stallkamp et al., 2011)) in Appendix A.2, where we can find the similar observations.
+
+GTSRB We also investigate the fairness issue in German Traffic Sign Recognition Benchmark (GTRSB) (Stallkamp et al., 2011). It consists of 43 classes of images from different traffic signs, with image sizes $3 2 \times 3 2 \times 3$ . In this dataset we also both naturally and adversarially train a 3-Layer CNN classifier. We list the model’s performance and sort the classes in the order of decreasing clean accuracy and adv. accuracy. From the Figure 2, we can see that for the naturally trained model (left), most classes have high accuracy which is over $90 \%$ , but for adversarial training, some classes’ accuracy drops by a large margin. Meanwhile, adversarial training also unequally improves the
+
+![](images/9c509360efdc347ec66edde4e391f362413010151a5df17cbe463cb175590e8b.jpg)  
+Figure 2: Class-wise Clean & Adversarial Accuracy on GTSRB of Naturally Trained Model (left) and Adversarially Trained Model (right).
+
+model’s robustness against PGD attacks given that some classes have very low adversarial accuracy. In this dataset, both natural model and robust model have clear distinguished adversairal accuracy (robustness) among classes.
+
+# 3 THEORETICAL ANALYSIS BASED ON A CONCEPTUAL EXAMPLE
+
+From our preliminary studies, we always observe that adversarially trained models have huge performance disparity (clean and adversarial accuracy) between different groups. In this section, we try to understand the unfairness problem via theoretical analysis based on a binary classification problem on a mixture-Gaussian distribution, which is similar to (Tsipras et al., 2018). We first state the necessary notions in this paper.
+
+Notations. In the following, we use $f$ to denote the classification model which is a mapping $f :$ $\mathcal { X }  \mathcal { V }$ from input data space $\mathcal { X }$ and output labels $\mathcal { V }$ . Generally, naturally training will find the optimal $f$ to minimize the overall clean error $\mathcal { R } _ { \mathrm { n a t } } ( f ) = \mathrm { P r } . ( f ( x ) \dot { } \neq y )$ ; and adversarially training will minimize the overall robust error $\mathcal { R } _ { \mathrm { r o b } } ( f ) = \mathrm { P r . } ( \exists \delta , | | \delta | | \leq \epsilon$ , s.t. $\dot { f } ( x + \delta ) \neq y )$ . Specifically in the following binary classification problem, $\mathcal { V } = \{ - 1 , + 1 \}$ and each class’s clean error and robust error are denoted as the conditional probabilities: $\mathcal { R } _ { \mathrm { n a t } } ( f , - 1 ) = \mathrm { P r } . ( f ( x ) = + 1 | y = - 1 )$ , and $\mathcal { R } _ { \mathrm { r o b } } ( f , - 1 ) = \mathrm { P r } . ( \exists \delta , | | \delta | | \leq \epsilon , \mathrm { s . t . } f ( \dot { x } + \delta ) = + 1 | y = - 1 )$ ), respectively.
+
+# 3.1 A BINARY CLASSIFICATION TASK
+
+Our study is motivated by (Tsipras et al., 2018) which uncovers one key behavior of adversarial training: it excludes high-dimensional non-robust features (which are vulnerable to attack) and only preserves lower-dimensional robust features for prediction. Thus, in our case, we assume our conceptual dataset has the data-label pairs $( x , y )$ sampled from a distribution $\mathcal { D }$ follows:
+
+$$
+y \overset { u . a . r } { \sim } \{ - 1 , + 1 \} , \quad \theta = ( \overset { \mathrm { d i m } = \mathrm { m } } { \overbrace { \gamma , \ldots , \gamma } } , \overset { \mathrm { d i m } = \mathrm { d } } { \overbrace { \eta , \ldots , \eta } } ) , \quad x \sim \left\{ \begin{array} { l l } { N ( \theta , \sigma _ { + 1 } ^ { 2 } I ) } & { \mathrm { i f ~ } y = + 1 } \\ { N ( - \theta , \sigma _ { - 1 } ^ { 2 } I ) } & { \mathrm { i f ~ } y = - 1 } \end{array} \right.
+$$
+
+where $\mathcal { N } ( \theta , \sigma _ { + 1 } ^ { 2 } I )$ is a normal distribution with mean vector $\theta$ and covariance matrix $\sigma _ { + 1 } ^ { 2 } I$ and same for class “-1”. Following the work (Tsipras et al., 2018), we suppose that the feature space consists of two kinds of features: (a) robust features with center $\gamma$ and dimension $m$ ; and (b) non-robust features with center $\eta$ and dimension $d$ . We assume $\eta < \epsilon < \gamma$ , so an adversarial perturbation $\delta$ with intensity $| | \delta | | _ { \infty } \dot { \leq } \epsilon$ can manipulate a non-robust feature to have a different sign in expectation, but $\delta$ cannot attack a robust feature. Usually, the non-robust features’ dimension $d$ is far higher than the robust features’ dimension $d$ , i.e., $( m < < d )$ ).
+
+In our case, we assume that the 2 classes have a key difference between their variances: $\sigma _ { + 1 } :$ $\sigma _ { - 1 } = K : 1$ , where $K > 1$ . In this theoretical example, our main hypothesis is that: the variance difference between 2 classes will not lead to strong disparity of model performance for a naturally trained model whose prediction is based on a high dimensional feature space. However, the variance difference can cause large performance gap (both accuracy and robustness) for adversarially trained models which are based on low-dimensional robust features. To illustrate this fact, we will explicitly calculate the 2 classes’ clean and robust errors in the proposed distribution for both clean models and robust models.
+
+# 3.2 OPTIMAL LINEAR MODEL TO MINIMIZE CLEAN ERROR
+
+We first calculate one linear model for this data to minimize the total clean errors. Specifically, we consider a linear classifier $f$ with its optimal parameters $w ^ { * }$ and $b ^ { * }$ :
+
+$$
+\begin{array} { r } { f ^ { * } ( x ) = \underset { w , b } { \operatorname { s i g n } } ( \langle w ^ { * } , x \rangle + b ^ { * } ) } \\ { \mathrm { ~ w h e r e ~ } w ^ { * } , b ^ { * } = \underset { w , b } { \operatorname { a r g m i n } } \ \operatorname* { P r } . ( f ( x ) \neq y ) } \end{array}
+$$
+
+where $w$ is features’ weight vector and $b$ is the model intersection. In later parts, we use $f$ to represent $f ^ { * }$ for convenience. We call the optimized model naturally trained model because it minimizes model’s clean error to get overall high clean accuracy. Typically, a naturally trained model will use both robust features and non-robust features for inference but its prediction outcome majorly depends on non-robust features. Next, we show the exact form of the errors for each class in Theorem 1 and the proof is provided in Appendix B.1.
+
+Theorem 1 Optimal linear classifier which minimizes overall clean error in $\mathcal { D }$ will have classconditional clean errors:
+
+$$
+\begin{array} { r l } & { r o r s \colon } \\ & { \mathcal { R } _ { n a t } ( f , - 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq \overbrace { A - \sqrt { K \cdot A ^ { 2 } + q ( K ) } } ^ { Z _ { n a t } ( f , - 1 ) ) } \} , } \\ & { \mathcal { R } _ { n a t } ( f , + 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq \underbrace { - K \cdot A + \sqrt { A ^ { 2 } + q ( K ) } } _ { Z _ { n a t } ( f , + 1 ) ) } \} , } \end{array}
+$$
+
+where 2σ(K2−1) pmγ2 + dη2 and q(K) = $\begin{array} { r } { q ( K ) = \frac { 2 \log ( K ) } { K ^ { 2 } - 1 } } \end{array}$ 2 log(K)2 . It has the robust error under attack $| | \delta | | \leq \epsilon _ { 0 }$ :
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { r o b } ( f , - 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq \overbrace { Z _ { n a t } ( f , - 1 ) + \frac { m \gamma + d \eta } { \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } } } \frac { \epsilon _ { 0 } } { \sigma } \} } ^ { Z _ { n b } ( f , - 1 ) ) } } \\ & { \mathcal { R } _ { r o b } ( f , + 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq \underbrace { Z _ { n a t } ( f , + 1 ) + \frac { m \gamma + d \eta } { \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } } } \frac { \epsilon _ { 0 } } { K \sigma } } _ { Z _ { m b } ( f , + 1 ) } \} . } \end{array}
+$$
+
+Note that the term $A$ (consisting of feature dimension $d , m$ and center $\gamma , \eta )$ represents how expressive the information from $\mathcal { D }$ that model $f$ can use for prediction. Thus, when the term $A$ is large, the model has close clean errors between the 2 classes, namely $\mathscr { R } _ { \mathrm { n a t } } ( f , - 1 ) \approx \mathscr { R } _ { \mathrm { n a t } } ( f , + 1 )$ . It is because the $q ( K )$ term in their z-scores2 can be ignored when $A$ is large. On the other hand for their robust errors, typically we assume the adversarial attack by $| | \delta | | \leq \epsilon _ { 0 }$ can bring in major threat to mislead natural model $\bar { f }$ , which will result both $Z _ { \mathrm { r o b } } ( f , - 1 )$ and $\dot { Z } _ { \mathrm { r o b } } ( f , + 1 )$ to be large positive numbers, so that the robust errors of both classes $\mathcal { R } _ { \mathrm { r o b } } ( f , - 1 )$ and $\mathcal { R } _ { \mathrm { r o b } } ( f , + 1 )$ are also large.
+
+# 3.3 OPTIMAL LINEAR MODEL TO MINIMIZE ROBUST ERROR
+
+During adversarial training, the desired linear classifier should minimize the total robust error, which minimizes the probability that there exists a perturbation $\delta$ constrained by budge $| | \delta | | _ { \infty } \leq \epsilon$ that can let the model make mistake. Formally, we describe a linear classifier after adversarial training as:
+
+$$
+\begin{array} { r } { f _ { \mathrm { a d v } } ^ { * } ( x ) = \mathrm { s i g n } ( \langle w _ { \mathrm { a d v } } ^ { * } , x \rangle + b _ { \mathrm { a d v } } ^ { * } ) \qquad } \\ { \mathrm { / h e r e } w _ { \mathrm { a d v } } ^ { * } , b _ { \mathrm { a d v } } ^ { * } = \underset { w , b } { \mathrm { a r g m i n } } \mathrm { P r } . ( \exists \delta , | | \delta | | \leq \epsilon , \mathrm { s . t . } f _ { \mathrm { a d v } } ( x + \delta ) \neq y ) . } \end{array}
+$$
+
+Similarly we use $f _ { \mathrm { a d v } }$ to denote $f _ { \mathrm { a d v } } ^ { * }$ for convenience. During adversarial training, the linear model will only preserve the weights on robust features and exclude all non-robust features as proved in Lemma 2 in the Appendix. We will also call the adversarially trained model in $\mathcal { D }$ a robust model, because its features cannot be easily manipulated by perturbations under $| | \delta | | \leq \epsilon$ . We show the robust model’s clean and robust errors in Theorem 2 and the proof is provided in Appendix B.2.
+
+Theorem 2 Optimal linear classifier which minimizes overall robust error in $\mathcal { D }$ will have classconditional clean errors:
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { R } _ { n a t } ( f _ { a d \nu } , - 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq B - \sqrt { K \cdot B ^ { 2 } + q ( K ) } - \frac { \sqrt { m } } { \sigma } \epsilon \} } \\ { \displaystyle \mathcal { R } _ { n a t } ( f _ { a d \nu } , + 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq - K \cdot B + \sqrt { B ^ { 2 } + q ( K ) } - \frac { \sqrt { m } } { K \sigma } \epsilon \} } \end{array}
+$$
+
+$\begin{array} { r } { B = \frac { 2 } { \sigma ( K ^ { 2 } - 1 ) } \sqrt { m } \cdot ( \gamma - \epsilon ) , q ( K ) = \frac { 2 \log ( K ) } { K ^ { 2 } - 1 } } \end{array}$ , and robust errors under attack $| | \delta | | \leq \epsilon _ { 0 }$
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { r o b } ( f _ { a d \nu } , - 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f _ { a d \nu } , - 1 ) + \sqrt { m } \frac { \epsilon _ { 0 } } { \sigma } \} } \\ & { \mathcal { R } _ { r o b } ( f _ { a d \nu } , + 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f _ { a d \nu } , + 1 ) + \sqrt { m } \frac { \epsilon _ { 0 } } { K \sigma } \} . } \end{array}
+$$
+
+Recall that we assume the dimension of non-robust features is much higher than that of robust features $a > > m )$ and $\gamma , \eta$ and $\epsilon$ have similar scale: $\epsilon = \Theta ( \gamma )$ and $\eta = \Theta ( \gamma )$ . Therefore, in Eq. (8) and Eq. (9), for model $f _ { \mathrm { a d v } }$ ’s clean errors, the decisive term $B$ is at scale $\Theta \dot { ( ( d / m ) ^ { - \frac { 1 } { 2 } } \cdot A ) }$ , where $A$ is the term in Eq.(3). In Corollary 1 (proved in Appendix B.3), we show that it is this relationship between $A$ and $B$ that will finally bring in the “unfair” issue to both model accuracy and robustness performance.
+
+Corollary 1 Adversarially Trained Model on $\mathcal { D }$ will have larger clean error disparity between the 2 classes, compared to a Naturally Trained model.
+
+We calculate 2 classes’ clean error difference: $( \mathcal { R } _ { \mathrm { n a t } } ( f , + 1 ) - \mathcal { R } _ { \mathrm { n a t } } ( f , - 1 ) )$ for natural model $f$ ; and $( \mathcal { R } _ { \mathrm { n a t } } ( f _ { \mathrm { a d v } } , + 1 ) - \mathcal { R } _ { \mathrm { n a t } } ( f _ { \mathrm { a d v } } , - 1 ) )$ for adversarially trained model $f _ { \mathrm { a d v } }$ . Since both terms are positive, we show their ratio (detailed proof in Appendix):
+
+$$
+\Omega = \frac { \mathcal { R } _ { \mathrm { n a t } } ( f _ { \mathrm { a d v } } , + 1 ) - \mathcal { R } _ { \mathrm { n a t } } ( f _ { \mathrm { a d v } } , - 1 ) } { \mathcal { R } _ { \mathrm { n a t } } ( f , + 1 ) - \mathcal { R } _ { \mathrm { n a t } } ( f , - 1 ) } \geq \frac { ( K ^ { 2 } - 1 ) \log ( K ) \sigma ^ { 2 } } { 2 \Theta ( \gamma ^ { 2 } ) } \cdot \Theta ( \frac { d } { m } ) ^ { \frac { 1 } { 2 } } .
+$$
+
+In Eq. (12), we can tell once $d / m$ is large, the ratio $\Omega$ is also large $\mathrm { ( e . g . ~ > ~ 1 }$ ) and the adversarial training is showed to enlarge the 2 classes’ clean error disparity. The ratio $\Omega$ in Eq. (12) uncovers the main factor which may cause the “unfair” phenomenon in adversarially trained models: because the robust models make prediction in a feature space with dimension $m$ which is much lower than $d$ (dimension for natural models), their clean accuracy disparity between classes can be more sensitive to the classes’ distributional difference $K$ . In this way the robust model presents strong disparity of clean accuracy.
+
+Furthermore, for the robust errors (i.e., Eqs. (10) and (42)) in adversariallly trained model, an adversarial attack under intensity $\epsilon _ { \mathrm { 0 } }$ will make the test error increase only by a small margin compared to the model’s clean error in Eqs. (8) and (9). It is because the their z-scores difference is de-√ cided by $\sqrt { m }$ which is small and much lower than $d$ . Because of the marginal difference between $R _ { \mathrm { n a t } } ( f _ { \mathrm { a d v } } , - 1 )$ and $R _ { \mathrm { r o b } } ( f _ { \mathrm { a d v } } , - 1 )$ (also for class $^ { \circ } + 1 ^ { \circ }$ ), the model’s fairness condition on robust errors will align to the clean errors (in Eq. (12)). Empirical results on real datasets also support this assumption (Figure 1). As a conclusion, adversarial training can bring in unfairness issues on both clean and robust performance.
+
+# 4 FAIR ROBUST LEARNING (FRL)
+
+Faced with the unfairness problem of adversarial training shown in Section 2 and 3, we desire to devise a Fair Robust Learning (FRL) strategy, in order to train robust models that have balanced accuracy and robustness performance for each class. Formally, we aim to train a classifier $f$ to have minimal overall robust error $( \mathcal { R } _ { \mathrm { r o b } } ( f ) )$ ; while stressing $f$ to satisfy a series of fairness constraints:
+
+$$
+\operatorname* { m i n i m i z e } _ { f } \quad \mathcal { R } _ { \mathrm { r o b } } ( f )
+$$
+
+s.t. $\mathcal { R } _ { \mathrm { n a t } } ( f , i ) - \mathcal { R } _ { \mathrm { n a t } } ( f ) \leq \tau _ { 1 }$ and $\mathcal { R } _ { \mathrm { r o b } } ( f , i ) - \mathcal { R } _ { \mathrm { r o b } } ( f ) \leq \tau _ { 2 }$ for each $i \in Y$ where $\tau _ { 1 }$ and $\tau _ { 2 }$ are small and positive values. The constraints in Eq. (13) restrict the model’s error for each class $i$ (both clean error $\mathcal { R } _ { \mathrm { n a t } } ( f , i )$ and robust error $\mathcal { R } _ { \mathrm { r o b } } ( \bar { f } , i ) )$ ) should not exceed the average level ( $\mathcal { R } _ { \mathrm { n a t } } ( f )$ and $\mathcal { R } _ { \mathrm { r o b } } ( f ) )$ by a large margin. Therefore, the model will not have specific weak points under the risk of wrong prediction or adversarial attacking. Next, we will discuss the detailed components of our Fair Robust Learning (FRL) algorithm to solve the problem in Eq. (13).
+
+4.1 TRADITIONAL MODEL DEBIASING METHOD: A REDUCTIONS APPROACH
+
+In order to solve the fair robust training problem in Eq. (13), we follow the main pipeline from traditional machine learning debiasing works such as (Agarwal et al., 2018), which reduces the problem in Eq. (13) into a series of Cost-sensitive classification problems and continuously penalizes the terms which violate the fairness constraints. We begin by introducing Lagrange multipliers $\phi = ( \phi _ { \mathrm { n a t } } ^ { i } , \phi _ { \mathrm { r o b } } ^ { i } )$ (non-negative) for each constraint in Eq. (13) and form the Lagrangian:
+
+$$
+L ( f , \phi ) = \mathcal { R } _ { \mathrm { r o b } } ( f ) + \sum _ { i = 1 } ^ { Y } \phi _ { \mathrm { n a t } } ^ { i } ( \mathcal { R } _ { \mathrm { n a t } } ( f , i ) - \mathcal { R } _ { \mathrm { n a t } } ( f ) - \tau _ { 1 } ) + \sum _ { i = 1 } ^ { Y } \phi _ { \mathrm { r o b } } ^ { i } ( \mathcal { R } _ { \mathrm { r o b } } ( f , i ) - \mathcal { R } _ { \mathrm { r o b } } ( f ) - \tau _ { 2 } )
+$$
+
+It equals to solving the max-min game between $f$ and $\phi$ as:
+
+$$
+\operatorname* { m a x } _ { \phi _ { \mathrm { n a t } } , \phi _ { \mathrm { r o b } } \ge 0 } \operatorname* { m i n } _ { f } L ( f , \phi ) .
+$$
+
+Typically, given a fixed $\phi$ , if the current model $f$ violates some constraints in Eq. (13) (for example $\dot { \mathcal { R } } _ { \mathrm { n a t } } ( \boldsymbol { f } , i ) - \mathcal { R } _ { \mathrm { n a t } } ( \boldsymbol { f } ) - \boldsymbol { \tau } _ { 1 } > 0 )$ , we first solve the outer-maximization problem in Eq. (15) by increasing its corresponding multiplier $\phi _ { \mathrm { n a t } } ^ { i }$ . As a result, we upweight the training weight (or cost) for the clean loss $\bar { \mathcal { R } } _ { \mathrm { n a t } } ( f , i )$ of all samples in the class $i$ . Then, the algorithm will solve the inner-minimization given new $\phi$ to optimize the model $f$ , the error of $\mathcal { R } _ { \mathrm { n a t } } ( f , i )$ is therefore heavily penalized and the model will give more priority to the correct prediction for the class $i$ . In this way the model gives more priority to mitigate violated terms in Eq. (14). During this process, the model $f$ and Lagrangian multiplier $\phi$ will be alternatively updated to achieve the equilibrium until we finally reach an optimal model that satisfies the fairness constraints. Based on this traditional debiasing strategy, next we will discuss the main difference of our task in the adversarial setting from this traditional approach.
+
+# 4.2 DEBIAS CLEAN ERROR AND BOUNDARY ERROR SEPARATELY
+
+One thing to note is that in the Eq (13), the robust error is always strongly related to clean errors (Zhang et al., 2019b; Tsipras et al., 2018) (see Eq. 16). Thus, during the debiasing process above, we could have twisted the influence on some class $i$ ’s clean and robust errors $\mathcal { R } _ { \mathrm { n a t } } \breve { ( f , i ) }$ and $\mathcal { R } _ { \mathrm { r o b } } ( f , i )$ . It means that when we upweight the cost for $\mathcal { R } _ { \mathrm { r o b } } ( f , i )$ as introduced in Eq. (15), we also implicitly upweight the cost for $\bar { \mathcal { R } } _ { \mathrm { n a t } } ^ { \bar { } } ( f , \bar { i } )$ . Thus, we will not get a precise update for $\phi$ . To solve this issue, we can separate the robust error into the sum of clean error and boundary error inspired by (Zhang et al., 2019b) as:
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { \mathrm { r o b } } ( f , i ) = \operatorname* { P r } \{ \exists \delta , \ \mathrm { s . t . } \ f ( x + \delta ) \neq y | y = i \} } \\ & { \qquad = \operatorname* { P r } \{ f ( x ) \neq y | y = i \} + \operatorname* { P r } . \{ \exists \delta , f ( x + \delta ) \cdot f ( x ) \leq 0 | y = i \} } \\ & { \qquad = \mathcal { R } _ { \mathrm { n a t } } ( f , i ) + \mathcal { R } _ { \mathrm { b d y } } ( f , i ) } \end{array}
+$$
+
+where $\mathcal { R } _ { \mathrm { b d y } } ( f , i ) = \operatorname* { P r } . \{ \exists \delta , f ( x + \delta ) \cdot f ( x ) \le 0 | y = i \}$ represents the probability that a sample from class $i$ lies close to the decision boundary and can be attacked. By separating the clean error and boundary error during adversarial training, we are able to independently debias the unfairness from both clean error and boundary error. Formally, we have the training objective as:
+
+$$
+\begin{array} { r l } & { \underset { f } { \mathrm { m i n i m i z e } } \quad \mathcal { R } _ { \mathrm { n a t } } ( f ) + \mathcal { R } _ { \mathrm { b d y } } ( f ) } \\ & { \mathrm { , ~ } i ) - \mathcal { R } _ { \mathrm { n a t } } ( f ) \leq \tau _ { 1 } \mathrm { a n d } \mathcal { R } _ { \mathrm { b d y } } ( f , i ) - \mathcal { R } _ { \mathrm { b d y } } ( f ) \leq \tau _ { 2 } \mathrm { f o r } \mathrm { e a c h } i \in Y } \end{array}
+$$
+
+We introduce Lagrangian multipliers $\phi = ( \phi _ { \mathrm { n a t } } ^ { i } , \phi _ { \mathrm { b d y } } ^ { i } )$ and solve the max-min game for Eq. (17) similar to Eq. (15). Note that if the constraints in Eq. (17) are satisfied, the fairness quality for robust error $( \mathcal { R } _ { \mathrm { r o b } } ( \bar { f _ { , } } i ) = \mathcal { R } _ { \mathrm { n a t } } ( f , i ) + \mathcal { R } _ { \mathrm { b d y } } ( f , i ) )$ of each class can also be guaranteed by $\tau _ { 1 } + \tau _ { 2 }$ . In practice, we will use surrogate loss functions (such as cross entropy) $\mathcal { L } ( f ( x ) , y )$ and max $\mathcal { L } ( f ( x ) , f ( x ^ { \prime } ) )$ to ||δ||≤ optimize the clean and boundary errors as suggested by (Zhang et al., 2019b).
+
+4.3 COST-SENSITIVE CLASSIFICATION FOR CLEAN ERRORS VS BOUNDARY ERRORS
+
+During the debiasing training process in Eq. (17), if one class $i$ ’s clean error violates the fairness inequality: $\mathcal { R } _ { \mathrm { n a t } } ( f , i \bar { \it \Delta } ) - \mathcal { R } _ { \mathrm { n a t } } ( \bar { f } ) - \tau _ { 1 } > 0$ , upweighting the cost for $\mathcal { R } _ { \mathrm { n a t } } ( f , i )$ can help penalize large $\bar { \mathcal { R } } _ { \mathrm { n a t } } \bar { ( f , i ) }$ and mitigate the unfairness issue as suggested by (Agarwal et al., 2018). Note that we refer to this strategy as “Reweight”. However, if the boundary error for class $i$ : $\mathcal { R } _ { \mathrm { b d y } } ( f , i ) - \mathcal { R } _ { \mathrm { b d y } } ( f ) -$ $\tau _ { 2 } > 0$ , we claim that only upweighting its cost (or Reweight) could not succeed to fulfill the cost-sensitive classification goal in adversarial setting. Our empirical studies in Section 5 show that upweighting the boundary error for some class $i$ cannot effectively reduce model’s boundary error specifically for class $i$ but can bring in side-effects to degrade class $i$ ’s clean accuracy. It is evident from (Ding et al., 2018) that increasing the margin $\epsilon$ during adversarial training can effectively improve model’s robustness against attacks under current intensity $\epsilon$ . Therefore, we hypothesize that enlarging the adversarial margin $\epsilon$ when generating adversarial examples during training specifically for the class $i$ can improve this class’s robustness and reduce the large boundary error $\bar { \mathcal { R } } _ { \mathrm { b d y } } ( f , i )$ . In this work, we refer to this strategy as “Re-margin”. Empirical study in Table 2 and Figure 3 validates its effectiveness.
+
+We present the main components and process of Fair Robust Learning (FRL) in Algorithm 1. Note that BEST $( f , \phi , \epsilon )$ denotes the adversarial training process under adjusted hyper-parameter $\phi , \epsilon$ mentioned in Eq. (14) and we test the performance under the validation set which is denoted as $\operatorname { E V A L } ( f , \cdot )$ . In Algorithm 1, in each iteration we first test our initialized or pretrained model $f$ on the validation set to check whether it violates the unfairness constraints (step 5). Then we update Lagrangian multiplier $\phi _ { \mathrm { n a t } }$ to reweight the clean loss for each class. We propose three strategies to update hyper-parameter to balance the boundary loss including Reweight (option 1), Remargin (option 2) and Reweight+Regmargin (option 3). We follow one of the options (step 7) for boundary loss. Finally we adversarially train the model under the updated setting by $\phi , \epsilon$ .
+
+Algorithm 1 The Fair Robust Learning (FRL) Algorithm   
+
+<table><tr><td>1: Input: Fairness constraints specified by T1 &gt; O and T2 &gt; O,test time attacking radius Eo and hyper-param update rate α1, @2</td><td></td></tr><tr><td>2: Output: Fairly robust neural network f</td><td></td></tr><tr><td></td><td>3:Randomly initialize network f or initialize network with pre-trained configuration</td></tr><tr><td>Set nat = O,dy = O and Φ= (Φnat, Φbdy),adv. training radius ∈i = ∈0 for each i ∈ )</td><td></td></tr><tr><td>4: repeat</td><td></td></tr><tr><td>5: Rnat(i,f),Rbdy(i,f)=EVAL(f, ∈o)</td><td>Evaluate f for each class</td></tr><tr><td>6: nat = nat + α1·(Rnat(i,f)-T1)</td><td>Update multiplier nat</td></tr><tr><td>7:</td><td>bdy=bdy+a2·(Rbdy(i,f）- T2) &gt; Option 1. Update multiplier bdy</td></tr><tr><td>7:</td><td>Or Φbdy = bdy; ∈i = ∈i ·exp(a2·(Rbdy(i,f) - T2))</td></tr><tr><td>7:</td><td>orΦbdy =Φbdy +α2·(Rbdy(i,f)-T2) ;</td></tr><tr><td></td><td>∈i = ∈i ·exp(α2(Rbdy(i,f)- T2)) &gt; Option 3.Reweight +Remargin</td></tr><tr><td>8: f ←BEST(f,Φ,∈)</td><td>&gt;Adv. training under hyper-paramΦ,e from current f</td></tr><tr><td>9: until Model f satisfies all constraints</td><td></td></tr></table>
+
+# 5 EXPERIMENT
+
+In this section, we will present the experimental results to validate the effectiveness of the proposed framework (FRL) for building fairly robust DNN models. We implement and compare our proposed three strategies (i.e., Reweight, Remargin and Reweight+Remargin) on real-world data and discuss their possible different consequences. We also discuss the main difference of the manner of our proposed three potential debiasing strategies.
+
+Experimental Setup & Baselines We conduct our experiments on CIFAR10 (Krizhevsky et al., 2009). For CIFAR10, we present our main results under the model architecture PreAct Residual Network (He et al., 2016). As comparison sets to show our method can improve fairness, we also present the original performance from two popular adversarial training algorithms (Madry et al., 2017; Zhang et al., 2019b). Meanwhile we add a baseline debiasing method which are inherited from (Agarwal et al., 2018) (we directly apply it to reweight the cost of adversarial examples during adversarial training) as a representative to show traditional debiasing methods might not be easily applied to solve unfairness issues in adversarial setting. For CIFAR10 dataset, we mainly test our method’s performance on a ResNet18 (He & Garcia, 2009)) model, and we apply the PGD attack (Madry et al., 2017) algorithm to generate adversarial examples under $l _ { \infty }$ -norm under $8 / 2 5 5$ . For each of the debiasing algorithm, we set the fairness constraints $\tau _ { 1 }$ and $\tau _ { 2 }$ be $5 \%$ and $7 \%$ respectively, for clean and boundary errors. Please refer to this $\operatorname { l i n k } ^ { 3 }$ for our empirical implementations.
+
+Debiasing Performance (CIFAR10) We first check whether our proposed FRL framework can help resolve the unfairness issue in adversarial training. Refer to our goal in Eq. (13) to achieve the fairness constraints to get both balanced clean and robustness performance. We report the trained model’s average clean error rate, boundary error rate and robust error rate (defined in Eq.(16)), as well as the worst intra-class clean, boundary and robust error rates (Table 1). Thus, for an optimal equally robust model, we hope each of these worst intra-class errors is not too large compared to the average errors. Meanwhile, it is also necessary that one debiasing strategy should not have too much sacrifice on the model’s overall clean and robustness performance.
+
+Table 1: Average & worst-class clean error, boundary error and robust error for various algorithms.   
+
+<table><tr><td></td><td>Avg. Clean</td><td>Worst Clean</td><td>Avg. Bdy.</td><td>Worst Bdy.</td><td>Avg. Rob.</td><td>Worst Rob.</td></tr><tr><td>PGD Adv.Training</td><td>17.3</td><td>40.9</td><td>39.4</td><td>54.4</td><td>56.9</td><td>82.6</td></tr><tr><td>TRADES(β = 1)</td><td>14.4</td><td>27.9</td><td>43.6</td><td>62.6</td><td>58.0</td><td>83.6</td></tr><tr><td>TRADES(β = 2)</td><td>16.9</td><td>34.9</td><td>39.1</td><td>56.6</td><td>55.5</td><td>82.2</td></tr><tr><td>BaselineReweight</td><td>19.2</td><td>28.3</td><td>39.2</td><td>53.7</td><td>58.2</td><td>80.1</td></tr><tr><td>FRL(Reweight)</td><td>17.0</td><td>22.5</td><td>41.6</td><td>51.2</td><td>58.6</td><td>73.3</td></tr><tr><td>FRL(Remargin)</td><td>16.9</td><td>24.9</td><td>41.6</td><td>50.6</td><td>58.5</td><td>76.3</td></tr><tr><td>FRL(Reweight+Remargin)</td><td>18.4</td><td>24.7</td><td>40.3</td><td>47.4</td><td>58.7</td><td>70.2</td></tr></table>
+
+In Table 1 for CIFAR10 dataset, we present the performance of all three versions of our proposed FRL framework. Compared to the baselines, all the FRL algorithms reduce the worst intra-class clean, boundary and robust error under different degrees. FRL (Reweight) can get the best debiasing performance to achieve minimal “worst-class” clean error, but it cannot debias boundary loss well. The method (Reweight $^ +$ Remargin) can be the most effective way to debias boundary error disparity and robust error disparity.Our added baseline method (Baseline Reweight) (Agarwal et al., 2018) only have minor help for clean performance fairness but cannot debias boundary error or robust error. For each debiasing method of FRL, compared to vanilla PGD and TRADES, the total average performance is only degraded by a slight margin $1 \sim 2 \%$ for clean error and $1 \sim 3 \%$ for robust error), thus the debiasing method will not sacrifice too much total performance.
+
+Debiasing Performance (GTSRB) We also apply our FRL debiasing method to GTSRB (Stallkamp et al., 2011), which consists of images from 43 various traffic signs. Since this dataset is highly unbalanced (some classes only have around 200 training images), we only keep 17 classes when performing adversarial training. For this dataset, we apply a 4-layer CNN classifier and test the robustness using PGD attack under $l _ { \infty }$ -norm by 12/255. In Table 2, we list the average and worst-class clean, robust and boundary errors for different training algorithms. The results show that the FRL method (Reweight, Reweight+Remargin) can effectively help to improve the model’s worst-class clean and robust performance. Furthermore, since the original dataset is imbalanced, the debiasing method brings in side-effect to improve the model’s overall performance, with lower average clean error and robust error.
+
+Table 2: Average & worst-class clean, boundary and robust error for various algorithms in GTSRB.   
+
+<table><tr><td></td><td>Avg. Clean</td><td>Worst Clean</td><td>Avg. Bdy.</td><td>Worst Bdy.</td><td>Avg. Rob.</td><td>Worst Rob.</td></tr><tr><td>PGDAdv. Training</td><td>1.2</td><td>9.1</td><td>18.3</td><td>42.3</td><td>20.6</td><td>49.5</td></tr><tr><td>TRADES(β=1)</td><td>1.6</td><td>7.3</td><td>21.5</td><td>50.4</td><td>23.1</td><td>59.7</td></tr><tr><td>TRADES(β= 2)</td><td>2.1</td><td>10.3</td><td>17.5</td><td>40.3</td><td>19.6</td><td>46.3</td></tr><tr><td>BaselineReweight</td><td>0.8</td><td>6.4</td><td>19.4</td><td>42.4</td><td>20.1</td><td>44.0</td></tr><tr><td>FRL(Reweight)</td><td>0.7</td><td>3.5</td><td>18.3</td><td>39.4</td><td>19.0</td><td>40.0</td></tr><tr><td>FRL(Remargin)</td><td>2.4</td><td>10.7</td><td>18.0</td><td>44.3</td><td>18.4</td><td>44.3</td></tr><tr><td>FRL(Reweight+Remargin)</td><td>0.8</td><td>4.0</td><td>16.6</td><td>34.2</td><td>17.5</td><td>38.2</td></tr></table>
+
+Compare Different Debiasing Strategies. In Figure 3, we take a closer look at the behavior of different proposed debiasing strategies mentioned in Section 4.3 and test whether they can succeed in solving the constrained training problem in Eq.(17). We present the model’s maximum violation (e.g. $v ( i ) =$
+
+![](images/b3be6d964323bbe4a85aeda4a3b1d52fd743519c38fabf185a5742e13ae1c798.jpg)  
+Figure 3: Debiasing Manner for 3 FRL Options in CIFAR10.
+
+$\mathcal { R } _ { \mathrm { n a t } } ( f , i ) - \mathcal { R } _ { \mathrm { n a t } } ( f , i ) \stackrel {  } { - } \tau _ { 1 } )$ among all classes for each training epoch that hot-started from a pretrained (adversarially) ResNet model. If $v ( i ) \leq 0$ for each class in $\mathcal { V }$ , each fairness constraint is satisfied. From the figure we can tell that FRL (Reweight) method cannot adequately balance the boundary error, and it always presents a trade-off relation with the clean error constraints. Introducing the Remargin method will facilitate to achieve fairness for boundary errors. More details (e.g. average and worst clean / robustness in training) are in Fig. 5 in Appendix A.2.
+
+# 6 RELATED WORKS
+
+Adversarial Attacks and Adversarial Training. The existence of adversarial attacks (Goodfellow et al., 2014; Szegedy et al., 2013; Carlini & Wagner, 2017) causes huge concerns when people adopt machine learning models in various application domains (Xu et al., 2019; Jin et al., 2020). As countermeasures against adversarial examples, adversarial training (robust optimization) algorithms (Goodfellow et al., 2014; Madry et al., 2017; Zhang et al., 2019b; Shafahi et al., 2019; Zhang et al., 2019a) are formulated as a min-max problem that directly minimize the model’s risk on the adversarial samples such that the machine learning model is robust under the adversarial attacks. They are shown to be one of the most reliable strategies to improve model safety. Another mainstream of defense methods are certified defense, which aims to provide provably robust DNNs under $l _ { p }$ norm bound (Wong & Kolter, 2018; Cohen et al., 2019) and guarantee the robustness. In this work, we focus on studying the potential risk of the defense algorithms from a new scope of the fairness concerns.
+
+Fairness in Machine Learning & Imbalanced Dataset. Fairness issues recently draw much attention from the community of machine learning. These issues can generally divided into two categorizations: (1) prediction outcome disparity: the models tend to have some unreasonable preference of prediction for some specific demographic groups (Zafar et al., 2017); and (2) prediction quality disparity: the models tend to have much lower performance on some specific groups than others (Buolamwini & Gebru, 2018). Please refer to the works (Barocas et al.; Mehrabi et al., 2019) for a more comprehensive and detailed summary of fairness study in machine learning. The reasons that cause these discrimination problems might come from data distribution or the learning algorithms. Unlike existing works, this work is the first to study the unfairness issue in the adversarial setting. We argue that robustly trained models are likely to have different accuracy and robustness quality among different classes, and it may be introduced by both data distribution and the adversarial training algorithm. We also mention imbalanced data learning problem (He & Garcia, 2009; Lin et al., 2017) as one related topic of our work. Since in our work, (e.g. Figure 1), we show that the prediction performance differences are indeed existing between different classes. This phenomenon is also well-studied in imbalanced data problems or long-tail distribution learning problems (Wang et al., 2017) where some classes have much fewer training samples than others. However, in our case, we show that this unfairness problem can also happen in the balanced data, so it desires new scopes and methods for a further study.
+
+# 7 CONCLUSION
+
+In this work we first theoretically and empirically uncover one side-effect of adversarial training algorithms: it can cause serious disparity for both clean accuracy and adversarial robustness between different classes of the data. As a first attempt to resolve unfairness issues from adversarial training, we propose the Fair Robust Learning (FRL) framework to mitigate this issue.
+
+# REFERENCES
+
+Alekh Agarwal, Alina Beygelzimer, Miroslav Dud´ık, John Langford, and Hanna Wallach. A reductions approach to fair classification. arXiv preprint arXiv:1803.02453, 2018.
+
+Solon Barocas, Moritz Hardt, and Arvind Narayanan. Fairness in machine learning.
+
+Joy Buolamwini and Timnit Gebru. Gender shades: Intersectional accuracy disparities in commercial gender classification. In Conference on fairness, accountability and transparency, pp. 77–91, 2018.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 ieee symposium on security and privacy (sp), pp. 39–57. IEEE, 2017.
+
+Jeremy M Cohen, Elan Rosenfeld, and J Zico Kolter. Certified adversarial robustness via randomized smoothing. arXiv preprint arXiv:1902.02918, 2019.
+
+Gavin Weiguang Ding, Yash Sharma, Kry Yik Chau Lui, and Ruitong Huang. Max-margin adversarial (mma) training: Direct input space margin maximization through adversarial training. arXiv preprint arXiv:1812.02637, 2018.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Haibo He and Edwardo A Garcia. Learning from imbalanced data. IEEE Transactions on knowledge and data engineering, 21(9):1263–1284, 2009.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Wei Jin, Yaxin Li, Han Xu, Yiqi Wang, and Jiliang Tang. Adversarial attacks and defenses on graphs: A review and empirical study. arXiv preprint arXiv:2003.00653, 2020.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense ´ object detection. In Proceedings of the IEEE international conference on computer vision, pp. 2980–2988, 2017.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Ninareh Mehrabi, Fred Morstatter, Nripsuta Saxena, Kristina Lerman, and Aram Galstyan. A survey on bias and fairness in machine learning. arXiv preprint arXiv:1908.09635, 2019.
+
+Nir Morgulis, Alexander Kreines, Shachar Mendelowitz, and Yuval Weisglass. Fooling a real car with adversarial traffic signs. arXiv preprint arXiv:1907.00374, 2019.
+
+Ali Shafahi, Mahyar Najibi, Mohammad Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! In Advances in Neural Information Processing Systems, pp. 3358–3369, 2019.
+
+Mahmood Sharif, Sruti Bhagavatula, Lujo Bauer, and Michael K Reiter. Accessorize to a crime: Real and stealthy attacks on state-of-the-art face recognition. In Proceedings of the 2016 acm sigsac conference on computer and communications security, pp. 1528–1540, 2016.
+
+Johannes Stallkamp, Marc Schlipsing, Jan Salmen, and Christian Igel. The German Traffic Sign Recognition Benchmark: A multi-class classification competition. In IEEE International Joint Conference on Neural Networks, pp. 1453–1460, 2011.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Dimitris Tsipras, Shibani Santurkar, Logan Engstrom, Alexander Turner, and Aleksander Madry. Robustness may be at odds with accuracy. arXiv preprint arXiv:1805.12152, 2018.
+
+Yu-Xiong Wang, Deva Ramanan, and Martial Hebert. Learning to model the tail. In Advances in Neural Information Processing Systems, pp. 7029–7039, 2017.
+
+Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In International Conference on Machine Learning, pp. 5286–5295. PMLR, 2018.
+
+Han Xu, Yao Ma, Haochen Liu, Debayan Deb, Hui Liu, Jiliang Tang, and Anil Jain. Adversarial attacks and defenses in images, graphs and text: A review. arXiv preprint arXiv:1909.08072, 2019.
+
+Muhammad Bilal Zafar, Isabel Valera, Manuel Gomez Rodriguez, and Krishna P Gummadi. Fairness beyond disparate treatment & disparate impact: Learning classification without disparate mistreatment. In Proceedings of the 26th international conference on world wide web, pp. 1171– 1180, 2017.
+
+Dinghuai Zhang, Tianyuan Zhang, Yiping Lu, Zhanxing Zhu, and Bin Dong. You only propagate once: Painless adversarial training using maximal principle. arXiv preprint arXiv:1905.00877, 2 (3), 2019a.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically principled trade-off between robustness and accuracy. arXiv preprint arXiv:1901.08573, 2019b.
+
+A APPENDIX.
+
+# A.1 OVERALL PERFORMANCE ON MORE MODELS
+
+Table 3: Adversarial training algorithms on CIFAR10 dataset (ResNet18 (above) and ReNet34(below)). We report the average clean accuracy and adversarial accuracy (under PGD attack by 8/255), as well as the worst / best clean accuracy and adv. accuracy among all classes.   
+A.2 THE PHENOMENON OF UNFAIR ROBUSTNESS ON GTSRB   
+
+<table><tr><td></td><td>Avg. Clean.</td><td>Avg. Adv.</td><td>Worst Clean</td><td>Best Clean</td><td>Worst Adv.</td><td>Best Adv.</td></tr><tr><td rowspan="4">Natural Training PGD Adv. Training TRADES</td><td>93.1</td><td>0.0</td><td>87.5</td><td>97.7</td><td>0.0</td><td>0.0</td></tr><tr><td>82.7</td><td>43.1</td><td>59.1</td><td>93.6</td><td>17.4</td><td>64.9</td></tr><tr><td>83.1</td><td>44.0</td><td>65.1</td><td>93.4</td><td>17.8</td><td>67.0</td></tr><tr><td>95.1</td><td>0.0</td><td>88.1</td><td>98.2</td><td>0.0</td><td>0.0</td></tr><tr><td rowspan="3">Natural Training PGD Adv. Training TRADES</td><td>86.6</td><td>46.3</td><td>72.3</td><td>96.4</td><td>19.8</td><td>72.2</td></tr><tr><td>85.5</td><td>56.3</td><td>67.0</td><td>95.2</td><td>27.5</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>79.5</td></tr></table>
+
+GTSRB We also show the similar unfairness phenomenon in German Traffic Sign Recognition Benchmark (GTRSB) (Stallkamp et al., 2011), which consist of 43 classes of images from different traffic signs, with image sizes $3 2 \times 3 2 \times 3$ . In this dataset we also both naturally and adversarially train a 3-Layer CNN classifier. We list the model’s performance and sort the classes in the order of decreasing clean accuracy and adv. accuracy. From the Figure 4, we also see the natural training has similar clean accuracy between different classes, but adversarial training will enlarge their gap and
+
+![](images/cf1d32259470a0d15efbf58c799366e430f5181072b487262cca52dd0dc2d6bd.jpg)  
+Figure 4: Unfairness in GTSRB
+
+result the clean performance has a heavier tail property. In this dataset, both natural model and robust model have clear distinguished adversairal accuracy (robustness). However, adversarial training even hardly provide any robustness improvement for some classes.
+
+<table><tr><td></td><td>Avg. Clean.</td><td>Avg. Adv.</td><td>Worst Clean</td><td>Best Clean</td><td>Worst Adv.</td><td>Best Adv.</td></tr><tr><td>Natural Training</td><td>99.5</td><td>18.9</td><td>91.7</td><td>100.0</td><td>0.0</td><td>72.5</td></tr><tr><td>PGD Adv. Training</td><td>94.5</td><td>44.4</td><td>50.0</td><td>100.0</td><td>1.3</td><td>90.0</td></tr><tr><td>TRADES</td><td>91.2</td><td>47.2</td><td>35.3</td><td>100.0</td><td>3.3</td><td>92.0</td></tr></table>
+
+Table 4: Adversarial training algorithms on GTSRB dataset (on a 3-layer CNN model). We report the average clean accuracy and adversarial accuracy (under PGD attack by 12/255), as well as the worst / best clean accuracy and adv. accuracy among all classes.
+
+# B PROOF OF THEOREMS
+
+# B.1 PROOF OF THEOREM 1
+
+Before proving Theorem 1, we first establish the optimal linear classifier in natural training through Lemma 1, which facilitates us to prove the clean error and robust error after natural training.
+
+Lemma 1 (Optimal linear classifier in natural training) For the data following the distribution in Eq. $( l )$ , the naturally trained linear classifier $f ( x ) = \bar { s } i g n ( w ^ { T } x + b )$ has the optimal weight that satisfy: $w _ { 1 } = w _ { 2 } = \cdot \cdot \cdot = w _ { m }$ and $w _ { m + 1 } = w _ { m + 2 } = \cdot \cdot \cdot = w _ { m + b }$ . Moreover, their ratio satisfy $w _ { 1 } : w _ { m + 1 } = \gamma : \eta$ and $b : w _ { 1 } = w _ { 0 } : 1$ where
+
+$$
+w _ { 0 } = A ^ { 2 } \frac { K ^ { 2 } + 1 } { K ^ { 2 } - 1 } - A ^ { 2 } K \sqrt { \frac { 4 } { ( K ^ { 2 } - 1 ) ^ { 2 } } + \frac { 2 \sigma ^ { 2 } \log K } { A ^ { 2 } ( K ^ { 2 } - 1 ) } } .
+$$
+
+![](images/ed69792d70fae8f506b7fe523aa38c2592505e9f54f9979d92591f69f9651796.jpg)  
+Figure 5: Debiasing training process
+
+Proof 1 (Proof of Lemma 1) We first prove $w _ { 1 } = w _ { 2 } = \cdot \cdot \cdot = w _ { m }$ and $w _ { m + 1 } = w _ { m + 2 } = \cdot \cdot \cdot =$ $w _ { m + b }$ by contradiction. We define $G _ { 1 } = \{ 1 , 2 , \dots , m \}$ and $G _ { 2 } = \{ m + 1 , m + 2 , \ldots , m + d \}$ . We make the following assumption: for the optimal w and $b$ , we assume there exist $w _ { i } < w _ { j }$ for $i \neq j$ and $i , j \in G _ { 1 }$ . Then we obtain the following clean error for two classes with this classifier $w$
+
+$$
+\begin{array} { l } { { R ( f , - 1 ) = P r \{ \displaystyle \sum _ { k \neq i , k \neq j } w _ { k } \mathcal { N } _ { k } + b + w _ { i } \mathcal { N } ( - \gamma , \sigma _ { - 1 } ^ { 2 } ) + w _ { j } \mathcal { N } ( - \gamma , \sigma _ { - 1 } ^ { 2 } ) > 0 \} } } \\ { { R ( f , + 1 ) = P r \{ \displaystyle \sum _ { k \neq i , k \neq j } w _ { k } \mathcal { N } _ { k } + b + w _ { i } \mathcal { N } ( + \gamma , \sigma _ { + 1 } ^ { 2 } ) + w _ { j } \mathcal { N } ( + \gamma , \sigma _ { + 1 } ^ { 2 } ) < 0 \} } } \end{array}
+$$
+
+If we use $w _ { j }$ to replace $w _ { i }$ , we obtain new errors
+
+$$
+\frac { \overline { { R ( f , - 1 ) } } = P r \{ \sum _ { k \neq i , k \neq j } w _ { k } \mathcal { N } _ { k } + b + w _ { j } \mathcal { N } ( - \gamma , \sigma _ { - 1 } ^ { 2 } ) + w _ { j } \mathcal { N } ( - \gamma , \sigma _ { - 1 } ^ { 2 } ) > 0 \} } { \overline { { R ( f , + 1 ) } } = P r \{ \sum _ { k \neq i , k \neq j } w _ { k } \mathcal { N } _ { k } + b + w _ { j } \mathcal { N } ( + \gamma , \sigma _ { + 1 } ^ { 2 } ) + w _ { j } \mathcal { N } ( + \gamma , \sigma _ { + 1 } ^ { 2 } ) < 0 \} . }
+$$
+
+Therefore, it contradicts with the assumption we make and we conclude for an optimal linear classifier in natural training, it must satisfies $w _ { 1 } = w _ { 2 } = \cdot \cdot \cdot = w _ { m }$ . The same argument applies to $i , j \in G _ { 2 }$ and we conclude $w _ { m + 1 } = w _ { m + 2 } = \cdot \cdot \cdot = w _ { m + d }$ similarly.
+
+Next, we calculate the ratio between $w _ { 1 } , w _ { m + 1 }$ .
+
+$$
+\begin{array} { r l } { R ( f ) } & { = P r \{ f ( x ) \neq y \} } \\ & { = P r \{ f ( x ) = 1 | y = - 1 \} \cdot P r \{ y = - 1 \} + P r \{ f ( x ) = - 1 | y = 1 \} \cdot P r \{ y = + 1 \} } \\ & { \propto P r \{ w ^ { T } x + b > 0 | y = - 1 \} + P r \{ w ^ { T } x + b < 0 | y = - 1 \} } \\ & { = P r \{ \underset { i \in G _ { 1 } } { \sum } w , N ( - \gamma , \sigma _ { - 1 } ^ { 2 } ) + \underset { j \in G _ { 2 } } { \sum } w _ { j } \mathcal { N } ( - \eta , \sigma _ { - 1 } ^ { 2 } ) + b > 0 | y = - 1 \} } \\ & { \quad + P r \{ \underset { i \in G _ { 1 } } { \sum } w _ { i } \mathcal { N } ( + \gamma , \sigma _ { + 1 } ^ { 2 } ) + \underset { j \in G _ { 2 } } { \sum } w _ { j } \mathcal { N } ( + \eta , \sigma _ { + 1 } ^ { 2 } ) + b < 0 | y = + 1 \} } \\ &  = P r \{ \mathcal { N } ( 0 , 1 ) < \underset { i \in G _ { 1 } } { \underbrace { \frac { b - m w _ { 1 } \gamma - d w _ { m + 1 } \eta } { \sqrt { m w _ { 1 } ^ { 2 } + d w _ { m + 1 } ^ { 2 } \sigma } } } } \} + P r \{ \mathcal { N } ( 0 , 1 ) < \underset { i \in \mathcal { N } _ { 1 } ^ { 2 } \times \underset { i \in \mathcal { N } _ { m + 1 } ^ { 2 } + d w _ { m + 1 } ^ { 2 } \sigma _ { K } ^ { 2 } } { \underbrace { \frac { - b - m w _ { 1 } \gamma - d w _ { m + 1 } \eta } { \sqrt { m w _ { 1 } ^ { 2 } + d w _ { m + 1 } ^ { 2 } \sigma } } } } \} } \end{array}
+$$
+
+We derive the optimal $w _ { 1 }$ and $w _ { m + 1 }$ by taking ∂R(f) = 0 and $\frac { \partial R ( f ) } { \partial w _ { m + 1 } } = 0$
+
+$$
+\frac { \partial R ( f ) } { \partial w _ { 1 } } = \frac { 1 } { \sqrt { 2 \pi } } \exp \Big ( - \frac { 1 } { 2 } \left( Z ( - 1 ) \right) ^ { 2 } \Big ) \cdot \frac { \partial Z ( - 1 ) } { \partial w _ { 1 } } + \frac { 1 } { \sqrt { 2 \pi } } \exp \Big ( - \frac { 1 } { 2 } \left( Z ( + 1 ) \right) ^ { 2 } \Big ) \cdot \frac { \partial Z ( + 1 ) } { \partial w _ { 1 } } = 0
+$$
+
+$$
+\frac { \partial R ( f ) } { \partial w _ { m + 1 } } = \frac { 1 } { \sqrt { 2 \pi } } \exp \Big ( - \frac { 1 } { 2 } \left( Z ( - 1 ) \right) ^ { 2 } \Big ) \cdot \frac { \partial Z ( - 1 ) } { \partial w _ { m + 1 } } + \frac { 1 } { \sqrt { 2 \pi } } \exp \Big ( - \frac { 1 } { 2 } \left( Z ( + 1 ) \right) ^ { 2 } \Big ) \cdot \frac { \partial Z ( + 1 ) } { \partial w _ { m + 1 } } = 0
+$$
+
+These imply
+
+$$
+\frac { \partial Z ( - 1 ) } { \partial w _ { 1 } } / \frac { \partial Z ( + 1 ) } { \partial w _ { 1 } } = \frac { \partial Z ( - 1 ) } { \partial w _ { m + 1 } } / \frac { \partial Z ( + 1 ) } { \partial w _ { m + 1 } }
+$$
+
+and therefore
+
+$$
+\frac { - \gamma d w _ { m + 1 } ^ { 2 } - b w _ { 1 } + d \eta w _ { 1 } w _ { m + 1 } } { - \gamma d w _ { m + 1 } ^ { 2 } + b w _ { 1 } + d \eta w _ { 1 } w _ { m + 1 } } = \frac { - \eta m w _ { 1 } ^ { 2 } - b w _ { 2 } + m \gamma w _ { 1 } w _ { m + 1 } } { - \eta m w _ { 1 } ^ { 2 } + b w _ { m + 1 } + m \gamma w _ { 1 } w _ { m + 1 } } .
+$$
+
+Simplifying it gives $w _ { 1 } : w _ { m + 1 } = \eta : \gamma .$ .
+
+Then, we calculate the ratio between $w _ { 1 }$ and $b$ . Based on the relation between $w _ { 1 }$ and $w _ { m + 1 }$ , we let $w _ { 1 } = \gamma w$ and $w _ { m + 1 } = \eta w$ for some constant $w .$ Substitute $w _ { 1 }$ and $w _ { m + 1 }$ into Eq. (23), we have
+
+$$
+\begin{array} { c l r } { { } } & { { } } & { { R ( f , - 1 ) = P r \{ { \cal N } ( 0 , 1 ) < \displaystyle \frac { b } { \sigma w \sqrt { w \gamma ^ { 2 } + d \eta ^ { 2 } } } - \frac { m \gamma ^ { 2 } w + d \eta ^ { 2 } w } { \sigma w \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } } } \} } } \\ { { } } & { { } } & { { } } \\ { { } } & { { } } & { { = P r \{ { \cal N } ( 0 , 1 ) < \displaystyle \frac { b } { \sigma w \sqrt { w \gamma ^ { 2 } + d \eta ^ { 2 } } } - \frac { \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } } } { \sigma } \} , } } \end{array}
+$$
+
+$$
+R ( f , + 1 ) = P r \{ { \cal N } ( 0 , 1 ) < \frac { - b } { \sigma w K \sqrt { w \gamma ^ { 2 } + d \eta ^ { 2 } } } + \frac { \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } } } { K \sigma } \} .
+$$
+
+For simplicity, we denote $A = \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } }$ and assume $\begin{array} { r } { w _ { o } = \frac { b } { w } } \end{array}$ . We will find optimal $b$ by letting ∂[R(f,−1)+R(f,+1)] = 0. In detail, it is
+
+$$
+\frac { 1 } { A \sigma \sqrt { 2 \pi } } \exp ( - \frac { 1 } { 2 } ( \frac { w _ { 0 } } { A \sigma } - \frac { A } { \sigma } ) ^ { 2 } ) - \frac { 1 } { K A \sigma \sqrt { 2 \pi } } \exp ( - \frac { 1 } { 2 } ( \frac { w _ { 0 } } { K A \sigma } - \frac { A } { K \sigma } ) ^ { 2 } ) = 0
+$$
+
+which gives $\begin{array} { r } { \frac { 1 } { 2 } ( \frac { w _ { 0 } } { K A \sigma } + \frac { A } { K \sigma } ) ^ { 2 } + \frac { 1 } { 2 } ( \frac { w _ { o } } { A \sigma } - \frac { A } { \sigma } ) ^ { 2 } ) = 2 \log K } \end{array}$ and therefore we obtain
+
+$$
+w _ { 0 } = A ^ { 2 } \frac { K ^ { 2 } + 1 } { K ^ { 2 } - 1 } - A ^ { 2 } K \sqrt { \frac { 4 } { ( K ^ { 2 } - 1 ) ^ { 2 } } + \frac { 2 \sigma ^ { 2 } \log K } { A ^ { 2 } ( K ^ { 2 } - 1 ) } } .
+$$
+
+Proof 2 (Proof of Theorem 1) Substitute the optimal linear model $\{ w , b \}$ in Eq. (23), we have clean errors
+
+$$
+\begin{array} { r } { \mathcal { R } _ { n a t } ( f , - 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f , - 1 ) \} , } \\ { \mathcal { R } _ { n a t } ( f , + 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f , + 1 ) \} , } \end{array}
+$$
+
+where
+
+$$
+\begin{array} { r } { Z _ { n a t } ( f , - 1 ) \} = \frac { 2 A } { ( K ^ { 2 } - 1 ) \sigma } - K \sqrt { \frac { 4 A ^ { 2 } } { ( K ^ { 2 } - 1 ) ^ { 2 } } + \frac { 2 \log K } { ( K ^ { 2 } - 1 ) } } , } \\ { Z _ { n a t } ( f , + 1 ) \} = \frac { - 2 K A } { ( K ^ { 2 } - 1 ) \sigma } + \sqrt { \frac { 4 A ^ { 2 } } { ( K ^ { 2 } - 1 ) ^ { 2 } \sigma ^ { 2 } } + \frac { 2 \log K } { ( K ^ { 2 } - 1 ) } } . } \end{array}
+$$
+
+Substitute the optimal linear model $\{ w , b \}$ into robust error in Eq. (35) and (36), we have robust errors:
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { r o b } ( f , - 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f , - 1 ) + \frac { m \gamma + d \eta } { \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } } } \frac { \epsilon _ { 0 } } { \sigma } \} , } \\ & { \mathcal { R } _ { r o b } ( f , + 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f , + 1 ) + \frac { m \gamma + d \eta } { \sqrt { m \gamma ^ { 2 } + d \eta ^ { 2 } } } \frac { \epsilon _ { 0 } } { K \sigma } \} . } \end{array}
+$$
+
+# B.2 PROOF OF THEOREM 2
+
+Before proving Theorem 2, we first establish the optimal linear classifier in adversarial training through Lemma 2, which facilitates us to prove the clean error and robust error after adversarial training.
+
+Lemma 2 (Optimal linear model in adversarial training) For the data distribution assumed in Eq. (1), the adversarially trained linear classifier $f ( x ) \stackrel { - } { = } s i g n ( w ^ { T } x + b )$ has the optimal weight that satisfy: $w _ { 1 } = w _ { 2 } = \cdot \cdot \cdot = w _ { m }$ , $w _ { m + 1 } = w _ { m + 2 } = \cdot \cdot \cdot = w _ { m + b } = 0$ and $b : w _ { 1 } = w _ { 0 } : 1$ where
+
+$$
+w _ { 0 } = m ( \gamma - \epsilon ) ^ { 2 } \frac { K ^ { 2 } + 1 } { K ^ { 2 } - 1 } - m ( \gamma - \epsilon ) ^ { 2 } K \sqrt { \frac { 4 } { ( K ^ { 2 } - 1 ) ^ { 2 } } + \frac { 2 \sigma ^ { 2 } \log K } { m ( \gamma - \epsilon ) ^ { 2 } ( K ^ { 2 } - 1 ) } } .
+$$
+
+# Proof 3 (Proof of Lemma 2)
+
+$$
+\begin{array} { r l } & { \displaystyle R _ { r o b } ( f , - 1 ) = P r \{ \exists \| \delta \| \le \epsilon , f ( x + \delta ) > 0 \mid y = - 1 \} } \\ & { \quad \quad = P r \{ \underset { \| \delta \| \le \epsilon } { \operatorname* { m a x } } f ( x + \delta ) > 0 \mid y = - 1 \} } \\ & { \quad \quad = P r \{ \underset { \| \delta \| \le \epsilon } { \operatorname* { m a x } } \underset { i = 1 } { \overset { m } { \sum } } w _ { i } ( \mathcal { N } ( - \gamma , \sigma _ { - 1 } ^ { 2 } ) + \delta _ { i } ) + \underset { i = m + 1 } { \overset { m + d } { \sum } } w _ { i } ( \mathcal { N } ( - \eta , \sigma _ { - 1 } ^ { 2 } ) + \delta _ { i } ) + b > 0 \} . } \end{array}
+$$
+
+Similarly, we have
+
+$$
+\begin{array} { r l } & { \displaystyle R _ { r o b } ( f , + 1 ) = P r \{ \exists \ | \delta | \leq \epsilon , f ( x + \delta ) < 0 | y = + 1 \} } \\ & { \quad \quad = P r \{ \underset { \| \delta \| \leq \epsilon } { \operatorname* { m a x } } \ f ( x + \delta ) > | y = + 1 \} } \\ & { \quad \quad = P r \{ \underset { \| \delta \| \leq \epsilon } { \operatorname* { m a x } } \left\{ \displaystyle \sum _ { i = 1 } ^ { m } w _ { i } ( \mathcal { N } ( \gamma , \sigma _ { + 1 } ^ { 2 } ) + \delta _ { i } ) + \sum _ { i = m + 1 } ^ { m + d } w _ { i } ( \mathcal { N } ( + \eta , \sigma _ { + 1 } ^ { 2 } ) + \delta _ { i } ) \right\} + b < 0 \} . } \end{array}
+$$
+
+To prove the theorem by contradiction, we first assume that for the optimal $w$ , there exist some $w _ { i } > 0$ where $i \in G _ { 2 } = \{ m + 1 , m + 2 , \ldots , m + d \}$ . Then
+
+$$
+R _ { r o b } ( f , - 1 ) = P r \{ \underset { \underset { j \neq i } { \underbrace { \sum _ { j \neq i } | \delta _ { j } | \leq \epsilon } } } { \underbrace { \sum _ { j \neq i } \operatorname* { m a x } } } w _ { j } ( \mathcal { N } ( \theta _ { j } , \sigma _ { - 1 } ^ { 2 } ) + \delta _ { j } ) + b + \underset { \mathbb { S } } { \underbrace { \operatorname* { m a x } } } w _ { i } ( \mathcal { N } ( - \eta , \sigma _ { - 1 } ^ { 2 } ) + \delta _ { i } ) > 0 \} .
+$$
+
+Because $w _ { i } > 0$ , $\mathbb { B }$ is maximized when $\delta = \epsilon$ . We obtain
+
+$$
+R _ { r o b } ( f , - 1 ) = P r \{ \mathbb { A } + w _ { i } N ( - \eta + \epsilon , \sigma _ { - 1 } ^ { 2 } ) > 0 \} \ge P r \{ \mathbb { A } > 0 \}
+$$
+
+So $w _ { i } = 0$ gives a better robust error. We can also assume $w _ { i } < 0$ and use similar contradiction to prove $w _ { i } = 0$ . Similar argument holds for $R _ { r o b } ( f , + 1 )$ . Therefore, we arrive at the conclusion $w _ { i } = 0$ for all $m + 1 \leq i \leq m + d$ . The calculation of $w _ { 0 }$ is similar to the proof of Lemma 1 and we omit the proof here.
+
+Proof 4 (Proof of Theorem 2) Substitute the optimal linear model in Lemma 2 into Eq. (23), we obtain the clean error on the adversarially trained model:
+
+$$
+\begin{array} { r l } & { R _ { n a t } ( f , - 1 ) = P r \{ N ( 0 , 1 ) < \underbrace { \frac { 2 \sqrt { m } ( \gamma - \epsilon ) } { ( K ^ { 2 } - 1 ) \sigma } - K \sqrt { \frac { 4 m ( \gamma - \epsilon ) ^ { 2 } } { ( K ^ { 2 } - 1 ) ^ { 2 } \sigma ^ { 2 } } + \frac { 2 \log K } { K ^ { 2 } - 1 } } } _ { Z _ { n a t } ( f _ { a b } , - 1 ) } \} , } \\ & { R _ { n a t } ( f , + 1 ) = P r \{ N ( 0 , 1 ) < \underbrace { - \frac { 2 \sqrt { m } ( \gamma - \epsilon ) } { ( K ^ { 2 } - 1 ) \sigma } + K \sqrt { \frac { 4 m ( \gamma - \epsilon ) ^ { 2 } } { ( K ^ { 2 } - 1 ) ^ { 2 } \sigma ^ { 2 } } + \frac { 2 \log K } { K ^ { 2 } - 1 } } } _ { Z _ { n a t } ( f _ { a b } , + 1 ) } \} . } \end{array}
+$$
+
+Substitute the optimal linear model in Lemma 2 into Eq. (35) and (36), we obtain the robust error on the adversarially trained model:
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { r o b } ( f _ { a d \nu } , - 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f _ { a d \nu } , - 1 ) + \sqrt { m } \frac { \epsilon _ { 0 } } { \sigma } \} , } \\ & { \mathcal { R } _ { r o b } ( f _ { a d \nu } , + 1 ) = P r \{ \mathcal { N } ( 0 , 1 ) \leq Z _ { n a t } ( f _ { a d \nu } , + 1 ) + \sqrt { m } \frac { \epsilon _ { 0 } } { K \sigma } \} . } \end{array}
+$$
+
+# B.3 PROOF OF COROLLARY 1
+
+Proof 5 (Proof of Corollary 1) We try to show $R ^ { \prime } ( f , + 1 ) - R ^ { \prime } ( f , - 1 ) > R ( f , + 1 ) - R ( f , - 1 ) .$
+
+$$
+\begin{array} { r l } & { R ^ { \prime } ( f , + 1 ) - R ^ { \prime } ( f , - 1 ) = \displaystyle \int _ { Z ^ { \prime } ( - 1 ) } ^ { Z ^ { \prime } ( + 1 ) } g ( x ) d x = \underbrace { g ( \epsilon ^ { \prime } ) } _ { \mathcal { C } } \underbrace { ( Z ^ { \prime } ( + 1 ) - Z ^ { \prime } ( - 1 ) ) } _ { A } } \\ & { R ( f , + 1 ) - R ( f , - 1 ) = \displaystyle \int _ { Z ( - 1 ) } ^ { Z ( + 1 ) } g ( x ) d x = \underbrace { g ( \epsilon ) } _ { \mathcal { D } } \underbrace { ( Z ( + 1 ) - Z ( - 1 ) ) } _ { B } } \end{array}
+$$
+
+where $Z ^ { \prime } ( - 1 ) \leq \epsilon ^ { \prime } \leq Z ^ { \prime } ( + 1 )$ and $Z ( - 1 ) \leq \epsilon \leq Z ( + 1 )$ according to Mean Value Theorem. Here $g ( \cdot )$ is the density function of standard normal distribution.
+
+Next, we try to show: $\begin{array} { r } { \frac { R ^ { \prime } ( f , + 1 ) - R ^ { \prime } ( f , - 1 ) } { R ( f , + 1 ) - R ( f , - 1 ) } = \frac { A \mathcal { C } } { B \mathcal { D } } > 1 , } \end{array}$ . Remind that
+
+$$
+\begin{array} { c } { { Z ( - 1 ) = \displaystyle \frac { 2 \sqrt { m + d } \Theta ( \gamma ) } { \sigma ( K ^ { 2 } - 1 ) } - K \sqrt { \displaystyle \frac { 4 m \Theta ( \gamma ^ { 2 } ) } { ( K ^ { 2 } - 1 ) ^ { 2 } \sigma ^ { 2 } } + \frac { 2 \log K } { K ^ { 2 } - 1 } } } } \\ { { = \displaystyle \frac { 2 \Theta ( \gamma ) } { ( K ^ { 2 } - 1 ) \sigma } ( \sqrt { m + d } - K \sqrt { m + d + q ( K ) } ) } } \\ { { \propto ( \sqrt { m + d } - K \sqrt { m + d + q ( K ) } ) , } } \end{array}
+$$
+
+where q(K) = σ2(K2−1) log K , and similarly we have
+
+$$
+\begin{array} { l } { { Z ( + 1 ) \propto ( - K \sqrt { m + d } + \sqrt { m + d + q ( K ) } ) , } } \\ { { Z ^ { \prime } ( - 1 ) \propto ( \sqrt { m } - K \sqrt { m + q ( K ) } ) , } } \\ { { Z ^ { \prime } ( + 1 ) \propto ( - K \sqrt { m } + \sqrt { m + q ( K ) } ) . } } \end{array}
+$$
+
+Therefore, we derive
+
+$$
+\begin{array} { r l } & { \frac { A } { B } = \frac { Z ^ { \prime } ( + 1 ) - Z ^ { \prime } ( - 1 ) } { Z ( + 1 ) - Z ( - 1 ) } } \\ & { \quad \propto \frac { ( - K \sqrt { m } + \sqrt { m + q ( K ) } ) - ( \sqrt { m } - K \sqrt { m + q ( K ) } ) } { ( - K \sqrt { m } + \sqrt { m + d + q ( K ) } ) - ( \sqrt { m } - K \sqrt { m + d + q ( K ) } ) } } \\ & { \quad = \frac { \sqrt { m + q ( K ) } - \sqrt { m } } { \sqrt { m + d + q ( K ) } - \sqrt { m + d } } } \\ & { \quad = \frac { \sqrt { m + d + q ( K ) } + \sqrt { m + d } } { \sqrt { m + q ( K ) } + \sqrt { m } } } \\ & { \quad = \Theta ( ( \frac { d } { m } ) ^ { \frac { 1 } { 2 } } ) } \end{array}
+$$
+
+and
+
+$$
+\frac { \mathcal { C } } { \mathcal { D } } = \frac { g ( \epsilon ^ { \prime } ) } { g ( \epsilon ) }
+$$
+
+where $Z ^ { \prime } ( - 1 ) \leq \epsilon ^ { \prime } \leq Z ^ { \prime } ( + 1 )$ and $Z ( - 1 ) \leq \epsilon \leq Z ( + 1 )$
+
+Finally,
+
+$$
+\frac { A B } { \mathcal { C D } } \geq q ( K ) \cdot \Theta ( ( \frac { d } { m } ) ^ { \frac { 1 } { 2 } } )
+$$