Add files using upload-large-folder tool

parse/train/QpT9Q_NNfQL/QpT9Q_NNfQL.md

@@ -0,0 +1,454 @@
+# NEURWIN: NEURAL WHITTLE INDEX NETWORK FOR RESTLESS BANDITS VIA DEEP RL
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Whittle index policy is a powerful tool to obtain asymptotically optimal solutions for the notoriously intractable problem of restless bandits. However, finding the Whittle indices remains a difficult problem for many practical restless bandits with convoluted transition kernels. This paper proposes NeurWIN, a neural Whittle index network that seeks to learn the Whittle indices for any restless bandits by leveraging mathematical properties of the Whittle indices. We show that a neural network that produces the Whittle index is also one that produces the optimal control for a set of Markov decision problems. This property motivates using deep reinforcement learning for the training of NeurWIN. We demonstrate the utility of NeurWIN by evaluating its performance for three recently studied restless bandit problems. Our experiment results show that the performance of NeurWIN is either better than, or as good as, state-of-the-art policies for all three problems.
+
+# 1 INTRODUCTION
+
+Many sequential decision problems can be modeled as multi-armed bandit problems. A bandit problem models each potential decision as an arm. In each round, we play $M$ arms out of a total of $N$ arms by choosing the corresponding decisions. We then receive a reward from the played arms. The goal is to maximize the long-term total discounted reward. Consider, for example, displaying advertisements on an online platform with the goal to maximize the long-term discounted clickthrough rates. This can be modeled as a bandit problem where each arm is a piece of advertisement and we choose which advertisements to be displayed every time a particular user visits the platform. It should be noted that the reward, i.e., click-through rate, of an arm is not stationary, but depends on our actions in the past. For example, a user that just clicked on a particular advertisement may be much less likely to click on the same advertisement in the near future. Such a problem is a classic case of the restless bandit problem, where the reward distribution of an arm depends on its state, which changes over time based on our past actions.
+
+The restless bandit problem is notoriously intractable (Papadimitriou & Tsitsiklis, 1999). Most recent efforts, such as recovering bandits (Pike-Burke & Grunewalder, 2019), rotting bandits (Seznec et al., 2020), and Brownian bandits (Slivkins & Upfal, 2008), only study some special instances of the restless bandit problem. The fundamental challenge of the restless bandit problem lies in the explosion of state space, as the state of the entire system is the Cartesian product of the states of individual arms. A powerful tool to address the explosion of state space is the Whittle index policy (Whittle, 1988). In a nutshell, the Whittle index policy calculates a Whittle index for each arm based on the arm’s current state, where the index loosely corresponds to the amount of cost that we are willing to pay to play the arm, and then plays the arm with the highest index. It has been shown that the Whittle index policy is either optimal or asymptotically optimal in many settings.
+
+In this paper, we present Neural Whittle Index Network (NeurWIN), a principled machine learning approach that finds the Whittle indices for virtually all restless bandit problems. We note that the Whittle index is an artificial construct that cannot be directly measured. Finding the Whittle index is typically intractable. As a result, the Whittle indices of many practical problems remain unknown except for a few special cases.
+
+We are able to circumvent the challenges of finding the Whittle indices by leveraging an important mathematical property of the Whittle index: Consider an alternative problem where there is only one arm and we decide whether to play the arm in each time instance. In this problem, we need to pay a constant cost of $\lambda$ every time we play the arm. The goal is to maximize the long-term discounted net reward, defined as the difference between the rewards we obtain from the arm and the costs we pay to play it. Then, the optimal policy is to play the arm whenever the Whittle index becomes larger than $\lambda$ . Based on this property, a neural network that produces the Whittle index can be viewed as one that finds the optimal policy for the alternative problem for any $\lambda$ .
+
+Using this observation, we propose a deep reinforcement learning method to train NeurWIN. To demonstrate the power of NeurWIN, we employ NeurWIN for three recently studied restless bandit problems, namely, recovering bandit (Pike-Burke & Grunewalder, 2019), wireless scheduling (Aalto et al., 2015), and stochastic deadline scheduling (Yu et al., 2018). There is no known Whittle index for the first problem, and there is only an approximation of the Whittle index under some relaxations for the second problem. Only the third problem has a precise characterization of the Whittle index. For the first two problems, the index policy using our NeurWIN achieves better performance than existing studies. For the third problem, the index policy using our NeurWIN has virtually the same performance as the Whittle index policy.
+
+The rest of the paper is organized as follows: Section 2 reviews related literature. Section 3 provides formal definitions of the Whittle index and our problem statement. Section 4 introduces our training algorithm for NeurWIN. Section 5 demonstrates the utility of NeurWIN by evaluating its performance under three recently studied restless bandit problems. Finally, Section 6 concludes the paper.
+
+# 2 RELATED WORK
+
+Restless bandit problems were first introduced in (Whittle, 1988). They are known to be intractable, and are in general PSPACE hard (Papadimitriou & Tsitsiklis, 1999). As a result, many studies focus on finding the Whittle index policy for restless bandit problems, such as in (Le Ny et al., 2008; Meshram et al., 2018; Tripathi & Modiano, 2019; Dance & Silander, 2015). However, these studies are only able to find the Whittle indices under various specific assumptions about the bandit problems.
+
+There has been a lot of studies on applying RL methods for bandit problems. (Dann et al., 2017) proposed a tool called Uniform-PAC for contextual bandits. (Zanette & Brunskill, 2018) described a framework-agnostic approach towards guaranteeing RL algorithms’ performance. (Jiang et al., 2017) introduced contextual decision processes (CDPs) that encompass contextual bandits for RL exploration with function approximation. (Riquelme et al., 2018) compared deep neural networks with Bayesian linear regression against other posterior sampling methods. However, none of these studies are applicable to restless bandits, where the state of an arm can change over time.
+
+Deep RL algorithms have been utilized in problems that resemble restless bandit problems, including HVAC control (Wei et al., 2017), cyber-physical systems (Leong et al., 2020), and dynamic multichannel access (Wang et al., 2018). In all these cases, a major limitation for deep RL is scalability. As the state spaces grows exponentially with the number of arms, these studies can only be applied to small-scale systems, and their evaluations are limited to cases when there are at most 5 zones, 6 sensors, and 8 channels, respectively.
+
+An emerging research direction is applying machine learning algorithms to learn Whittle indices. (Borkar & Chadha, 2018) proposed employing the LSPE(0) algorithm (Yu & Bertsekas, 2009) coupled with a polynomial function approximator. The approach was applied in (Avrachenkov & Borkar, 2019) for scheduling web crawlers. However, this work can only be applied to restless bandits whose states can be represented by a single number, and it only uses a polynomial function approximator, which may have low representational power (Sutton & Barto, 2018). (Fu et al., 2019) proposed a Q-learning based heuristic to find Whittle indices. However, as shown in its experiment results, the heuristic may not produce Whittle indices even when the training converges.
+
+# 3 PROBLEM SETTING
+
+In this section, we provide a brief overview of restless bandit problems and the Whittle index. We then formally define the problem statement.
+
+# 3.1 RESTLESS BANDIT PROBLEMS
+
+A restless bandit problem consists of $N$ restless arms. In each round $t$ , a control policy observes the state of each arm $i$ , denoted by $s _ { i } [ t ]$ , and selects $M$ arms to activate. We call the selected arms as active and the others as passive. We use $a _ { i } [ t ]$ to denote the policy’s decision on each arm $i$ , where $a _ { i } [ t ] = 1$ if the arm is active and $a _ { i } [ t ] = 0$ if it is passive at round $t$ . Each arm $i$ generates a stochastic reward $r _ { i } [ t ]$ with distribution $R _ { i , a c t } ( s _ { i } [ t ] )$ if it is active, and with distribution $R _ { i , p a s s } ( s _ { i } [ t ] )$ if it is passive. The state of each arm $i$ in the next round evolves by the transition kernel of either $\bar { P _ { i , a c t } } ( s _ { i } [ t ] )$ or $P _ { i , p a s s } ( s _ { i } [ t ] )$ , depending on whether the arm is active. The goal of the control policy is to maximize the total discounted reward, which can be expressed as $\begin{array} { r } { \sum _ { t = 1 } ^ { \infty } \sum _ { i = 1 } ^ { N } \beta ^ { t } r _ { i } [ t ] } \end{array}$ with $\beta$
+
+A control policy is effectively a function that takes the vector $( s _ { 1 } [ t ] , s _ { 2 } [ t ] , \ldots , s _ { N } [ t ] )$ as the input and produces the vector $( a _ { 1 } [ t ] , a _ { 2 } [ t ] , \dotsc , a _ { N } [ t ] )$ as the output. It should be noted that the space of input is exponential in $N$ . If each arm can be in one of $K$ possible states, then the number of possible inputs is $\bar { K } ^ { N }$ . This feature, which is usually referred to as the curse of dimensionality, makes finding the optimal control policy intractable.
+
+# 3.2 THE WHITTLE INDEX
+
+An index policy seeks to address the curse of dimensionality through decomposition. In each round, it calculates an index, denoted by $W _ { i } ( s _ { i } [ t ] )$ , for each arm $i$ based on its current state. The index policy then selects the $M$ arms with the highest indices to activate. It should be noted that the index of an arm $i$ is independent from the states of any other arms.
+
+Obviously, the performance of an index policy depends on the design of the index function $W _ { i } ( \cdot )$ . A popular index with solid theoretical foundation is the Whittle index, which is defined below. Since we only consider one arm at a time, we drop the subscript $i$ for the rest of the paper.
+
+Consider a system with only one arm, and a control policy that determines whether to activate the arm in each round $t$ . Suppose that the policy needs to pay an activation cost of $\lambda$ every time it chooses to activate the arm. The goal of the control policy is to maximize the total discounted net reward, $\begin{array} { r } { \sum _ { t = 1 } ^ { \infty } \beta ^ { t } ( \boldsymbol { r } [ t ] - \lambda a [ t ] ) } \end{array}$ . The optimal control policy can be expressed by the set of states in which it would activate this arm for a particular $\lambda$ , and we denote this set by $\boldsymbol { \mathcal { A } } ( \boldsymbol { \lambda } )$ . Intuitively, the higher the cost, the less likely the optimal control policy would activate the arm in a given state, and hence the set $\boldsymbol { \mathcal { A } } ( \boldsymbol { \lambda } )$ should decrease monotonically. When an arm satisfies this intuition, we say that the arm is indexable.
+
+Definition 1 (Indexability). An arm is said to be indexable if $\boldsymbol { \mathcal { A } } ( \lambda )$ decreases monotonically from the set of all states to the empty set as $\lambda$ increases from $- \infty$ to $\infty$ . A restless bandit problem is said to be indexable if all arms are indexable.
+
+Definition 2 (The Whittle Index). If an arm is indexable, then its Whittle index of each state s is defined as $W ( s ) : = \operatorname* { s u p } _ { \lambda } \{ \lambda : s \in { \dot { A } } ( \lambda ) \}$ .
+
+Even when an arm is indexable, finding its Whittle index can still be intractable, especially when the transition kernel of the arm is convoluted1. Our NeurWIN finds the Whittle index by leveraging the following property of the Whittle index: Consider the single-armed bandit problem. Suppose the initial state of an indexable arm is $s$ at round one. Consider two possibilities: The first is that the control policy activates the arm at round one, and then uses the optimal policy starting from round two; and the second is that the control policy does not activate the arm at round one, and then uses the optimal policy starting from round two. Let $Q _ { \lambda , a c t } ( s )$ and $Q _ { \lambda , p a s s } ( s )$ be the expected discounted net reward for these two possibilities, respectively, and let $D _ { s } ( \lambda ) : = \left( Q _ { \lambda , a c t } ( s ) - Q _ { \lambda , p a s s } ( s ) \right)$ be their difference. Clearly, the optimal policy should activate an arm under state $s$ and activation cost $\lambda$ if $D _ { s } ( \lambda ) \geq 0$ . We then have the following:
+
+Theorem 1. (Zhao, 2019, Thm 3.14) If an arm is indexable, then, for every state $s _ { : }$ , $D _ { s } ( \lambda ) \geq 0 i f$ and only if $\lambda \leq W ( s )$ .
+
+Our NeurWIN uses Thm. 1 to train neural networks that predict the Whittle index for any indexable arms. From Def. 1, a sufficient condition for indexability is when $D _ { s } ( \lambda )$ is a decreasing function. Thus, we define the concept of strong indexability as follows:
+
+Definition 3 (Strong Indexability). An arm is said to be strongly indexable if $D _ { s } ( \lambda )$ is strictly decreasing in λ for every state s.
+
+# 3.3 PROBLEM STATEMENT
+
+We now formally describe the objective of this paper. We assume that we are given a simulator of one single restless arm as a black box. The simulator provides two functionalities: First, it allows us to set the initial state of the arm to any arbitrary state $s$ . Second, in each round $t$ , the simulator takes $a [ t ]$ , the indicator function that the arm is activated, as the input and produces the next state $s [ t + 1 ]$ and the reward $r [ t ]$ as the outputs.
+
+Our goal is to derive low-complexity index algorithms for restless bandit problems by training a neural network that approximates the Whittle index of each restless arm using its simulator. A neural network takes the state $s$ as the input and produces a real number $f _ { \theta } ( s )$ as the output, where $\theta$ is the vector containing all weights and biases of the neural network. Recall that $W ( s )$ is the Whittle index of the arm. We aim to find appropriate $\theta$ that makes $| f _ { \theta } ( s ) - W ( s ) |$ small for all $s$ . Such a neural network is said to be Whittle-accurate.
+
+Definition 4 (Whittle-accurate). A neural network with parameters $\theta$ is said to be $\gamma$ -Whittleaccurate $i f \vert f _ { \theta } ( s ) - W ( s ) \vert \leq \gamma ,$ , for all $s$ .
+
+# 4 NEURWIN ALGORITHM: NEURAL WHITTLE INDEX NETWORK
+
+In this section, we present NeurWIN, a deep-RL algorithms that trains neural networks to predict the Whittle indices. Since the Whittle index of an arm is independent from other arms, NeurWIN trains one neural network for each arm independently. In this section, we discuss how NeurWIN trains the Whittle index for one single arm.
+
+# 4.1 CONDITIONS FOR WHITTLE-ACCURATE
+
+![](images/813104b72f4ae619d291e6960f1af44abcaecd868b99cd51f9720a4ea53cb9d6.jpg)  
+Figure 1: An illustrative motivation of NeurWIN.
+
+Before presenting NeurWIN, we first discuss the conditions for a neural network to be $\gamma \cdot$ -Whittleaccurate.
+
+Suppose we are given a simulator of an arm and a neural network with parameters $\theta$ . We can then construct an environment of the arm along with an activation cost $\lambda$ as shown in Fig. 1. In each round $t$ , the environment takes the real number $f _ { \theta } ( s [ t ] )$ as the input. The input is first fed into a step function to produce $a [ t ] = 1 \bigl ( f _ { \theta } ( s [ t ] ) \geq \lambda \bigr )$ , where $1 ( \cdot )$ is the indicator function. Then, $a ( t )$ is fed into the simulator of the arm to produce $r [ t ]$ and $s [ t + 1 ]$ . Finally, the environment outputs the net reward $r [ t ] - \lambda a [ t ]$ and the next state $s [ t + 1 ]$ . We call this environment $E n v ( \lambda )$ . Thus, the neural network can be viewed as a controller for $E n v ( \lambda )$ . The following corollary is a direct result from Thm. 1.
+
+Corollary 1. If $f _ { \boldsymbol { \theta } } ( s ) = W ( s ) , \forall s$ , then the neural network with parameters $\theta$ is the optimal controller for $E n v ( \lambda )$ , for any $\lambda$ and initial state $s [ 1 ]$ . Moreover, given $\lambda$ and $s [ 1 ]$ , the optimal discounted net reward is $\operatorname* { m a x } \{ Q _ { \lambda , a c t } ( s [ 1 ] ) , Q _ { \lambda , p a s s } ( \bar { s } [ 1 ] ) \}$ .
+
+Corollary 1 can be viewed as a necessary condition for a neural network to be 0-Whittle-accurate.   
+Below, we establish a sufficient condition for $\gamma$ -Whittle-accuracy.
+
+Theorem 2. If the arm is strongly indexable, then for any $\gamma > 0$ and an arbitrarily small positive constant $\delta$ , there exists a positive  such that the following statement holds: $H ,$ for any states $s _ { 0 } , s _ { 1 }$ and any activation cost $\bar { \lambda ^ { \prime } } \in [ f _ { \theta } ( s _ { 0 } ) - \delta , f _ { \theta } ( s _ { 0 } ) + \delta ]$ , the discounted net reward of applying a neural network to $E n v ( \lambda )$ with initial state $s _ { 1 }$ is at least $\dot { \operatorname* { m a x } } \{ Q _ { \lambda , a c t } ( s _ { 1 } ) , Q _ { \lambda , p a s s } ( s _ { 1 } ) \} - \epsilon _ { \ i }$ , then the neural network is $\gamma$ -Whittle-accurate.
+
+Proof. For a given $\gamma$ , let $\epsilon = \operatorname * { m i n } _ { s } \lbrace \operatorname * { m i n } \lbrace Q _ { W ( s ) + \gamma , p a s s } ( s ) - Q _ { W ( s ) + \gamma , a c t } ( s ) , Q _ { W ( s ) - \gamma , a c t } ( s ) -$ $Q _ { W ( s ) - \gamma , p a s s } ( s ) \} \} / 2$ . Since the arm is strongly indexable and $W ( s )$ is its Whittle index, we have $\epsilon > 0$ .
+
+We prove the theorem by establishing the following equivalent statement: If the neural network is not $\gamma$ -Whittle-accurate, then there exists states $s _ { 0 } , s _ { 1 }$ , activation cost $\lambda \in [ f _ { \theta } ( s _ { 0 } ) - \delta , f _ { \theta } ( s _ { 0 } ) + \delta ]$ , such that the discounted net reward of applying a neural network to $E n v ( \lambda )$ with initial state $s _ { 1 }$ is strictly less than $\operatorname* { m a x } \{ Q _ { \lambda , a c t } ( s _ { 1 } ) , Q _ { \lambda , p a s s } ( s _ { 1 } ) \} - \epsilon$ .
+
+Suppose the neural network is not $\gamma$ -Whittle-accurate, then there exists a state $s ^ { \prime }$ such that $\left| f _ { \theta } ( s ^ { \prime } ) - \right.$ $W ( s ^ { \prime } ) | > \gamma$ . We set $s _ { 0 } = s _ { 1 } = s ^ { \prime }$ . For the case $f _ { \theta } ( s ^ { \prime } ) > W ( s ^ { \prime } ) + \gamma$ , we set $\lambda = f _ { \boldsymbol { \theta } } ( s ^ { \prime } ) + \delta$ . Since $\lambda > W ( s ^ { \prime } ) + \gamma$ , we have $\operatorname* { m a x } \{ Q _ { \lambda , a c t } ( s ^ { \prime } ) , Q _ { \lambda , p a s s } ( s ^ { \prime } ) \} = Q _ { \lambda , p a s s } ( s ^ { \prime } )$ and $Q _ { \lambda , p a s s } ( s ^ { \prime } ) \_$ $Q _ { \lambda , a c t } ( s ^ { \prime } ) \geq 2 \epsilon$ . On the other hand, since $f _ { \theta } ( s ^ { \prime } ) > \lambda$ , the neural network would activate the arm in the first round and its discounted reward is at most
+
+$$
+Q _ { \lambda , a c t } ( s ^ { \prime } ) < Q _ { \lambda , p a s s } ( s ^ { \prime } ) - 2 \epsilon < \operatorname * { m a x } \{ Q _ { \lambda , a c t } ( s ^ { \prime } ) , Q _ { \lambda , p a s s } ( s ^ { \prime } ) \} - \epsilon .
+$$
+
+For the case $f _ { \theta } ( s ^ { \prime } ) < W ( s ^ { \prime } ) - \gamma$ , a similar argument shows that the discounted reward for the neural network when $\lambda = f _ { \boldsymbol { \theta } } \big ( \boldsymbol { s } ^ { \prime } \big ) - \delta$ is smaller than $\operatorname* { m a x } \{ Q _ { \lambda , a c t } ( s ^ { \prime } ) , Q _ { \lambda , p a s s } ( s ^ { \prime } ) \} - \epsilon$ . This completes the proof. □
+
+# 4.2 TRAINING PROCEDURES FOR NEURWIN
+
+Thm. 2 states that a neural network that yields near-optimal net reward for any environments $E n v ( \lambda )$ is also Whittle-accurate. This observation motivates the usage of deep reinforcement learning to find Whittle-accurate neural networks. To make the output of the environments differentiable with respect to the input $f _ { \theta } ( s [ t ] )$ , we replace the step function in Fig. 1 with a sigmoid function $\sigma _ { m } ( f _ { \theta } ( s [ t ] ) - \lambda ) : = \left( 1 + e x p ( - m ( f _ { \theta } ( s [ t ] ) - \lambda ) ) \right) ^ { - 1 }$ , where $m$ is a sensitivity parameter. The environment then chooses $a [ t ] = 1$ with probability $\sigma _ { m } ( f _ { \theta } ( s [ t ] ) - \lambda )$ , and $a [ t ] = 0$ with probability $1 - \sigma _ { m } ( f _ { \theta } ( s [ t ] ) - \lambda )$ . We call this differentiable environment $E n v ^ { * } ( \lambda )$ .
+
+Our training procedure consists of multiple mini-batches, where each mini-batch is composed of a fixed number of episodes. At the beginning of each mini-batch, we randomly select two states $s _ { 0 }$ and $s _ { 1 }$ . Motivated by the condition in Thm. 2, we consider the environment $\Dot { E n } v ^ { * } ( f _ { \theta } ( s _ { 0 } ) )$ with initial state $s _ { 1 }$ and aim to improve the empirical discounted net reward of applying the neural network to such an environment.
+
+Our approach is based on the REINFORCE algorithm (Williams, 1992). In each episode $e$ , we set $\lambda = f _ { \theta } ( s _ { 0 } )$ and initial state to be $s _ { 1 }$ . We then apply the neural network with parameters $\theta$ to $E n v ^ { * } ( \lambda )$ and observe the sequences of actions $( a [ 1 ] , a [ 2 ] , \dots )$ and states $( s [ 1 ] , s [ 2 ] , \dots )$ . We can use these sequences to calculate their gradients with respect to $\theta$ through backward propagation, which we denote by $h _ { e }$ . We also observe the discounted net reward and denote it by $G _ { e }$ . After all episodes in the mini-batch finish, we calculate the average of all $G _ { e }$ as a bootstrapped baseline and denote it by $\bar { G } _ { b }$ . Finally, we do a weighted gradient ascent with the weight for episode $e$ being its offset net reward, $G _ { e } - \bar { G } _ { b }$ . When the step size is chosen appropriately, the neural network will be more likely to follow the sequences of actions of episodes with larger $G _ { e }$ after the weighted gradient ascent, and thus will have a better empirical discounted net reward. The complete algorithm is described in Alg. 1.
+
+Obviously, the choice of $s _ { 0 }$ and $s _ { 1 }$ can have significant impact on the convergence speed of Alg. 1. In our implementation, we choose $s _ { 0 }$ uniformly at random in each mini-batch. The choice of $s _ { 1 }$ depends on the bandit problems. Some bandit problems naturally visit certain states far less frequently than other states. For such problems, we choose $s _ { 1 }$ to be those less-frequently-visited states with higher probabilities, so as to ensure that Alg. 1 is able to learn the optimal control for these states. For other problems, we simply choose $s _ { 1 } = s _ { 0 }$ .
+
+# Algorithm 1: NeurWIN Training
+
+<table><tr><td>Input: Parameters 0,discount factor β ∈ (O,1),learning rate L,sigmoid parameter m Output: Trained neural network parameters 0+ foreachmini-batchbdo Randomly choose so and s1,and set X ← fe(so) ; foreach episode ein themini-batch do Set the arm to state s1,and set he ←O ; foreach round t in the episode do Choose a[t] =1 w.p.δm(fe(s[t])-λ),and a[t]=O w.p.1-δm(fe(s[t])-λ); if a[t]=1then he←he+Vθln(om(fe(s[t])-λ));</td></tr><tr><td>else end Ge ← empirical discounted net reward in episode e;</td></tr><tr><td>end</td></tr><tr><td>he←he+Vθln(1-δm(fe(s[t])-λ)) ;</td></tr></table>
+
+# 5 EXPERIMENTS
+
+# 5.1 OVERVIEW
+
+In this section, we demonstrate NeurWIN’s utility by evaluating it under three recently studied applications of restless bandit problems. In each application, we consider that there are $N$ arms and a controller can play $M$ of them in each round. We evaluate three different pairs of $( N , M )$ : $( 4 , 1 )$ , (100, 10), and (100, 25), and average the results of 200 independent runs when the problems are stochastic. Some applications consider that different arms can have different behaviors. For such scenarios, we consider that there are multiple types of arms and train a separate NeurWIN for each type. During testing, the controller calculates the index of each arm based on the arm’s state and schedules the $M$ arms with the highest indices.
+
+The performance of NeurWIN is compared against the proposed policies in the respective recent studies. In addition, we also implement and evaluate the REINFORCE algorithm (Williams, 1992) and the QWIC algorithm $\mathrm { F u }$ et al., 2019). The REINFORCE algorithm aims to find the optimal control by viewing a restless bandit problem as a Markov decision problem. Under this view, the number of states is exponential in $N$ and the number of possible actions is $\textstyle { \binom { N } { M } }$ . Thus, we are only able to evaluate REINFORCE for the case $N = 4$ and $M = 1$ . The QWIC algorithm aims to find the Whittle index through Q-learning. It is a tabular method and does not scale well as the state space increases. Thus, we only evaluate QWIC when the size of the state space is small.
+
+We use the same neural network architecture for NeurWIN in all three applications. The neural network is a fully connected one that consists of one input layer, one output layer, and two hidden layers. There are 16 and 32 neurons in the two hidden layers. The output layer has one neuron, and the input layer size is the same as the dimension of the state of one single arm. As for the REINFORCE algorithm, we choose the neural network architecture so that the total number of parameters is slightly more than $N$ times as the number of parameters in NeurWIN to make a fair comparison. ReLU activation function is used for the two hidden layers. An initial learning rate $L = 0 . 0 0 1$ is set for all cases, with the Adam optimizer (Kingma & Ba, 2015) employed for the gradient ascent step. The discount factor is $\beta = 0 . 9 9 9$ and each mini-batch consists of five episodes.
+
+For all cases, we implement the NeurWIN algorithm using PyTorch (Paszke et al., 2019), and train the agent on a single arm modelled after OpenAI’s Gym API (Brockman et al., 2016). We provide a brief overview of each application and the experiment setting in the following sections. We refer readers to the appendices for detailed discussions on experiment settings.
+
+# 5.2 RECOVERING BANDITS
+
+The recovering bandits (Pike-Burke & Grunewalder, 2019) aim to model the time-varying behaviors of consumers. In particular, it considers that a consumer who has just bought a certain product, say, a television, would be much less interested in advertisements of the same product in the near future. However, the consumer’s interest in these advertisements may recover over time. Thus, the recovering bandit models the reward of playing an arm, i.e., displaying an advertisement, by a function $f ( \operatorname* { m i n } \{ z , z _ { m a x } \} )$ , where $z$ is the time since the arm was last played and $z _ { m a x }$ is a constant specified by the arm. There is no known Whittle index or optimal control policy for this problem.
+
+The recent study (Pike-Burke & Grunewalder, 2019) on recovering bandit focuses on learning the function $f ( \cdot )$ for each arm. Once it obtains an estimate of $f ( \cdot )$ , it uses a heuristic called $d$ -lookahead to determine which arms to play. The $d$ -lookahead policy enumerates all possible actions in the next $d$ rounds, and then pick the sequence of actions that yield that highest reward. Since the controller can choose $M$ arms out of $N$ arms to activate, with $\mathbf { \bar { \rho } } _ { ( \mathcal { M } ) }$ different possibilities, in each round, the complexity of the heuristic is $O ( { \bigl ( } _ { M } ^ { N } ) ^ { d } )$ when $d > 1$ . Thus, we are only able to evaluate 1-lookahead when $N = 1 0 0$ . When $N = 4$ and $M = 1$ , we evaluate 1-lookahead and 3-lookahead.
+
+In our experiment, we consider that there are four types of arms and there are $\textstyle { \frac { N } { 4 } }$ arms for each type. Different types of arms have different functions $f ( \cdot )$ . The state of each arm is its value of $\operatorname* { m i n } \{ z , z _ { m a x } \}$ and we set $z _ { m a x } = 2 0$ for all arms.
+
+Experiment results are shown in Fig. 2. It can be observed that NeurWIN is able to outperform 1-lookahead in all settings with just a few thousands of training episodes. In contrast, for the case $N = 4$ and $M = 1$ , REINFORCE only sees slight performance improvement over 50,000 training episodes and remains far worse than NeurWIN. This may be due to the explosion of state space. Even though $N$ is only 4, the total number of possible states is $2 0 ^ { 4 } = 1 6 0 , \bar { 0 } 0 0$ , making it difficult for REINFORCE to learn the optimal control in just 50, 000 episodes. In contrast, since NeurWIN learns the Whittle index of each arm separately, its size of state space is only 20. QWIC performs poorly. This suggests that it does not learn a good approximation to the Whittle index.
+
+![](images/5bf56f13c24ed50b504ac17e4972420531b4eecafb0182c59a68e16219fd1c75.jpg)  
+Figure 2: Experiment results for the recovering bandits.
+
+# 5.3 WIRELESS SCHEDULING
+
+A recent paper (Aalto et al., 2015) studies the problem of wireless scheduling over fading channels. In this problem, each arm corresponds to a wireless client. Each wireless client has some data to be transmitted and it suffers from a holding cost of 1 unit per round until it has finished transmitting all its data. The channel quality of a wireless client, which determines the amount of data can be transmitted if the wireless client is scheduled, changes over time. The goal is to minimize the sum of holding costs of all wireless clients. Equivalently, we view the reward of the system as the negative of the total holding cost.
+
+Finding the Whittle index through theoretical analysis is difficult. Even for the simplified case when the channel quality is i.i.d. over time and can only be in one of two possible states, the recent paper (Aalto et al., 2015) can only derive the Whittle index under some approximations. It then proposes a size-aware index policy using its approximated index.
+
+In the experiment, we adopt the settings of channel qualities of the recent paper. The channel of a wireless client can be in either a good state or a bad state. The amount of data that can be transmitted in a round is $3 3 . 6 \mathrm { k b }$ in a good state, and $8 . 4 \mathrm { k b }$ in a bad state. Initially, the amount of load is uniformly between 0 and 1Mb. The state of each arm is its channel state and the amount of remaining load. The size of state space is $2 \times 1 0 ^ { 6 }$ for each arm. We consider that there are two types of arms, and different types of arms have different probabilities of being in the good state. We train a NeurWIN for each type. During testing, there are $\begin{array} { l } { { \frac { N } { 2 } } } \end{array}$ arms of each type.
+
+Experiment results are shown in Fig. 3. It can be observed that NeurWIN is able to outperform the size-aware index policy with about 100, 000 training episodes. This result is significant when one considers the fact that the size-aware index is itself an approximation to the Whittle index. The experiment results thus suggest that NeurWIN is able to find a more accurate approximation to the Whittle index than the best known theoretical result. It can also be observed that REINFORCE performs poorly.
+
+![](images/b00a6b2b41d42aa0651721728336d2c9be570df757da20cb7f02d66a31be05af.jpg)  
+Figure 3: Average rewards and confidence bounds of different policies for wireless scheduling.
+
+# 5.4 DEADLINE SCHEDULING
+
+A recent study (Yu et al., 2018) proposes a deadline scheduling problem for the scheduling of electrical vehicle charging stations. In this problem, a charging station has $N$ charging spots and enough power to charge $M$ vehicles in each round. When a charging spot is available, a new vehicle may join the system and occupy the spot. Upon occupying the spot, the vehicle announces the time that it will leave the station and the amount of electricity that it needs to be charged. The charging station obtains a reward for each unit of electricity that it provides to a vehicle. However, if the station cannot fully charge the vehicle by the time it leaves, then the station needs to pay a penalty. The goal of the station is to maximize its net reward, defined as the difference between the amount of reward and the amount of penalty. Under an i.i.d. arrival assumption, the recent study has derived the precise characterization of the Whittle index, which we refer to as the deadline Whittle index. We further prove that this problem is strongly indexable in the appendix.
+
+We use exactly the same setting as in the recent study (Yu et al., 2018) for our experiment. In this problem, the state of an arm is denoted by a pair of integers $( D , B )$ , where $B$ is the amount of electricity that the vehicle still needs and $D$ is the time until the vehicle leaves the station. When a charging spot is available, its state is $( 0 , 0 )$ . $B$ is upper-bounded by 9 and $D$ is upper-bounded by 12. Hence, the size of state space is 109 for each arm.
+
+The experiment results are shown in Fig. 4. It can be observed that the performance of NeurWIN converges to that of the deadline Whittle index in less than 500 training episodes.
+
+![](images/2bbc46602e332d404ac7433f5a1535d09e1cd933747c841a3a8b26b17d64317e.jpg)  
+Figure 4: Average rewards and confidence bounds of different policies for deadline scheduling.
+
+# 5.5 EXPERIMENT RESULTS WITH NOISY SIMULATORS
+
+The training of NeurWIN requires a simulator for each arm. In this section, we evaluate the performance of NeurWIN when the simulator is not perfectly precise. In particular, let $R _ { a c t } ( s )$ and $R _ { p a s s } ( s )$ be the rewards of an arm in state $s$ when it is activated and not activated, respectively. Then, the simulator estimates that the rewards are $R _ { a c t } ^ { \prime } ( s ) = ( 1 + G _ { a c t , s } ) R _ { a c t } ( s )$ and $R _ { p a s s } ^ { \prime } ( s ) = ( 1 + G _ { p a s s , s } ) R _ { i , p a s s } ( s )$ , respectively, where $G _ { a c t , s }$ and $G _ { p a s s , s }$ are independent Gaussian random variables with mean 0 and variance 0.05. In other words, the simulator has an average $5 \%$ error in its reward estimation.
+
+We train NeurWIN using the noisy simulators for the recovering bandits problem and the deadline scheduling problem. For each problem, we compare the performance of NeurWIN against the respective baseline policies. Unlike NeurWIN, the baseline policies make decisions based on the true reward functions rather than the estimated ones. The results for the case $N = 1 0 0$ and $M = 2 5$ are shown in Fig. 5. It can be observed that NeurWIN is still able to achieve superior performance.
+
+![](images/3e0feb9328226ec698239a24b784b0f767b13523662b428e1d2fd6ff24192b24.jpg)  
+Figure 5: Experiment results for NeurWIN with noisy simulators.
+
+# 6 CONCLUSION
+
+This paper introduced NeurWIN: a deep RL method for estimating the Whittle index for restless bandit problems. The performance of NeurWIN is evaluated by three different restless bandit problems. In each of them, NeurWIN significantly outperforms state-of-the-art control policies in terms of the total discounted reward.
+
+NeurWIN can have important implications for restless bandit problems. There are many problems where the environments are well-defined, but the optimal control is not known. NeurWIN can obviously be used for such problems. For problems where the environments are not known a priori, NeurWIN nicely compliments existing studies that aim to learn the environments through online learning but fail to find the optimal control policy.
+
+# REFERENCES
+
+Samuli Aalto, Pasi Lassila, and Prajwal Osti. Whittle index approach to size-aware scheduling with time-varying channels. In Proceedings of the 2015 ACM SIGMETRICS International Conference on Measurement and Modeling of Computer Systems, pp. 57–69, 2015.
+
+K. Avrachenkov and V. S. Borkar. A learning algorithm for the whittle index policy for scheduling web crawlers. In 2019 57th Annual Allerton Conference on Communication, Control, and Computing (Allerton), pp. 1001–1006, 2019.
+
+V. S. Borkar and K. Chadha. A reinforcement learning algorithm for restless bandits. In 2018 Indian Control Conference (ICC), pp. 89–94, 2018.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Christopher R Dance and Tomi Silander. When are kalman-filter restless bandits indexable? In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1711–1719. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/5922-when-are-kalman-filterrestless-bandits-indexable.pdf.
+
+Christoph Dann, Tor Lattimore, and Emma Brunskill. Unifying pac and regret: Uniform pac bounds for episodic reinforcement learning. In Proceedings of the 31st International Conference on Neural Information Processing Systems, NIPS’17, pp. 5717–5727, Red Hook, NY, USA, 2017. Curran Associates Inc. ISBN 9781510860964.
+
+J. Fu, Y. Nazarathy, S. Moka, and P. G. Taylor. Towards q-learning the whittle index for restless bandits. In 2019 Australian New Zealand Control Conference (ANZCC), pp. 249–254, 2019.
+
+Nan Jiang, Akshay Krishnamurthy, Alekh Agarwal, John Langford, and Robert E. Schapire. Contextual decision processes with low Bellman rank are PAC-learnable. volume 70 of Proceedings of Machine Learning Research, pp. 1704–1713, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr.press/v70/ jiang17c.html.
+
+Diederick P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015.
+
+J. Le Ny, M. Dahleh, and E. Feron. Multi-uav dynamic routing with partial observations using restless bandit allocation indices. In 2008 American Control Conference, pp. 4220–4225, 2008.
+
+Alex S. Leong, Arunselvan Ramaswamy, Daniel E. Quevedo, Holger Karl, and Ling Shi. Deep reinforcement learning for wireless sensor scheduling in cyber–physical systems. Automatica, 113:108759, 2020. ISSN 0005-1098. doi: https://doi.org/ 10.1016/j.automatica.2019.108759. URL http://www.sciencedirect.com/science/ article/pii/S0005109819306223.
+
+R. Meshram, D. Manjunath, and A. Gopalan. On the whittle index for restless multiarmed hidden markov bandits. IEEE Transactions on Automatic Control, 63(9):3046–3053, 2018.
+
+Jose Ni ´ no-Mora. Dynamic priority allocation via restless bandit marginal productivity indices. ˜ Top, 15(2):161–198, 2007.
+
+Christos H. Papadimitriou and John N. Tsitsiklis. The complexity of optimal queuing network control. Mathematics of Operations Research, 24(2):293–305, 1999. ISSN 0364765X, 15265471. URL http://www.jstor.org/stable/3690486.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alche-Buc, E. Fox, ´ and R. Garnett (eds.), Advances in Neural Information Processing Systems 32, pp. 8026–8037. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/9015-pytorchan-imperative-style-high-performance-deep-learning-library.pdf.
+
+Ciara Pike-Burke and Steffen Grunewalder. Recovering bandits. In Advances in Neural Information Processing Systems, pp. 14122–14131, 2019.
+
+Carlos Riquelme, George Tucker, and Jasper Snoek. Deep bayesian bandits showdown: An empirical comparison of bayesian deep networks for thompson sampling. In International Conference on Learning Representations (ICLR), 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ SyYe6k-CW.
+
+Julien Seznec, Pierre Menard, Alessandro Lazaric, and Michal Valko. A single algorithm for both restless and rested rotting bandits. In International Conference on Artificial Intelligence and Statistics, pp. 3784–3794, 2020.
+
+Aleksandrs Slivkins and Eli Upfal. Adapting to a changing environment: the brownian restless bandits. In COLT, pp. 343–354, 2008.
+
+Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. The MIT Press, second edition, 2018. URL http://incompleteideas.net/book/the-book2nd.html.
+
+V. Tripathi and E. Modiano. A whittle index approach to minimizing functions of age of information. In 2019 57th Annual Allerton Conference on Communication, Control, and Computing (Allerton), pp. 1160–1167, 2019.
+
+S. Wang, H. Liu, P. H. Gomes, and B. Krishnamachari. Deep reinforcement learning for dynamic multichannel access in wireless networks. IEEE Transactions on Cognitive Communications and Networking, 4(2):257–265, 2018.
+
+T. Wei, Yanzhi Wang, and Q. Zhu. Deep reinforcement learning for building hvac control. In 2017 54th ACM/EDAC/IEEE Design Automation Conference (DAC), pp. 1–6, 2017.
+
+Peter Whittle. Restless bandits: Activity allocation in a changing world. Journal of applied probability, pp. 287–298, 1988.
+
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Mach. Learn., 8(3–4):229–256, May 1992. ISSN 0885-6125. doi: 10.1007/ BF00992696. URL https://doi.org/10.1007/BF00992696.
+
+Huizhen Yu and Dimitri P Bertsekas. Convergence results for some temporal difference methods based on least squares. IEEE Transactions on Automatic Control, 54(7):1515–1531, 2009.
+
+Z. Yu, Y. Xu, and L. Tong. Deadline scheduling as restless bandits. IEEE Transactions on Automatic Control, 63(8):2343–2358, 2018.
+
+Andrea Zanette and Emma Brunskill. Problem dependent reinforcement learning bounds which can identify bandit structure in MDPs. volume 80 of Proceedings of Machine Learning Research, pp. 5747–5755, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL ¨ http: //proceedings.mlr.press/v80/zanette18a.html.
+
+Qing Zhao. Multi-armed bandits: Theory and applications to online learning in networks. Synthesis Lectures on Communication Networks, 12(1):1–165, 2019.
+
+# A RECOVERING BANDITS’ TRAINING AND INFERENCE DETAILS
+
+A.1 FORMULATED RESTLESS BANDIT FOR THE RECOVERING BANDITS’ CASE
+
+We list here the terms that describes one restless arm in the recovering bandits’ case:
+
+State $s [ t ]$ : The state is a single value $s [ t ] = z [ t ]$ called the waiting time. The waiting time $z [ t ]$ indicates the time since the arm was last played. The arm state space is determined by the maximum allowed waiting time $z _ { m a x }$ , giving a state space $\begin{array} { r } { \boldsymbol { S } : = [ 1 , \boldsymbol { z } _ { m a x } ] } \end{array}$ .
+
+Action $a [ t ]$ : As with all other considered cases, the agent can either activate the arm $a [ t ] = 1$ , or not select it $a [ t ] = 0$ . The action space is then $\mathcal { A } : = \{ 0 , \bar { 1 } \}$ .
+
+Reward $r [ t ]$ : The reward is provided by the recovering function $f ( z [ t ] )$ , where $z [ t ]$ is the time since the arm was last played at time $t$ . If the arm is activated, the function value at $z [ t ]$ is the earned reward. A reward of zero if given if the arm is left passive $a [ t ] = 0$ . Figure 6 shows the four recovering functions used in this work. The recovering functions are generated from,
+
+$$
+f ( z [ t ] ) = \theta _ { 0 } ( 1 - e ^ { - \theta _ { 1 } \cdot z [ t ] } )
+$$
+
+Where the $\Theta = [ \theta _ { 0 } , \theta _ { 1 } ]$ values specify the recovering function. The $\Theta$ values for each class are given in table 1.
+
+Table 1: $\Theta$ values used in the recovering bandits’ case   
+
+<table><tr><td>Class</td><td>00Value</td><td>01 Value</td></tr><tr><td></td><td></td><td>0.2</td></tr><tr><td>A B</td><td>10</td><td>0.4</td></tr><tr><td>C</td><td>8.5</td><td></td></tr><tr><td></td><td>7</td><td>0.6</td></tr><tr><td>D</td><td>5.5</td><td>0.8</td></tr></table>
+
+Next state $s [ t + 1 ]$ : The state evolves based on the selected action. If $a [ t ] = 1$ , the state is reset to $s [ t + 1 ] = 1$ , meaning that bandit’s reward decayed to the initial waiting time $z [ t + 1 ] = 1$ . If the arm is left passive $a [ t ] = 0$ , the next state becomes $s [ t + 1 ] = \operatorname* { m i n } \{ z [ t ] \stackrel { . } { + } 1 , z _ { m a x } \stackrel { . } { } \}$ .
+
+![](images/af098c94a1f0a3ff3003bc87e200546e98380804865b6986ea25688d9ac2b542.jpg)  
+Figure 6: The selected recovering functions for the recovering bandits’ case. For testing, we set each quarter of the instantiated $N$ arms to one of the shown $f ( z )$ functions.
+
+# A.2 TRAINING SETTING
+
+The general training procedure for the NeurWIN algorithm is outlined in its pseudo code in section 4. Here we discuss the parameter selection and details specific to the recovering bandits’ case. We train the neural network using NeurWIN for 50, 000 episode, and save the trained parameters at an episode interval of 100 episodes. The purpose of saving the parameters is to infer their control policies, and compare it with the 1-lookahead policy. In total, for 50, 000 training episodes, we end up with 500 models for inference. The selected neural network has 609 trainable parameters given as $\{ 1 , 1 6 , 3 2 , 1 \}$ layer neurons.
+
+For training parameters, we select the sigmoid value $m = 5$ , the episode’s time horizon $T = 1 0 0$ timesteps, the mini-batch size to 5 episodes, and the discount factor $\beta = 0 . 9 9 9$ . As with all other cases, each mini-batch of episodes has the same initial state $s [ t = 1 ]$ which is provided by the arm. To ensure the agent experiences as many states in $[ 1 , z _ { m a x } ]$ as possible, we set an initial state sampling distribution given as P r{s[t = 1] = z} = 2z21+22+...+2zmax . H ence, the probability of selecting the initial state to be $s [ t = 1 ] = z _ { m a x }$ is 0.5. This initialization distribution allows the agent to experience the recovery function’s awards at higher $z$ values.
+
+At the agent side, we set the activation cost $\lambda$ at the beginning of each mini-batch. $\lambda$ is chosen to be the estimate index value $f _ { \theta } ( s ^ { ' } )$ of a randomly selected state in $s ^ { ' } \in [ 1 , z _ { m a x } ]$ . The training continues as described in NeurWIN’s pseudo code: the agent receives the state, and selects an action $a [ t ]$ . If the agent activates the arm $a [ t ] = 1$ , it receives a reward equal to the recovery function’s value at $z$ , and subtracts $\lambda$ from it. Otherwise, the reward $r [ t ]$ is kept the same for $a [ t ] = 0$ . We note that no noise was added with the clean simulator, and the agent discounts the original reward value $\beta ^ { t } r [ t ] = \beta ^ { t } f ( z [ t ] )$ . The process continues for all timesteps in the episode up to $T = 1 0 0$ , and for remaining mini-batch episodes. A gradient ascent step is taken on the bootstrapped mini-batch return as described in section 4.
+
+# A.3 INFERENCE SETTING
+
+The inference setup measures NeurWIN’s control policy for several $\binom { N } { M }$ settings. We test, for a single run, the control policies of NeurWIN and 1-lookahead over a time horizon $T \ : = \ : 3 0 0 0$ timesteps. We set $N$ arms such that a quarter have one recovering function class from table 1. For example, when $N = 1 0 0$ , 25 arms would have recovering function A that generates their rewards.
+
+At each timestep, the 1-lookahead policy ranks the recovering functions reward values, and selects the $M$ arms with the highest reward values for activation. The incurred discounted reward at time $t$ is the discounted sum of all activated arms’ rewards. The total discounted reward is then the discounted rewards over time horizon $T = 3 0 0 0$ . For inferring NeurWIN’s control policy, we record the total discounted reward for each of the 500 models. An example testing procedure is as follows: we instantiate $N$ arms each having a neural network trained to 10, 000 episodes. At each timestep $t$ , the neural networks provide the estimated index $f _ { i , \theta } ( s _ { i } [ t ] )$ for $i = 1 , 2 , \dots , N$ . The control policy activates the $M$ arms with the highest index values. The incurred discounted reward at time $t$ is the discounted sum of all activated arm’s rewards $\begin{array} { r } { \beta ^ { t } R [ t ] = \beta ^ { t } \sum _ { j = 1 } ^ { M } f _ { j } ( z [ t ] ) } \end{array}$ . The same process continues for all timesteps in the horizon $T = 3 0 0 0$ . We then load the model parameters trained on 10, 100 episodes, and repeat the aforementioned testing process using the same seed values.
+
+# A.4 REINFORCE TRAINING AND INFERENCE SETTING ON RECOVERING BANDITS
+
+The REINFORCE algorithm was applied only the $\textstyle { \binom { N } { M } }$ case where $N \ = \ 4$ , and $M \ = \ 1$ . For training, REINFORCE had four arms each with one of the recovery functions detailed in table 1. The training parameters are: initial learning rate $L = 0 . 0 0 1$ , mini-batch size is 5 episodes, and a training episode time horizon $T = 1 0 0$ timesteps. Training was done up to 50, 000 episodes, where the trained parameters were saved at an interval of 100 episodes. The selected neural network had 2504 trainable parameters. This neural network size is larger than $6 0 9 \times 4 = 2 4 3 6$ parameters of four NeurWIN neural networks.
+
+For testing, the same procedure is followed as in A.3. The trained REINFORCE models were loaded, and each tested on the same arms as NeurWIN and deadline Whittle index policies. The testing was made for all 500 trained model (each being trained up to a different episode count). The final control policy result was plotted along with NeurWIN and the 1-lookahead policies for $\binom { 4 } { 1 }$ arms.
+
+# A.5 QWIC TRAINING AND INFERENCE SETTING ON RECOVERING BANDITS
+
+The Q-learning Whittle Index Controller (was trained in an offline setting using fixed WIC) pserestless a deth given in activatio $\mathrm { F u }$ et a(i.e. . $N$ $M$ ${ \binom { 4 } { 1 } } \ { \binom { 1 0 0 } { 1 0 } } \ { \binom { \bar { 1 } 0 0 } { 2 5 } } \ )$ $\lambda \in \Lambda$ as index for each state. The algorithm   
+learns $\mathrm { Q }$ function $Q \in \mathbb { R } ^ { \Lambda \times S \times \{ 0 , 1 \} }$ . The estimated index $\tilde { \lambda } [ s ]$ per state $s$ is determined during   
+training as,
+
+$$
+\tilde { \lambda } [ s ] = \operatorname * { a r g m i n } _ { \lambda \in \Lambda } \vert Q ( \lambda , s , 1 ) - Q ( \lambda , s , 0 ) \vert
+$$
+
+Hence, the converged index values and control performance depends on the initial set of candidate values $\Lambda$ . We select $\Lambda$ to be 100 values evenly spaced in the interval [0, 10]. We note the set selection was based on NeurWIN’s learned index values, which provides an advantage to QWIC training.
+
+The exploration-exploitation trade-off is steered by parameter $\epsilon$ . $\epsilon$ is initialized to $\epsilon _ { m a x } = 1$ , and decays with factor $\alpha = 0 . 0 1$ to $\epsilon _ { m i n } = 0 . 0 1$ . $\epsilon$ is updated at each timestep during training until it settles at $\epsilon _ { m i n }$ .
+
+Other training parameters were selected as: initial learning rate $L = 0 . 0 0 1$ , training episode time horizon of $T = 1 0 0$ timesteps, discount factor $\beta ~ = ~ 0 . 9 9 9$ , . Training was done up to 50, 000 episodes, where the Q-learned indices $\bar { \Lambda }$ were saved at an interval of 100 episodes.
+
+For testing, we use the same testing setting as in NeurWIN and REINFORCE. The learned indices are loaded for each training interval. In total, 500 estimated index mappings were tested for 200 independent runs, each trained up to a certain episode limit.
+
+# B WIRELESS SCHEDULING TRAINING AND INFERENCE DETAILS
+
+B.1 RESTLESS ARM DEFINITION FOR THE WIRELESS SCHEDULING CASE
+
+As with the recovering bandits’ case, we first list the state $s [ t ]$ , action $a [ t ]$ , reward $r [ t ]$ , and next state $s [ t + 1 ]$ that forms one restless arm:
+
+State $s [ t ]$ : The state is a vector $( y [ t ] , v [ t ] )$ , where $y [ t ]$ is the arm’s remaining load in bits, and $v [ t ]$ is the wireless channel’s state indicator. $v [ t ] = 1$ means a good channel state and a higher transmission rate $r _ { 2 }$ , while $v [ t ] = 0$ is a bad channel state with a lower transmission rate $r _ { 1 }$ .
+
+Action $a [ t ]$ : The agent either activates the arm $a [ t ] = 1$ , or keeps it passive $a [ t ] = 0$ . The reward and next state depend on the chosen action.
+
+Reward $r [ t ]$ : The arm’s reward is the negative of holding cost $\psi$ , which is a cost incurred at each timestep for not completing the job. If the selected action $a [ t ] = 1$ , then the reward at time $t$ is $r [ t ] = \bar { - } \psi - \lambda$ . Otherwise, reward is just $r [ t ] = - \psi$ .
+
+Next state $s [ t + 1 ]$ : The next state evolves differently as given below,
+
+$$
+s [ t + 1 ] = \left\{ { \begin{array} { l l } { ( y [ t ] - r _ { 2 } , 1 ) \qquad } & { { \mathrm { i f ~ } } q ( v [ t ] ) = 1 , a [ t ] = 1 } \\ { \qquad } \\ { ( y [ t ] - r _ { 1 } , 0 ) \qquad } & { { \mathrm { i f ~ } } q ( v [ t ] ) = 0 , a [ t ] = 1 } \\ { \qquad } \\ { ( y [ t ] , q ( v [ t ] ) ) \qquad } & { { \mathrm { o t h e r w i s e } } } \end{array} } \right.
+$$
+
+Where $q ( v [ t ] )$ is the probability of a good channel state.
+
+# B.2 TRAINING SETTING
+
+We again emphasize that NeurWIN training happens only on one restless arm. The general training procedure was described in NeurWIN’s pseudo code. This discussion pertains only to the wireless scheduling case.
+
+The neural network has 625 trainable parameters given as $\{ 2 , 1 6 , 3 2 , 1 \}$ neuron layers. The training happens for 1, 000, 000 episodes, and we save the model parameters at each 1000 episodes. Hence, the training results in 1000 models trained up to different episode limit.
+
+For the wireless scheduling case, we set the sigmoid value $m = 0 . 0 1$ , mini-batch size to 5 episodes, and the discount factor to $\beta = 0 . 9 9 9$ . Episode time horizon is dependent on the remaining job size $y [ t ]$ . The episode terminates either if $y [ t ] = 0$ or $t = 3 0 0 0$ . The holding cost is set to $c = 1$ , which is incurred for each timestep the job is not completed. We also set the good transmission rate $r _ { 2 } = 3 3 . 6 \mathrm { k b }$ , and the bad channel transmission rate $r _ { 1 } = 8 . 4 \mathrm { k b }$ . During training, the good channel probability is $q ( v [ t ] ) = 0 . 5$ .
+
+The episode defines one job size sampled uniformly from the range $y [ t = 1 ] \sim ( 0 , 1 \mathrm { M b } ]$ . All episodes in one mini-batch have the same initial state, as well as the same sequence of good channel states $[ v [ t = 1 ] , v [ t = 2 ] , \ldots , v [ t = T ] ]$ .
+
+At the agent side, NeurWIN receives the initial state $s [ t = 1 ]$ , and sets the activation cost $\lambda =$ $f _ { \theta } ( s [ t = 1 ] )$ for all timesteps of all mini-batch episodes. As mentioned before, we save the trained model at an interval of 1000 episodes. For $1 , 0 0 0 , 0 0 0$ episodes, this results in 1000 models trained up to their respective episode limit.
+
+# B.3 INFERENCE SETTING
+
+For testing, the aim is to measure the trained models’ control performance against the size-aware index. We instantiate $N$ arms and activate $M$ arms at each timestep $t$ until all users’ jobs terminate. We average the total discounted reward for all control policies over 200 independent inference runs. Half of the arms have a good channel probability $q ( v [ \bar { t } ] ) = 0 . 7 5$ . The other half has a good channel probability $q ( v [ t ] ) = 0 . 1$ .
+
+We compare NeurWIN’s control policy at different training episodes’ limits with the size-aware index policy. The size-aware index is defined as follows: at each timestep, the policy prioritizes arms in the good channel state, and calculates their secondary index. The secondary index $\hat { v } _ { i }$ of arm $i$ state $( y _ { i } [ t ] , v _ { i } [ t ] )$ is defined as,
+
+$$
+\hat { v } _ { i } ( y _ { i } [ t ] , v _ { i } [ t ] ) = \frac { c _ { i } r _ { i , 2 } } { y _ { i } [ t ] }
+$$
+
+The size-aware policy then activates the highest $M$ indexed arms. In case the number of good channel arms is below $M$ , the policy also calculate the primary index of all remaining arms. The primary index $v _ { i }$ of arm $i$ state $( y _ { i } [ t ] , v _ { i } [ t ] )$ is defined as,
+
+$$
+v _ { i } ( y _ { i } [ t ] , v _ { i } [ t ] ) = \frac { c _ { i } } { q _ { i } [ t ] ( r _ { i , 2 } / r _ { i , 1 } ) - 1 }
+$$
+
+Rewards received from all arms are summed, and discounted using $\beta = 0 . 9 9 9$ . The inference phase proceeds until all jobs have been completed.
+
+For NeurWIN’s control policy, we record the total discounted reward for the offline-trained models. For example, we set $N$ arms each coupled with a model trained on $1 0 , 0 0 0$ episodes. The models output their arms’ indices, and the top $M$ indexed arms are activated. In case the remaining arms are less than the sum $M$ , we activate all remaining arms at timestep ll arms’ rewards. Once testing for the curre $t$ . timestep reward t model is finishe $\begin{array} { r } { \beta ^ { t } R [ t ] = \beta ^ { t } \sum _ { i = 1 } ^ { N } r [ t ] } \end{array}$ isel 11, 000 for each arm, and repeat the process. We note that the arms’ initial loads are the same across runs, and that the sequence of good channel states is random.
+
+# B.4 REINFORCE TRAINING AND INFERENCE SETTING ON WIRELESS SCHEDULING
+
+The REINFORCE algorithm was applied only the $\binom { 4 } { 1 }$ case. The four arms have the same training setting as described in section B.2. The training parameters are: initial learning rate $L = 0 . 0 0 1$ mini-batch size is 5 episodes, and good channel probability for all four arms $q ( v [ t ] ) = 0 . 5$ . The episode time horizon has a hard limit of $\bar { T } = \dot { 3 0 0 0 }$ timesteps. However, an episode can terminate if all arms’ loads were fully processed (i.e. episodes, where the trained parameters were sav $\begin{array} { r } { \sum _ { i = 1 } ^ { 4 } y _ { i } [ t ] = 0 } \end{array}$ ). Training was done up to 100, 000of 1000 episodes. The selected neural network had 2532 trainable parameters so to have slightly more parameters than four NeurWIN neural networks.
+
+For testing, the same procedure is followed as in B.3. The trained REINFORCE models were loaded, and each tested on the same arms as NeurWIN and size-aware index. The final control policy result was plotted along with NeurWIN and Whittle index policy for the $\binom { 4 } { 1 }$ testing setup.
+
+# C DEADLINE SCHEDULING TRAINING AND INFERENCE DETAILS
+
+C.1 FORMULATED RESTLESS BANDIT FOR THE DEADLINE SCHEDULING CASE
+
+The state $s [ t ]$ , action $a [ t ]$ , reward $r [ t ]$ , and next state $s [ t + 1 ]$ of one arm are listed below:
+
+State $s [ t ]$ : The state is a vector $( D , B )$ . $B$ denotes the job size (i.e. amount of electricity needed for an electric vehicle), and $D$ is the job’s time until the hard drop deadline $d$ is reached (i.e. time until an electric vehicle leaves).
+
+Action $a [ t ]$ : The agent can either activate the arm $a [ t ] = 1$ , or leave it passive $a [ t ] = 0$ . The next state changes based on two different transition kernels depending on the selected action. The reward is also dependent on the action at time $t$ .
+
+Reward $r [ t ]$ : The agent, at time $t$ , receives a reward $r [ t ]$ from the arm,
+
+$$
+r [ t ] = \left\{ \begin{array} { l l } { ( 1 - c ) a [ t ] } & { \mathrm { ~ i f ~ } B [ t ] > 0 , D [ t ] > 1 } \\ { \qquad } \\ { ( 1 - c ) a [ t ] - F ( B [ t ] - a [ t ] ) } & { \mathrm { ~ i f ~ } B [ t ] > 0 , D [ t ] = 1 } \\ { \qquad } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+Where $c$ is a constant processing cost incurred when activating the arm, $F ( B [ t ] - a [ t ] )$ is the penalty function for failing to complete the job before $D = 1$ . The penalty function was chosen to be $F ( B [ t ] - a [ t ] ) = \bar { 0 } . 2 ( B [ t ] - a [ t ] ) ^ { 2 }$ .
+
+Next state $s [ t + 1 ]$ : The next state $D [ t + 1 ]$ decreases by one, while the job size $B$ depends on the selected action as,
+
+$$
+s [ t + 1 ] = \left\{ \begin{array} { l l } { ( D [ t ] - 1 , B [ t ] - a [ t ] ) \qquad } & { \mathrm { ~ i f ~ } D [ t ] > 1 } \\ { \qquad } \\ { ( D , B ) \mathrm { ~ w i t h ~ p r o b . ~ } Q ( D , B ) \qquad } & { \mathrm { ~ i f ~ } D [ t ] \leq 1 } \end{array} \right.
+$$
+
+Where $Q ( D , B )$ is the arrival probability of a new job (i.e. a new electric vehicle arriving at a charging station) if the position is empty. For training and inference, we set $Q ( D , B ) = 0 . 7$ .
+
+C.2 STRONG INDEXABILITY PROOF FOR THE DEADLINE SCHEDULING CASE
+
+It has been shown that the Whittle index for this problem is,
+
+$$
+v ( D , B ) : = \left\{ \begin{array} { l l } { 0 \qquad } & { \mathrm { i f } \ B = 0 } \\ { \qquad } \\ { 1 - c \qquad } & { \mathrm { i f } \ 1 \leq B \leq D - 1 } \\ { \qquad } \\ { \beta ^ { D - 1 } F ( B - D + 1 ) \qquad } \\ { - \beta ^ { D - 1 } F ( B - D ) + 1 - c \qquad } & { \mathrm { i f } \ D \leq B } \end{array} \right.
+$$
+
+We further demonstrate that this problem is strongly indexable.
+
+Theorem 3. The restless bandit for the deadline scheduling problem is strongly indexable.
+
+Proof. Fix a state $s = ( D , B )$ , the function $D _ { s } ( \lambda ) : = ( Q _ { \lambda , a c t } ( s ) - Q _ { \lambda , p a s s } ( s ) )$ is a continuous and piece-wise linear function since the number of states is finite. Thus, it is sufficient to prove that $D _ { s } ( \lambda )$ is strictly decreasing at all points of $\lambda$ where $D _ { s } ( \lambda )$ is differentiable. Let $L _ { \lambda , a c t } ( s )$ be the sequence of actions taken by a policy that activates the arm at round 1, and then uses the optimal policy starting from round 2. Let $L _ { \lambda , p a s s } ( s )$ be the sequence of actions taken by a policy that does not activate the arm at round 1, and then uses the optimal policy starting from round 2. We prove this theorem by comparing $L _ { \lambda , a c t } ( s )$ and $L _ { \lambda , p a s s } ( s )$ on every sample path. We consider the following two scenarios:
+
+In the first scenario, $L _ { \lambda , a c t } ( s )$ and $L _ { \lambda , p a s s } ( s )$ are the same starting from round 2. Let $b$ be the remaining job size when the current deadline expires under $L _ { \lambda , a c t } ( s )$ . Since $L _ { \lambda , p a s s } ( s )$ is the same as $L _ { \lambda , a c t } ( s )$ starting from round 2, its remaining job size when the current deadline expires is $b + 1$ . Thus, $D _ { s } ( \lambda ) = 1 - c - \lambda + \beta ^ { D - 1 } ( F ( b + 1 ) - F ( b ) )$ , which is strictly decreasing in $\lambda$ whenever $D _ { s } ( \lambda )$ is differentiable.
+
+In the second scenario, $L _ { \lambda , a c t } ( s )$ and $L _ { \lambda , p a s s } ( s )$ are not the same after round 2. Let $\tau$ be the first time after round 2 that they are different. Since they are the same between round 2 and round $\tau$ , the remaining job size under $L _ { \lambda , a c t } ( s )$ is no larger than that under $L _ { \lambda , p a s s } ( s )$ . Moreover, the Whittle index is increasing in job size. Hence, we can conclude that, on round $\tau$ , $L _ { \lambda , p a s s } ( s )$ activates the arm and $L _ { \lambda , a c t } ( s )$ does not activate the arm. After round $\tau$ , $L _ { \lambda , a c t } ( s )$ and $L _ { \lambda , p a s s } ( s )$ are in the same state and will choose the same actions for all following rounds. Thus, the two sequences only see different rewards on round 1 and round $\tau$ , and we have $D _ { s } ( \lambda ) = ( 1 - c - \lambda ) ( 1 - \bar { \beta } ^ { \tau - 1 } )$ , which is strictly decreasing in $\lambda$ whenever $D _ { s } ( \lambda )$ is differentiable.
+
+Combining the two scenarios, the proof is complete.
+
+# C.3 TRAINING SETTING
+
+NeurWIN training is made for 1000 episodes on the deadline scheduling case. We save the trained model parameters at an interval of 5 episodes for inferring the control policy after training. Hence, the training produces 200 different set of parameters that output the estimated index given their respective training limit. The neural network had 625 trainable parameters given as $\{ 2 , 1 6 , 3 2 , 1 \}$ , where the input layer matches the state size.
+
+For the deadline scheduling training, we set the sigmoid value $m = 1$ , episode’s time horizon $T =$ 3000 timesteps, mini-batch size to 5 episodes, and the discount factor $\beta = 0 . 9 9 9$ . The processing cost $c = 0 . 5$ , with the job arrival rate $Q ( D , B ) = 0 . 7 $ . Training procedure follows section 4.2 from the main text. The arm randomly picks an initial state $s [ t = 1 ] = ( D , B )$ , with a maximum $\bar { D } = 1 2$ , and maximum $\bar { B } = 9$ . The arm fixes the initial states across episodes in the same minibatch for proper return comparison. The sequence of job arrivals in an episode’s horizon is also fixed across a mini-batch. For example, one episode in mini-batch 1 would have the sequence $[ ( 1 1 , 5 ) , ( 6 , 2 ) , ( 8 , 4 ) , \dots , ( 3 , 5 ) ]$ , then all other episodes in the same mini-batch would pass the same sequence. This way, the actions taken by the agent would be the critical factor in comparing a mini-batch return, and ultimately in tuning the estimated index value $f _ { \theta } ( \cdot )$ .
+
+At the agent side, NeurWIN receives the initial state $s [ t = 1 ]$ , sets the activation cost $\begin{array} { r } { \lambda = f _ { \theta } ( s [ t = } \end{array}$ 1]). This activation cost $\lambda$ selection method hence depends on the current network parameters $\theta$ , which are modified after every gradient ascent step. Training follows as described in NeurWIN’s pseudo code.
+
+In figure 7, we plot the trained NeurWIN index for all possible state enumerations of $\bar { B } = 9$ and $D \in \{ 1 , 2 , 3 \}$ . The output index from the untrained neural network is also plotted for convergence comparison.
+
+In figure 8, the trained restless bandit indices for noisy reward function is given. All possible states in $\bar { B } = 9$ for $D \in \{ 1 , 2 , 3 \}$ . For $\mathcal { N } ( 0 , 0 . 0 5 )$ added noise per timestep, the learned indices still match the state ordering found when trained with the true reward function.
+
+![](images/a86f16ada89204cc2a7caa48332f0e559f03826f3f8d9cc091a5819021d55ca5.jpg)  
+Figure 7: Trained indices using the true reward function.
+
+![](images/102af8a16f22b31d92b1abdad3ce5377cc2697aeb8f23927ee37a54d5e48cc95.jpg)  
+Figure 8: Trained indices using the noisy reward function.
+
+# C.4 INFERENCE SETTING
+
+In order to infer the resultant control policy, we are required to test the performance on models saved at different episodes’ intervals. In other words, the trained models’ parameters are tested at an interval of episodes, and their discounted rewards are plotted for comparison.
+
+From the trained models described in C.3, we instantiate $N$ arms, and activate $M$ arms at each timestep. The inference step compares the resultant control policy with the deadline Whittle index $v ( D , B )$ .
+
+The testing is done for a time horizon of $T = 3 0 0 0$ timesteps. The queue, modelled as $N$ restless arms, has $M$ positions activated at each timestep. Each arm has a unique sequence of job arrivals from other arms that differentiates its index value. For the deadline Whittle index, we calculate the indices according to 8, and activate the highest $M$ indices-associated arms. The accumulated reward from all arm (activated and passive) is then discounted with $\beta$ .
+
+For NeurWIN control policy, we instantiate $N$ arms, and test the trained models up to a given episode. For example, we load a NeurWIN model trained for 100 episodes on one arm, and set $N$ arms each with its own trained agent on 100 episodes. Once the testing is complete, we load the next model trained at 105 episodes, and repeat the process for 105 episodes. The final result is NeurWIN’s control policy’s performance on $N$ arms given the models’ training.
+
+We perform the testing over 200 independent runs up to 1000 episodes, where each run the arms are seeded differently. We stress that both the deadline Whittle index and NeurWIN policies were applied on identical seeded arms across the 200 runs. Meaning the sequence of arrivals and rewards experienced was fixed for each arm in each run. Results were provided in the main text for this setting.
+
+# C.5 REINFORCE TRAINING AND INFERENCE SETTING ON DEADLINE SCHEDULING
+
+The REINFORCE algorithm was applied on the $\binom { 4 } { 1 }$ testing case. For training, REINFORCE was trained on the same training setting as described in C.3 with the same parameters when appropriate.
+
+The four restless arms were seeded differently to give unique job sequences. Training was made until 1000 episodes, where the trained parameters were saved at an interval of 5 episodes. The selected neural network had 2532 trainable parameters. The REINFORCE parameters’ count are purposefully slightly larger than $6 2 5 \times 4 = 2 5 0 0$ parameters of four NeurWIN neural networks.
+
+For testing, the same procedure is followed as explained in C.4. The trained REINFORCE models were loaded, and each tested on the same arms as NeurWIN and deadline Whittle index policies. The testing was made for all 200 trained model (each being trained up to a different episode count). The final control policy result was plotted along with NeurWIN and Whittle index policy for $\binom { 4 } { 1 }$ arms.
+
+C.6 QWIC TRAINING AND INFERENCE SETTING ON DEADLINE SCHEDULING
+
+QWIC was trained in an offline setting for the sets ${ \binom { 4 } { 1 } } \ { \binom { 1 0 0 } { 1 0 } } \ { \binom { 1 0 0 } { 2 5 } }$ . We select the same candidate set $\Lambda$ as in the recovering bandits case, which is 100 values evenly spaced in the interval [0, 10]. $\epsilon$ was initialized to $\epsilon _ { m a x } = 1$ , and decays with factor $\alpha = 0 . 0 1$ to $\epsilon _ { m i n } = 0 . 0 1$ . $\epsilon$ is updated at each timestep during training until it decays to $\epsilon _ { m i n }$ .
+
+Other training parameters: initial learning rate $L = 0 . 0 0 1$ , training episode time horizon of $T =$ 3000 timesteps, discount factor $\beta = 0 . 9 9 9$ , . Training was done up to $1 , 0 0 0$ episodes, where the select $\mathsf { q }$ -learned indices $\bar { \Lambda }$ were saved at an interval of 5 episodes. We test the Q-learning indices using the same setting as NeurWIN and REINFORCE. The estimated index mappings were tested for 200 independent runs.
+
+We refer the reader to the code for further implementation details.

parse/train/Uu1Nw-eeTxJ/Uu1Nw-eeTxJ.md

@@ -0,0 +1,358 @@
+# ON LEARNING UNIVERSAL REPRESENTATIONS ACROSS LANGUAGES
+
+Xiangpeng Wei1,2∗, Rongxiang Weng3, Yue $\mathbf { H } \mathbf { u } ^ { 1 , 2 }$ , Luxi $\mathbf { X _ { i n g } } ^ { \mathbf { _ { j , 2 } } }$ , Heng $\mathbf { Y } \mathbf { u } ^ { 3 }$ , Weihua Luo3
+
+1Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China 2School of Cyber Security, University of Chinese Academy of Sciences, Beijing, China {weixiangpeng,huyue,xingluxi}@iie.ac.cn 3Machine Intelligence Technology Lab, Alibaba Group, Hangzhou, China {wengrx,yuheng.yh,weihua.luowh}@alibaba-inc.com
+
+# ABSTRACT
+
+Recent studies have demonstrated the overwhelming advantage of cross-lingual pre-trained models (PTMs), such as multilingual BERT and XLM, on crosslingual NLP tasks. However, existing approaches essentially capture the cooccurrence among tokens through involving the masked language model (MLM) objective with token-level cross entropy. In this work, we extend these approaches to learn sentence-level representations and show the effectiveness on crosslingual understanding and generation. Specifically, we propose a Hierarchical Contrastive Learning (HICTL) method to (1) learn universal representations for parallel sentences distributed in one or multiple languages and (2) distinguish the semantically-related words from a shared cross-lingual vocabulary for each sentence. We conduct evaluations on two challenging cross-lingual tasks, XTREME and machine translation. Experimental results show that the HICTL outperforms the state-of-the-art XLM-R by an absolute gain of $4 . 2 \%$ accuracy on the XTREME benchmark as well as achieves substantial improvements on both of the highresource and low-resource English $ \mathrm { X }$ translation tasks over strong baselines.
+
+# 1 INTRODUCTION
+
+Pre-trained models (PTMs) like ELMo (Peters et al., 2018), GPT (Radford et al., 2018) and BERT (Devlin et al., 2019) have shown remarkable success of effectively transferring knowledge learned from large-scale unlabeled data to downstream NLP tasks, such as text classification (Socher et al., 2013) and natural language inference (Bowman et al., 2015; Williams et al., 2018), with limited or no training data. To extend such pretraining-finetuning paradigm to multiple languages, some endeavors such as multilingual BERT (Devlin et al., 2019) and XLM (Conneau & Lample, 2019) have been made for learning cross-lingual representation. More recently, Conneau et al. (2020) present XLM-R to study the effects of training unsupervised cross-lingual representations at a huge scale and demonstrate promising progress on cross-lingual tasks.
+
+However, all of these studies only perform a masked language model (MLM) with token-level (i.e., subword) cross entropy, which limits PTMs to capture the co-occurrence among tokens and consequently fail to understand the whole sentence. It leads to two major shortcomings for current cross-lingual PTMs, i.e., the acquisition of sentence-level representations and semantic alignments among parallel sentences in different languages. Considering the former, Devlin et al. (2019) introduced the next sentence prediction (NSP) task to distinguish whether two input sentences are continuous segments from the training corpus. However, this simple binary classification task is not enough to model sentence-level representations (Joshi et al., 2020; Yang et al., 2019; Liu et al., 2019; Lan et al., 2020; Conneau et al., 2020). For the latter, (Huang et al., 2019) defined the cross-lingual paraphrase classification task, which concatenates two sentences from different languages as input and classifies whether they are with the same meaning. This task learns patterns of sentence-pairs well but fails to distinguish the exact meaning of each sentence.
+
+In response to these problems, we propose to strengthen PTMs through learning universal representations among semantically-equivalent sentences distributed in different languages. We introduce a novel Hierarchical Contrastive Learning (HICTL) framework to learn language invariant sentence representations via self-supervised non-parametric instance discrimination. Specifically, we use a BERT-style model to encode two sentences separately, and the representation of the first token (e.g., [CLS] in BERT) will be treated as the sentence representation. Then, we conduct instance-wise comparison at both sentence-level and word-level, which are complementary to each other. At the sentence level, we maximize the similarity between two parallel sentences while minimizing which among non-parallel ones. At the word-level, we maintain a bag-of-words for each sentence-pair, each word in which is considered as a positive sample while the rest words in vocabulary are negative ones. To reduce the space of negative samples, we conduct negative sampling for word-level contrastive learning. With the HICTL framework, the PTMs are encouraged to learn language-agnostic representation, thereby bridging the semantic discrepancy among cross-lingual sentences.
+
+The HICTL is conducted on the basis of XLM-R (Conneau et al., 2020) and experiments are performed on several challenging cross-lingual tasks: language understanding tasks (e.g., XNLI, XQuAD, and MLQA) in the XTREME (Hu et al., 2020) benchmark, and machine translation in the IWSLT and WMT benchmarks. Extensive empirical evidence demonstrates that our approach can achieve consistent improvements over baselines on various tasks of both cross-lingual language understanding and generation. In more detail, our HICTL obtains absolute gains of $4 . 2 \%$ (up to $6 . 0 \%$ on zero-shot sentence retrieval tasks, e.g. BUCC and Tatoeba) accuracy on XTREME over XLM-R. For machine translation, our HICTL achieves substantial improvements over baselines on both low-resource (IWSLT English $\cdot {  } \mathrm { X }$ ) and high-resource (WMT English ${  } \mathrm { X }$ ) translation tasks.
+
+# 2 RELATED WORK
+
+Pre-trained Language Models. Recently, substantial work has shown that pre-trained models (PTMs) (Peters et al., 2018; Radford et al., 2018; Devlin et al., 2019) on the large corpus are beneficial for downstream NLP tasks. The application scheme is to fine-tune the pre-trained model using the limited labeled data of specific target tasks. For cross-lingual pre-training, both Devlin et al. (2019) and Conneau & Lample (2019) trained a transformer-based model on multilingual Wikipedia which covers various languages, while XLM-R (Conneau et al., 2020) studied the effects of training unsupervised cross-lingual representations on a very large scale.
+
+For sequence-to-sequence pre-training, UniLM (Dong et al., 2019) fine-tuned BERT with an ensemble of masks, which employs a shared Transformer network and utilizing specific self-attention mask to control what context the prediction conditions on. Song et al. (2019) extended BERT-style models by jointly training the encoder-decoder framework. XLNet (Yang et al., 2019) trained by predicting masked tokens auto-regressively in a permuted order, which allows predictions to condition on both left and right context. Raffel et al. (2019) unified every NLP problem as a text-to-text problem and pre-trained a denoising sequence-to-sequence model at scale. Concurrently, BART (Lewis et al., 2020) pre-trained a denoising sequence-to-sequence model, in which spans are masked from the input but the complete output is auto-regressively predicted.
+
+Previous works have explored using pre-trained models to improve text generation, such as pretraining both the encoder and decoder on several languages (Song et al., 2019; Conneau & Lample, 2019; Raffel et al., 2019) or using pre-trained models to initialize encoders (Edunov et al., 2019; Zhang et al., $2 0 1 9 \mathrm { a }$ ; Guo et al., 2020). Zhu et al. (2020) and Weng et al. (2020) proposed a BERTfused NMT model, in which the representations from BERT are treated as context and fed into all layers of both the encoder and decoder. Zhong et al. (2020) formulated the extractive summarization task as a semantic text matching problem and proposed a Siamese-BERT architecture to compute the similarity between the source document and the candidate summary, which leverages the pre-trained BERT in a Siamese network structure. Our approach also belongs to the contextual pre-training so it could be applied to various downstream NLU and NLG tasks.
+
+Contrastive Learning. Contrastive learning (CTL) (Saunshi et al., 2019) aims at maximizing the similarity between the encoded query $q$ and its matched key $k ^ { + }$ while keeping randomly sampled keys $\{ k _ { 0 } ^ { - } , k _ { 1 } ^ { - } , k _ { 2 } ^ { - } , \ldots \}$ faraway from it. With similarity measured by a score function $s ( q , k )$ , a form of a contrastive loss function, called InfoNCE (Oord et al., 2018), is considered in this paper:
+
+![](images/75c997a95b348d0d989069ce52c9f105c084b518de013b9509453a07c2ee7240.jpg)  
+Figure 1: Illustration of Hierarchical Contrastive Learning (HICTL). $n$ is the batch size, $m$ denotes the number of negative samples for word-level contrastive learning. $\boldsymbol { B }$ and $\nu$ indicates the bag-ofwords of the instance $\langle x _ { i } , y _ { i } \rangle$ and the overall vocabulary of all languages, respectively.
+
+$$
+\mathcal { L } _ { c t l } = - \log \frac { \exp ( s ( q , k ^ { + } ) ) } { \exp ( s ( q , k ^ { + } ) ) + \sum _ { i } \exp ( s ( q , k _ { i } ^ { - } ) ) } ,
+$$
+
+where the score function $s ( q , k )$ is essentially implemented as the cosine similarity kqk·kkk . q and k are often encoded by a learnable neural encoder, such as BERT (Devlin et al., 2019) or ResNet (He et al., 2016). $k ^ { + }$ and $k ^ { - }$ are typically called positive and negative samples. In addition to the form illustrated in Eq. (1), contrastive losses can also be based on other forms, such as margin-based loses (Hadsell et al., 2006) and variants of NCE losses (Mnih & Kavukcuoglu, 2013).
+
+Contrastive learning is at the core of several recent work on unsupervised or self-supervised learning from computer vision (Wu et al., 2018; Oord et al., 2018; Ye et al., 2019; He et al., 2019; Chen et al., 2020; Tian et al., 2020) to natural language processing (Mikolov et al., 2013; Mnih & Kavukcuoglu, 2013; Devlin et al., 2019; Clark et al., 2020b; Feng et al., 2020; Chi et al., 2020). Kong et al. (2020) improved language representation learning by maximizing the mutual information between a masked sentence representation and local n-gram spans. Clark et al. (2020b) utilized a discriminator to predict whether a token is replaced by a generator given its surrounding context. Iter et al. (2020) proposed to pre-train language models with contrastive sentence objectives that predict the surrounding sentences given an anchor sentence. In this paper, we propose HICTL to encourage parallel cross-lingual sentences to have the identical semantic representation and distinguish whether a word is contained in them as well, which can naturally improve the capability of cross-lingual understanding and generation for PTMs.
+
+# 3 METHODOLOGY
+
+# 3.1 HIERARCHICAL CONTRASTIVE LEARNING
+
+We propose hierarchical contrastive learning (HICTL), a novel comparison learning framework that unifies cross-lingual sentences as well as related words. HICTL can learn from both non-parallel and parallel multilingual data, and the overall architecture of HICTL is illustrated in Figure 1. We represent a training batch of the original sentences as $\mathbf { x } = \{ x _ { 1 } , x _ { 2 } , . . . , x _ { n } \}$ and its aligned counterpart is denoted as $\mathbf { y } = \{ y _ { 1 } , y _ { 2 } , . . . , y _ { n } \}$ , where $n$ is the batch size. For each pair $\left. x _ { i } , y _ { i } \right.$ , $y _ { i }$ is either the translation in the other language of $x _ { i }$ when using parallel data or the perturbation through reordering tokens in $x _ { i }$ when only monolingual data is available. $\mathbf { x } ^ { \backslash i }$ is denoted as a modified version of $\mathbf { x }$ where the $i$ -th instance is removed.
+
+Sentence-Level CTL. As illustrated in Figure 1a, we apply the XLM-R as the encoder to represent sentences into hidden representations. The first token of every sequence is always a special token (e.g., [CLS]), and the final hidden state corresponding to this token is used as the aggregate sentence representation for pre-training, that is, $r _ { x } = f \circ g ( \mathcal { M } ( x ) )$ where $g ( \cdot )$ is the aggregate function and $f ( \cdot )$ is a linear projection, $\circ$ denotes the composition of operations. To obtain universal representation among semantically-equivalent sentences, we encourage $r _ { x _ { i } }$ (the query, denoted as $q$ ) to be as similar as possible to $r _ { y _ { i } }$ (the positive sample, denoted as $k ^ { + }$ ) but dissimilar to all other instances (i.e., $\mathbf { y } ^ { \backslash i } \cup \mathbf { x } ^ { \backslash i }$ , considered as a series of negative samples, denoted as $\{ k _ { 1 } ^ { - } , k _ { 2 } ^ { - } , . . . , k _ { 2 n - 2 } ^ { - } \} )$ in a training batch. Formally, the sentence-level contrastive loss for $x _ { i }$ is defined as
+
+![](images/a4a1556f7fa56184d62e608b55c1fc749577b336b14cf3ffe4bca58b826ca40c.jpg)  
+Figure 2: Illustration of constructing hard negative samples (HNS). A circle (the radius is $d ^ { + } = \parallel$ $k ^ { + } - q ~ \| _ { 2 } )$ in the embedding space represents a manifold near in which sentences are semantically equivalent. We can generate a coherent sample (i.e., $\hat { k } ^ { - }$ ) that interpolate between known pair $q$ and $k ^ { - }$ . The synthetic negative $\hat { k } ^ { - }$ can be controlled adaptively with proper difficulty during training. The curly brace in green indicates the walking range of hard negative samples, the closer to the circle the harder the sample is.
+
+$$
+\mathcal { L } _ { s c t l } ( x _ { i } ) = - \log \frac { \exp { \circ s ( q , k ^ { + } ) } } { \exp { \circ s ( q , k ^ { + } ) } + \sum _ { j = 1 } ^ { | \mathbf { y } ^ { \backslash i } \cup \mathbf { x } ^ { \backslash i } | } \exp { \circ s ( q , k _ { j } ^ { - } ) } } .
+$$
+
+Symmetrically, we also expect $r _ { y _ { i } }$ (the query, denoted as $\tilde { q }$ ) to be as similar as possible to $r _ { x _ { i } }$ (the positive sample, denoted as $\tilde { k } ^ { + }$ ) but dissimilar to all other instances in the same training batch, thus,
+
+$$
+\mathcal { L } _ { s c t l } ( y _ { i } ) = - \log \frac { \exp \circ s ( \tilde { q } , \tilde { k } ^ { + } ) } { \exp \circ s ( \tilde { q } , \tilde { k } ^ { + } ) + \sum _ { j = 1 } ^ { | \mathbf { y } ^ { \backslash i } \cup \mathbf { x } ^ { \backslash i } | } \exp \circ s ( \tilde { q } , \tilde { k } _ { j } ^ { - } ) } .
+$$
+
+The sentence-level contrastive loss over the training batch can be formulated as
+
+$$
+\mathcal { L } _ { S } = \frac { 1 } { 2 n } \sum _ { i = 1 } ^ { n } \big \{ \mathcal { L } _ { s c t l } ( x _ { i } ) + \mathcal { L } _ { s c t l } ( y _ { i } ) \big \} .
+$$
+
+For sentence-level contrastive learning, we treat other instances contained in the training batch as negative samples for the current instance. However, such randomly selected negative samples are often uninformative, which poses a challenge of distinguishing very similar but nonequivalent samples. To address this issue, we employ smoothed linear interpolation (Bowman et al., 2016; Zheng et al., 2019) between sentences in the embedding space to alleviate the lack of informative samples for pre-training, as shown in Figure 2. Given a training batch $\{ \langle x _ { i } , y _ { i } \rangle \} _ { i = 1 } ^ { n }$ , where $n$ is the batch size. In this context, having obtained the embeddings of a triplet, an anchor $q$ and a positive $k ^ { + }$ as well as a negative $k ^ { - }$ (supposing $q$ , $k ^ { + }$ and $k ^ { - }$ are representations of sentences $x _ { i } , y _ { i }$ and $y _ { i } ^ { - } \in \mathbf { x } ^ { \backslash i } \cup \mathbf { y } ^ { \backslash i }$ , respectively), we construct a harder negative sample $\hat { k } ^ { - }$ to replace $k _ { j } ^ { - }$ :
+
+$$
+\begin{array} { r } { \hat { k } ^ { - } = \left\{ \begin{array} { l l } { q + \lambda ( k ^ { - } - q ) , \lambda \in ( \frac { d ^ { + } } { d ^ { - } } , 1 ] \quad } & { i f \quad d ^ { - } > d ^ { + } ; } \\ { k ^ { - } \quad } & { i f \quad d ^ { - } \leq d ^ { + } . } \end{array} \right. } \end{array}
+$$
+
+where $d ^ { + } = \parallel  { k ^ { + } } -  { q } \parallel _ { 2 }$ and $d ^ { - } = \parallel \boldsymbol { k } ^ { - } - \boldsymbol { q } \parallel _ { 2 }$ . For the first condition, the hardness of $\hat { k } ^ { - }$ increases when $\lambda$ becomes smaller. To this end, we intuitively set $\boldsymbol { \lambda }$ as
+
+$$
+\lambda = \left( \frac { d ^ { + } } { d ^ { - } } \right) ^ { \zeta \cdot p _ { a v g } ^ { + } } , \quad \zeta \in ( 0 , 1 )
+$$
+
+where p+avg $\begin{array} { r l r } { p _ { a v g } ^ { + } } & { { } = } & { \frac { 1 } { 1 0 0 } \sum _ { \jmath \in [ - 1 0 0 , - 1 ] } e ^ { - \mathcal { L } _ { S } ^ { ( \jmath ) } } } \end{array}$ is the average log-probability over the last 100 training batches and $\mathcal { L } _ { S }$ formulated in Eq. (4) is the sentence-level contrastive loss of one training batch. During pre-training, when the model tends to distinguish positive samples easily, which means negative samples are not informative already. At this time, $p _ { a v g } ^ { + } \uparrow$ and $\textstyle { \frac { d ^ { + } } { d ^ { - } } } \downarrow$ , which leads $\lambda \downarrow$ and harder negative samples are adaptively synthesized in the following training steps, vice versa. As hard negative samples usually result in significant changes of the model parameters, we introduce the slack coefficient $\zeta$ to prevent the model from being trained in the wrong direction, when it accidentally switch from random negative samples to very hard ones. In practice, we empirically set $\zeta = 0 . 9$ .
+
+Word-Level CTL. Intuitively, predicting the related words in other languages for each sentence can bridge the representations of words in different languages. As shown in Figure 1b, we concatenate the sentence pair $\left. x _ { i } , y _ { i } \right.$ as $x _ { i } \circ y _ { i }$ : [CLS] $x _ { i }$ [SEP] $y _ { i }$ [SEP] and the bag-of-words of which is denoted as $\boldsymbol { B }$ . For word-level contrastive learning, the final state of the first token is treated as the query $( \bar { q } )$ , each word $w _ { t } \in B$ is considered as the positive sample and all the other words $( \mathcal V \backslash B$ , i.e., the words in $\nu$ that are not in $\boldsymbol { B }$ where $\nu$ indicates the overall vocabulary of all languages) are negative samples. As the vocabulary usually with large space, we propose to only use a subset $\mathcal { S } \subset \bar { \mathcal { V } } \backslash B$ sampled according to the normalized similarities between $\bar { q }$ and the embeddings of the words. As a result, the subset $s$ naturally contains the hard negative samples which are beneficial for learning high-quality representations (Ye et al., 2019). Specifically, the word-level contrastive loss for $\left. x _ { i } , y _ { i } \right.$ is defined as
+
+$$
+\mathcal { L } _ { w c t l } ( x _ { i } , y _ { i } ) = - \frac { 1 } { | \mathcal { B } | } \sum _ { t = 1 } ^ { | \mathcal { B } | } \log \frac { \exp { \circ s ( \bar { q } , e ( w _ { t } ) ) } } { \exp { \circ s ( \bar { q } , e ( w _ { t } ) ) } + \sum _ { w _ { j } \in \mathcal { S } } \exp { \circ s ( \bar { q } , e ( w _ { j } ) ) } } .
+$$
+
+where $e ( \cdot )$ is the embedding lookup function and $| B |$ is the number of unique words in the concatenated sequence $x _ { i } \circ y _ { i }$ . The overall word-level contrastive loss can be formulated as:
+
+$$
+\mathcal { L } _ { W } = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathcal { L } _ { w c t l } ( x _ { i } , y _ { i } ) .
+$$
+
+Multi-Task Pre-training. Both MLM and translation language model (TLM) are combined with HICTL by default, as the prior work (Conneau $\&$ Lample, 2019) has verified the effectiveness of them in XLM. In summary, the model can be optimized by minimizing the entire training loss:
+
+$$
+\mathcal { L } = \mathcal { L } _ { L M } + \mathcal { L } _ { S } + \mathcal { L } _ { W } ,
+$$
+
+where $\mathcal { L } _ { L M }$ is implemented as either the TLM when using parallel data or the MLM when only monolingual data is available to recover the original words of masked positions given the contexts.
+
+# 3.2 CROSS-LINGUAL FINE-TUNING
+
+Language Understanding. The representations produced by HICTL can be used in several ways for language understanding tasks whether they involve single text or text pairs. Concretely, (i) the [CLS] representation of single-sentence in sentiment analysis or sentence pairs in paraphrasing and entailment is fed into an extra output-layer for classification. $( i i )$ The pre-trained encoder can be used to assign POS tags to each word or to locate and classify all the named entities in the sentence for structured prediction, as well as (iii) to extract answer spans for question answering.
+
+Language Generation. We also explore using HICTL to improve machine translation. In the previous work, Conneau & Lample (2019) has shown that the pre-trained encoders can provide a better initialization of both supervised and unsupervised NMT systems. Liu et al. (2020b) has shown that NMT models can be improved by incorporating pre-trained sequence-to-sequence models on various language pairs but highest-resource settings. As illustrated in Figure 3, we use the model pre-trained by HICTL as the encoder, and add a new set of decoder parameters that are learned from scratch. To prevent pre-trained weights from being washed out by supervised training, we train the encoder-decoder model in two steps. In the first step, we freeze the pre-trained encoder and only update the decoder. In the second step, we train all parameters for a relatively small number of iterations. In both cases, we compute the similarities between the [CLS] representation of the encoder and all target words in advance. Then we aggregate them with the logits before the softmax of each decoder step through an element-wise additive operation. The encoder-decoder model is optimized by maximizing the log-likelihood of bitext at both steps.
+
+![](images/d07d6a0671d2e0c808fccbac4ffc25a9a3f974ed1d25cb610832c4e8836683ec.jpg)  
+Figure 3: Fine-tuning on NMT task.
+
+Table 1: Overall results on XTREME benchmark. Results of mBERT (Devlin et al., 2019), XLM (Conneau & Lample, 2019) and XLM-R (Conneau et al., 2020) are from XTREME (Hu et al., 2020). Results of $\ddagger$ are from our in-house replication. HNS is short for “Hard Negative Samples”.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Pair sentence</td><td colspan="2">Structured prediction</td><td colspan="3">Question answering</td><td colspan="2">Sentence retrieval</td><td rowspan="2">Avg.</td></tr><tr><td>XNLI</td><td>PAWS-X</td><td>POS</td><td>NER</td><td>XQuAD</td><td>MLQA</td><td>TyDiQA-GoldP</td><td>BUCC</td><td>Tatoeba</td></tr><tr><td>Metrics</td><td>Acc.</td><td>Acc.</td><td>F1</td><td>F1</td><td>F1/EM</td><td>F1/EM</td><td>F1 /EM</td><td>F1</td><td>Acc.</td><td></td></tr><tr><td colspan="9">Cross-lingual zero-shot transfer(models are trained on English data)</td><td></td><td></td></tr><tr><td>mBERT</td><td>65.4</td><td>81.9</td><td>70.3</td><td>62.2</td><td>64.5 /49.4</td><td>61.4 /44.2</td><td>59.7 /43.9</td><td>56.7</td><td>38.7</td><td>59.6</td></tr><tr><td>XLM</td><td>69.1</td><td>80.9</td><td>70.1</td><td>61.2</td><td>59.8/44.3</td><td>48.5 /32.6</td><td>43.6/29.1</td><td>56.8</td><td>32.6</td><td>55.5</td></tr><tr><td>XLM-RBase</td><td>76.2</td><td>-</td><td>-</td><td>-</td><td>=</td><td>63.7 /46.3</td><td>=</td><td>1</td><td>-</td><td>1</td></tr><tr><td>HICTLBase</td><td>77.3</td><td>84.5</td><td>71.4</td><td>64.1</td><td>73.5 / 58.7</td><td>65.8/47.6</td><td>61.9 /42.8</td><td>1</td><td>：</td><td></td></tr><tr><td>XLM-R</td><td>79.2</td><td>86.4</td><td>73.8</td><td>65.4</td><td>76.6/60.8</td><td>71.6/53.2</td><td>65.1/45.0</td><td>66.0</td><td>57.3</td><td>68.2</td></tr><tr><td>HICTL</td><td>81.0</td><td>87.5</td><td>74.8</td><td>66.2</td><td>77.9 / 61.7</td><td>72.8 /54.5</td><td>66.0/45.7</td><td>68.4</td><td>59.7</td><td>69.6</td></tr><tr><td colspan="9">Translate-train-all(modelsaretrainedonEnglish trainingdataandits translated dataonthetarget language)</td><td></td><td></td></tr><tr><td>mBERT</td><td>75.1</td><td>88.9</td><td>-</td><td>1</td><td>72.4 /58.3</td><td>67.6/49.8</td><td>64.2/49.3</td><td>1</td><td>-</td><td>-</td></tr><tr><td>XLM-R</td><td>82.9</td><td>90.1</td><td>74.6</td><td>66.8</td><td>80.4 / 65.6</td><td>72.4/54.7</td><td>66.2/48.2</td><td>67.9</td><td>59.1</td><td>70.6</td></tr><tr><td>HICTL</td><td>84.5</td><td>92.2</td><td>76.8</td><td>68.4</td><td>82.8/67.3</td><td>74.4/57.1</td><td>69.7 / 52.5</td><td>71.8</td><td>63.1</td><td>73.2</td></tr><tr><td>+HNS</td><td>84.7</td><td>92.8</td><td>77.2</td><td>69.0</td><td>82.9 / 67.4</td><td>74.8 /57.3</td><td>71.1/53.2</td><td>77.6</td><td>69.1</td><td>74.8</td></tr></table>
+
+# 4 EXPERIMENTS
+
+We consider two evaluation benchmarks: nine cross-lingual language understanding tasks in the XTREME benchmark and machine translation tasks (IWSLT’14 English German, IWSLT’14 English Spanish, WMT’16 Romanian English, IWSLT’17 English {French, Chinese} and WMT’14 English {German, French}). In this section, we describe the data and training details, and provide detailed evaluation results.
+
+# 4.1 DATA AND MODEL
+
+During pre-training, we follow Conneau et al. (2020) to build a Common-Crawl Corpus using the CCNet (Wenzek et al., 2019) tool1 for monolingual texts. Table 7 (see appendix A) reports the language codes and data size in our work. For parallel data, we use the same (English-to-X) MT dataset as (Conneau & Lample, 2019), which are collected from MultiUN (Eisele & Yu, 2010) for French, Spanish, Arabic and Chinese, the IIT Bombay corpus (Kunchukuttan et al., 2018a) for Hindi, the OpenSubtitles 2018 for Turkish, Vietnamese and Thai, the EUbookshop corpus for German, Greek and Bulgarian, Tanzil for both Urdu and Swahili, and GlobalVoices for Swahili. Table 8 (see appendix A) shows the statistics of the parallel data.
+
+We adopt the Transformer-Encoder (Vaswani et al., 2017) as the backbone with 12 layers and 768 hidden units for $\mathrm { H I C T L _ { B a s e } }$ , and 24 layers and 1024 hidden units for HICTL. We initialize the parameters of HICTL with XLM-R (Conneau et al., 2020). Hyperparameters for pre-training and fine-tuning are shown in Table 9 (see appendix B). We run the pre-training experiments on 8 V100 GPUs, batch size 1024. The number of negative samples $m { = } 5 1 2$ for word-level contrastive learning.
+
+# 4.2 EXPERIMENTAL EVALUATION
+
+Cross-lingual Language Understanding (XTREME) There are nine tasks in XTREME that can be grouped into four categories: (i) sentence classification consists of Cross-lingual Natural Language Inference (XNLI) (Conneau et al., 2018) and Cross-lingual Paraphrase Adversaries from
+
+Table 2: Comparison with existing methods on XTREME tasks.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Pair sentence</td><td colspan="2">Structured prediction</td><td colspan="3">Question answering</td></tr><tr><td>XNLI</td><td>PAWS-X</td><td>POS</td><td>NER</td><td>XQuAD</td><td>MLQA</td><td>TyDiQA-GoldP</td></tr><tr><td>Metrics</td><td>Acc.</td><td>Acc.</td><td>F1</td><td>F1</td><td>F1/EM</td><td>F1/EM</td><td>F1/EM</td></tr><tr><td colspan="8">Translate-train-all</td></tr><tr><td>FILTER</td><td>83.9</td><td>91.4</td><td>76.2</td><td>67.7</td><td>82.4/ 68.0</td><td>76.2 /57.7</td><td>68.3/50.9</td></tr><tr><td>VECO</td><td>83.0</td><td>91.1</td><td>75.1</td><td>65.7</td><td>79.9 /66.3</td><td>73.1/54.9</td><td>75.0 /58.9</td></tr><tr><td>HICTL</td><td>84.7</td><td>92.8</td><td>77.2</td><td>69.0</td><td>82.9 / 67.4</td><td>74.8 /57.3</td><td>71.1/53.2</td></tr></table>
+
+Table 3: Ablation study on XTREME tasks.   
+
+<table><tr><td>Model</td><td>XNLI Acc.</td><td>PAWS-X Acc.</td><td>POS F1</td><td>NER F1</td><td>XQuAD F1/EM</td><td>MLQA F1/EM</td><td>TyDiQA-GoldP F1/EM</td><td>BUCC F1</td><td>Tatoeba Acc.</td><td>Avg.</td></tr><tr><td>FULL MODEL</td><td>84.7</td><td>92.8</td><td>77.2</td><td>69.0</td><td>82.9 /67.4</td><td>74.8 / 57.3</td><td>71.1/53.2</td><td>77.6</td><td>69.1</td><td>74.8</td></tr><tr><td>w/o Sentence-CTL</td><td>82.9</td><td>90.5</td><td>75.9</td><td>67.8</td><td>82.3 /66.7</td><td>74.3 /56.5</td><td>69.7 /52.3</td><td>71.4</td><td>62.6</td><td>72.4</td></tr><tr><td>w/o Word-CTL</td><td>84.3</td><td>92.1</td><td>76.3</td><td>68.4</td><td>82.5 /66.9</td><td>74.1/56.7</td><td>70.2/52.5</td><td>76.8</td><td>68.4</td><td>74.2</td></tr><tr><td>w/o MT data</td><td>84.2</td><td>92.4</td><td>76.6</td><td>68.2</td><td>82.6/67.0</td><td>74.5/56.8</td><td>70.1/52.3</td><td>74.7</td><td>66.8</td><td>73.8</td></tr></table>
+
+Word Scrambling (PAWS-X) (Zhang et al., 2019b). (ii) Structured prediction includes POS tagging and NER. We use POS tagging data from the Universal Dependencies v2.5 (Nivre et al., 2018) treebanks. Each word is assigned one of 17 universal POS tags. For NER, we use the Wikiann dataset (Pan et al., 2017). (iii) Question answering includes three tasks: Cross-lingual Question Answering (XQuAD) (Artetxe et al., 2019), Multilingual Question Answering (MLQA) (Lewis et al., 2019), and the gold passage version of the Typologically Diverse Question Answering dataset (TyDiQA-GoldP) (Clark et al., 2020a). (iv) Sentence retrieval includes two tasks: BUCC (Zweigenbaum et al., 2017) and Tatoeba (Artetxe & Schwenk, 2019), which aims to extract parallel sentences between the English corpus and target languages. As XTREME provides no training data, thus we directly evaluate pre-trained models on test sets.
+
+Table 1 provides detailed results on four categories in XTREME. First, compared to the state of the art XLM-R baseline, HICTL further achieves significant gains of $1 . 4 3 \%$ and $2 . 8 0 \%$ on average on nine tasks with cross-lingual zero-shot transfer and translate-train-all settings, respectively. Second, mining hard negative samples via smoothed linear interpolation play an important role in contrastive learning, which significantly improves accuracy by 1.6 points on average. Third, HICTL with hardness aware augmentation delivers large improvements on zero-shot sentence retrieval tasks (scores 5.8 and 6.0 points higher on BUCC and Tatoeba, respectively). Following (Hu et al., 2020), we directly evaluate pre-trained models on test sets without any extra labeled data or fine-tuning techniques used in (Fang et al., 2020; Luo et al., 2020). These results demonstrate the capacity of HICTL on learning cross-lingual representations. We also compare our best model with two existing models: FILTER (Fang et al., 2020) and VECO (Luo et al., 2020). The results demonstrate that HICTL achieves the best performance on most tasks with less monolingual data.
+
+Ablation experiments are present at Table 3. Comparing the full model, we can draw several conclusions: (1) removing the sentence-level CTL objective hurts performance consistently and significantly, (2) the word-level CTL objective has least drop compared to others, and (3) the parallel (MT) data has a large impact on zero-shot multilingual sentence retrieval tasks. Moreover, Table 2 provides the comparisons between HICTL and existing methods.
+
+Machine Translation The main idea of HICTL is to summarize cross-lingual parallel sentences into a shared representation that we term as semantic embedding, using which semantically related words can be distinguished from others. Thus it is natural to apply this global embedding to text generation. We fine-tune the pre-trained HICTL with the base setting on machine translation tasks with both low-resource and high-resource settings. For the low-resource scenario, we choose IWSLT’14 English German $( \mathrm { E n }  \mathrm { D e } ) ^ { 2 }$ , IWSLT’14 English Spanish ( $\mathrm { E n \to E s }$ ), WMT’16
+
+Table 4: BLEU scores $[ \% ]$ on high-resource tasks. Results with $\dagger$ and $\ddagger$ are from VECO (Luo et al., 2020) and our in-house implementation, respectively. In our implementation, we use XLM-R and the best version of HiCTL (pre-traind with CCNet-100 and hard negative samples) to initialize the encoder, respectively.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Layers</td><td colspan="2">WMT&#x27;14</td></tr><tr><td>Encoder</td><td>Decoder</td><td>En→De</td><td>En→Fr</td></tr><tr><td>Randomly Initialize</td><td></td><td></td><td></td><td></td></tr><tr><td>Transformer-Big (Vaswani et al., 2017)</td><td>6</td><td>6</td><td>28.4</td><td>41.0</td></tr><tr><td>Deep-Transformer (Liu et al., 2020a)</td><td>60</td><td>12</td><td>30.1</td><td>43.8</td></tr><tr><td>Deep MSC Model (Wei et al., 2020)</td><td>18</td><td>6</td><td>30.56</td><td>1</td></tr><tr><td>Pre-trained Models Initialize</td><td></td><td></td><td></td><td></td></tr><tr><td>CTNMT (Yang et al.,2020)</td><td>18</td><td>6</td><td>30.1</td><td>42.3</td></tr><tr><td>BERT-fused NMT (Zhu et al.,2020)</td><td>18</td><td>6</td><td>30.75</td><td>43.78</td></tr><tr><td>mBART+ (Liu et al.,2020b)</td><td>12</td><td>12</td><td>30.0</td><td>43.2</td></tr><tr><td>VECO (Luo et al., 2020)</td><td>24</td><td>6</td><td>31.5</td><td>44.4</td></tr><tr><td>XLM-R‡</td><td>24</td><td>6</td><td>30.91</td><td>43.27</td></tr><tr><td>HICTL</td><td>24</td><td>6</td><td>31.74</td><td>43.95</td></tr></table>
+
+Table 5: BLEU scores $[ \% ]$ on low-resource tasks. Results with $^ \ddag$ are from our in-house implementation. We provide additional experimental results (to follow experiments in Zhu et al. (2020)) on IWSLT’14 English Spanish $( \mathrm { E n \to E s } )$ ) task. $\mathrm { H I C T L _ { B a s e } }$ represents the BASE sized model that is pre-trained on CCNet-100 with hard negative samples.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="3">IWSLT&#x27;14</td><td rowspan="2">WMT&#x27;16 Ro→En</td><td colspan="2">IwSLT&#x27;17</td></tr><tr><td>En→De</td><td>De→En</td><td>En→Es</td><td>En→Fr</td><td>En→Zh</td></tr><tr><td>Transformer (Vaswani et al., 2017)‡</td><td>28.64</td><td>34.51</td><td>39.3</td><td>33.51</td><td>35.8</td><td>26.5</td></tr><tr><td>BERT-fused NMT (Zhu et al., 2020)</td><td>30.45</td><td>36.11</td><td>41.4</td><td>39.10</td><td>38.7</td><td>28.2</td></tr><tr><td>HICTLBase</td><td>31.88</td><td>37.96</td><td>42.1</td><td>39.88</td><td>40.2</td><td>29.9</td></tr></table>
+
+Romanian English $( \mathrm { R o } \to \mathrm { E n } )$ ), IWSLT’17 English French $( \mathrm { E n \to F r } )$ and English Chinese $( \mathrm { E n { \to } Z h } )$ ) translation3. There are 160k, 183k, 236k, $2 3 5 \mathrm { k }$ , 0.6M bilingual sentence pairs for $\mathrm { E n } {  } \mathrm { D e }$ , E $\mathbf { n } {  } \mathrm { E s }$ , En ${  } \mathrm { F r }$ , $\mathrm { E n } \to \mathrm { Z h }$ and $\mathrm { R o } {  } \mathrm { E n }$ tasks. For the rich-resource scenario, we work on WMT’14 ${ \mathrm { E n } } {  } \{ \mathrm { D e } , \mathrm { F r } \}$ , the corpus sizes are 4.5M and 36M respectively. We concatenate newstest 2012 and newstest 2013 as the validation set and use newstest 2014 as the test set.
+
+During fine-tuning, we use the pre-trained model to initialize the encoder and introduce a randomly initialized decoder. We develop a shallower decoder with 4 identical layers to reduce the computation overhead. At the first fine-tune step, we concatenate the datasets of all language pairs in either low-resource or high-resource settings to optimize the decoder only until convergence4. Then we tune the whole encoder-decoder model using a per-language corpus at the second step. The initial learning rate is 2e-5 and inverse sqrt learning rate (Vaswani et al., 2017) scheduler is also adopted. For WMT’14 En De, we use beam search with width 4 and length penalty 0.6 for inference. For other tasks, we use width 5 and a length penalty of 1.0. We use multi-bleu.perl to evaluate IWSLT’14 $\mathrm { E n } {  } \mathrm { D e }$ and WMT tasks, but sacreBLEU for the remaining tasks, for fair comparison with previous work.
+
+Results on both high-resource and low-resource tasks are reported in Table 4 and Table 5, respectively. We implemented standard Transformer (apply the base and big setting for IWSLT and WMT tasks respectively) as baseline. The proposed HICTL can improve the BLEU scores of the eight tasks by 3.34, 2.95, 3.24, 3.45, 2.8, 6.37, 4.4, and 3.4. In addition, our approach also outperforms the BERT-fused model (Yang et al., 2020), a method treats BERT as an extra context and fuses the representations extracted from BERT with each encoder and decoder layer. Note we achieve new state-of-the-art results on IWSLT’1 $4 ~ \mathrm { E n } {  } \mathrm { D e }$ , IWSLT’17 $\mathrm { E n } {  } \{ \mathrm { F r } , \mathrm { Z h } \}$ translations. These improvements show that mapping different languages into a universal representation space is beneficial for both low-resource and high-resource translations.
+
+Table 6: BLEU scores $[ \% ]$ on Zero-shot MT via Language Transfer. We bold the highest transferring score for each language family.   
+
+<table><tr><td rowspan="3">TestLanguages</td><td colspan="4">Fine-tuning Languages</td></tr><tr><td>Cs-→En</td><td></td><td></td><td>Hi→En</td></tr><tr><td>mBART</td><td>HiCTL</td><td>mBART</td><td>HiCTL</td></tr><tr><td>Cs→En</td><td>21.6</td><td>22.4</td><td></td><td></td></tr><tr><td>Ro→En</td><td>19.5</td><td>19.0</td><td colspan="2"></td></tr><tr><td>It-→En</td><td>16.7</td><td>18.6</td><td colspan="2"></td></tr><tr><td>Nl→En</td><td>17.0</td><td>18.1</td><td colspan="2"></td></tr><tr><td>Hi→En</td><td></td><td></td><td>23.5</td><td>25.2</td></tr><tr><td>Ne→En</td><td></td><td></td><td>14.5</td><td>16.0</td></tr><tr><td>Si→En</td><td></td><td></td><td>13.0</td><td>14.7</td></tr><tr><td>Gu→En</td><td></td><td></td><td>0.0</td><td>0.1</td></tr></table>
+
+We also evaluate our model on tasks where no bi-text is available for the target language pair. Following mBART (Liu et al., 2020b), we adopt the setting of language transfer. That is, no bi-text for the target pair is available, but there is bi-text for translating from some other language into the target language. For explanation, supposing there is no parallel data for the target language pair Italian English $( \mathrm { I t } \to \mathrm { E n } )$ ), but we can transfer knowledge learned from Czech English $\mathrm { \ C s \to E n }$ , a high-resource language pair) to $\mathrm { I t } {  } \mathrm { E n }$ . We consider $\mathrm { X } { \to } \mathrm { E n }$ translation, covering Indic languages (Ne, Hi, Si, Gu) and European languages (Ro, It, Cs, Nl). For European languages, we fine-tune on $\mathrm { C s } {  } \mathrm { E n }$ translation, the parallel data is from WMT’19 that contains 11M sentence pairs. We test on {Cs, Ro, It, $\mathrm { N l } \} {  } \mathrm { E n }$ , in which test sets are from previous WMT (Cs, Ro) or IWSLT (It, Nl) competitions. For Indic languages, we fine-tune on $\mathrm { H i } { \xrightarrow { } } \mathrm { E n }$ translation (1.56M sentence pairs are from IITB (Kunchukuttan et al., 2018b)), and test on $\{ \mathrm { R o , I t , C s , N l } \} \mathrm { \to { E n } }$ translations.
+
+Results are shown in Table 6. We can always obtain reasonable transferring scores at low-resource pairs over different fine-tuned models. However, our experience shows that the randomly initialized models without pre-training always achieve near 0 BLEU. The underlying scenario is that multilingual pre-training produces universal representations across languages so that once the model learns to translate one language, it learns to translate all languages with similar representations. Moreover, a failure happened in $\mathrm { G u } {  } \mathrm { E n }$ translation, we conjecture that we only use 0.3GB monolingual data for pre-training, which is difficult to learn informative representations for Gujarati.
+
+# 5 CONCLUSION
+
+We have demonstrated that pre-trained language models (PTMs) trained to learn commonsense knowledge from large-scale unlabeled data highly benefit from hierarchical contrastive learning (HICTL), both in terms of cross-lingual understanding and generation. Learning universal representations at both word-level and sentence-level bridges the semantic discrepancy across languages. As a result, our HICTL sets a new level of performance among cross-lingual PTMs, improving on the state of the art by a large margin.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank the anonymous reviewers for the helpful comments. We also thank Jing Yu for the instructive suggestions. This work is supported by the National Key R&D Program of China under Grant No.2017YFB0803301 and No. 2018YFB1403202.
+
+# REFERENCES
+
+Mikel Artetxe and Holger Schwenk. Massively multilingual sentence embeddings for zero-shot cross-lingual transfer and beyond. Transactions of the Association for Computational Linguistics, 7:597–610, 2019.
+
+Mikel Artetxe, Sebastian Ruder, and Dani Yogatama. On the cross-lingual transferability of monolingual representations. arXiv preprint arXiv:1910.11856, 2019.
+
+Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 632–642, Lisbon, Portugal, September 2015. Association for Computational Linguistics. doi: 10.18653/v1/D15-1075. URL https://www.aclweb.org/anthology/D15-1075.
+
+Samuel R. Bowman, Luke Vilnis, Oriol Vinyals, Andrew M. Dai, Rafal Jozefowicz, and Samy ´ Bengio. Generating sentences from a continuous space. In Proceedings of the 20th SIGNLL Conference on Computational Natural Language Learning, CoNLL 2016, Berlin, Germany, August 11-12, 2016, pp. 10–21, 2016. URL https://doi.org/10.18653/v1/k16-1002.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In Proceedings of Machine Learning and Systems 2020, pp. 10719–10729, 2020.
+
+Zewen Chi, Li Dong, Furu Wei, Nan Yang, Saksham Singhal, Wenhui Wang, Xia song, Xian-Ling Mao, Heyan Huang, and Ming Zhou. Infoxlm: An information-theoretic framework for crosslingual language model pre-training. CoRR, abs/2007.07834, 2020. URL https://arxiv. org/abs/2007.07834.
+
+Jonathan H Clark, Eunsol Choi, Michael Collins, Dan Garrette, Tom Kwiatkowski, Vitaly Nikolaev, and Jennimaria Palomaki. Tydi qa: A benchmark for information-seeking question answering in typologically diverse languages. arXiv preprint arXiv:2003.05002, 2020a.
+
+Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. ELECTRA: pretraining text encoders as discriminators rather than generators. In 8th International Conference on Learning Representations, ICLR 2020. OpenReview.net, 2020b.
+
+Alexis Conneau and Guillaume Lample. Cross-lingual language model pretraining. In Proc. of NIPS 2019, pp. 7059–7069, 2019. URL http://papers.nips.cc/paper/ 8928-cross-lingual-language-model-pretraining.pdf.
+
+Alexis Conneau, Ruty Rinott, Guillaume Lample, Adina Williams, Samuel Bowman, Holger Schwenk, and Veselin Stoyanov. XNLI: Evaluating cross-lingual sentence representations. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 2475–2485, Brussels, Belgium, October-November 2018. Association for Computational Linguistics. doi: 10.18653/v1/D18-1269. URL https://www.aclweb.org/anthology/ D18-1269.
+
+Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzman, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Un-´ supervised cross-lingual representation learning at scale. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 8440–8451, Online, July 2020. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/ 2020.acl-main.747.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 4171–4186, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1423. URL https: //www.aclweb.org/anthology/N19-1423.
+
+Li Dong, Nan Yang, Wenhui Wang, Furu Wei, Xiaodong Liu, Yu Wang, Jianfeng Gao, Ming Zhou, and Hsiao-Wuen Hon. Unified language model pre-training for natural language understanding and generation. In Advances in Neural Information Processing Systems 32, NeurIPS 2019, pp. 13063–13075. Curran Associates, Inc., 2019.
+
+Sergey Edunov, Alexei Baevski, and Michael Auli. Pre-trained language model representations for language generation. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 4052–4059, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1409. URL https://www.aclweb.org/ anthology/N19-1409.
+
+Andreas Eisele and Chen Yu. Multiun: A multilingual corpus from united nation documents. In International Conference on Language Resources & Evaluation, 2010.
+
+Yuwei Fang, Shuohang Wang, Zhe Gan, Siqi Sun, and Jingjing Liu. FILTER: an enhanced fusion method for cross-lingual language understanding. CoRR, abs/2009.05166, 2020. URL https: //arxiv.org/abs/2009.05166.
+
+Fangxiaoyu Feng, Yinfei Yang, Daniel Cer, Naveen Arivazhagan, and Wei Wang. Languageagnostic BERT sentence embedding. CoRR, abs/2007.01852, 2020. URL https://arxiv. org/abs/2007.01852.
+
+Junliang Guo, Zhirui Zhang, Linli Xu, Hao-Ran Wei, Boxing Chen, and Enhong Chen. Incorporating bert into parallel sequence decoding with adapters. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 10843–10854. Curran Associates, Inc., 2020. URL https://proceedings.neurips. cc/paper/2020/file/7a6a74cbe87bc60030a4bd041dd47b78-Paper.pdf.
+
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR 2006), pp. 1735–1742. IEEE Computer Society, 2006.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, pp. 770–778. IEEE Computer Society, 2016.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross B. Girshick. Momentum contrast for unsupervised visual representation learning. CoRR, abs/1911.05722, 2019.
+
+Junjie Hu, Sebastian Ruder, Aditya Siddhant, Graham Neubig, Orhan Firat, and Melvin Johnson. XTREME: A massively multilingual multi-task benchmark for evaluating cross-lingual generalization. CoRR, abs/2003.11080, 2020. URL https://arxiv.org/abs/2003.11080.
+
+Haoyang Huang, Yaobo Liang, Nan Duan, Ming Gong, Linjun Shou, Daxin Jiang, and Ming Zhou. Unicoder: A universal language encoder by pre-training with multiple cross-lingual tasks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pp. 2485–2494, Hong Kong, China, November 2019. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/D19-1252.
+
+Dan Iter, Kelvin Guu, Larry Lansing, and Dan Jurafsky. Pretraining with contrastive sentence objectives improves discourse performance of language models. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 4859–4870, Online, 2020. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/ 2020.acl-main.439.
+
+Mandar Joshi, Danqi Chen, Yinhan Liu, Daniel S. Weld, Luke Zettlemoyer, and Omer Levy. Spanbert: Improving pre-training by representing and predicting spans. Trans. Assoc. Comput. Linguistics, 8:64–77, 2020. URL https://transacl.org/ojs/index.php/tacl/ article/view/1853.
+
+Lingpeng Kong, Cyprien de Masson d’Autume, Lei Yu, Wang Ling, Zihang Dai, and Dani Yogatama. A mutual information maximization perspective of language representation learning. In 8th International Conference on Learning Representations, ICLR 2020. OpenReview.net, 2020.
+
+Anoop Kunchukuttan, Pratik Mehta, and Pushpak Bhattacharyya. The IIT bombay english-hindi parallel corpus. In Proceedings of the Eleventh International Conference on Language Resources and Evaluation, LREC 2018. European Language Resources Association (ELRA), 2018a.
+
+Anoop Kunchukuttan, Pratik Mehta, and Pushpak Bhattacharyya. The IIT Bombay English-Hindi parallel corpus. In Proceedings of the Eleventh International Conference on Language Resources and Evaluation (LREC 2018), 2018b. URL https://www.aclweb.org/anthology/ L18-1548.
+
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. ALBERT: A lite BERT for self-supervised learning of language representations. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ H1eA7AEtvS.
+
+Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. BART: Denoising sequence-to-sequence pretraining for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 7871–7880. Association for Computational Linguistics, 2020.
+
+Patrick Lewis, Barlas Oguz, Ruty Rinott, Sebastian Riedel, and Holger Schwenk. Mlqa: Evaluating ˘ cross-lingual extractive question answering. arXiv preprint arXiv:1910.07475, 2019.
+
+Xiaodong Liu, Kevin Duh, Liyuan Liu, and Jianfeng Gao. Very deep transformers for neural machine translation. arXiv preprint arXiv:2008.07772, 2020a.
+
+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. CoRR, abs/1907.11692, 2019. URL http://arxiv.org/abs/1907.11692.
+
+Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, and Luke Zettlemoyer. Multilingual denoising pre-training for neural machine translation. CoRR, abs/2001.08210, 2020b.
+
+Fuli Luo, Wei Wang, Jiahao Liu, Yijia Liu, Bin Bi, Songfang Huang, Fei Huang, and Luo Si. VECO: variable encoder-decoder pre-training for cross-lingual understanding and generation. CoRR, abs/2010.16046, 2020. URL https://arxiv.org/abs/2010.16046.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Gregory S. Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems 26, pp. 3111–3119, 2013.
+
+Andriy Mnih and Koray Kavukcuoglu. Learning word embeddings efficiently with noise-contrastive estimation. In Advances in Neural Information Processing Systems 26, pp. 2265–2273, 2013.
+
+Joakim Nivre, Mitchell Abrams, Zeljko Agic, Lars Ahrenberg, Lene Antonsen, and et al. Universal Dependencies 2.2, 2018. URL https://hal.archives-ouvertes.fr/ hal-01930733. LINDAT/CLARIN digital library at the Institute of Formal and Applied Linguistics (UFAL), Faculty of Mathematics and Physics, Charles University. ´
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predic- ¨ tive coding. CoRR, abs/1807.03748, 2018. URL http://arxiv.org/abs/1807.03748.
+
+Xiaoman Pan, Boliang Zhang, Jonathan May, Joel Nothman, Kevin Knight, and Heng Ji. Crosslingual name tagging and linking for 282 languages. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1946–1958, Vancouver, Canada, July 2017. Association for Computational Linguistics. doi: 10.18653/v1/P17-1178. URL https://www.aclweb.org/anthology/P17-1178.
+
+Matthew Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 2227–2237, New Orleans, Louisiana, June 2018. Association for Computational Linguistics. doi: 10.18653/v1/N18-1202. URL https://www.aclweb.org/anthology/N18-1202.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws. com/openaiassets/researchcovers/languageunsupervised/language understanding paper. pdf, 2018.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.
+
+Nikunj Saunshi, Orestis Plevrakis, Sanjeev Arora, Mikhail Khodak, and Hrishikesh Khandeparkar. A theoretical analysis of contrastive unsupervised representation learning. In Proceedings of the 36th International Conference on Machine Learning, volume 97, pp. 5628–5637, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/ v97/saunshi19a.html.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew $\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pp. 1631–1642, Seattle, Washington, USA, October 2013. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/D13-1170.
+
+Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, and Tie-Yan Liu. MASS: masked sequence to sequence pre-training for language generation. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, volume 97, pp. 5926–5936. PMLR, 2019.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. In Andrea Vedaldi, Horst Bischof, Thomas Brox, and Jan-Michael Frahm (eds.), Computer Vision - ECCV 2020 - 16th European Conference, Glasgow, UK, August 23-28, 2020, Proceedings, Part XI, volume 12356 of Lecture Notes in Computer Science, pp. 776–794. Springer, 2020. doi: 10.1007/ 978-3-030-58621-8\ 45. URL https://doi.org/10.1007/978-3-030-58621-8_ 45.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 30, NIPS 2017, pp. 5998–6008. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf.
+
+Xiangpeng Wei, Heng Yu, Yue Hu, Yue Zhang, Rongxiang Weng, and Weihua Luo. Multiscale collaborative deep models for neural machine translation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 414–426, Online, July 2020. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/ 2020.acl-main.40.
+
+Rongxiang Weng, Heng Yu, Shujian Huang, Shanbo Cheng, and Weihua Luo. Acquiring knowledge from pre-trained model to neural machine translation. In Proceedings of the AAAI Conference on Artificial Intelligence, pp. 9266–9273, 2020.
+
+Guillaume Wenzek, Marie-Anne Lachaux, Alexis Conneau, Vishrav Chaudhary, Francisco Guzman, Armand Joulin, and Edouard Grave. Ccnet: Extracting high quality monolingual datasets from web crawl data. arXiv preprint arXiv:1911.00359, 2019.
+
+Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 1112–1122, New Orleans, Louisiana, June 2018. Association
+
+for Computational Linguistics. doi: 10.18653/v1/N18-1101. URL https://www.aclweb.   
+org/anthology/N18-1101.
+
+Zhirong Wu, Yuanjun Xiong, Stella X. Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In 2018 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2018, pp. 3733–3742. IEEE Computer Society, 2018.
+
+Jiacheng Yang, Mingxuan Wang, Hao Zhou, Chengqi Zhao, Weinan Zhang, Yong Yu, and Lei Li. Towards making the most of BERT in neural machine translation. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, pp. 9378–9385. AAAI Press, 2020. URL https://aaai.org/ojs/index.php/AAAI/article/view/6479.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In Advances in Neural Information Processing Systems 32, NeurIPS 2019, pp. 5753–5763. Curran Associates, Inc., 2019.
+
+Mang Ye, Xu Zhang, Pong C. Yuen, and Shih-Fu Chang. Unsupervised embedding learning via invariant and spreading instance feature. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, pp. 6210–6219. Computer Vision Foundation / IEEE, 2019.
+
+Xingxing Zhang, Furu Wei, and Ming Zhou. HIBERT: Document level pre-training of hierarchical bidirectional transformers for document summarization. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 5059–5069, Florence, Italy, July 2019a. Association for Computational Linguistics. doi: 10.18653/v1/P19-1499. URL https://www.aclweb.org/anthology/P19-1499.
+
+Yuan Zhang, Jason Baldridge, and Luheng He. PAWS: Paraphrase adversaries from word scrambling. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 1298–1308, Minneapolis, Minnesota, June 2019b. Association for Computational Linguistics. doi: 10.18653/v1/N19-1131. URL https://www.aclweb.org/anthology/ N19-1131.
+
+Han Zhao, Junjie Hu, and Andrej Risteski. On learning language-invariant representations for universal machine translation. In Hal Daume III and Aarti Singh (eds.), ´ Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pp. 11352–11364. PMLR, 13–18 Jul 2020. URL http://proceedings.mlr. press/v119/zhao20b.html.
+
+Wenzhao Zheng, Zhaodong Chen, Jiwen Lu, and Zhou Jie. Hardness-aware deep metric learning. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, Long Beach, CA, USA, June 16-20, 2019, pp. 72–81, 2019. URL http://openaccess.thecvf.com/content_CVPR_2019/html/Zheng_ Hardness-Aware_Deep_Metric_Learning_CVPR_2019_paper.html.
+
+Ming Zhong, Pengfei Liu, Yiran Chen, Danqing Wang, Xipeng Qiu, and Xuanjing Huang. Extractive summarization as text matching. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 6197–6208. Association for Computational Linguistics, 2020. URL https://www.aclweb.org/anthology/2020.acl-main.552.
+
+Jinhua Zhu, Yingce Xia, Lijun Wu, Di He, Tao Qin, Wengang Zhou, Houqiang Li, and Tie-Yan Liu. Incorporating BERT into neural machine translation. In 8th International Conference on Learning Representations, ICLR 2020. OpenReview.net, 2020. URL https://openreview. net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } = \underline { { \underline { { \mathbf { \delta \pi } } } } } .$ Hyl7ygStwB.
+
+Pierre Zweigenbaum, Serge Sharoff, and Reinhard Rapp. Overview of the second BUCC shared task: Spotting parallel sentences in comparable corpora. In Proceedings of the 10th Workshop on Building and Using Comparable Corpora, pp. 60–67, Vancouver, Canada, August 2017. Association for Computational Linguistics. doi: 10.18653/v1/W17-2512. URL https: //www.aclweb.org/anthology/W17-2512.
+
+Table 7: The statistics of CCNet corpus used for pretraining.   
+
+<table><tr><td>Code</td><td>Size (GB)</td><td>Code</td><td>Size (GB)</td><td>Code</td><td>Size (GB)</td><td>Code</td><td>Size (GB)</td><td>Code</td><td>Size (GB)</td></tr><tr><td>af</td><td>1.3</td><td>et</td><td>6.1</td><td>ja</td><td>24.2</td><td>mt</td><td>0.2</td><td>sq</td><td>3.0</td></tr><tr><td>am</td><td>0.7</td><td>eu</td><td>2.0</td><td>jv</td><td>0.2</td><td>my</td><td>0.9</td><td>sr</td><td>5.1</td></tr><tr><td>ar</td><td>20.4</td><td>fa</td><td>21.6</td><td>ka</td><td>3.4</td><td>ne</td><td>2.6</td><td>su</td><td>0.1</td></tr><tr><td>as</td><td>0.1</td><td>fi</td><td>19.2</td><td>kk</td><td>2.6</td><td>nl</td><td>15.8</td><td>SV</td><td>10.8</td></tr><tr><td>az</td><td>3.6</td><td>fr</td><td>46.5</td><td>km</td><td>1.0</td><td>no</td><td>3.7</td><td>SW</td><td>1.6</td></tr><tr><td>be</td><td>3.5</td><td>fy</td><td>0.2</td><td>kn</td><td>1.2</td><td>om</td><td>0.1</td><td>ta</td><td>8.2</td></tr><tr><td>bg</td><td>22.6</td><td>ga</td><td>0.5</td><td>ko</td><td>17.2</td><td>or</td><td>0.6</td><td>te</td><td>2.6</td></tr><tr><td>bn</td><td>7.9</td><td>gd</td><td>0.1</td><td>ku</td><td>0.4</td><td>pa</td><td>0.8</td><td>th</td><td>14.7</td></tr><tr><td>br</td><td>0.1</td><td>gl</td><td>2.9</td><td>ky</td><td>1.2</td><td>pl</td><td>16.8</td><td>tl</td><td>0.8</td></tr><tr><td>bs</td><td>0.1</td><td>gu</td><td>0.3</td><td>la</td><td>2.5</td><td>ps</td><td>0.7</td><td>tr</td><td>17.3</td></tr><tr><td>ca</td><td>10.1</td><td>ha</td><td>0.3</td><td>lo</td><td>0.6</td><td>pt</td><td>15.9</td><td>ug</td><td>0.4</td></tr><tr><td>CS</td><td>16.3</td><td>he</td><td>6.7</td><td>lt</td><td>7.2</td><td>ro</td><td>8.6</td><td>uk</td><td>9.1</td></tr><tr><td>cy</td><td>0.8</td><td>hi</td><td>20.2</td><td>lv</td><td>6.4</td><td>ru</td><td>48.1</td><td>ur</td><td>5.0</td></tr><tr><td>da</td><td>15.2</td><td>hr</td><td>5.4</td><td>mg</td><td>0.2</td><td>sa</td><td>0.3</td><td>uz</td><td>0.7</td></tr><tr><td>de</td><td>46.3</td><td>hu</td><td>9.5</td><td>mk</td><td>1.9</td><td>sd</td><td>0.4</td><td>vi</td><td>44.6</td></tr><tr><td>el</td><td>29.3</td><td>hy</td><td>5.5</td><td>ml</td><td>4.3</td><td>si</td><td>2.1</td><td>xh</td><td>0.1</td></tr><tr><td>en</td><td>49.7</td><td>id</td><td>10.6</td><td>mn</td><td>1.7</td><td>sk</td><td>4.9</td><td>yi</td><td>0.3</td></tr><tr><td>eo</td><td>0.9</td><td>is</td><td>1.3</td><td>mr</td><td>1.3</td><td>sl</td><td>2.8</td><td>zh</td><td>36.8</td></tr><tr><td>es</td><td>44.6</td><td>it</td><td>19.8</td><td>ms</td><td>3.2</td><td>S0</td><td>0.4</td><td>-</td><td>-</td></tr></table>
+
+Table 8: Parallel data used for pre-training.   
+
+<table><tr><td>Code</td><td>Sentence Pair (#millions)</td><td>Code</td><td>Sentence Pair (#millions)</td></tr><tr><td>en-ar</td><td>9.8</td><td>en-ru</td><td>11.7</td></tr><tr><td>en-bg</td><td>0.6</td><td>en-sw</td><td>0.2</td></tr><tr><td>en-de</td><td>9.3</td><td>en-th</td><td>3.3</td></tr><tr><td>en-el</td><td>4.0</td><td>en-tr</td><td>0.5</td></tr><tr><td>en-es</td><td>11.4</td><td>en-ur</td><td>0.7</td></tr><tr><td>en-fr</td><td>13.2</td><td>en-vi</td><td>3.5</td></tr><tr><td>en-hi</td><td>1.6</td><td>en-zh</td><td>9.6</td></tr></table>
+
+# A PRE-TRAINING DATA
+
+During pre-training, we follow Conneau et al. (2020) to build a Common-Crawl Corpus using the CCNet (Wenzek et al., 2019) tool5 for monolingual texts. Table 7 reports the language codes and data size in our work. For parallel data, we use the same (English-to- $X$ ) MT dataset as (Conneau & Lample, 2019), which are collected from MultiUN (Eisele & Yu, 2010) for French, Spanish, Arabic and Chinese, the IIT Bombay corpus (Kunchukuttan et al., 2018a) for Hindi, the OpenSubtitles 2018 for Turkish, Vietnamese and Thai, the EUbookshop corpus for German, Greek and Bulgarian, Tanzil for both Urdu and Swahili, and GlobalVoices for Swahili. Table 8 shows the statistics of the parallel data.
+
+# B HYPERPARAMETERS FOR PRE-TRAINING AND FINE-TUNING
+
+As shown in Table 9, we present the hyperparameters for pre-training HICTL. We use the same vocabulary as well as the sentence-piece model with XLM-R (Conneau et al., 2020). During finetuning on XTREME, we search the learning rate over $\{ 5 \mathrm { e } { - } 6 , 1 \mathrm { e } { - } 5 , 1 . 5 \mathrm { e } { - } 5 , 2 \mathrm { e } { - } 5 , 2 . 5 \mathrm { e } { - } 5 , 3 \mathrm { e } { - } 5 \}$ and batch size over $\{ 1 6 , 3 2 \}$ for BASE-size models. And we select the best LARGE-size model by searching the learning rate over $\{ 3 \mathrm { e } { - } 6 , 5 \mathrm { e } { - } 6 , 1 \mathrm { e } { - } 5 \}$ as well as batch size over $\{ 3 2 , 6 4 \}$ .
+
+Table 9: Hyperparameters used for pre-training.   
+
+<table><tr><td>Hyperparameters</td><td>BASE</td><td>LARGE</td></tr><tr><td>Number of layers</td><td>12</td><td>24</td></tr><tr><td>Hidden size</td><td>768</td><td>1024</td></tr><tr><td>FFN inner hidden size</td><td>3072</td><td>4096</td></tr><tr><td>Attention heads</td><td>12</td><td>16</td></tr><tr><td>Mask percent (monolingual/bilingual)</td><td>15%/25%</td><td>15%/25%</td></tr><tr><td>Adam ∈</td><td>1e-6</td><td>1e-6</td></tr><tr><td>Adam β</td><td>(0.9, 0.98)</td><td>(0.9, 0.999)</td></tr><tr><td>Learning rate</td><td>2.5e-4</td><td>1e-4</td></tr><tr><td>Learning rate schedule</td><td>linear</td><td>linear</td></tr><tr><td>Warmup steps</td><td>10,000</td><td>10,000</td></tr><tr><td>Attention dropout</td><td>0.1</td><td>0.1</td></tr><tr><td>Dropout</td><td>0.1</td><td>0.1</td></tr><tr><td>Max sequence length (monolingual/bilingual)</td><td>256</td><td>256</td></tr><tr><td>Batch size</td><td>1024</td><td>1024</td></tr><tr><td>Training steps</td><td>200k</td><td>200k</td></tr></table>
+
+Table 10: Results on Cross-lingual Natural Language Inference (XNLI) for each language. We report the accuracy on each of the 15 XNLI languages and the average accuracy of our HICTL as well as five baselines: BiLSTM (Conneau et al., 2018), mBERT (Devlin et al., 2019), XLM (Conneau & Lample, 2019), Unicoder (Huang et al., 2019) and XLM-R (Conneau et al., 2020). Results of $\ddagger$ are from our in-house replication.   
+
+<table><tr><td>MODEL</td><td>en</td><td>fr</td><td>es</td><td>de</td><td>el</td><td>bg</td><td>ru</td><td>tr</td><td>ar</td><td>vi</td><td>th</td><td>zh</td><td>hi</td><td>sw</td><td>ur</td><td>Avg</td></tr><tr><td colspan="10">Evaluation of cross-lingual sentence encoders (Cross-lingual transfer)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BiLSTM</td><td>73.7</td><td>67.7</td><td>68.7</td><td>67.7</td><td>68.9</td><td>67.9</td><td>65.4</td><td>64.2</td><td>64.8</td><td>66.4</td><td>64.1</td><td>65.8</td><td>64.1</td><td></td><td>55.7</td><td>58.4</td><td>65.6</td></tr><tr><td>mBERT</td><td>81.4</td><td>，</td><td>74.3</td><td>70.5</td><td>1</td><td>-</td><td>1</td><td>-</td><td>62.1</td><td></td><td></td><td>-</td><td>63.8</td><td>-</td><td>-</td><td>58.3</td><td>1</td></tr><tr><td>XLM</td><td>85.0</td><td>78.7</td><td>78.9</td><td>77.8</td><td>76.6</td><td>77.4</td><td>75.3</td><td>72.5</td><td>73.1</td><td></td><td>76.1</td><td>73.2</td><td>76.5</td><td>69.6</td><td>68.4</td><td>67.3</td><td>75.1</td></tr><tr><td>Unicoder</td><td>85.1</td><td>79.0</td><td>79.4</td><td>77.8</td><td>77.2</td><td>77.2</td><td>76.3</td><td>72.8</td><td>73.5</td><td>76.4</td><td></td><td>73.6</td><td>76.2</td><td>69.4</td><td>69.7</td><td>66.7</td><td>75.4</td></tr><tr><td>XLM-RBase</td><td>85.8</td><td>79.7</td><td>80.7</td><td>78.7</td><td>77.5</td><td>79.6</td><td>78.1</td><td>74.2</td><td></td><td>73.8</td><td>76.5</td><td>74.6</td><td>76.7</td><td>72.4</td><td>66.5</td><td>68.3</td><td>76.2</td></tr><tr><td>HICTLBase</td><td>86.3</td><td>80.5</td><td>81.3</td><td>79.5</td><td>78.9</td><td>80.6</td><td>79.0</td><td>75.4</td><td>74.8</td><td>77.4</td><td></td><td>75.7</td><td>77.6</td><td>73.1</td><td>69.9</td><td>69.7</td><td>77.3</td></tr><tr><td colspan="10">Machine translateat training (Translate-train)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BiLSTM</td><td>73.7</td><td>68.3</td><td>68.8</td><td>66.5</td><td>66.4</td><td>67.4</td><td>66.5</td><td>64.5</td><td>65.8</td><td>66.0</td><td></td><td>62.8</td><td>67.0</td><td>62.1</td><td>58.2</td><td>56.6</td><td>65.4</td></tr><tr><td>mBERT</td><td>81.9</td><td>1</td><td>77.8</td><td>75.9</td><td>1</td><td>1</td><td>1</td><td>1</td><td>70.7</td><td>1</td><td>1</td><td></td><td>76.6</td><td>1</td><td>1</td><td>61.6</td><td>1</td></tr><tr><td>XLM Unicoder</td><td>85.0</td><td>80.2</td><td>80.8</td><td>80.3</td><td>78.1</td><td>79.3</td><td>78.1</td><td>74.7</td><td>76.5</td><td>76.6</td><td></td><td>75.5</td><td>78.6</td><td>72.3</td><td>70.9</td><td>63.2</td><td>76.7</td></tr><tr><td></td><td>85.1</td><td>80.0</td><td>81.1</td><td>79.9</td><td>77.7</td><td>80.2</td><td>77.9</td><td>75.3</td><td>76.7</td><td>76.4</td><td></td><td>75.2</td><td>79.4</td><td>71.8</td><td>71.8</td><td>64.5</td><td>76.9</td></tr><tr><td>HICTLBase</td><td>85.7</td><td>81.3</td><td>82.1</td><td>80.2</td><td>81.4</td><td>81.0</td><td>80.5</td><td>79.7</td><td></td><td>77.4</td><td>78.2</td><td>77.5</td><td>80.2</td><td>75.4</td><td>73.5</td><td>72.9</td><td>79.1</td></tr><tr><td colspan="10">Fine-tunemultilingualmodelonalltrainingsets (Translate-train-all)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>XLM</td><td>85.0</td><td>80.8</td><td>81.3</td><td>80.3</td><td>79.1</td><td>80.9</td><td>78.3</td><td>75.6</td><td>77.6</td><td>78.5</td><td></td><td>76.0</td><td>79.5</td><td>72.9</td><td>72.8</td><td>68.5</td><td>77.8</td></tr><tr><td>Unicoder</td><td>85.6</td><td>81.1</td><td>82.3</td><td>80.9</td><td>79.5</td><td>81.4</td><td>79.7</td><td>76.8</td><td>78.2</td><td>77.9</td><td></td><td>77.1</td><td>80.5</td><td>73.4</td><td>73.8</td><td>69.6</td><td>78.5</td></tr><tr><td>XLM-RBase</td><td>85.4</td><td>81.4</td><td>82.2</td><td>80.3</td><td>80.4</td><td>81.3</td><td>79.7</td><td>78.6</td><td>77.3</td><td>79.7</td><td></td><td>77.9</td><td>80.2</td><td>76.1</td><td>73.1</td><td>73.0</td><td>79.1</td></tr><tr><td>HICTLBase</td><td>86.5</td><td>82.3</td><td>83.2</td><td>80.8</td><td>81.6</td><td>82.2</td><td>81.3</td><td>80.5</td><td>78.1</td><td></td><td>80.4</td><td>78.6</td><td>80.7</td><td>76.7</td><td>73.8</td><td>73.9</td><td>80.0</td></tr><tr><td>XLM-R</td><td>89.1</td><td>85.1</td><td>86.6</td><td>85.7</td><td>85.3</td><td>85.9</td><td>83.5</td><td>83.2</td><td></td><td>83.1</td><td>83.7</td><td>81.5</td><td>83.7</td><td>81.6</td><td>78.0</td><td>78.1</td><td>83.6</td></tr><tr><td>XLM-R</td><td>88.9</td><td>84.7</td><td>86.2</td><td>84.8</td><td>85.0</td><td>85.3</td><td>82.4</td><td>82.7</td><td></td><td>82.4</td><td>82.8</td><td>80.9</td><td>83.0</td><td>80.2</td><td>77.3</td><td>77.2</td><td>82.9</td></tr><tr><td>HICTL</td><td>89.3</td><td>85.5</td><td>86.9</td><td>86.1</td><td>85.7</td><td>86.1</td><td>83.7</td><td>83.9</td><td></td><td>83.3 83.5</td><td></td><td>81.8</td><td>84.2</td><td>81.0</td><td>78.4</td><td>77.9</td><td>83.8</td></tr></table>
+
+# C RESULTS FOR EACH DATASET AND LANGUAGE
+
+Below, we provide detailed results for each dataset and language on XTREME, as shown in Table 10- 14. Results of XLM-R are from our implementation.
+
+# D VISUALIZATION OF SENTENCE EMBEDDINGS
+
+We collect 10 sets of samples from WMT’14-19, each of them contains 100 parallel sentences distributed in 5 languages. As the t-SNE visualization in Figure 4, a set of sentences under the same meaning are clustered more densely for HICTL than XLM-R, which reveals the strong capability
+
+Table 11: PAWS-X accuracy scores for each language.   
+
+<table><tr><td>Model</td><td>en</td><td>de</td><td>es</td><td>fr</td><td>ja</td><td>ko</td><td>zh</td><td>avg</td></tr><tr><td colspan="9">Translate-train-all</td></tr><tr><td>XLM-R</td><td>95.7</td><td>92.2</td><td>92.7</td><td>92.5</td><td>84.7</td><td>85.9</td><td>87.1</td><td>90.1</td></tr><tr><td>HICTL,Wiki-15 + MT</td><td>96.6</td><td>93.2</td><td>93.3</td><td>92.9</td><td>86.5</td><td>87.3</td><td>88.6</td><td>91.2</td></tr><tr><td>HICTL, CCNet-100 + MT</td><td>96.9</td><td>93.8</td><td>94.4</td><td>94.3</td><td>88.0</td><td>88.2</td><td>89.4</td><td>92.2</td></tr><tr><td>+HARD NEGATIVE SAMPLES</td><td>97.4</td><td>94.2</td><td>95.0</td><td>94.2</td><td>89.1</td><td>89.5</td><td>90.2</td><td>92.8</td></tr></table>
+
+Table 12: POS results (Accuracy) for each language.   
+
+<table><tr><td>Model</td><td>af</td><td>ar</td><td>bg</td><td>de</td><td>el</td><td>en</td><td>es</td><td>et</td><td>eu</td><td>fa</td><td>f</td><td>fr</td><td>he</td><td>hi</td><td>hu</td><td>id</td><td>it</td></tr><tr><td>Translate-train-all</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>XLM-R</td><td>90.6</td><td>67.4</td><td>89.1</td><td>89.9</td><td>86.8</td><td>96.3</td><td>89.6</td><td>87.1</td><td>74.0</td><td>70.8</td><td>86.0</td><td>87.7</td><td>68.6</td><td>77.4</td><td>82.8</td><td>72.6</td><td>91.1</td></tr><tr><td>HICTL,Wiki-15 + MT</td><td>91.0</td><td>69.3</td><td>89.1</td><td>89.4</td><td>87.8</td><td>97.6</td><td>88.2</td><td>88.2</td><td>74.8</td><td>72.0</td><td>86.7</td><td>87.9</td><td>70.2</td><td>79.0</td><td>84.2</td><td>74.3</td><td>90.8</td></tr><tr><td>HICTL, CCNet-100 + MT</td><td>91.8</td><td>70.2</td><td>90.7</td><td>90.8</td><td>89.0</td><td>98.3</td><td>89.7</td><td>90.1</td><td>76.2</td><td>73.0</td><td>88.5</td><td>90.2</td><td>70.7</td><td>80.0</td><td>86.4</td><td>74.5</td><td>92.0</td></tr><tr><td>+HARD NEGATIVE SAMPLES</td><td>92.2</td><td>71.0</td><td>91.5</td><td>91.3</td><td>90.0</td><td>97.7</td><td>91.0</td><td>89.4</td><td>75.7</td><td>73.5</td><td>88.8</td><td>90.1</td><td>71.1</td><td>79.7</td><td>85.4</td><td>75.1</td><td>91.7</td></tr><tr><td></td><td>ja</td><td>kk</td><td>ko</td><td>mr</td><td>nl</td><td>pt</td><td>ru</td><td>ta</td><td>te</td><td>th</td><td>t</td><td>tr</td><td>ur</td><td>vi</td><td>yo</td><td>zh</td><td>avg</td></tr><tr><td>Translate-train-all</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>XLM-R</td><td>17.3</td><td>78.3</td><td>55.5</td><td>82.1</td><td>89.8</td><td>88.9</td><td>89.8</td><td>65.7</td><td>87.0</td><td>48.6</td><td>92.9</td><td>77.9</td><td>71.7</td><td>56.8</td><td>24.7</td><td>27.2</td><td>74.6</td></tr><tr><td>HICTL,Wiki-15 + MT</td><td>28.4</td><td>79.2</td><td>54.2</td><td>80.7</td><td>90.9</td><td>88.4</td><td>90.5</td><td>67.3</td><td>89.1</td><td>48.7</td><td>92.2</td><td>77.6</td><td>72.0</td><td>58.8</td><td>27.2</td><td>27.1</td><td>75.5</td></tr><tr><td>HICTL,CCNet-100 + MT</td><td>30.2</td><td>80.4</td><td>55.1</td><td>82.1</td><td>91.2</td><td>90.2</td><td>90.7</td><td>68.1</td><td>90.1</td><td>50.3</td><td>95.2</td><td>78.7</td><td>73.3</td><td>59.2</td><td>27.8</td><td>27.9</td><td>76.8</td></tr><tr><td>+HARD NEGATIVE SAMPLES</td><td>31.9</td><td>80.9</td><td>57.0</td><td>83.5</td><td>91.7</td><td>91.0</td><td>91.2</td><td>69.5</td><td>90.8</td><td>50.3</td><td>94.8</td><td>79.4</td><td>73.4</td><td>59.5</td><td>28.6</td><td>28.7</td><td>77.2</td></tr></table>
+
+of HICTL on learning universal representations across different languages. Note that the t-SNE visualization of HICTL still demonstrates some noises, we attribute them to the lack of hard negative examples for sentence-level contrastive learning and leave this to future work for consideration.
+
+Table 13: NER results (F1) for each language.   
+
+<table><tr><td>Model</td><td></td><td>en</td><td>af ar</td><td>bg</td><td>bn</td><td>de</td><td>el</td><td>es</td><td>et</td><td>eu</td><td>fa</td><td>fi</td><td>fr</td><td>he</td><td>hi</td><td>hu</td><td>id</td><td></td><td>it</td><td>ja jv</td></tr><tr><td>Translate-train-all</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>XLM-R</td><td>86.881.4</td><td></td><td>55.2</td><td>82.9</td><td>81.1</td><td>79.1</td><td>81.5</td><td>81.1</td><td>81.3</td><td>60.664.1</td><td></td><td>80.6</td><td>83.2</td><td>60.1</td><td>76.1</td><td>79.4</td><td>53.2</td><td>80.7</td><td>22.7</td><td>63.9</td></tr><tr><td>HICTL, Wiki-15 + T</td><td>87.0</td><td>82.3</td><td>55.2</td><td>84.7</td><td>79.0</td><td>81.2</td><td>80.1</td><td>81.6</td><td>79.8</td><td>61.4</td><td>61.9</td><td>82.8</td><td>80.5</td><td>60.4</td><td>74.6</td><td>79.8</td><td>54.8</td><td>83.5</td><td>24.9</td><td>66.1</td></tr><tr><td>HICTL, CCNet-100 +MT</td><td>88.6</td><td>80.9</td><td>55.4</td><td>85.6</td><td>81.8</td><td>82.0</td><td>82.5</td><td>80.8</td><td>81.2</td><td>62.5</td><td>64.2</td><td>81.2</td><td>83.0</td><td>60.3</td><td>77.3</td><td>84.4</td><td>55.8</td><td>83.7</td><td>26.0</td><td>65.0</td></tr><tr><td>+HARD NEGATIVE SAMPLES</td><td>88.9</td><td>82.0</td><td>56.6</td><td>83.7</td><td>83.4</td><td>82.8</td><td>84.8</td><td>83.0</td><td>83.8</td><td>65.4</td><td>65.4</td><td>82.0</td><td>82.6</td><td>60.5</td><td>74.7</td><td>81.5</td><td>58.1</td><td>84.7</td><td>27.9</td><td>65.9</td></tr><tr><td></td><td>ka</td><td>kk</td><td>ko</td><td>ml</td><td>mr</td><td>ms</td><td>my</td><td>nl</td><td>pt</td><td>ru</td><td>sw</td><td>ta</td><td>te</td><td>th</td><td>tl</td><td>tr</td><td>ur</td><td>vi</td><td>yo</td><td>zh</td></tr><tr><td>XLMR</td><td>74.2</td><td></td><td>58.0 63.3</td><td>68.3</td><td>69.8</td><td>59.5</td><td>57.5</td><td>86.2</td><td>82.3</td><td>68.570.7</td><td></td><td>59.8</td><td>58.5</td><td>2.4</td><td>72.6</td><td>75.9</td><td>59.7</td><td>79.4</td><td></td><td>37.035.4</td></tr><tr><td>HICTL, Wiki-15 + MT</td><td>75.0</td><td>56.7</td><td>62.2</td><td>69.4</td><td>68.8</td><td>57.9</td><td>55.6</td><td>87.9</td><td>84.2</td><td>71.9</td><td>74.4</td><td>61.6</td><td>59.2</td><td>2.2</td><td>74.2</td><td>79.5</td><td>58.1</td><td>83.0</td><td>35.2</td><td>33.0</td></tr><tr><td>HICTL, CCNet-100 + MT</td><td>72.8</td><td>57.6</td><td></td><td>64.670.4</td><td>71.5</td><td>61.1</td><td>59.0</td><td>87.7</td><td>85.1</td><td>70.374.3</td><td></td><td>60.6</td><td>57.9</td><td>5.6</td><td>77.5</td><td>79.0</td><td>59.8</td><td>83.7</td><td>37.7</td><td>36.9</td></tr><tr><td>+HARD NEGATIVE SAMPLES</td><td>76.8</td><td>60.9</td><td>65.0</td><td>71.4</td><td>72.5</td><td>59.0</td><td>56.3</td><td>85.9</td><td>84.5</td><td>71.4</td><td>75.6</td><td>62.9</td><td>58.8</td><td>3.9</td><td></td><td>77.780.4</td><td>59.1</td><td>83.6</td><td>37.7</td><td>37.2</td></tr></table>
+
+Table 14: Tatoeba results (Accuracy) for each language   
+
+<table><tr><td>Model</td><td>af</td><td>ar</td><td>bg</td><td>bn</td><td>de</td><td>el</td><td>es</td><td>et</td><td>eu</td><td>fa</td><td>f</td><td>fr</td><td>he</td><td>hi</td><td>hu</td><td>id</td><td>it</td><td>ja</td></tr><tr><td>Translate-train-all</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>XLM-R</td><td>59.7</td><td>50.5</td><td>72.2</td><td>45.4</td><td>89.5</td><td>61.3</td><td>77.6</td><td>51.7</td><td>38.6</td><td>71.7</td><td>72.8</td><td>76.9</td><td>66.3</td><td>73.1</td><td>65.1</td><td>77.5</td><td>68.5</td><td>63.1</td></tr><tr><td>HICTL, Wiki-15 + MT</td><td>61.5</td><td>51.4</td><td>76.1</td><td>47.9</td><td>92.1</td><td>63.4</td><td>80.5</td><td>55.9</td><td>37.8</td><td>74.6</td><td>76.7</td><td>78.0</td><td>68.4</td><td>74.5</td><td>68.8</td><td>80.4</td><td>70.2</td><td>63.9</td></tr><tr><td>HICTL, CCNet-100 + MT</td><td>63.0</td><td>50.9</td><td>76.8</td><td>47.0</td><td>94.6</td><td>68.8</td><td>80.9</td><td>59.3</td><td>41.5</td><td>77.3</td><td>78.2</td><td>80.3</td><td>70.2</td><td>77.9</td><td>72.1</td><td>81.3</td><td>73.7</td><td>66.2</td></tr><tr><td>+HARD NEGATIVE SAMPLES</td><td>68.9</td><td>57.7</td><td>83.2</td><td>55.4</td><td>98.2</td><td>74.5</td><td>88.5</td><td>62.4</td><td>47.7</td><td>80.2</td><td>82.9</td><td>85.5</td><td>79.1</td><td>85.0</td><td>76.8</td><td>90.3</td><td>80.8</td><td>72.7</td></tr><tr><td></td><td>jv</td><td>ka</td><td>kk</td><td>ko</td><td>ml</td><td>mr</td><td>ml</td><td>pt</td><td>ru</td><td>sw</td><td>ta</td><td>te</td><td>th</td><td>t</td><td>tr</td><td>ur</td><td>vi</td><td>zh</td></tr><tr><td>XLM-R</td><td>15.8</td><td>53.3</td><td>51.2</td><td>63.1</td><td>66.2</td><td>59.0</td><td>81.0</td><td>84.4</td><td>76.9</td><td>19.8</td><td>28.3</td><td>37.8</td><td>28.9</td><td>36.7</td><td>68.9</td><td>26.6</td><td>77.9</td><td>69.8</td></tr><tr><td>HICTL,Wiki-15 + MT</td><td>18.7</td><td>55.8</td><td>51.0</td><td>65.5</td><td>67.3</td><td>61.2</td><td>82.9</td><td>84.4</td><td>78.3</td><td>22.2</td><td>28.6</td><td>41.4</td><td>33.5</td><td>41.6</td><td>71.2</td><td>26.7</td><td>80.2</td><td>73.6</td></tr><tr><td>HICTL, CCNet-100 + MT</td><td>19.6</td><td>57.3</td><td>54.6</td><td>68.0</td><td>71.8</td><td>62.0</td><td>88.1</td><td>88.9</td><td>77.7</td><td>26.1</td><td>32.9</td><td>39.5</td><td>32.9</td><td>43.2</td><td>71.2</td><td>27.8</td><td>79.9</td><td>74.7</td></tr><tr><td>+HARD NEGATIVE SAMPLES</td><td>27.2</td><td>63.0</td><td>61.5</td><td>72.6</td><td>75.3</td><td>67.8</td><td>92.8</td><td>92.8</td><td>85.4</td><td>32.0</td><td>36.7</td><td>47.8</td><td>41.5</td><td>49.8</td><td>77.0</td><td>34.3</td><td>84.3</td><td>81.3</td></tr></table>
+
+![](images/ed8a6d67f3644e02a244e20676dae30223fee2351f4b4a456f36457157729ba6.jpg)  
+Figure 4: Visualizations (t-SNE projection) of sentence embeddings output by HICTL (left) and XLM-R (right). We collect 10 sets of samples from WMT’14-19, each of them contains 100 parallel sentences distributed in 5 languages (i.e., English, French, German, Russian, and Spanish). Each set is identified by a color and different languages marked by different shapes. We can see that a set of sentences under the same meaning are clustered more densely for HICTL than XLM-R, which reveals the strong capability of HICTL on learning universal representations across different languages.

parse/train/kWSeGEeHvF8/kWSeGEeHvF8.md

@@ -0,0 +1,396 @@
+# BENCHMARKS FOR DEEP OFF-POLICY EVALUATION
+
+Justin $\mathbf { F u ^ { * 1 } }$ Mohammad Norouzi∗2 Ofir Nachum∗2 George Tucker∗2   
+Ziyu Wang2 Alexander Novikov3 Mengjiao Yang2 Michael R. Zhang2   
+Yutian Chen3 Aviral Kumar1 Cosmin Paduraru3 Sergey Levine1 Tom Le Paine∗3
+
+1UC Berkeley 2Google Brain 3DeepMind justinfu@berkeley.edu,{mnorouzi,ofirnachum,gjt,tpaine}@google.com
+
+# ABSTRACT
+
+Off-policy evaluation (OPE) holds the promise of being able to leverage large, offline datasets for both evaluating and selecting complex policies for decision making. The ability to learn offline is particularly important in many real-world domains, such as in healthcare, recommender systems, or robotics, where online data collection is an expensive and potentially dangerous process. Being able to accurately evaluate and select high-performing policies without requiring online interaction could yield significant benefits in safety, time, and cost for these applications. While many OPE methods have been proposed in recent years, comparing results between papers is difficult because currently there is a lack of a comprehensive and unified benchmark, and measuring algorithmic progress has been challenging due to the lack of difficult evaluation tasks. In order to address this gap, we present a collection of policies that in conjunction with existing offline datasets can be used for benchmarking off-policy evaluation. Our tasks include a range of challenging high-dimensional continuous control problems, with wide selections of datasets and policies for performing policy selection. The goal of our benchmark is to provide a standardized measure of progress that is motivated from a set of principles designed to challenge and test the limits of existing OPE methods. We perform an evaluation of state-of-the-art algorithms and provide open-source access to our data and code to foster future research in this area†.
+
+# 1 INTRODUCTION
+
+Reinforcement learning algorithms can acquire effective policies for a wide range of problems through active online interaction, such as in robotics (Kober et al., 2013), board games and video games (Tesauro, 1995; Mnih et al., 2013; Vinyals et al., 2019), and recommender systems (Aggarwal et al., 2016). However, this sort of active online interaction is often impractical for real-world problems, where active data collection can be costly (Li et al., 2010), dangerous (Hauskrecht & Fraser, 2000; Kendall et al., 2019), or time consuming (Gu et al., 2017). Batch (or offline) reinforcement learning, has been studied extensively in domains such as healthcare (Thapa et al., 2005; Raghu et al., 2018), recommender systems (Dudík et al., 2014; Theocharous et al., 2015; Swaminathan et al., 2017), education (Mandel et al., 2014), and robotics (Kalashnikov et al., 2018). A major challenge with such methods is the off-policy evaluation (OPE) problem, where one must evaluate the expected performance of policies solely from offline data. This is critical for several reasons, including providing high-confidence guarantees prior to deployment (Thomas et al., 2015), and performing policy improvement and model selection (Bottou et al., 2013; Doroudi et al., 2017).
+
+The goal of this paper is to provide a standardized benchmark for evaluating OPE methods. Although considerable theoretical (Thomas & Brunskill, 2016; Swaminathan & Joachims, 2015; Jiang & Li, 2015; Wang et al., 2017; Yang et al., 2020) and practical progress (Gilotte et al., 2018; Nie et al., 2019; Kalashnikov et al., 2018) on OPE algorithms has been made in a range of different domains, there are few broadly accepted evaluation tasks that combine complex, high-dimensional problems commonly explored by modern deep reinforcement learning algorithms (Bellemare et al., 2013; Brockman et al., 2016) with standardized evaluation protocols and metrics. Our goal is to provide a set of tasks with a range of difficulty, excercise a variety of design properties, and provide policies with different behavioral patterns in order to establish a standardized framework for comparing OPE algorithms. We put particular emphasis on large datasets, long-horizon tasks, and task complexity to facilitate the development of scalable algorithms that can solve high-dimensional problems.
+
+Our primary contribution is the Deep Off-Policy Evaluation (DOPE) benchmark. DOPE is designed to measure the performance of OPE methods by 1) evaluating on challenging control tasks with properties known to be difficult for OPE methods, but which occur in real-world scenarios, 2) evaluating across a range of policies with different values, to directly measure performance on policy evaluation, ranking and selection, and 3) evaluating in ideal and adversarial settings in terms of dataset coverage and support. These factors are independent of task difficulty, but are known to have a large impact on OPE performance. To achieve 1, we selected tasks on a set of design principles outlined in Section 3.1. To achieve 2, for each task we include 10 to 96 policies for evaluation and devise an evaluation protocol that measures policy evaluation, ranking, and selection as outlined in Section 3.2. To achieve 3, we provide two domains with differing dataset coverage and support properties described in Section 4. Finally, to enable an easy-to-use research platform, we provide the datasets, target policies, evaluation API, as well as the recorded results of state-of-the-art algorithms (presented in Section 5) as open-source.
+
+# 2 BACKGROUND
+
+We briefly review the off-policy evaluation (OPE) problem setting. We consider Markov decision processes (MDPs), defined by a tuple $( S , \mathcal { A } , \mathcal { T } , R , \rho _ { 0 } , \gamma )$ , with state space $s$ , action space $\mathcal { A }$ , transition distribution $\mathcal { T } ( s ^ { \prime } | s , a )$ , initial state distribution $\rho _ { 0 } ( s )$ , reward function $R ( s , a )$ and discount factor $\gamma \in \mathsf { \Gamma } ( 0 , 1 ]$ . In reinforcement learning, we are typically concerned with optimizing or estimating the performance of a policy $\pi ( a | s )$ .
+
+The performance of a policy is commonly measured by the policy value $V ^ { \pi }$ , defined as the expected sum of discounted rewards:
+
+$$
+V ^ { \pi } : = \mathbb { E } _ { s _ { 0 } \sim \rho _ { 0 } , s _ { 1 : \infty } , a _ { 0 : \infty } \sim \pi } \left[ \sum _ { { t = 0 } } ^ { \infty } \gamma ^ { t } R ( s _ { t } , a _ { t } ) \right] .
+$$
+
+If we have access to state and action samples collected from a policy $\pi$ , then we can use the sample mean of observed returns to estimate the value function above. However, in off-policy evaluation we are typically interested in estimating the value of a policy when the data is collected from a separate behavior policy $\pi _ { B } ( a | s )$ . This setting can arise, for example, when data is being generated online from another process, or in the purely offline case when we have a historical dataset.
+
+![](images/700f87fffedfa36de8d8c27b1ca0fa0c858a4fb539b569c44990ab8b8bfb60e8.jpg)  
+Figure 1: In Off-Policy Evaluation (top) the goal is to estimate the value of a single policy given only data. Offline Policy Selection (bottom) is a closely related problem: given a set of $_ \mathrm { N }$ policies, attempt to pick the best given only data.
+
+In this work we consider the latter, purely offline setting. The typical setup for this problem formulation is that we are provided with a discount $\gamma$ , a dataset of trajectories collected from a behavior policy $\mathcal { D } = \{ ( s _ { 0 } , a _ { 0 } , r _ { 0 } , s _ { 1 } , . . . ) \}$ , and optionally the action probabilities for the behavior policy $\pi _ { B } { \left( { { a } _ { t } } | { { s } _ { t } } \right) }$ . In many practical applications, logging action propensities is not possible, for example, when the behavior policy is a mix of ML and hard-coded business logic. For this reason, we focus on the setting without propensities to encourage future work on behavior-agnostic OPE methods. For the methods that require propensities, we estimate the propensities with behavior cloning.
+
+The objective can take multiple flavors, as shown in Fig. 1. A common task in OPE is to estimate the performance, or value, of a policy $\pi$ (which may not be the same as $\pi _ { B }$ ) so that the estimated value is as close as possible to $V ^ { \pi }$ under a metric such as MSE or absolute error. A second task is to perform policy selection, where the goal is to select the best policy or set of policies out of a group of candidates. This setup corresponds to how OPE is commonly used in practice, which is to find the best performing strategy out of a pool when online evaluation is too expensive to be feasible.
+
+# 3 DOPE: DEEP OFF-POLICY EVALUATION
+
+The goal of the Deep Off-Policy Evaluation (DOPE) benchmark is to provide tasks that are challenging and effective measures of progress for OPE methods, yet is easy to use in order to better facilitate research. Therefore, we design our benchmark around a set of properties which are known to be difficult for existing OPE methods in order to gauge their shortcomings, and keep all tasks amenable to simulation in order for the benchmark to be accessible and easy to evaluate.
+
+# 3.1 TASK PROPERTIES
+
+We describe our motivating properties for selecting tasks for the benchmark as follows:
+
+High Dimensional Spaces (H) High-dimensionality is a key-feature in many real-world domains where it is difficult to perform feature engineering, such as in robotics, autonomous driving, and more. In these problems, it becomes challenging to accurately estimate quantities such as the value function without the use of high-capacity models such a neural networks and large datasets with wide state coverage. Our benchmark contains complex continuous-space tasks which exercise these challenges.
+
+Long Time-Horizon (L) Long time horizon tasks are known to present difficult challenges for OPE algorithms. Some algorithms have difficulty doing credit assignment for these tasks. This can be made worse as the state dimension or action dimension increases.
+
+Sparse Rewards (R) Sparse reward tasks increase the difficulty of credit assignment and add exploration challenges, which may interact with data coverage in the offline setting. We include a range robotics and navigation tasks which are difficult to solve due to reward sparsity.
+
+Temporally extended control (T) The ability to make decisions hierarchically is major challenge in many reinforcement learning applications. We include two navigation tasks which require high-level planning in addition to low-level control in order to simulate the difficulty in such problems.
+
+# 3.2 EVALUATION PROTOCOL
+
+The goal of DOPE to provide metrics for policy ranking, evaluation and selection. Many existing OPE methods have only been evaluated on point estimates of value such as MSE, but policy selection is an important, practical use-case of OPE. In order to explicitly measure the quality of using OPE for policy selection, we provide a set of policies with varying value, and devise two metrics that measure how well OPE methods can rank policies.
+
+For each task we include a dataset of logged experiences $\mathcal { D }$ , and a set of policies $\left\{ \pi _ { 1 } , \pi _ { 2 } , . . . , \pi _ { N } \right\}$ with varying values. For each policy, OPE algorithms must use $\mathcal { D }$ to produce an estimate of the policy’s value. For evaluation of these estimates, we provide "ground truth values" $\{ V ^ { \pi _ { 1 } } , V ^ { \pi _ { 2 } } , . . . , V ^ { \pi _ { N } } \}$ that are computed by running the policy for $M \geq 1 0 0 0$ episodes, where the exact value of $M$ is given by the number of episodes needed to lower the error bar on the ground truth values to 0.666. The estimated values are then compared to these ground truth values using three different metrics encompassing both policy evaluation and selection (illustrated in Figure 2; see Appendix A.1 for mathematical definitions).
+
+![](images/11851548f158ebede726189b9cf558877988ffcb203baa31c41a44eac8b697c7.jpg)  
+Figure 2: Error is a natural measure for off-policy evaluation. However for policy selection, it is sufficient to (i) rank the policies as measured by rank correlation, or (ii) select a policy with the lowest regret.
+
+Absolute Error This metric measures estimate accuracy instead of its usefulness for ranking. Error is the most commonly used metric to assess performance of OPE algorithms. We opted to use absolute error instead of MSE to be robust to outliers.
+
+Regret $@ \mathbf { k }$ This metric measures how much worse the best policies identified by the estimates are than the best policy in the entire set. It is computed by identifying the top- $\mathbf { \nabla \cdot k }$ policies according to the estimated returns. Regret $@ \mathbf { k }$ is the difference between the actual expected return of the best policy in the entire set, and the actual value of the best policy in the top-k set.
+
+Rank correlation This metric directly measures how well estimated values rank policies, by computing the correlation between ordinal rankings according by the OPE estimates and ordinal rankings according to the ground truth values.
+
+# 4 DOMAINS
+
+DOPE contains two domains designed to provide a more comprehensive picture of how well OPE methods perform in different settings. These two domains are constructed using two benchmarks previously proposed for offline reinforcement learning: RL Unplugged (Gulcehre et al., 2020) and D4RL (Fu et al., 2020), and reflect the challenges found within them.
+
+The DOPE RL Unplugged domain is constrained in two important ways: 1) the data is always generated using online RL training, ensuring there is adequate coverage of the state-action space, and 2) the policies are generated by applying offline RL algorithms to the same dataset we use for evaluation, ensuring that the behavior policy and evaluation policies induce similar state-action distributions. Using it, we hope to understand how OPE methods work as task complexity increases from simple Cartpole tasks to controlling a Humanoid body while controlling for ideal data.
+
+On the other hand, the DOPE D4RL domain has: 1) data from various sources (including random exploration, human teleoperation, and RL-trained policies with limited exploration), which results in varying levels of coverage of the state-action space, and 2) policies that are generated using online RL algorithms, making it less likely that the behavior and evaluation policies share similar induced state-action distributions. Both of these result in distribution shift which is known to be challenging for OPE methods, even in simple tasks. So, using it we hope to measure how well OPE methods work in more practical data settings.
+
+# 4.1 DOPE RL UNPLUGGED
+
+DeepMind Control Suite (Tassa et al., 2018) is a set of control tasks implemented in MuJoCo (Todorov et al., 2012). We consider the subset included in RL Unplugged. This subset includes tasks that cover a range of difficulties. From Cartpole swingup, a simple task with a single degree of freedom, to Humanoid run which involves control of a complex bodies with 21 degrees o freedom. All tasks use the default feature representation of the system state, including proprioceptive information such as joint positions and velocity, and additional sensor information and target position where appropriate. The observation dimension ranges from 5 to 67.
+
+![](images/84968532df8fece1f619e1d287c427bd7de0a0bda8240af93031ff20b68e1997.jpg)
+
+Datasets and policies We train four offline RL algorithms (D4PG (Barth-Maron et al., 2018), ABM (Siegel et al., 2020), CRR (Wang et al., 2020) and behavior cloning), varying their hyperparameters. For each algorithm-task-hyperparameter combination, we train an agent with 3 random seeds on the DM Control Suite dataset from RL Unplugged and record policy snapshots at exponentially increasing intervals (after 25k learner steps, 50k, 100K, 200K, etc). Following Gulcehre et al. (2020), we consider a deterministic policy for D4PG and stochastic policies for BC, ABM and CRR. The datasets are taken from the RL Unplugged benchmark, where they were created by training multiple (online) RL agents and collecting both successful and unsuccessful episodes throughout training. All offline RL algorithms are implemented using the Acme framework (Hoffman et al., 2020).
+
+# 4.2 DOPE D4RL
+
+Gym-MuJoCo tasks. Gym-MuJoCo consists of several continuous control tasks implemented within the MuJoCo simulator (Todorov et al., 2012) and provided in the OpenAI Gym (Brockman et al., 2016) benchmark for online RL. We include the HalfCheetah, Hopper, Walker2D, and Ant tasks. We include this domain primarily for comparison with past works, as a vast array of popular RL methods have been evaluated and developed on these tasks (Schulman et al., 2015; Lillicrap et al., 2015; Schulman et al., 2017; Fujimoto et al., 2018; Haarnoja et al., 2018).
+
+<table><tr><td>Statistics</td><td>cartpole swingup</td><td>cheetah run</td><td>finger turn hard</td><td>fish swim</td><td>humanoid run</td><td>walker stand</td><td>walker walk</td><td colspan="2">insert ball</td><td>manipulator manipulator insert peg</td></tr><tr><td>Dataset size</td><td>40K</td><td>300K</td><td>500K</td><td>200K</td><td>3M</td><td>200K</td><td>200K</td><td colspan="2">1.5M</td><td>1.5M</td></tr><tr><td>State dim.</td><td>5</td><td>17</td><td>12</td><td>24</td><td>67</td><td>24</td><td>24</td><td colspan="2">44</td><td>44</td></tr><tr><td>Action dim.</td><td>1</td><td>6</td><td>2</td><td>5</td><td>21</td><td>6</td><td>6</td><td colspan="2">5</td><td>5</td></tr><tr><td>Properties</td><td>-</td><td>H,L</td><td>H,L</td><td>H,L</td><td>H,L</td><td>H,L</td><td>H,L</td><td>H,L,T</td><td></td><td>H, L,T</td></tr><tr><td>Statistics</td><td>maze2d</td><td>antmaze</td><td>halfcheetah</td><td>hopper</td><td>walker</td><td>ant</td><td>hammer</td><td>door</td><td>relocate</td><td>pen</td></tr><tr><td>Dataset size</td><td>1/2/4M</td><td>1M</td><td>1M</td><td>1M</td><td>1M</td><td>1M</td><td>11K/1M</td><td>7K/1M</td><td>10K/1M</td><td>5K/500K</td></tr><tr><td># datasets</td><td>1</td><td>1</td><td>5</td><td>5</td><td>5</td><td>5</td><td>3</td><td>3</td><td>3</td><td>3</td></tr><tr><td>State dim.</td><td>4</td><td>29</td><td>17</td><td>11</td><td>17</td><td>111</td><td>46</td><td>39</td><td>39</td><td>45</td></tr><tr><td>Action dim.</td><td>2</td><td>8</td><td>6</td><td>3</td><td>6</td><td>8</td><td>26</td><td>28</td><td>30</td><td>24</td></tr><tr><td>Properties</td><td>T</td><td>T,R</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H,R</td><td>H,R</td><td>H,R</td><td>H,R</td></tr></table>
+
+![](images/6714f53bf565ea0dfd74bc5362e43ea3fb4200525a2e21d7b8ab73feb9bf0b90.jpg)  
+Table 1: Task statistics for RLUnplugged tasks (top) and D4RL tasks (bottom). Dataset size is the number of $( s , a , r , s ^ { \prime } )$ tuples. For each dataset, we note the properties it possesses: high dimensional spaces $( \mathbf { H } )$ , long time-horizon $( \mathbf { L } )$ , sparse rewards $\mathbf { ( R ) }$ , temporally extended control (T).   
+Figure 3: Online evaluation of policy checkpoints for 4 Offline RL algorithms with 3 random seeds. We observe a large degree of variability between the behavior of algorithms on different tasks. Without online evaluation, tuning the hyperparameters (e.g., choice of Offline RL algorithm and policy checkpoint) is challenging. This highlights the practical importance of Offline policy selection when online evaluation is not feasible. See Figure A.7 for additional tasks.
+
+Gym-MuJoCo datasets and policies. For each task, in order to explore the effect of varying distributions, we include 5 datasets originally proposed by Fu et al. (2020). 3 correspond to different performance levels of the agent – “random”, “medium”, and “expert”. We additionally include a mixture of medium and expert dataset, labeled “medium-expert”, and data collected from a replay buffer until the policy reaches the medium level of performance, labeled “medium-replay”. For policies, we selected 11 policies collected from evenly-spaced snapshots of training a Soft Actor-Critic agent (Haarnoja et al., 2018), which covers a range of performance between random and expert.
+
+![](images/5ebaf04dbcc5d5329215c6948aac75e01b21eec2cfb583947e099c796f08b7bd.jpg)
+
+Maze2D and AntMaze tasks. Maze2D and AntMaze are two maze navigation tasks originally proposed in D4RL (Fu et al., 2020). The domain consists of 3 mazes ranging from easy to hard (“umaze”, “medium”, “large”), and two morphologies: a 2D ball in Maze2D and the “Ant” robot of the Gym benchmark in AntMaze. For Maze2D, we provide a less challenging reward computed base on distance to a fixed goal. For the AntMaze environment reward is given only upon reaching the fixed goal.
+
+![](images/230fb40322661ee9e56fde36f9e0aa6c6498c3d89dda574401938853d0e5e4f4.jpg)
+
+Maze2D and AntMaze datasets and policies. Datasets for both morphologies consists of undirect data navigating randomly to different goal locations. The datasets for Maze2D are collected by using a high-level planner to command waypoints to a low-level PID controller in order to reach randomly selected goals. The dataset in AntMaze is generated using the same high-level planner, but the lowlevel planner is replaced with a goal-conditioned policy trained to reach arbitrary waypoints. Both of these datasets are generated from non-Markovian policies, as the high-level controller maintains a history of waypoints reached in order to construct a plan to the goal. We provide policies for all environments except “antmaze-large” by taking training snapshots obtained while running the DAPG algorithm (Rajeswaran et al., 2017). Because obtaining high-performing policies for “antmaze-large” was challenging, we instead used imitation learning on a large amount of expert data to generate evaluation policies. This expert data is obtained by collecting additional trajectories that reach the goal using a high-level waypoint planner in conjunction with a low-level goal-conditioned policy (this is the same method as was used to generate the dataset, Sec. 5 (Fu et al., 2020)).
+
+Adroit tasks. The Adroit domain is a realistic simulation based on the Shadow Hand robot, first proposed by Rajeswaran et al. (2017). There are 4 tasks in this domain: opening a door (“door”), pen twirling (“pen”), moving a ball to a target location (“relocate”), and hitting a nail with a hammer (“hammer”). These tasks all contain sparse rewards and are difficult to learn without demonstrations.
+
+![](images/a060b287ea06307afdc9142b542fc4ee4111f00969b104002141935214db2b8f.jpg)
+
+Adroit datasets and policies. We include 3 datasets for each task. The “human” dataset consists of a small amount of human demonstrations performing the task. The “expert” dataset consists of data collected from an expert trained via DAPG (Rajeswaran et al., 2017). Finally, the “cloned” dataset contains a mixture of human demonstrations and data collected from an imitation learning algorithm trained on the demonstrations. For policies, we include 11 policies collected from snapshots while running the DAPG algorithm, which range from random performance to expert performance.
+
+# 5 BASELINES AND RESULTS
+
+The goal of our evaluation is two-fold. First, we wish to measure the performance of a variety of existing algorithms to provide baselines and reference numbers for future research. Second, we wish to identify shortcomings in these approaches to reveal promising directions for future research.
+
+# 5.1 BASELINES
+
+We selected six methods to evaluate, which cover a variety of approaches that have been explored for the OPE problem.
+
+Fitted Q-Evaluation (FQE) As in Le et al. (2019), we train a neural network to estimate the value of the evaluation policy $\pi$ by bootstrapping from $Q ( s ^ { \prime } , \pi ( s ^ { \prime } ) )$ . We tried two different implementations, one from Kostrikov & Nachum $( 2 0 2 0 ) ^ { 3 }$ and another from Paine et al. (2020) labeled FQE-L2 and FQE-D respectively to reflect different choices in loss function and parameterization.
+
+Model-Based (MB) Similar to Paduraru (2007), we train dynamics and reward models on transitions from the offline dataset $\mathcal { D }$ . Our models are deep neural networks trained to maximize the log likelihood of the next state and reward given the current state and action, similar to models from successful model-based RL algorithms (Chua et al., 2018; Janner et al., 2019). We follow the setup detailed in Zhang et al. (2021). We include both the feed-forward and auto-regressive models labeled MB-FF and MB-AR respectively. To evaluate a policy, we compute the return using simulated trajectories generated by the policy under the learned dynamics model.
+
+Importance Sampling (IS) We perform importance sampling with a learned behavior policy. We use the implementation from Kostrikov & Nachum $( 2 0 2 0 ) ^ { 3 }$ , which uses self-normalized (also known as weighted) step-wise importance sampling (Precup, 2000). Since the behavior policy is not known explicitly, we learn an estimate of it via a max-likelihood objective over the dataset $\mathcal { D }$ , as advocated by Xie et al. (2018); Hanna et al. (2019). In order to be able to compute log-probabilities when the target policy is deterministic, we add artificial Gaussian noise with standard deviation 0.01 for all deterministic target policies.
+
+![](images/6b07deff82df731588238cb98f45f16473cd5edfe227e22423bbbf9c81785fce.jpg)  
+Figure 4: DOPE RL Unplugged Mean overall performance of baselines.
+
+![](images/542ca5444478436600eca9ff64545a7663deac4fdc14cb169fe2abbecbe92520.jpg)  
+Figure 5: DOPE D4RL Mean overall performance of baselines.
+
+Doubly-Robust (DR) We perform weighted doubly-robust policy evaluation Thomas & Brunskill (2016) using the implementation of Kostrikov & Nachum (2020)3. Specifically, this method combines the IS technique above with a value estimator for variance reduction. The value estimator is learned using deep FQE with an L2 loss function. More advanced approaches that trade variance for bias exist (e.g., MAGIC (Thomas & Brunskill, 2016)), but we leave implementing them to future work.
+
+DICE This method uses a saddle-point objective to estimate marginalized importance weights $d ^ { \pi } ( s , a ) / d ^ { \pi _ { B } } ( s , a )$ ; these weights are then used to compute a weighted average of reward over the offline dataset, and this serves as an estimate of the policy’s value in the MDP. We use the implementation from Yang et al. (2020) corresponding to the algorithm BestDICE.4
+
+Variational Power Method (VPM) This method runs a variational power iteration algorithm to estimate the importance weights $d ^ { \pi } ( s , a ) / d ^ { \pi _ { B } } ( s , a )$ without the knowledge of the behavior policy. It then estimates the target policy value using weighted average of rewards similar to the DICE method. Our implementation is based on the same network and hyperparameters for OPE setting as in Wen et al. (2020). We further tune the hyper-parameters including the regularization parameter $\lambda$ , learning rates $\alpha \theta$ and $\alpha _ { v }$ , and number of iterations on the Cartpole swingup task using ground-truth policy value, and then fix them for all other tasks.
+
+# 5.2 RESULTS
+
+To facilitate aggregate metrics and comparisons between tasks and between DOPE RL Unplugged and DOPE D4RL, we normalize the returns and estimated returns to range between 0 and 1. For each set of policies we compute the worst value $V _ { w o r s t } = m i n \{ V ^ { \pi _ { 1 } } , V ^ { \pi _ { 2 } } , . . . , V ^ { \pi _ { N } } \}$ and best value $V _ { b e s t } = m a x \{ V ^ { \pi _ { 1 } } , V ^ { \pi _ { 2 } } , . . . , V ^ { \pi _ { N } } \}$ and normalize the returns and estimated returns according to $x ^ { \prime } = ( x - V _ { w o r s t } ) / ( V _ { b e s t } - V _ { w o r s t } )$ .
+
+We present results averaged across DOPE RL Unplugged in Fig. 4, and results for DOPE D4RL in Fig. 5. Overall, no evaluated algorithm attains near-oracle performance under any metric (absolute error, regret, or rank correlation). Because the dataset is finite, we do not expect that achieving oracle performance is possible. Nevertheless, based on recent progress on this benchmark (e.g., Zhang et al. (2021)), we hypothesize that the benchmark has room for improvement, making it suitable for driving further improvements on OPE methods and facilitating the development of OPE algorithms that can provide reliable estimates on the types of high-dimensional problems that we consider.
+
+While all algorithms achieve sub-optimal performance, some perform better than others. We find that on the DOPE RL Unplugged tasks model based (MB-AR, MB-FF) and direct value based methods (FQE-D, FQE-L2) significantly outperform importance sampling methods (VPM, DICE, IS) across all metrics. This is somewhat surprising as DICE and VPM have shown promising results in other settings. We hypothesize that this is due to the relationship between the behavior data and evaluation policies, which is different from standard OPE settings. Recall that in DOPE RL Unplugged the behavior data is collected from an online RL algorithm and the evaluation policies are learned via offline RL from the behavior data. In our experience all methods work better when the behavior policy is a noisy/perturbed version of the evaluation policy. Moreover, MB and FQE-based methods may implicitly benefit from the architectural and optimization advancements made in policy optimization settings, which focus on similar environments and where these methods are more popular than importance sampling approaches. Note that within the MB and FQE methods, design details can create a significant difference in performance. For example model architecture (MB-AR vs MB-FF) and implementation differences (FQE-D vs FQE-L2) show differing performance on certain tasks.
+
+![](images/59bf833b107ef1d31a150045d7e13ac9e40e4d9b9cbc89b4c573185ea8deff70.jpg)  
+Figure 6: Rank correlation for each baseline algorithm for each RL Unplugged task considered.
+
+![](images/3af2dbbd351bfeda6415b37cb655672a0ea43e6e378379836703f9c249726a6e.jpg)  
+Figure 7: Scatter plots of estimate vs ground truth return for MB-AR and FQE-D on selected tasks.
+
+On DOPE D4RL, direct value based methods still do well, with FQE-L2 performing best on the Absolute Error and Regret $@ 1$ metrics. However, there are cases where other methods outperform FQE. Notably, IS and DR outperform FQE-L2 under the rank correlation metric. As expected, there is a clear performance gap between DOPE RL Unplugged and DOPE D4RL. While both domains have challenging tasks, algorithms perform better under the more ideal conditions of DOPE RL Unplugged than under the challenging conditions of DOPE D4RL (0.69 vs 0.25 rank correlation respectively).
+
+In Fig. A.2 we show the rank correlation for each task in DOPE RL Unplugged. Most tasks follow the overall trends, but we will highlight a few exceptions. 1) Importance sampling is among the best methods for the humanoid run task, significantly outperforming direct value-based methods. 2) while MB-AR and FQE-D are similar overall, there are a few tasks where the difference is large, for example FQE-D outperfroms MB-AR on finger turn hard, and manipulator insert ball, where as MB-AR outperforms FQE-D on cartpole swingup, fish swim, humanoid run, and manipulator insert peg. We show the scatter plots for MB-AR and FQE-D on these tasks in Fig 7 which highlights different failure modes: when MB-AR performs worse, it assigns similar values for all policies; when FQE-D performs worse, it severely over-estimates the values of poor policies.
+
+We present more detailed results, separated by task, in Appendix A.2. Note in particular how in Table A.2.2, which shows the regret $@ 1$ metric for different D4RL tasks, the particular choice of dataset for the Gym-MuJoCo, Adroit, and AntMaze domains causes a significant difference in the performance of OPE methods. This indicates the importance of evaluating multiple distinct datasets, with different data distribution properties (e.g., more narrow datasets, such as expert data, vs. broader datasets, such as random data), as no tested method is reliably robust to the effects of dataset variation.
+
+High-dimensional tasks requiring temporally extended control were also challenging, as highlighted by the performance on the AntMaze domain. No algorithm was able to achieve a good absolute error value on such tasks, and importance sampling was the only method able to achieve a correlation consistently above zero, suggesting that these more complex tasks are a particularly important area for future methods to focus on.
+
+# 6 RELATED WORK
+
+Off-policy evaluation (OPE) has been studied extensively across a range of different domains, from healthcare (Thapa et al., 2005; Raghu et al., 2018; Nie et al., 2019), to recommender systems (Li et al., 2010; Dudík et al., 2014; Theocharous et al., 2015), and robotics (Kalashnikov et al., 2018). While a full survey of OPE methods is outside the scope of this article, broadly speaking we can categories OPE methods into groups based the use of importance sampling (Precup, 2000), value functions (Sutton et al., 2009; Migliavacca et al., 2010; Sutton et al., 2016; Yang et al., 2020), and learned transition models (Paduraru, 2007), though a number of methods combine two or more of these components (Jiang & Li, 2015; Thomas & Brunskill, 2016; Munos et al., 2016). A significant body of work in OPE is also concerned with providing statistical guarantees (Thomas et al., 2015). Our focus instead is on empirical evaluation – while theoretical analysis is likely to be a critical part of future OPE research, combining such analysis with empirical demonstration on broadly accepted and standardized benchmarks is likely to facilitate progress toward practically useful algorithms.
+
+Current evaluation of OPE methods is based around several metrics, including error in predicting the true return of the evaluated policy (Voloshin et al., 2019), correlation between the evaluation output and actual returns (Irpan et al., 2019), and ranking and model selection metrics (Doroudi et al., 2017). As there is no single accepted metric used by the entire community, we provide a set of candidate metrics along with our benchmark, with a detailed justification in Section 5. Our work is closely related to (Paine et al., 2020) which studies OPE in a similar setting, however in our work we present a benchmark for the community and compare a range of OPE methods. Outside of OPE, standardized benchmark suites have led to considerable standardization and progress in RL (Stone & Sutton, 2001; Dutech et al., 2005; Riedmiller et al., 2007). The Arcade Learning Environment (ALE) (Bellemare et al., 2013) and OpenAI Gym (Brockman et al., 2016) have been widely used to compare online RL algorithms to good effect. More recently, Gulcehre et al. (2020); Fu et al. (2020) proposed benchmark tasks for offline RL. Our benchmark is based on the tasks and environments described in these two benchmarks, which we augment with a set of standardized policies for evaluation, results for a number of existing OPE methods, and standardized evaluation metrics and protocols. Voloshin et al. (2019) have recently proposed benchmarking for OPE methods on a variety of tasks ranging from tabular problems to image-based tasks in Atari. Our work differs in several key aspects. Voloshin et al. (2019) is composed entirely of discrete action tasks, whereas out benchmark focuses on continuous action tasks. Voloshin et al. (2019) assumes full support for the evaluation policy under the behavior policy data, whereas we designed our datasets and policies to ensure that different cases of dataset and policy distributions could be studied. Finally, all evaluations in Voloshin et al. (2019) are performed using the MSE metric, and they do not provide standardized datasets. In contrast, we provide a variety of policies for each problem which enables one to evaluate metrics such as ranking for policy selection, and a wide range of standardized datasets for reproducbility.
+
+# 7 CONCLUSION
+
+We have presented the Deep Off-Policy Evaluation (DOPE) benchmark, which aims to provide a platform for studying policy evaluation and selection across a wide range of challenging tasks and datasets. In contrast to prior benchmarks, DOPE provides multiple datasets and policies, allowing researchers to study how data distributions affect performance and to evaluate a wide variety of metrics, including those that are relevant for offline policy selection. In comparing existing OPE methods, we find that no existing algorithms consistently perform well across all of the tasks, which further reinforces the importance of standardized and challenging OPE benchmarks. Moreover, algorithms that perform poorly under one metric, such as absolute error, may perform better on other metrics, such as correlation, which provides insight into what algorithms to use depending on the use case (e.g., policy evaluation vs. policy selection).
+
+We believe that OPE is an exciting area for future research, as it allows RL agents to learn from large and abundant datasets in domains where online RL methods are otherwise infeasible. We hope that our benchmark will enable further progress in this field, though important evaluation challenges remain. As the key benefit of OPE is the ability to utilize real-world datasets, a promising direction for future evaluation efforts is to devise effective ways to use such data, where a key challenge is to develop evaluation protocols that are both reproducible and accessible. This could help pave the way towards developing intelligent decision making agents that can leverage vast banks of logged information to solve important real-world problems.
+
+# REFERENCES
+
+Charu C Aggarwal et al. Recommender systems, volume 1. Springer, 2016.
+
+Gabriel Barth-Maron, Matthew W. Hoffman, David Budden, Will Dabney, Dan Horgan, Dhruva TB, Alistair Muldal, Nicolas Heess, and Timothy Lillicrap. Distributional policy gradients. In International Conference on Learning Representations, 2018.
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47: 253–279, 2013.
+
+Léon Bottou, Jonas Peters, Joaquin Quiñonero-Candela, Denis X Charles, D Max Chickering, Elon Portugaly, Dipankar Ray, Patrice Simard, and Ed Snelson. Counterfactual reasoning and learning systems: The example of computational advertising. The Journal of Machine Learning Research, 14(1):3207–3260, 2013.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. In Advances in Neural Information Processing Systems, pp. 4754–4765, 2018.
+
+Shayan Doroudi, Philip S Thomas, and Emma Brunskill. Importance sampling for fair policy selection. Grantee Submission, 2017.
+
+Miroslav Dudík, Dumitru Erhan, John Langford, Lihong Li, et al. Doubly robust policy evaluation and optimization. Statistical Science, 29(4):485–511, 2014.
+
+Alain Dutech, Timothy Edmunds, Jelle Kok, Michail Lagoudakis, Michael Littman, Martin Riedmiller, Bryan Russell, Bruno Scherrer, Richard Sutton, Stephan Timmer, et al. Reinforcement learning benchmarks and bake-offs ii. Advances in Neural Information Processing Systems (NIPS), 17:6, 2005.
+
+Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020.
+
+Scott Fujimoto, Herke Hoof, and David Meger. Addressing function approximation error in actorcritic methods. In International Conference on Machine Learning, pp. 1587–1596, 2018.
+
+Alexandre Gilotte, Clément Calauzènes, Thomas Nedelec, Alexandre Abraham, and Simon Dollé. Offline a/b testing for recommender systems. In Proceedings of the Eleventh ACM International Conference on Web Search and Data Mining, pp. 198–206, 2018.
+
+Shixiang Gu, Ethan Holly, Timothy Lillicrap, and Sergey Levine. Deep reinforcement learning for robotic manipulation with asynchronous off-policy updates. In 2017 IEEE international conference on robotics and automation (ICRA), pp. 3389–3396. IEEE, 2017.
+
+Caglar Gulcehre, Ziyu Wang, Alexander Novikov, Tom Le Paine, Sergio Gómez Colmenarejo, Konrad Zolna, Rishabh Agarwal, Josh Merel, Daniel Mankowitz, Cosmin Paduraru, et al. Rl unplugged: Benchmarks for offline reinforcement learning. arXiv preprint arXiv:2006.13888, 2020.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018.
+
+Josiah Hanna, Scott Niekum, and Peter Stone. Importance sampling policy evaluation with an estimated behavior policy. In International Conference on Machine Learning, pp. 2605–2613. PMLR, 2019.
+
+Milos Hauskrecht and Hamish Fraser. Planning treatment of ischemic heart disease with partially observable markov decision processes. Artificial Intelligence in Medicine, 18(3):221–244, 2000.
+
+Matt Hoffman, Bobak Shahriari, John Aslanides, Gabriel Barth-Maron, Feryal Behbahani, Tamara Norman, Abbas Abdolmaleki, Albin Cassirer, Fan Yang, Kate Baumli, et al. Acme: A research framework for distributed reinforcement learning. arXiv preprint arXiv:2006.00979, 2020.
+
+Alexander Irpan, Kanishka Rao, Konstantinos Bousmalis, Chris Harris, Julian Ibarz, and Sergey Levine. Off-policy evaluation via off-policy classification. In Advances in Neural Information Processing Systems, pp. 5437–5448, 2019.
+
+Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Model-based policy optimization. In Advances in Neural Information Processing Systems, pp. 12519–12530, 2019.
+
+Nan Jiang and Lihong Li. Doubly robust off-policy value evaluation for reinforcement learning. arXiv preprint arXiv:1511.03722, 2015.
+
+Dmitry Kalashnikov, Alex Irpan, Peter Pastor, Julian Ibarz, Alexander Herzog, Eric Jang, Deirdre Quillen, Ethan Holly, Mrinal Kalakrishnan, Vincent Vanhoucke, et al. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. arXiv preprint arXiv:1806.10293, 2018.
+
+Alex Kendall, Jeffrey Hawke, David Janz, Przemyslaw Mazur, Daniele Reda, John-Mark Allen, Vinh-Dieu Lam, Alex Bewley, and Amar Shah. Learning to drive in a day. In 2019 International Conference on Robotics and Automation (ICRA), pp. 8248–8254. IEEE, 2019.
+
+Jens Kober, J Andrew Bagnell, and Jan Peters. Reinforcement learning in robotics: A survey. The International Journal of Robotics Research, 32(11):1238–1274, 2013.
+
+Ilya Kostrikov and Ofir Nachum. Statistical bootstrapping for uncertainty estimation in off-policy evaluation, 2020.
+
+Hoang M Le, Cameron Voloshin, and Yisong Yue. Batch policy learning under constraints. arXiv preprint arXiv:1903.08738, 2019.
+
+Lihong Li, Wei Chu, John Langford, and Robert E Schapire. A contextual-bandit approach to personalized news article recommendation. In Proceedings of the 19th international conference on World wide web, pp. 661–670, 2010.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Travis Mandel, Yun-En Liu, Sergey Levine, Emma Brunskill, and Zoran Popovic. Offline policy evaluation across representations with applications to educational games. In AAMAS, pp. 1077– 1084, 2014.
+
+Martino Migliavacca, Alessio Pecorino, Matteo Pirotta, Marcello Restelli, and Andrea Bonarini. Fitted policy search: Direct policy search using a batch reinforcement learning approach. In 3rd International Workshop on Evolutionary and Reinforcement Learning for Autonomous Robot Systems (ERLARS 2010), pp. 35. Citeseer, 2010.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. In NIPS Deep Learning Workshop. 2013.
+
+Rémi Munos, Tom Stepleton, Anna Harutyunyan, and Marc G. Bellemare. Safe and efficient off-policy reinforcement learning. arXiv preprint arXiv:1606.02647, 2016.
+
+Xinkun Nie, Emma Brunskill, and Stefan Wager. Learning when-to-treat policies. arXiv preprint arXiv:1905.09751, 2019.
+
+Cosmin Paduraru. Planning with approximate and learned models of markov decision processes. 2007.
+
+Tom Le Paine, Cosmin Paduraru, Andrea Michi, Caglar Gulcehre, Konrad Zolna, Alexander Novikov, Ziyu Wang, and Nando de Freitas. Hyperparameter selection for offline reinforcement learning. arXiv preprint arXiv:2007.09055, 2020.
+
+Doina Precup. Eligibility traces for off-policy policy evaluation. Computer Science Department Faculty Publication Series, pp. 80, 2000.
+
+Aniruddh Raghu, Omer Gottesman, Yao Liu, Matthieu Komorowski, Aldo Faisal, Finale Doshi-Velez, and Emma Brunskill. Behaviour policy estimation in off-policy policy evaluation: Calibration matters. arXiv preprint arXiv:1807.01066, 2018.
+
+Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. arXiv preprint arXiv:1709.10087, 2017.
+
+Martin Riedmiller, Jan Peters, and Stefan Schaal. Evaluation of policy gradient methods and variants on the cart-pole benchmark. In 2007 IEEE International Symposium on Approximate Dynamic Programming and Reinforcement Learning, pp. 254–261. IEEE, 2007.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International conference on machine learning, pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Noah Y Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael Neunert, Thomas Lampe, Roland Hafner, and Martin Riedmiller. Keep doing what worked: Behavioral modelling priors for offline reinforcement learning. In International Conference on Learning Representations, 2020.
+
+Peter Stone and Richard S Sutton. Scaling reinforcement learning toward robocup soccer. In Icml, volume 1, pp. 537–544. Citeseer, 2001.
+
+Richard S Sutton, Hamid Reza Maei, Doina Precup, Shalabh Bhatnagar, David Silver, Csaba Szepesvári, and Eric Wiewiora. Fast gradient-descent methods for temporal-difference learning with linear function approximation. In Proceedings of the 26th Annual International Conference on Machine Learning, pp. 993–1000, 2009.
+
+Richard S Sutton, A Rupam Mahmood, and Martha White. An emphatic approach to the problem of off-policy temporal-difference learning. The Journal of Machine Learning Research, 17(1): 2603–2631, 2016.
+
+Adith Swaminathan and Thorsten Joachims. Counterfactual risk minimization: Learning from logged bandit feedback. In International Conference on Machine Learning, pp. 814–823, 2015.
+
+Adith Swaminathan, Akshay Krishnamurthy, Alekh Agarwal, Miro Dudik, John Langford, Damien Jose, and Imed Zitouni. Off-policy evaluation for slate recommendation. In Advances in Neural Information Processing Systems, pp. 3632–3642, 2017.
+
+Gerald Tesauro. Temporal difference learning and td-gammon. Communications of the ACM, 38(3): 58–68, 1995.
+
+Devinder Thapa, In-Sung Jung, and Gi-Nam Wang. Agent based decision support system using reinforcement learning under emergency circumstances. In International Conference on Natural Computation, pp. 888–892. Springer, 2005.
+
+Georgios Theocharous, Philip S Thomas, and Mohammad Ghavamzadeh. Personalized ad recommendation systems for life-time value optimization with guarantees. In Twenty-Fourth International Joint Conference on Artificial Intelligence, 2015.
+
+Philip Thomas and Emma Brunskill. Data-efficient off-policy policy evaluation for reinforcement learning. In International Conference on Machine Learning, pp. 2139–2148, 2016.
+
+Philip S Thomas, Georgios Theocharous, and Mohammad Ghavamzadeh. High-confidence off-policy evaluation. In Twenty-Ninth AAAI Conference on Artificial Intelligence, 2015.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.
+
+Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019.
+
+Cameron Voloshin, Hoang M Le, Nan Jiang, and Yisong Yue. Empirical study of off-policy policy evaluation for reinforcement learning. arXiv preprint arXiv:1911.06854, 2019.
+
+Yu-Xiang Wang, Alekh Agarwal, and Miroslav Dudık. Optimal and adaptive off-policy evaluation in contextual bandits. In International Conference on Machine Learning, pp. 3589–3597. PMLR, 2017.
+
+Ziyu Wang, Alexander Novikov, Konrad Zołna, Jost Tobias Springenberg, Scott Reed, Bobak ˙ Shahriari, Noah Siegel, Josh Merel, Caglar Gulcehre, Nicolas Heess, and Nando de Freitas. Critic regularized regression. arXiv preprint arXiv:2006.15134, 2020.
+
+Junfeng Wen, Bo Dai, Lihong Li, and Dale Schuurmans. Batch stationary distribution estimation. arXiv preprint arXiv:2003.00722, 2020.
+
+Yuan Xie, Boyi Liu, Qiang Liu, Zhaoran Wang, Yuan Zhou, and Jian Peng. Off-policy evaluation and learning from logged bandit feedback: Error reduction via surrogate policy. arXiv preprint arXiv:1808.00232, 2018.
+
+Mengjiao Yang, Ofir Nachum, Bo Dai, Lihong Li, and Dale Schuurmans. Off-policy evaluation via the regularized lagrangian. arXiv preprint arXiv:2007.03438, 2020.
+
+Michael R Zhang, Thomas Paine, Ofir Nachum, Cosmin Paduraru, George Tucker, ziyu wang, and Mohammad Norouzi. Autoregressive dynamics models for offline policy evaluation and optimization. In International Conference on Learning Representations, 2021. URL https: //openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ kmqjgSNXby.
+
+# A APPENDIX
+
+# A.1 METRICS
+
+The metrics we use in our paper are defined as follows:
+
+Absolute Error We evaluate policies using absolute error in order to be robust to outliers. The absolute error is defined as the difference between the value and estimated value of a policy:
+
+$$
+\mathrm { A b s E r r } = | V ^ { \pi } - \hat { V } ^ { \pi } |
+$$
+
+Where $V ^ { \pi }$ is the true value of the policy, and ${ \hat { V } } ^ { \pi }$ is the estimated value of the policy.
+
+Regret $@ \mathbf { k }$ Regret $@ \mathbf { k }$ is the difference between the value of the best policy in the entire set, and the value of the best policy in the top- $\mathbf { \nabla } \cdot \mathbf { k }$ set (where the top- $\mathbf { \nabla } \cdot \mathbf { k }$ set is chosen by estimated values). It can be defined as:
+
+$$
+{ \mathrm { R e g r e t } } \ @ { \mathrm { k } } = \operatorname* { m a x } _ { i \in 1 : N } V _ { i } ^ { \pi } - \operatorname* { m a x } _ { j \in { \mathrm { t o p k } } ( 1 : N ) } V _ { j } ^ { \pi }
+$$
+
+Where $\mathrm { t o p k } ( 1 : N )$ denotes the indices of the top $\mathbf { K }$ policies as measured by estimated values ${ \hat { V } } ^ { \pi }$
+
+Rank correlation Rank correlation (also Spearman’s $\rho$ ) measures the correlation between the ordinal rankings of the value estimates and the true values. It can be written as:
+
+$$
+\mathrm { R a n k C o r r } = { \frac { \mathrm { C o v } ( V _ { 1 : N } ^ { \pi } , \hat { V } _ { 1 : N } ^ { \pi } ) } { \sigma ( V _ { 1 : N } ^ { \pi } ) \sigma ( \hat { V } _ { 1 : N } ^ { \pi } ) } }
+$$
+
+# A.2 DETAILED RESULTS
+
+Detailed results figures and tables are presented here. We show results by task in both tabular and chart form, as well as scatter plots which compare the estimated returns against the ground truth returns for every policy.
+
+# A.2.1 CHART RESULTS
+
+First we show the normalized results for each algorithm and task.
+
+![](images/8ff4364835b59575c4bab1f0423f6308e86c50cd02bbe08c7a89e003fd9f1069.jpg)  
+Figure A.1: Absolute error for each baseline algorithm for each RL Unplugged task considered.
+
+![](images/485ca075b1658539cd32f00ae7f327dd7d4a06528b953cfe8fd1706684e1505f.jpg)  
+Figure A.2: Rank correlation for each baseline algorithm for each RL Unplugged task considered.
+
+![](images/189bb4cdd710c279f5f72357dbf116f2c92c751c39499233c3dbb5511ad3211a.jpg)  
+Figure A.3: Regret $@ 1$ for each baseline algorithm for each RL Unplugged task considered.
+
+![](images/302d93007761a975655e56294eb45c6cf3cc5e3e2cdf9e2ba932b5d32576ed78.jpg)  
+Figure A.4: Absolute error for each baseline algorithm for each D4RL task domain considered.
+
+![](images/f14447e37cd7898fc1e9ceecef71a88cd525f73d5002fa2c3ae541684ae3eaa3.jpg)  
+Figure A.5: Rank correlation for each baseline algorithm for each D4RL task domain considered.
+
+![](images/038611844c687a4593ffbbe7920420665a87be89fcb5f263c532031ab813b385.jpg)  
+Figure A.6: Regret $@ 1$ for each baseline algorithm for each D4RL task domain considered.
+
+![](images/7b266cd217f7285dc0e6999fe1505a7bd9a90d9a73443f625ce28e6f3e281ad2.jpg)  
+Figure A.7: Online evaluation of policy checkpoints for 4 Offline RL algorithms with 3 random seeds. We observe a large degree of variability between the behavior of algorithms on different tasks.
+
+# A.2.2 TABULAR RESULTS
+
+Next, we present the results for each task and algorithm in tabular form, with means and standard deviations reported across 3 seeds.
+
+Table A.1: Average absolute error between OPE metrics and ground truth values at a discount factor of 0.995 In each column, absolute error values that are not significantly different from the best $( p > 0 . 0 5 )$ are bold faced. Methods are ordered by median.   
+
+<table><tr><td></td><td></td><td>Cartpole swingup</td><td>Cheetah run</td><td>Finger turn hard</td><td>Fish swim</td><td>Humanoid run</td></tr><tr><td>Aahilreteirrerrt in</td><td>Variational power method</td><td>37.53 ±3.50</td><td>61.89 ±4.25</td><td>46.22 ±3.93</td><td>31.27 ±0.99</td><td>35.29 ±3.03</td></tr><tr><td></td><td>Importance Sampling</td><td>68.75 ±2.39</td><td>44.29 ±1.91</td><td>90.10 ±4.68</td><td>34.82±1.93</td><td>27.89 ±1.98</td></tr><tr><td>puno.8</td><td>Best DICE</td><td>22.73 ±1.65</td><td>23.35 ±1.32</td><td>33.52 ±3.48</td><td>59.48 ±2.47</td><td>31.42 ±2.04</td></tr><tr><td></td><td>Model based - FF</td><td>6.80±0.85</td><td>13.64±0.59</td><td>35.99 ±3.00</td><td>4.75±0.23</td><td>30.12 ±2.40</td></tr><tr><td></td><td>FQE (L2)</td><td>19.02 ±1.34</td><td>48.26 ±1.78</td><td>27.91 ±1.18</td><td>19.82 ±1.57</td><td>56.28 ±3.52</td></tr><tr><td>pne do</td><td>Doubly Robust (IS,FQE)</td><td>24.38 ±2.51</td><td>40.27 ±2.05</td><td>25.26 ±2.48</td><td>20.28±1.90</td><td>53.64±3.68</td></tr><tr><td></td><td>FQE (distributional)</td><td>12.63±1.21</td><td>36.50 ±1.62</td><td>10.23 ±0.93</td><td>7.76±0.95</td><td>32.36 ±2.27</td></tr><tr><td></td><td>Model based - AR</td><td>5.32 ±0.54</td><td>4.64±0.46</td><td>22.93 ±1.72</td><td>4.31±0.22</td><td>20.95 ±1.61</td></tr><tr><td></td><td></td><td>Walker stand</td><td>Walker walk</td><td>Manipulator insert ball</td><td>Manipulator insert peg</td><td>Median ↓</td></tr><tr><td>Ahh irreirritit nann punon pue</td><td>Variational power method</td><td>96.76 ±3.59</td><td>87.24 ±4.25</td><td>79.25 ±6.19</td><td>21.95 ±1.17</td><td>46.22</td></tr><tr><td></td><td>Importance Sampling</td><td>66.50 ±1.90</td><td>67.24±2.70</td><td>29.93±1.10</td><td>12.78 ±0.66</td><td>44.29</td></tr><tr><td></td><td>Best DICE</td><td>27.58 ±3.01</td><td>47.28±3.13</td><td>103.45 ±5.21</td><td>22.75 ±3.00</td><td>31.42</td></tr><tr><td></td><td>Model based - FF</td><td>23.34 ±2.41</td><td>52.23 ±2.34</td><td>34.30 ±2.55</td><td>121.12 ±1.58</td><td>30.12</td></tr><tr><td></td><td>FQE (L2)</td><td>6.51±0.71</td><td>18.34 ±0.95</td><td>36.32 ±1.07</td><td>31.12 ±2.37</td><td>27.91</td></tr><tr><td></td><td>Doubly Robust (IS,FQE)</td><td>26.82 ±2.66</td><td>24.63 ±1.69</td><td>13.33 ±1.16</td><td>22.28 ±2.34</td><td>24.63</td></tr><tr><td>PE</td><td>FQE (distributional)</td><td>21.49 ±1.41</td><td>27.57 ±1.54</td><td>9.75±1.10</td><td>12.66 ±1.39</td><td>12.66</td></tr><tr><td></td><td>Model based - AR</td><td>19.12 ±1.23</td><td>5.14±0.49</td><td>17.13 ±1.34</td><td>9.71±0.70</td><td>9.71</td></tr></table>
+
+Table A.2: Spearman’s rank correlation $( \rho )$ coefficient (bootstrap mean $\pm$ standard deviation) between different OPE metrics and ground truth values at a discount factor of 0.995. In each column, rank correlation coefficients that are not significantly different from the best $( p > 0 . 0 5 )$ are bold faced. Methods are ordered by median. Also see Table A.3 and Table A.1 for Normalized Regret $\textcircled { \omega } 5$ and Average Absolute Error results.   
+
+<table><tr><td></td><td></td><td>Cartpole swingup</td><td>Cheetah run</td><td>Finger turn hard</td><td>Fish swim</td><td>Humanoid run</td></tr><tr><td>rg ernreetiretr Yinn puno</td><td>Importance Sampling</td><td>-0.23 ±0.11</td><td>-0.01 ±0.12</td><td>-0.45±0.08</td><td>-0.17 ±0.11</td><td>0.91 ±0.02</td></tr><tr><td></td><td>Best DICE</td><td>-0.16 ±0.11</td><td>0.07 ±0.11</td><td>-0.22 ±0.11</td><td>0.44±0.09</td><td>-0.10 ±0.10</td></tr><tr><td></td><td>Variational power method</td><td>0.01±0.11</td><td>0.01 ±0.12</td><td>-0.25 ±0.11</td><td>0.56±0.08</td><td>0.36 ±0.09</td></tr><tr><td></td><td>Doubly Robust (IS,FQE)</td><td>0.55±0.09</td><td>0.56±0.08</td><td>0.67 ±0.05</td><td>0.11±0.12</td><td>-0.03±0.12</td></tr><tr><td></td><td>Model based -FF</td><td>0.83±0.05</td><td>0.64±0.08</td><td>0.08 ±0.11</td><td>0.95 ±0.02</td><td>0.35±0.10</td></tr><tr><td>Ppg da</td><td>FQE (distributional)</td><td>0.69 ±0.07</td><td>0.67 ±0.06</td><td>0.94±0.01</td><td>0.59±0.10</td><td>0.74±0.06</td></tr><tr><td></td><td>FQE (L2)</td><td>0.70±0.07</td><td>0.56±0.08</td><td>0.83±0.04</td><td>0.10±0.12</td><td>-0.02 ±0.12</td></tr><tr><td></td><td>Model based -AR</td><td>0.91±0.02</td><td>0.74±0.07</td><td>0.57 ±0.09</td><td>0.96±0.01</td><td>0.90 ±0.02</td></tr><tr><td></td><td></td><td>Walker stand</td><td>Walker walk</td><td>Manipulator insert ball</td><td>Manipulator insert peg</td><td>Median ↑</td></tr><tr><td>rgh eneeetrrrer nnn punorn preg</td><td>Importance Sampling</td><td>0.59±0.08</td><td>0.38±0.10</td><td>-0.72±0.05</td><td>-0.25 ±0.08</td><td>-0.17</td></tr><tr><td></td><td>Best DICE</td><td>-0.11±0.12</td><td>-0.58 ±0.08</td><td>0.19 ±0.11</td><td>-0.35±0.10</td><td>-0.11</td></tr><tr><td></td><td>Variational power method</td><td>-0.35±0.10</td><td>-0.10±0.11</td><td>0.61±0.08</td><td>0.41±0.09</td><td>0.01</td></tr><tr><td></td><td>Doubly Robust (IS,FQE)</td><td>0.88±0.03</td><td>0.85±0.04</td><td>0.42 ±0.10</td><td>-0.47±0.09</td><td>0.55</td></tr><tr><td></td><td>Model based -FF</td><td>0.82±0.04</td><td>0.80±0.05</td><td>0.06±0.10</td><td>-0.56 ±0.08</td><td>0.64</td></tr><tr><td></td><td>FQE (distributional)</td><td>0.87±0.02</td><td>0.89 ±0.03</td><td>0.63±0.08</td><td>-0.23 ±0.10</td><td>0.69</td></tr><tr><td>0</td><td>FQE (L2)</td><td>0.96±0.01</td><td>0.94±0.02</td><td>0.70 ±0.07</td><td>-0.48±0.08</td><td>0.70</td></tr><tr><td></td><td>Model Based -AR</td><td>0.96±0.01</td><td>0.98±0.00</td><td>-0.33±0.09</td><td>0.47 ±0.09</td><td>0.90</td></tr></table>
+
+<table><tr><td></td><td></td><td>Cartpole swingup</td><td>Cheetah run</td><td>Finger turn hard</td><td>Fish swim</td><td>Humanoid run</td></tr><tr><td>pin punon&#x27;sa gdo</td><td>Importance Sampling</td><td>0.73±0.16</td><td>0.40 ±0.21</td><td>0.64±0.05</td><td>0.12 ±0.05</td><td>0.31±0.09</td></tr><tr><td></td><td>Best DICE</td><td>0.68 ±0.41</td><td>0.27±0.05</td><td>0.44±0.04</td><td>0.35 ±0.24</td><td>0.84±0.22</td></tr><tr><td></td><td>Variational power method</td><td>0.50±0.13</td><td>0.37 ±0.04</td><td>0.45 ±0.13</td><td>0.02 ±0.02</td><td>0.56 ±0.08</td></tr><tr><td></td><td>Doubly Robust (IS,FQE)</td><td>0.28±0.05</td><td>0.09 ±0.05</td><td>0.56±0.12</td><td>0.61±0.12</td><td>0.99 ±0.00</td></tr><tr><td></td><td>FQE (L2)</td><td>0.06±0.04</td><td>0.17±0.05</td><td>0.30±0.11</td><td>0.50±0.03</td><td>0.99 ±0.00</td></tr><tr><td>Prreeereer</td><td>Model based - FF</td><td>0.02±0.02</td><td>0.24±0.12</td><td>0.43±0.04</td><td>0.00±0.00</td><td>0.44±0.02</td></tr><tr><td></td><td>FQE (distributional)</td><td>0.03±0.09</td><td>0.11 ±0.09</td><td>0.10±0.12</td><td>0.49 ±0.06</td><td>0.24±0.15</td></tr><tr><td></td><td>Model based -AR</td><td>0.00±0.02</td><td>0.01±0.02</td><td>0.63±0.11</td><td>0.03±0.02</td><td>0.32 ±0.06</td></tr><tr><td></td><td></td><td>Walker stand</td><td>Walker walk</td><td>Manipulator insert ball</td><td>Manipulator insert peg</td><td>Median ↓</td></tr><tr><td>nn punon oeeeeeer</td><td>Importance Sampling</td><td>0.54 ±0.11</td><td>0.54±0.23</td><td>0.83±0.05</td><td>0.22 ±0.03</td><td>0.54</td></tr><tr><td></td><td>Best DICE</td><td>0.24±0.07</td><td>0.55±0.06</td><td>0.44±0.07</td><td>0.75 ±0.04</td><td>0.44</td></tr><tr><td></td><td>Variational power method</td><td>0.41±0.02</td><td>0.39 ±0.02</td><td>0.52 ±0.20</td><td>0.32±0.02</td><td>0.41</td></tr><tr><td></td><td>Doubly Robust (IS,FQE)</td><td>0.02±0.01</td><td>0.05 ±0.07</td><td>0.30±0.10</td><td>0.73±0.01</td><td>0.30</td></tr><tr><td></td><td>FQE (L2)</td><td>0.04±0.02</td><td>0.00±0.02</td><td>0.37 ±0.07</td><td>0.74±0.01</td><td>0.30</td></tr><tr><td>&#x27;OATTS</td><td>Model based - FF</td><td>0.18±0.10</td><td>0.03±0.05</td><td>0.83±0.06</td><td>0.74±0.01</td><td>0.24</td></tr><tr><td></td><td>FQE (distributional)</td><td>0.03±0.03</td><td>0.01±0.02</td><td>0.50±0.30</td><td>0.73±0.01</td><td>0.11</td></tr><tr><td></td><td>Model based - AR</td><td>0.04±0.02</td><td>0.04±0.02</td><td>0.85±0.02</td><td>0.30±0.04</td><td>0.04</td></tr></table>
+
+Table A.3: Normalized Regret $\textcircled { \omega } 5$ (bootstrap mean $\pm$ standard deviation) for OPE methods vs. ground truth values at a discount factor of 0.995. In each column, normalized regret values that are not significantly different from the best $( p > 0 . 0 5 )$ are bold faced. Methods are ordered by median.
+
+<table><tr><td></td><td></td><td>Halfcheetah expert</td><td>Halfcheetah medium</td><td>Halfcheetah medium-expert</td><td>Halfcheetah medium-replay</td><td>Halfcheetah random</td></tr><tr><td></td><td>VPM</td><td>1404±152 945±164</td><td>1217±123</td><td>1400±146</td><td>1409 ±154</td><td>1405±155</td></tr><tr><td></td><td>Best DICE</td><td>944±161</td><td>1374±153 1382±130</td><td>1427 ±111</td><td>1384±148</td><td>1411±154</td></tr><tr><td></td><td></td><td>Doubly Robust 1025 ±95</td><td>1222±134</td><td>1078±132</td><td>1440±158</td><td>1446 ±156</td></tr><tr><td>JA'qI</td><td>FQE (L2)</td><td>1031±95</td><td>1211 ±130</td><td>1015 ±103 1014±101</td><td>1001±129 1003±132</td><td>949 ±126</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>938±125</td></tr><tr><td>IS</td><td></td><td>Antmaze large-diverse</td><td>Antmaze large-play</td><td>Antmaze medium-diverse</td><td>Antmaze medium-play</td><td>Antmaze umaze</td></tr><tr><td>JA'iI</td><td></td><td>0.62±0.01</td><td>0.85±0.00</td><td>0.55 ±0.01</td><td>0.81±0.00</td><td>0.62 ±0.04</td></tr><tr><td></td><td>VPM Best DICE</td><td>0.02±0.02 5.55 ±0.36</td><td>0.26±0.24 19.62 ±1.28</td><td>0.07±0.05 2.42 ±1.56</td><td>0.11±0.06 19.47 ±2.15</td><td>0.12±0.03 14.97 ±1.93</td></tr><tr><td></td><td>Doubly Robust</td><td>0.99 ±0.01</td><td>1.59 ±0.01</td><td>0.61±0.03</td><td>1.47 ±0.01</td><td>0.87±0.04</td></tr><tr><td></td><td>FQE (L2)</td><td>0.53±0.01</td><td>0.78±0.00</td><td>0.29 ±0.01</td><td>0.71±0.01</td><td>0.39±0.03</td></tr><tr><td></td><td></td><td>Antmaze</td><td></td><td>Door</td><td>Door</td><td></td></tr><tr><td></td><td></td><td>umaze-diverse</td><td>Door cloned</td><td>expert</td><td>human</td><td>Hammer cloned</td></tr><tr><td>IS</td><td></td><td>0.14±0.02</td><td></td><td></td><td></td><td></td></tr><tr><td>JAt'S5I</td><td>VPM</td><td>0.12 ±0.03</td><td>891±188</td><td>648±122 879±182</td><td>870±173 862±163</td><td>7403 ±1126 7459 ±1114</td></tr><tr><td></td><td>Best DICE</td><td>0.17±0.04</td><td>1040 ±188 697±79</td><td>856±134</td><td>1108±199</td><td>4169 ±839</td></tr><tr><td></td><td>Doubly Robust</td><td>0.11±0.02</td><td>424±73</td><td>1353±218</td><td>379±65</td><td>6101±679</td></tr><tr><td></td><td>FQE (L2)</td><td>0.11±0.03</td><td>438±81</td><td>1343 ±84</td><td>389±60</td><td>5415 ±558</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>Hammer</td><td>Hammer</td><td>Maze2d</td><td>Maze2d</td><td>Maze2d</td></tr><tr><td>IS</td><td></td><td>expert</td><td>human</td><td>large</td><td>medium</td><td>umaze</td></tr><tr><td>JAI'qI</td><td></td><td>3052 ±608</td><td>7352 ±1118</td><td>45.61±10.43</td><td>61.29 ±7.78</td><td>50.20±9.16</td></tr><tr><td></td><td>VPM Best DICE</td><td>7312 ±1117</td><td>7105±1107</td><td>44.10 ±10.69</td><td>60.30±8.37</td><td>62.81±8.40</td></tr><tr><td></td><td></td><td>3963 ±758 Doubly Robust 3485 ±590</td><td>5677±936</td><td>42.46±9.66 22.94±6.82</td><td>58.97 ±9.57 23.64±4.96</td><td>21.95 ±4.69</td></tr><tr><td></td><td>FQE (L2)</td><td>2950±728</td><td>5768 ±751 6000 ±612</td><td>24.31 ±6.56</td><td>35.11 ±6.33</td><td>76.93 ±4.42 79.67 ±4.93</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>Pen</td><td>Pen</td><td>Pen</td><td>Relocate</td><td>Relocate</td></tr><tr><td>IS</td><td></td><td>cloned</td><td>expert</td><td>human</td><td>cloned</td><td>expert</td></tr><tr><td>JAAtiI</td><td></td><td>1707±128</td><td>4547 ±222</td><td>3926±128</td><td>632 ±215</td><td>2731±147</td></tr><tr><td></td><td>VPM</td><td>2324±129</td><td>2325±136</td><td>1569±215</td><td>586±135</td><td></td></tr><tr><td></td><td>Best DICE</td><td>1454±219</td><td></td><td>4193 ±244</td><td></td><td>620±214</td></tr><tr><td></td><td></td><td></td><td>2963±279</td><td>2846±200</td><td>1347 ±485</td><td>1095 ±221</td></tr><tr><td></td><td></td><td>Doubly Robust 1323 ±98</td><td>2013±564</td><td>2872±170</td><td>412±124</td><td>1193 ±350</td></tr><tr><td></td><td>FQE (L2)</td><td>1232 ±105</td><td>1057 ±281</td><td></td><td>439 ±125</td><td>1351±393</td></tr><tr><td></td><td></td><td>Relocate</td><td>Ant</td><td>Ant</td><td>Ant</td><td>Ant</td></tr><tr><td></td><td></td><td>human</td><td>expert</td><td>medium</td><td>medium-expert</td><td> medium-replay</td></tr><tr><td>IS</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>638 ±217</td><td>605±104</td><td>594±104</td><td>604±102</td><td>603±101</td></tr><tr><td></td><td>VPM</td><td>806±166</td><td>607 ±108</td><td>570±109</td><td>604±106</td><td>612±105</td></tr><tr><td>JA'SqI</td><td>Best DICE</td><td>4526 ±474</td><td>558±108</td><td>495 ±90</td><td>471±100</td><td>583±110</td></tr><tr><td></td><td>Doubly Robust</td><td>606±116</td><td>584±114</td><td>345 ±66</td><td>326±66</td><td>421±72</td></tr><tr><td></td><td>FQE (L2)</td><td>593±113</td><td>583±122</td><td>345 ±64</td><td>319 ±67</td><td>410±79</td></tr><tr><td></td><td></td><td>Ant</td><td>Hopper</td><td>Hopper</td><td>Hopper</td><td>Walker2d</td></tr><tr><td></td><td></td><td>random</td><td>expert</td><td>medium</td><td>random</td><td>expert</td></tr><tr><td>JA'qI IS</td><td></td><td>606±103</td><td>106±29</td><td>405 ±48</td><td>412±45</td><td>405 ±62</td></tr><tr><td></td><td>VPM</td><td>570±99</td><td>442 ±43</td><td>433±44</td><td>438±44</td><td>367±68</td></tr><tr><td></td><td>Best DICE</td><td>530±92</td><td>259±54</td><td>215±41</td><td>122 ±16</td><td>437 ±60</td></tr><tr><td></td><td>Doubly Robust</td><td>404±106</td><td>426 ±99</td><td>307±85</td><td>289±50</td><td>519±179</td></tr><tr><td></td><td>FQE (L2)</td><td>398±111</td><td>282±76</td><td>283±73</td><td>261±42</td><td>453±142</td></tr><tr><td></td><td></td><td>Walker2d</td><td>Walker2d</td><td>Walker2d</td><td>Walker2d</td><td>Median</td></tr><tr><td></td><td></td><td>medium</td><td>medium-expert</td><td>medium-replay</td><td>random</td><td></td></tr><tr><td>IS JA.'iI</td><td></td><td>428±60</td><td>436 ±62</td><td>427±60</td><td>430 ±61</td><td>603.82</td></tr><tr><td></td><td>VPM</td><td>426±60</td><td>425 ±61</td><td>424±64</td><td>440±58</td><td>585.53</td></tr><tr><td></td><td>Best DICE</td><td>273±31</td><td>322±60</td><td>374±51</td><td>419 ±57</td><td>530.43</td></tr><tr><td></td><td></td><td>368±74</td><td>217 ±46</td><td>296±54</td><td>347±74</td><td>411.99</td></tr><tr><td></td><td>Doubly Robust FQE (L2)</td></tr><tr><td></td><td></td><td>Halfcheetah expert</td><td>Halfcheetah medium-expert</td><td>Halfcheetah medium-replay</td><td>Halfcheetah random</td><td>Door cloned</td></tr><tr><td>Rr rrr</td><td>Best DICE</td><td>-0.44 ±0.30</td><td>-0.08±0.35</td><td>-0.15 ±0.41</td><td>-0.70 ±0.22</td><td>0.18 ±0.31</td></tr><tr><td></td><td>VPM</td><td>0.18±0.35</td><td>-0.47 ±0.29</td><td>-0.07±0.36</td><td>0.27±0.36</td><td>-0.29±0.36</td></tr><tr><td></td><td>FQE (L2)</td><td>0.78±0.15</td><td>0.62±0.27</td><td>0.26±0.37</td><td>-0.11 ±0.41</td><td>0.55 ±0.27</td></tr><tr><td></td><td>IS</td><td>0.01±0.35</td><td>-0.06±0.37</td><td>0.59 ±0.26</td><td>-0.24±0.36</td><td>0.66±0.22</td></tr><tr><td></td><td>Doubly Robust</td><td>0.77 ±0.17</td><td>0.62 ±0.27</td><td>0.32 ±0.37</td><td>-0.02 ±0.38</td><td>0.60±0.28</td></tr><tr><td></td><td></td><td>Door</td><td>Hammer</td><td>Hammer</td><td>Maze2d</td><td>Maze2d</td></tr><tr><td></td><td></td><td>expert</td><td>cloned</td><td>expert</td><td>large</td><td>medium</td></tr><tr><td>Rar rarr</td><td>Best DICE</td><td>-0.06±0.32</td><td>0.35 ±0.38</td><td>-0.42 ±0.31</td><td>0.56±0.21</td><td>-0.64±0.23</td></tr><tr><td></td><td>VPM</td><td>0.65 ±0.23</td><td>-0.77 ±0.22</td><td>0.39 ±0.31</td><td>-0.26 ±0.33</td><td>-0.05±0.39</td></tr><tr><td></td><td>FQE (L2)</td><td>0.89 ±0.09</td><td>-0.15±0.33</td><td>0.29 ±0.34</td><td>0.30±0.36</td><td>0.16±0.38</td></tr><tr><td></td><td>IS</td><td>0.76±0.17</td><td>0.58 ±0.27</td><td>0.64±0.24</td><td>0.63 ±0.19</td><td>0.44±0.25</td></tr><tr><td></td><td>Doubly Robust</td><td>0.76±0.13</td><td>-0.70±0.20</td><td>0.49 ±0.31</td><td>0.31±0.36</td><td>0.41 ±0.35</td></tr><tr><td></td><td></td><td>Pen</td><td>Relocate</td><td>Ant</td><td>Ant</td><td>Ant</td></tr><tr><td></td><td></td><td>expert</td><td>expert</td><td>expert</td><td>medium</td><td>medium-expert</td></tr><tr><td>Rrr rrer</td><td>Best DICE</td><td>-0.53±0.30</td><td>-0.27±0.34</td><td>-0.13±0.37</td><td>-0.36±0.28</td><td>-0.33±0.40</td></tr><tr><td></td><td>VPM</td><td>0.08±0.33</td><td>0.39 ±0.31</td><td>-0.42 ±0.38</td><td>-0.20±0.31</td><td>-0.28±0.28</td></tr><tr><td></td><td>FQE (L2)</td><td>-0.01 ±0.33</td><td>-0.57 ±0.28</td><td>-0.13±0.32</td><td>0.65±0.25</td><td>0.37 ±0.35</td></tr><tr><td></td><td>IS</td><td>-0.45 ±0.31</td><td>0.52 ±0.23</td><td>0.14±0.41</td><td>-0.17 ±0.32</td><td>-0.21 ±0.35</td></tr><tr><td></td><td>Doubly Robust</td><td>0.52±0.28</td><td>-0.40±0.24</td><td>-0.28 ±0.32</td><td>0.66±0.26</td><td>0.35 ±0.35</td></tr><tr><td></td><td></td><td>Ant</td><td>Ant</td><td>Hopper</td><td>Hopper</td><td>Hopper</td></tr><tr><td></td><td></td><td>medium-replay</td><td>random</td><td>expert</td><td>medium</td><td>random</td></tr><tr><td></td><td>Best DICE VPM</td><td>-0.24±0.39 -0.26±0.29</td><td>-0.21 ±0.35</td><td>-0.08 ±0.32 0.21±0.32</td><td>0.19 ±0.33 0.13±0.37</td><td>-0.13±0.39 -0.46±0.20</td></tr><tr><td></td><td>FQE (L2)</td><td>0.57 ±0.28</td><td>0.24±0.31 0.04±0.33</td><td>-0.33 ±0.30</td><td>-0.29±0.33</td><td>-0.11±0.36</td></tr><tr><td>Rrr raer</td><td>IS</td><td>0.07±0.39</td><td>0.26±0.34</td><td>0.37 ±0.27</td><td>-0.55 ±0.26</td><td>0.23±0.34</td></tr><tr><td></td><td>Doubly Robust</td><td>0.45±0.32</td><td>0.01±0.33</td><td>-0.41 ±0.27</td><td>-0.31 ±0.34</td><td>-0.19 ±0.36</td></tr><tr><td></td><td></td><td>Walker2d</td><td>Walker2d</td><td>Walker2d</td><td>Walker2d</td><td>Walker2d</td></tr><tr><td></td><td></td><td>expert</td><td>medium</td><td>medium-expert</td><td>medium-replay</td><td>random</td></tr><tr><td>Rar rrrr</td><td>Best DICE</td><td>-0.37 ±0.27</td><td>0.12 ±0.38</td><td>-0.34±0.34</td><td>0.55 ±0.23</td><td>-0.19 ±0.36</td></tr><tr><td></td><td>VPM</td><td>0.17 ±0.32</td><td>0.44±0.21</td><td>0.49 ±0.37</td><td>-0.52±0.25</td><td>-0.42 ±0.34</td></tr><tr><td></td><td>FQE (L2)</td><td>0.35 ±0.33</td><td>-0.09 ±0.36</td><td>0.25 ±0.32</td><td>-0.19 ±0.36</td><td>0.21±0.31</td></tr><tr><td></td><td>IS</td><td>0.22 ±0.37</td><td>-0.25 ±0.35</td><td>0.24±0.33</td><td>0.65±0.24</td><td>-0.05 ±0.38</td></tr><tr><td></td><td>Doubly Robust</td><td>0.26 ±0.34</td><td>0.02 ±0.37</td><td>0.19 ±0.33</td><td>-0.37 ±0.39</td><td>0.16±0.29</td></tr><tr><td></td><td></td><td>Median</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RRrr rTT</td><td>Best DICE</td><td>-0.19</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>VPM</td><td>-0.05</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>FQE (L2)</td><td>0.21</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>IS</td><td>0.23</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Doubly Robust</td><td>0.26</td><td></td><td></td><td></td><td></td></tr><tr><td rowspan="2"></td><td rowspan="2">Halfcheetah</td><td rowspan="2">Halfcheetah expert medium</td><td rowspan="2"></td><td rowspan="2">Halfcheetah medium-expert</td><td rowspan="2">Halfcheetah Halfcheetah medium-replay random</td></tr><tr><td></td></tr><tr><td rowspan="5">Rreeeer</td><td>Best DICE</td><td>0.32 ±0.40</td><td>0.82 ±0.29 0.38±0.37</td><td>0.30±0.07</td><td>0.81±0.30</td></tr><tr><td>VPM</td><td>0.14±0.09 0.33 ±0.19</td><td>0.80±0.34</td><td>0.25 ±0.09</td><td>0.12 ±0.07</td></tr><tr><td>Doubly Robust O.11±0.08</td><td>0.37 ±0.15</td><td>0.14±0.07</td><td>0.33±0.18</td><td>0.31±0.10</td></tr><tr><td>FQE (L2) 0.12 ±0.07</td><td>0.38±0.13</td><td>0.14±0.07</td><td>0.36±0.16</td><td>0.37 ±0.08</td></tr><tr><td>0.15 ±0.08</td><td>0.05±0.05</td><td>0.73 ±0.42</td><td>0.13±0.10</td><td>0.31 ±0.11</td></tr><tr><td rowspan="11">eeeer</td><td></td><td>Antmaze</td><td>Antmaze</td><td>Antmaze Antmaze</td><td>Antmaze</td></tr><tr><td>Best DICE 0.54±0.34</td><td>large-diverse large-play</td><td>medium-diverse</td><td>medium-play</td><td>umaze</td></tr><tr><td>VPM 0.88 ±0.27</td><td>0.96 ±0.13 0.45 ±0.30</td><td>0.04±0.11</td><td>0.09 ±0.10</td><td>0.69 ±0.39</td></tr><tr><td>Doubly Robust 0.83 ±0.30</td><td></td><td>0.14±0.10</td><td>0.03±0.08</td><td>0.62 ±0.32</td></tr><tr><td>0.93 ±0.25</td><td>0.93±0.21 1.00±0.03</td><td>0.05 ±0.07 0.16 ±0.10</td><td>0.17±0.31 0.05±0.19</td><td>0.42 ±0.36 0.41 ±0.35</td></tr><tr><td>FQE (L2) IS</td><td></td><td>0.14±0.09</td><td>0.18±0.06</td><td>0.86±0.06</td></tr><tr><td rowspan="10">eeeeer VPM</td><td>0.39 ±0.26</td><td>0.71 ±0.20</td><td></td><td></td><td></td></tr><tr><td>Antmaze</td><td>Door</td><td>Door</td><td>Door</td><td>Hammer</td></tr><tr><td>umaze-diverse</td><td>cloned</td><td>expert</td><td>human</td><td>cloned</td></tr><tr><td>Best DICE 0.42 ±0.28</td><td>0.65 ±0.45</td><td>0.37 ±0.27</td><td>0.10±0.27</td><td>0.67 ±0.48</td></tr><tr><td>0.63±0.32 Doubly Robust 0.79 ±0.14</td><td>0.81±0.33 0.11±0.08</td><td>0.03±0.03</td><td>0.69 ±0.24</td><td>0.72 ±0.39</td></tr><tr><td>FQE (L2)</td><td></td><td>0.05 ±0.07</td><td>0.05 ±0.09</td><td>0.78 ±0.38 0.36 ±0.39</td></tr><tr><td>0.64±0.37</td><td>0.11 ±0.06</td><td>0.03±0.03</td><td>0.05 ±0.08</td><td>0.03±0.15</td></tr><tr><td>0.22 ±0.36</td><td>0.02 ±0.07</td><td>0.01±0.04</td><td>0.45 ±0.40</td><td></td></tr><tr><td>Hammer</td><td>Hammer</td><td>Maze2d</td><td>Maze2d</td><td>Maze2d</td></tr><tr><td>expert</td><td>human</td><td>large</td><td>medium</td><td>umaze</td></tr><tr><td rowspan="7">Peeeier VPM IS</td><td>Best DICE</td><td>0.24±0.34 0.04±0.08</td><td>0.15±0.08</td><td>0.44±0.05</td><td>0.03±0.07</td></tr><tr><td>0.04±0.07</td><td>0.18 ±0.29</td><td>0.66 ±0.10</td><td>0.24±0.24</td><td>0.06 ±0.12</td></tr><tr><td>Doubly Robust 0.09 ±0.09</td><td>0.46±0.23</td><td>0.21 ±0.16</td><td>0.27 ±0.14</td><td>0.03 ±0.07</td></tr><tr><td>FQE (L2) 0.05±0.04</td><td>0.46±0.23</td><td>0.20±0.14</td><td>0.31 ±0.14</td><td>0.03±0.07</td></tr><tr><td>0.01 ±0.04</td><td>0.19 ±0.30</td><td>0.16±0.23</td><td>0.15 ±0.15</td><td>0.02±0.12</td></tr><tr><td>Pen</td><td>Pen</td><td>Pen</td><td>Relocate</td><td>Relocate</td></tr><tr><td rowspan="4">Best DICE VPM</td><td>cloned</td><td>expert</td><td>human</td><td>cloned</td><td>expert</td></tr><tr><td>0.12 ±0.08</td><td>0.33 ±0.20</td><td>0.04±0.09</td><td>0.96 ±0.18</td><td>0.97±0.07</td></tr><tr><td>0.36 ±0.18</td><td>0.25 ±0.13</td><td>0.28 ±0.12</td><td>0.11 ±0.29</td><td>0.76 ±0.23</td></tr><tr><td>Doubly Robust 0.13 ±0.06 0.12 ±0.07</td><td>0.05±0.07</td><td>0.09±0.08</td><td>0.18±0.27</td><td>0.98 ±0.08</td></tr><tr><td rowspan="4">eeeeer IS</td><td>FQE (L2)</td><td>0.11±0.14</td><td>0.07 ±0.05</td><td>0.29±0.42</td><td>1.00±0.06</td></tr><tr><td>0.14±0.09</td><td>0.31±0.10</td><td>0.17 ±0.15</td><td>0.63±0.41</td><td>0.18±0.14</td></tr><tr><td>Relocate</td><td></td><td>Ant</td><td></td><td>Ant</td></tr><tr><td>human</td><td>Ant expert</td><td></td><td>Ant</td><td></td></tr><tr><td rowspan="4">VPM</td><td></td><td></td><td>medium</td><td> medium-expert</td><td>medium-replay</td></tr><tr><td>Best DICE 0.97 ±0.11</td><td>0.62 ±0.15</td><td>0.43±0.10</td><td>0.60±0.16</td><td>0.64±0.13</td></tr><tr><td>0.77±0.18</td><td>0.88±0.22</td><td>0.40±0.21</td><td>0.32 ±0.24</td><td>0.72 ±0.43</td></tr><tr><td>Doubly Robust 0.17 ±0.15 0.17 ±0.14</td><td>0.43 ±0.22</td><td>0.12 ±0.18</td><td>0.37 ±0.13</td><td>0.05±0.09</td></tr><tr><td rowspan="8">Peeeier IS</td><td>FQE (L2)</td><td>0.43 ±0.22</td><td>0.12 ±0.18</td><td>0.36±0.14</td><td>0.05 ±0.09 0.16±0.23</td></tr><tr><td>0.63±0.41</td><td>0.47 ±0.32</td><td>0.61±0.18</td><td>0.46±0.18</td><td></td></tr><tr><td>Ant</td><td>Hopper</td><td>Hopper</td><td>Hopper</td><td>Walker2d</td></tr><tr><td>random</td><td>expert</td><td>medium</td><td>random</td><td>expert</td></tr><tr><td>Best DICE 0.50 ±0.29 0.15±0.24</td><td>0.20±0.08</td><td>0.18±0.19</td><td>0.30±0.15</td><td>0.35 ±0.36</td></tr><tr><td>VPM Doubly Robust 0.28±0.15</td><td>0.13±0.10</td><td>0.10±0.14</td><td>0.26±0.10</td><td>0.09±0.19 0.06 ±0.07</td></tr><tr><td>0.28±0.15</td><td>0.34±0.35 0.41±0.20</td><td>0.32 ±0.32 0.32 ±0.32</td><td>0.41±0.17 0.36±0.22</td><td>0.06 ±0.07</td></tr><tr><td>FQE (L2) IS</td><td>0.56 ±0.22</td><td>0.06±0.03</td><td>0.38 ±0.28</td><td>0.05 ±0.05 0.43±0.26</td></tr><tr><td rowspan="4">Best DICE</td><td></td><td></td><td>Walker2d</td><td>Walker2d</td><td>Median</td></tr><tr><td></td><td>Walker2d Walker2d</td><td>medium-replay</td><td>random</td><td></td></tr><tr><td>medium</td><td>medium-expert</td><td></td><td>0.39 ±0.33</td><td>0.38</td></tr><tr><td>0.27 ±0.43 0.08±0.06</td><td>0.78±0.27 0.24±0.42</td><td>0.18±0.12 0.46 ±0.31</td><td>0.88±0.20</td><td></td></tr><tr><td rowspan="4">reeeer</td><td>VPM</td><td></td><td></td><td></td><td></td><td>0.28</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Doubly Robust 0.25±0.09</td><td>0.30±0.12</td><td>0.68±0.23</td><td>0.15 ±0.20</td><td></td><td>0.25</td></tr><tr><td></td><td></td><td>0.22 ±0.14</td><td>0.24±0.20</td><td>0.15±0.21</td><td></td></tr><tr><td rowspan="4">IS</td><td>FQE (L2)</td><td></td><td></td><td></td><td></td><td>0.24</td></tr><tr><td></td><td>0.31±0.10</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>0.13 ±0.07</td><td></td><td></td><td></td><td></td></tr><tr><td>0.70 ±0.39</td><td></td><td></td><td>0.02 ±0.05</td><td>0.74±0.33</td><td>0.18</td></tr></table>
+
+# A.2.3 SCATTER PLOTS
+
+Finally, we present scatter plots plotting the true returns of each policy against the estimated returns.   
+Each point on the plot represents one evaluated policy.
+
+![](images/27dc0c330afae693162789506b4d638cb93996d1e87cdc79c83d85c040a6f531.jpg)  
+Figure A.8: Scatter plots of estimate vs ground truth return for each baseline on each task in DOPE RL Unplugged.
+
+![](images/2badfd8bb0006de9a5a57679cb157db81407d77dac97614bb712ce41623c1edc.jpg)  
+Figure A.9: Scatter plots of estimate vs ground truth return for each baseline on each task in DOPE D4RL (part 1).
+
+![](images/7bb5c1d87eab326cf266de6dbb4bc6e97d349271db3da26f6a9d5551f9a3b8fc.jpg)  
+Figure A.10: Scatter plots of estimate vs ground truth return for each baseline on each task in DOPE D4RL (part 2).
+
+![](images/31553c26e4588016bff4c0d1dfe07158cc733c5ce3acc93075f0d6d7a3939dce.jpg)  
+Figure A.11: Scatter plots of estimate vs ground truth return for each baseline on each task in DOPE D4RL (part 3).
+
+![](images/116074c98f24877ea5ccac9d4003864d2ca03ff67f17db00810258cd5ef95178.jpg)  
+Figure A.12: Scatter plots of estimate vs ground truth return for each baseline on each task in DOPE D4RL (part 4).
+
+![](images/fd464a243d9bb7bdd8d54cd696233b55a9824cc2a258f3a8dd598cdb9bbef6f0.jpg)  
+Figure A.13: Scatter plots of estimate vs ground truth return for each baseline on each task in DOPE D4RL (part 5).
+
+![](images/238c4fe77e72766a7ff6255ac3f5a8811bb758ad0ffea132c70da7d22cef3eae.jpg)  
+Figure A.14: Scatter plots of estimate vs ground truth return for each baseline on each task in DOPE D4RL (part 6).

parse/train/rkQu4Wb0Z/rkQu4Wb0Z.md

@@ -0,0 +1,273 @@
+# DNN REPRESENTATIONS AS CODEWORDS:MANIPULATING STATISTICAL PROPERTIES V I APENALTY REGULARIZATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Performance of Deep Neural Network (DNN) heavily depends on the characteristics of hidden layer representations. Unlike the codewords of channel coding, however, the representations of learning cannot be directly designed or controlled. Therefore, we develop a family of penalty regularizers where each one aims to affect one of the representation’s statistical properties such as sparsity, variance, or covariance. The regularizers are extended to perform class-wise regularization, and the extension is found to provide an outstanding shaping capability. A variety of statistical properties are investigated for ten different regularization strategies including dropout and batch normalization, and several interesting findings are reported. Using the family of regularizers, performance improvements are confirmed for MNIST, CIFAR-100, and CIFAR-10 classification problems. But more importantly, our results suggest that understanding how to manipulate statistical properties of representations can be an important step toward understanding DNN, and that the role and effect of DNN regularizers need to be reconsidered.
+
+# 1 INTRODUCTION
+
+With a Deep Neural Network (DNN), information contained in the input data $x$ is transformed into multiple representations over multiple layers. Performance of machine learning tasks is known to heavily depend on the choice of representations over $p ( x )$ , but $p ( x )$ is almost always unknown and the representations cannot be directly controlled to match an arbitrary design even if $p ( x )$ was known. As of today, the best that can be done is to indirectly affect the representations by adding constraints, modifying cost function, and tuning learning process, etc.
+
+In Shannon’s information theory, channel coding theory deals with the problem of reliably sending the maximum amount of information through a given channel $p ( y | x )$ (Cover & Thomas, 2012). Because the channel is known and fixed, coding becomes a design problem where one needs to design codebook, encoder, and decoder. Usually, the channel is used $n$ times in a sequence to send a codeword of length $n$ (expressed as $x ^ { n }$ ). A codebook is a collection of all codewords that can be chosen and sent to the channel, and each message $w$ with information of interest is mapped into one of the codewords during the design phase.
+
+Because channel coding is a design problem, the optimal solutions are well understood for some of the important applications such as Gaussian channel and Binary Symmetric Channel (BSC). Gaussian channel is the most important continuous alphabet channel problem. It assumes that the received signal $y ^ { n }$ is a noisy version of $x ^ { n }$ , where the noise is independent of $x$ and additive with an i.i.d. Gaussian distribution over the $n$ symbols. Surprisingly, when $n \to \infty$ , the optimal codebook turns out to be a collection of codewords that are generated by randomly drawing numbers from a Gaussian distribution. Then, a codeword’s $n$ symbols form an i.i.d. Gaussian distribution (for instance, see Chap. 9 of Cover & Thomas (2012)). BSC is one of the most popular discrete alphabet channel problems, and $x$ can take a value of 0 or 1. The received signal $y$ is a corrupted version of $x$ where it is flipped with a fixed probability. For BSC, Hamming code is a well-known solution where redundant bits are included in $x ^ { n }$ to resist the corruption (for instance, see Chap. 7 of Cover & Thomas (2012)). The correction capability is dependent on the minimum Hamming distance among all pairs of two different codewords.
+
+It would be helpful if the elegant channel coding theories can be applied to the design and control of DNN representation, but unfortunately the representation problem is clearly different from the channel coding problem. First of all, a learning problem does not have a fixed and known channel $p ( y ^ { n } | x ^ { n } )$ . Secondly, we can design and control the DNN model to use, but we do not have the luxury of explicitly designing codebook. Therefore, the representations can be formed in any way that is possible.
+
+Nonetheless, we can attempt to gain insights and ideas from the established coding theory. In this work, we first recognize that the optimal solution to Gaussian channel problem has i.i.d. Gaussian codewords. Although it is unclear if forcing representations of a layer to have an i.i.d. Gaussian property will be helpful, we experiment the idea by expanding known penalty regularization strategies to include L1, variance, and covariance. L1 and covariance (Cogswell et al., 2016) have been studied before (individually), but with our best knowledge, variance of a unit (neuron) and using a combination of them have not been considered in the literature. Secondly, we recognize that only a single codeword is assigned to a message (label for learning problems) for a well designed codebook. When this idea is applied to learning problems via penalty regularization, the penalty term needs to be applied per-class such that we can shape the codeword of each label. Note that almost all of the existing penalty regularization strategies have been applied to all classes together. Thirdly, we recognize that Gaussian codebook and Hamming codebook are fundamentally different. A Gaussian codebook uses continuous alphabets in an uncorrelated manner over $n$ symbols, but Hamming codebook uses only binary values (0 and 1). With the difference, it is inevitable for Gaussian code to utilize long codewords (very large $n$ ) and probabilistically guarantee pair-wise distance, while it is essential for Hamming code to utilize carefully designed vector-space structures (orthogonality, null space, etc.) using relatively short codewords. Because we are often interested in a relatively small number of neurons for representations, we consider a regularization strategy where each label’s activation for a unit is ‘hardened’ (by cw-VR regularizer that is introduced later) such that the representation vector is closer to a binary codeword than an i.i.d. Gaussian codeword.
+
+# 1.1 RELATED WORKS
+
+# Regularization
+
+The classical regularizers apply L2 (Hoerl & Kennard, 1970) and L1 (Tibshirani, 1996) penalties to the weights of models, and they are widely used for DNN as well. Wen et al. (2016) extended L1 regularizer by using group lasso to regularize the structures of DNN (i.e., filters, channels, filter shapes, and layer depth). Regularization has been applied to representations, too. Srivastava et al. (2014) devised dropout that randomly applies activation masking over the neurons. While dropout is applied in a multiplicative manner, Glorot et al. (2011) used L1 penalty regularization on the activations to encourage sparse representations. XCov proposed by Cheung et al. (2014) minimizes the covariance between autoencoding units and label encoding units of the same layer such that representations can be disentangled. DeCov, developed by Cogswell et al. (2016), is also a penalty regularizer and it minimizes the off-diagonals of a layer’s representation covariance matrix. DeCov reduces co-adaptation of units by encouraging units to be decorrelated. It is called CR (Covariance Regularizer) in this study for consistent naming. Statistics over mini-batch samples or in-layer activations have been used for regularization, too. Batch normalization proposed by Ioffe & Szegedy (2015) exploits mini-batch statistics to normalize activations. It was developed to accelerate training speed by preventing internal covariate shift, but it was also found to be a useful regularizer. In line with batch normalization, weight normalization, developed by Salimans & Kingma (2016), uses mini-batch statistics to normalize weight vectors. Layer normalization proposed by Ba et al. (2016) is a RNN version of batch normalization, where they compute the mean and variance used for normalization from all of the summed inputs to the neurons in a layer on a single training case. There are many other publications on DNN regularization techniques, but we still do not have a sufficient understanding on how they really work. A recent work by Zhang et al. (2016) shows that the traditional concept of controlling generalization error by regularizing the effective capacity cannot be applied to DNN.
+
+# Class-wise Learning
+
+True class information is available for supervised learning problems. Traditionally, the class information has been used only for evaluating the correctness of predictions and the relevant cost function terms. Some of the recent works, however, have adopted the class-wise concept in the learning algorithm itself. In those works, class information is used as a switch or for emphasizing the discriminative aspects over different classes. As an example, Li et al. (2008) proposed a kernel learning method using class-wise information to model the manifold structure. They modify locality preserving projection to be class dependent. Jiang et al. (2011) added label consistent regularizers for learning a discriminative dictionary. As for DNN, a recent work by Liao et al. (2016) used a clustering based regularization that encourages parsimonious representations. In their work, similar representations in sample, spatial, and channel dimensions are clustered and used for regularization such that similar representations are encouraged to become even more similar. While their work can be applied to unsupervised as well as supervised problems, our work utilizes a much simpler method of directly using class labels during training to avoid $\mathbf { k }$ -means like clustering. Another recent work by Belharbi et al. (2017) directly uses class labels to encourage similar representations per class as in our work. Their work, however, is based on sum of pair-wise distances among the mini-batch samples of the same labels, and therefore computationally more demanding. The cw-VR (classwise Variance Regularizer) and cw-CR (class-wise Covariance Regularizer) in this work are very simple penalty regularizers that were designed for the purpose of controlling statistical properties of representations.
+
+# 2 THREE STATISTICAL PROPERTIES AND CLASS-WISE REGULARIZATION
+
+For channel coding problems, we can characterize the statistical properties of optimal codewords as discussed in Section 1. Our goal is to make DNN representation vectors to have such statistical properties and analyze their effects. Because an explicit design and control of representation vector is not possible for the learning problems, we utilize penalty regularizers to manipulate the statistical properties instead.
+
+# 2.1 THREE STATISTICAL PROPERTIES
+
+Three of the most basic statistical properties are considered in this work - sparsity, variance, and covariance. Sparsity over layer $l$ ’s representation vector $\mathbf { h } _ { l }$ has been extensively studied in the literature. For variance, we are referring to the variance of a unit’s activation values over mini-batch samples. When the variance is forced to be very small, the activation value needs to be close to the sample mean for all labels, and therefore the unit loses its discriminative power over multiple labels. While this is undesirable, regularizing variance turns out to be meaningful because the cross-entropy cost function prevents the variance becoming zero, and a healthy compromise can be achieved between cross-entropy and variance terms. This is similar to the situation of classic weight regularization, where the weights actually never become zero by regularization. For covariance, we calculate pair-wise covariance over the unit activations of a layer. When covariance is evaluated to be large for a pair of units (neurons) in the same layer, it indicates that the two are strongly correlated. This is undesirable if we are pursuing i.i.d. property over unit activations, and having a regularizer to control the level of correlation can be useful.
+
+# 2.2 CLASS-WISE REGULARIZATION
+
+To pursue statistical properties for each class, we adopt the concept of class-wise learning.
+
+For instance, it is undesirable if the variance becomes exactly zero for a unit’s activation as mentioned above. Variance of zero for a class, however, can be desirable because it simply states that a consistent activation value will be observed over all samples with the same class label. Note that overall variance over all labels can be still large while class-wise variance is zero - as long as interclass difference exists, the overall variance will not be zero. We combine this concept of class-wise regularization to the three concepts of sparsity, variance, and covariance. Analytical formulations can be found in the following section.
+
+# 3 PENALTY LOSS FUNCTIONS
+
+In this section, we provide the model for calculating basic statistics and formulate the penalty loss functions that are used for regularization.
+
+# 3.1 BASIC STATISTICS
+
+For layer $l$ , the output activation vector of a linear filter followed by ReLU is defined as $\mathbf { h } _ { l } \ =$ $\mathrm { m a x } ( \bar { \mathbf { W } } _ { l } ^ { \top } \mathbf { h } _ { l - 1 } + \mathbf { b } _ { l } ^ { \top } , 0 )$ . Because we will be focusing on layer $l$ for most of the explanations, we drop the layer index and $\mathbf { h }$ is used to indicate $\mathbf { h } _ { l }$ instead. Then, $h _ { i }$ is the ith element of $\mathbf { h }$ (i.e. activation of $i$ th unit), and $w _ { k i }$ is the $( k , i )$ element of $\mathbf { W }$ .
+
+To use statistical properties of representations, we define mean of unit $i$ , $\mu _ { i }$ , and covariance between unit $i$ and unit $j , c _ { i , j }$ , using the $N$ samples in each mini-batch.
+
+$$
+\begin{array} { l } { \displaystyle \mu _ { i } = \frac { 1 } { N } \sum _ { n } h _ { i , n } } \\ { \displaystyle c _ { i , j } = \frac { 1 } { N } \sum _ { n } ( h _ { i , n } - \mu _ { i } ) ( h _ { j , n } - \mu _ { j } ) } \end{array}
+$$
+
+Here, $h _ { i , n }$ is the activation of unit $i$ for nth sample in the mini-batch. From equation (2), variance of $i$ unit can be written as below.
+
+$$
+\nu _ { i } = c _ { i , i }
+$$
+
+When class-wise statistics need to be considered, we choose a single label $m$ and evaluate mean, covariance, and variance using only the data samples with label $m$ in the mini-batch.
+
+$$
+\begin{array} { l } { \displaystyle \mu _ { i } ^ { m } = \frac { 1 } { \vert S _ { m } \vert } \sum _ { n \in S _ { m } } h _ { i , n } } \\ { \displaystyle c _ { i , j } ^ { m } = \frac { 1 } { \vert S _ { m } \vert } \sum _ { n \in S _ { m } } ( h _ { i , n } - \mu _ { i } ^ { m } ) ( h _ { j , n } - \mu _ { j } ^ { m } ) } \\ { \displaystyle \nu _ { i } ^ { m } = c _ { i , i } ^ { m } } \end{array}
+$$
+
+Here, $S _ { m }$ is the set containing indexes of the samples whose label is $m$ , and $| S _ { m } |$ is the cardinality of the set $S _ { m }$ .
+
+# 3.2 PENALTY LOSS FUNCTIONS
+
+Using the notations in Section 3.1, the loss functions and their derivatives can be derived and summarized as in Table 1. L1-weight and L2-weight are well-known, and they impose L1 and L2 penalties on the weights, respectively. The rest in the table apply penalties on the representation. L1-rep is similar to L1-weight, but the penalty is applied to the representation h. Obviously, L2 can also be applied to the representation, but it is excluded in this study because it tends to perform worse than L1 when applied to representation. VR (Variance Regularization) calculates variance of each unit’s activation over mini-batch dataset and uses the calculated value as the penalty. CR (Cross-covariance Regularization) uses off-diagonal terms of the mini-batch covariance matrix of activations as the penalty term. As mentioned earlier, CR in this work is the same as DeCov presented by Cogswell et al. (2016), but we use the term CR for the consistency of naming. As in DeCov, we subtract variance terms and consider cross-covariance terms only (see penalty loss function in Table 1). cw-VR and cw-CR are similar to VR and CR, respectively, except that the values are calculated for each class using the mini-batch samples with the same class label. cw-L1-rep can be defined, but its penalty loss function turns out to be the same as L1-rep’s loss function. Therefore, cw-L1-rep is excluded in this study.
+
+# Interpretation of derivatives
+
+While the penalty functions were chosen from the three distinct statistical properties and class-wise concept, their derivatives show that some of them are closely related. For the derivatives of VR and
+
+Table 1: Penalty loss functions of regularizers   
+
+<table><tr><td>Penalty loss function</td><td>Derivatives</td></tr><tr><td>ΩL1-weight =∑∑ |wkil ki</td><td>0SL1-weight = sign(Wki) wki</td></tr><tr><td>ΩL2-weight =∑∑ wi</td><td>L2-weight = 2Wki dwki</td></tr><tr><td>ki ΩL1-rep =∑∑Ihinl</td><td>SL1-rep = sign(hi,n) dhi，n</td></tr><tr><td>n i ΩvR =Mui</td><td>0vR 2 (hin-μi) Ohi，n N</td></tr><tr><td>i =∑∑(ci,j）²-∑(ui）² ΩCR</td><td>0ScR 2 £ Ci,j(hj，n-μj) Ohi，n N</td></tr><tr><td>i i -∑∑ Ωcw-VR u</td><td>ji 0Scw-VR 2 (hi，n- μm),n ∈ Sm Ohi，n |Sml</td></tr><tr><td>m i Ωcw-CR =∑(∑∑(ci,j)²-∑(ui)²)</td><td>0Scw-CR 2 £ c(hjn-μ），n ∈ Sm dhi，n |Sml ji</td></tr></table>
+
+CR, it can be observed that they have similar structures. If VR’s derivative $\frac { \partial \Omega _ { V R } } { \partial h _ { i , n } }$ becomes zero for all $i$ , then CR’s derivative $\frac { \partial \Omega _ { C R } } { \partial h _ { i , n } }$ becomes zero as well. The vice versa does not hold, but the effects of VR and CR can be expected to be similar or at least related to each other for the learning process. In the same way, the relationship between cw-VR and cw-CR is the same as the relationship between VR and CR. Therefore, we can expect cw-VR and cw-CR to have similar effects, too. On the other hand, the derivative of L1-rep has a distinct formulation, and it can be expected to have a distinct effect on learning.
+
+There is another important effect that is not necessarily obvious from the derivative formulations. For L1-weight and L2-weight, the derivatives are dependent on the weights $w _ { k i }$ only, and they are independent of the activations $h _ { i , n }$ . Therefore, the weights need to become smaller to reduce the regularization penalty. For the other five representation regularizers, their derivatives are all dependent on activation $h _ { i , n }$ . So, a simple way to reduce the regularization penalties is to scale the activations to small values (instead of satisfying the balances among the terms in the equation to reach zero gradients and force the desired statistical properties). This scaling will not have any effect on prediction output as long as all the elements of $\bar { \mathbf { h } } ^ { l }$ are scaled together to $\alpha \mathbf { h } ^ { l }$ - the last softmax layer works as a normalization function for the output layer, and therefore the cross-entropy penalty term is not affected by such a scaling. This means that there is a chance for the learning algorithm to squash activations just so that representation regularization terms can be ignored. As we will see later, indeed activation squashing happens by learning, but the desired statistical properties are still sufficiently enforced. Nonetheless, it must be possible to design better penalty regularizers that are immune to activation squashing, and such regularizers might be much more effective for manipulating statistical properties of representations.
+
+# 4 EXPERIMENTS - MNIST
+
+In this section, we consider ten regularization strategies and compare them using the MNIST dataset (LeCun et al., 1998). We use a Multilayer Perceptron (MLP) with five hidden fully connected layers and an output layer. Each hidden layer has 100 units with Rectified Linear Unit (ReLU) activation function, and the output layer consists of 10 softmax units. All experiments (in this work) were carried out using TensorFlow 1.3.
+
+Table 2: Error performance of popular regularizers (MNIST)   
+
+<table><tr><td rowspan="2">Layer</td><td rowspan="2">Baseline</td><td colspan="2">Penalty on weight</td><td colspan="2">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>All</td><td>3.06±0.15</td><td>2.90±0.08</td><td>2.96±0.09</td><td>4.08±0.06</td><td>2.69±0.06</td></tr></table>
+
+Table 3: Error performance of representation regularizers (MNIST)   
+
+<table><tr><td rowspan="2">Layer</td><td colspan="3">All classes</td><td colspan="2">Class-wise</td></tr><tr><td>L1-rep</td><td>VR</td><td>CR</td><td>cw-VR</td><td>cw-CR</td></tr><tr><td>Output</td><td>2.61±0.04</td><td>2.67±0.15</td><td>2.62±0.07</td><td>2.56±0.02</td><td>2.55±0.08</td></tr><tr><td>Layer 5</td><td>2.61±0.11</td><td>2.70±0.03</td><td>2.67±0.04</td><td>2.63±0.05</td><td>2.61±0.06</td></tr><tr><td>Layer 4</td><td>2.75±0.05</td><td>2.89±0.11</td><td>2.69±0.13</td><td>2.67±0.12</td><td>2.71±0.04</td></tr><tr><td>Layer 3</td><td>3.35±0.08</td><td>3.16±0.09</td><td>3.11±0.13</td><td>3.22±0.06</td><td>3.22±0.06</td></tr><tr><td>Layer 2</td><td>3.40±0.11</td><td>3.15±0.21</td><td>3.01±0.10</td><td>3.14±0.10</td><td>3.24±0.11</td></tr><tr><td>Layer 1</td><td>4.31±0.14</td><td>2.98±0.09</td><td>3.13±0.09</td><td>3.25±0.04</td><td>3.14±0.03</td></tr></table>
+
+Table 4: Error performance of representation regularizers - multiple layers (MNIST)   
+
+<table><tr><td></td><td>L1-rep</td><td>VR</td><td>CR</td><td>cw-VR</td><td>cw-CR</td></tr><tr><td>Output</td><td>2.61±0.04</td><td>2.67±0.15</td><td>2.62±0.07</td><td>2.56±0.02</td><td>2.55±0.08</td></tr><tr><td>Output, 5</td><td>2.48±0.12</td><td>2.67±0.11</td><td>2.43±0.08</td><td>2.46±0.07</td><td>2.55±0.10</td></tr><tr><td>Output, 5, 4</td><td>2.78±0.11</td><td>2.58±0.06</td><td>2.80±0.12</td><td>2.53±0.07</td><td>2.48±0.07</td></tr><tr><td>Output, 5, 4, 3</td><td>2.79±0.10</td><td>2.78±0.08</td><td>2.83±0.14</td><td>2.80±0.10</td><td>2.72±0.04</td></tr><tr><td>Output, 5,4, 3, 2</td><td>3.19±0.10</td><td>2.91±0.13</td><td>2.77±0.07</td><td>2.90±0.10</td><td>2.75±0.07</td></tr><tr><td>All</td><td>3.26±0.09</td><td>2.86±0.07</td><td>2.80±0.08</td><td>2.83±0.07</td><td>2.85±0.12</td></tr></table>
+
+# 4.1 PERFORMANCE RESULTS
+
+For each regularization term, the level of regularization was determined by tuning the penalty loss weight using a validation dataset and a grid search. Then, we trained each model five-times and calculated the test error performance as the average and one standard deviation over the five performance results. In Table 2 and Table 3, the results show that representation regularizers outperform the popular regularizers and that the representation strategies perform better when applied to upper layers of DNN. Interestingly, the best performance is achieved by applying representation regularization to the output layer as shown in Table 3. This might be because the regularizer directly affects only the regularizing layer and the layers below, or because manipulating statistical properties is more effective for the higher layer representations that have stronger or codeword-like structures. To better understand the effect of a layer, multiple layer results are shown in Table 4. The best performance is achieved when output layer is regularized together with one or two upper hidden layers. Among all the results in the three tables, CR performs best and achieves $2 . 4 3 \%$ of error.
+
+# 4.2 STATISTICAL PROPERTIES OF 10 REGULARIZATION STRATEGIES
+
+We use nine metrics to compare the statistical properties of the ten regularization strategies. Among the nine metrics, first seven of them are calculated by directly evaluating the penalty loss functions shown in Table 1. The raw evaluation values, however, are difficult to interpret because they have different scales. So, we normalize the metrics as following (see the raw evaluation values shown in Table 10 and Table 11). First, square-root is applied to L2-weight, VR, and CR because their units are quadratic, and square-root of square-root is applied to cw-VR and cw-CR because their units are quartic. Then, all the metrics of each regularizer are divided by the regularizer’s own $\sqrt { \Omega _ { L 2 - w e i g h t } }$ such that all are normalized with respect to its 2-norm weight values. Finally, all the metrics are normalized by baseline’s metrics and 100 is multiplied such that we can focus on the relative change in percentage compared to the baseline’s metrics. The remaining two metrics are the average number of activated classes per unit as the measure of sparsity and ratio of dead units, and they are explained in Appendix C. $\Omega _ { L 1 - w e i g h t }$ and $\Omega _ { L { 2 } - w e i g h t }$ are calculated from the weights of all layers excluding biases, and the others are calculated from layer 5’s activations using test dataset.
+
+Table 5: Evaluation of statistical properties (layer 5) - popular strategies   
+
+<table><tr><td rowspan="2">Metric</td><td rowspan="2">Baseline</td><td colspan="2">Penalty on weight</td><td colspan="2">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>ΩL1-weight (all)</td><td>100.00</td><td>88.05</td><td>92.25</td><td>99.14</td><td>84.82</td></tr><tr><td>ΩL2-weight (all)</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td></tr><tr><td>ΩL1-rep</td><td>100.00</td><td>115.28</td><td>110.26</td><td>36.11</td><td>16.94</td></tr><tr><td>ΩvR</td><td>100.00</td><td>113.97</td><td>109.58</td><td>61.18</td><td>27.69</td></tr><tr><td>ΩcR</td><td>100.00</td><td>111.55</td><td>107.51</td><td>39.35</td><td>5.80</td></tr><tr><td>Ωcw-VR</td><td>100.00</td><td>114.08</td><td>109.68</td><td>72.91</td><td>50.50</td></tr><tr><td>Ωcw-CR</td><td>100.00</td><td>112.68</td><td>108.55</td><td>78.49</td><td>20.54</td></tr><tr><td>Aug_Act_Class</td><td>5.24</td><td>5.54</td><td>5.35</td><td>4.60</td><td>2.48</td></tr><tr><td>Ratio_Dead_Unit</td><td>14%</td><td>5%</td><td>9%</td><td>0%</td><td>1%</td></tr></table>
+
+Table 6: Evaluation of statistical properties (layer 5) - representation regularizers   
+
+<table><tr><td rowspan="2">Metric</td><td colspan="3">All classes</td><td colspan="2">Class-wise</td></tr><tr><td>L1-rep</td><td>VR</td><td>CR</td><td>cw-VR</td><td>cw-CR</td></tr><tr><td>ΩL1-weight (all)</td><td>93.08</td><td>96.42</td><td>95.83</td><td>86.85</td><td>84.14</td></tr><tr><td>ΩL2-weight (all)</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td></tr><tr><td>ΩL1-rep</td><td>1.07</td><td>9.16</td><td>9.73</td><td>3.41</td><td>5.49</td></tr><tr><td>ΩvR</td><td>7.77</td><td>9.24</td><td>9.42</td><td>3.91</td><td>5.28</td></tr><tr><td>ΩCR</td><td>0.33</td><td>0.64</td><td>0.63</td><td>0.15</td><td>0.27</td></tr><tr><td>Ωcw-VR</td><td>19.85</td><td>28.12</td><td>29.61</td><td>11.25</td><td>14.27</td></tr><tr><td>Ωcw-CR</td><td>3.69</td><td>6.79</td><td>7.15</td><td>1.66</td><td>2.37</td></tr><tr><td>Avg_Act_Class</td><td>0.23</td><td>5.12</td><td>5.38</td><td>4.14</td><td>5.29</td></tr><tr><td>Ratio_Dead_Unit</td><td>77%</td><td>9%</td><td>5%</td><td>23%</td><td>7%</td></tr></table>
+
+We can observe two distinct groups of regularizers by investigating Table 5 and Table 6. We can observe that the representation regularizers have much smaller values for the representation metrics. This is because the representation regularizers squash activations in the way described in Section 3.2. As mentioned in Section 3.2, VR and cw-VR are related to CR and cw-CR, respectively. We can see that their values of metrics are similar to each other. Despite this similarity of the five representation regularization, L1-rep and cw-VR have unique characteristics. L1-rep obviously enforces sparsity and causes much more dead units than the others. The regularizer cw-VR always shows the smallest metric values among four strategies (VR, CR, cw-VR, and cw-CR). This can be an evidence of the four regularizers’ close relationship. The metric values of dropout and batch normalization (BN) are located somewhere between baseline and representation regularizers. They cause similar effects on representation metrics as the representation regularizers, but much less effect are observed. It is also interesting to note that both dropout and BN have only $0 \sim 1 \%$ of dead units (neurons). Dropout and BN are implicit methods in the sense that they do not target any particular statistical property, but they certainly seem to have distinct effects compared to the other regularizers.
+
+# 4.3 VISUALIZATION OF REPRESENTATIONS
+
+Due to activation squashing, metrics of statistical properties can become misleading. Therefore, we visualize the representation of Layer 5 to more intuitively understand the statistical properties that are affected by the regularizers. Samples for three regularizers are shown in Figure 1 and Figure 2, and all figures for the ten regularizers are shown in appendix (Figure 3 and Figure 4).
+
+# Histogram of a single unit
+
+We first visualize the distribution of activation per unit in Figure 1 to observe sparsity and variance properties. Activation histograms were generated by using 10,000 test data, and each color corresponds to a different class. Since activations are generated as the output of ReLU activation function, many have zero value that can distort the histogram. We, therefore, excluded zeros from activations when drawing the histogram plots. In Figure 1(a), it can be seen that baseline has a large class-wise variance and inter-class overlaps. The histogram of cw-VR in (b), however, shows the effect of separating the classes because class-wise variance is significantly reduced. For each class, the activation is ‘hardened’. L1-rep in (c) can be confirmed to have only one class that is activated, and this confirms the sparsity. As described in Table 6, Avg Act Class of L1-rep is close to zero, so most of its histograms show very few active samples.
+
+![](images/eb2543fb65c0f8b3c3294b37a3bd7808d7ac7c0a603d8eb5c2a1b7bad22a2949.jpg)  
+Figure 1: Histogram of a sample nueron’s activation values over test dataset. The sample was chosen from $\mathbf { h } _ { 5 }$ . Compared to baseline, cw-VR clearly shows non-overlapping distributions for different labels. L1-rep shows a similar distribution shape as in the baseline, but only a single label is activated in this example. Best viewed in color.
+
+# Scatter plot of a pair of units
+
+To show the relationship between two representation units, we randomly chose two units from a representation vector $\mathbf { h } _ { 5 }$ and drew a scatter plot of their activation values for the test dataset. As shown in Figure 2, baseline shows a modest linearity, which is consistent with the high covariance value. Since CR in (b) reduces cross-covariance per unit, it can be seen that overall linearity is significantly reduced compared to the baseline and the randomly chosen pair of units becomes almost independent. In the same way, cw-CR has reduced class-wise cross-covariance. Furthermore, its class-wise variance is small and thus end up having small ball-shaped concentrations of points.
+
+![](images/ea64bbe4ead1da5e497615fc4db2dae317c28ae55693fc4472086360c1d21589.jpg)  
+Figure 2: Scatter plot of activation values of randomly chosen two units from $\mathbf { h } _ { 5 }$ . Compared to baseline, CR has clearly less correlation indicating less co-adaptation. cw-CR also shows low coadaptation, but it has smaller ball shapes per label because of the low class-wise variance. Best viewed in color.
+
+# 5 EXPERIMENTS - CIFAR-10/100
+
+While performance improvement is not the primary focus of this work, we provide additional test results with performance evaluations and show that the representation regularizers are useful for pushing the accuracy performance to the next level. In particular, we provide additional test results for CIFAR-100 and CIFAR-10 datasets (Krizhevsky & Hinton, 2009). For CIFAR-100, we have chosen a toy CNN architecture to confirm performance improvement of representation regularizers. Concurrently using two of the regularizers is experimented as well. For CIFAR-10, we have tested representation regularizers using Residual Network (ResNet) that is known as one of the best performing deep neural networks for image data.
+
+Table 7: Error performance of regularizers (CIFAR-100)   
+
+<table><tr><td colspan="2">Regularizer</td><td>Train error</td><td>Test error</td></tr><tr><td>Baseline</td><td>None</td><td>25.50</td><td>56.02</td></tr><tr><td rowspan="2">Penalty on weight</td><td>L1-weight</td><td>18.16</td><td>55.99</td></tr><tr><td>L2-weight Dropout (fc)</td><td>33.75 28.02</td><td>54.93 55.28</td></tr><tr><td rowspan="2" colspan="2">Implicit method</td><td>Dropout (all) 79.28 28.28</td><td>80.08 55.33</td></tr><tr><td>BN (fc) BN (all) L1-rep 98.93</td><td>8.63 57.82 99.00</td></tr><tr><td rowspan="6">Penalty on representation</td><td rowspan="2">Single</td><td>VR CR cw-VR</td><td>27.02 53.66</td></tr><tr><td>33.24 22.85</td><td>54.67 54.15</td></tr><tr><td>cW-CR VR+CR</td><td>27.84</td><td>53.78</td></tr><tr><td></td><td>13.88</td><td>54.68</td></tr><tr><td>VR+cw-VR</td><td>19.43</td><td>56.12</td></tr><tr><td>VR+cw-CR</td><td></td><td></td></tr><tr><td rowspan="8">Combination</td><td></td><td>28.53</td><td>54.94</td></tr><tr><td>CR+cw-VR</td><td>21.11</td><td></td></tr><tr><td>CR + cw-CR</td><td></td><td>53.30</td></tr><tr><td>cw-VR+ cW-CR</td><td>18.05 25.77</td><td>54.75</td></tr><tr><td></td><td>98.93</td><td>55.64</td></tr><tr><td>L1-rep + VR</td><td></td><td>99.00</td></tr><tr><td>L1-rep + CR</td><td>98.93</td><td>99.00</td></tr><tr><td>L1-rep + cw-VR L1-rep + cw-CR</td><td>98.93 98.93</td><td>99.00 99.00</td></tr></table>
+
+# 5.1 COMBINING MULTIPLE STRATEGIES: CIFAR-100
+
+We use a toy CNN network for experimenting with CIFAR-100. The CNN network consists of four convolution layers and a fully connected layer, all with 100 hidden units. ReLU is used as the activation function. The second, third, and fourth convolution layers are followed by a max pooling layer. The last 10,000 instances of 50,000 training data were used as the validation data. Using the validation data, validation performance was evaluated for the regularizer weight values of $\{ 0 . 1 , \bar { 0 } . 0 1$ , $0 . 0 0 1 , 0 . 0 0 0 1 \}$ . The best weight value was found for each regularizer, and the test performance was evaluated for the fixed weight values. For representation regularizers, regularization was applied to the fully connected layer. The performance results are shown in Table 7. From the table, it can be seen that the test error is improved from baseline $5 6 . 0 2 \%$ to $5 3 . 6 6 \%$ by using a single regularizer (VR) and to $5 3 . 3 0 \%$ by using two regularizers (CR and cw-VR). Therefore, $2 . 7 2 \%$ of improvement is achieved by the best performing regularizer combination. Aside from the performance improvement, it is interesting to observe that L1-rep consistently fails to train for the CIFAR-100 data. With 100 labels, too much sparsity might hurt the performance. This is a plausible hypothesis considering that we have only 100 neurons to encode 100 labels. A shared use of neurons over multiple classes might be a better direction to pursue. In general, the relationship between the number of labels and the desired statistical properties of representation remains a topic to be studied.
+
+# 5.2 PERFORMANCE IMPROVEMENT OF RESNET-32
+
+ResNet was first proposed by He et al. (2016). ResNet consists of multiple basic blocks that are serially connected, and shortcut connections to force residuals to be calculated. We apply five regularization strategies without modifying the ResNet-32 architecture. Regularization was applied to the output layer only. Experimental results in Table 8 show that performance is improved over the state-of-the-art ResNet-32 model, and cw-VR shows the best performance. This indicates that representation regularizers are compatible with ResNet, and most likely also with other state-of-the-art models.
+
+Table 8: Error performance of regularizers on ResNet-32 (CIFAR-10)   
+
+<table><tr><td>Model</td><td>He et al.</td><td>Ours</td></tr><tr><td>ResNet-32</td><td>7.51</td><td>7.39</td></tr><tr><td rowspan="3">ResNet-32 +L1-rep ResNet-32 + VR ResNet-32+CR</td><td>7.27</td><td></td></tr><tr><td></td><td>7.22</td></tr><tr><td></td><td>7.27</td></tr><tr><td>ResNet-32+cw-VR</td><td></td><td>7.17</td></tr><tr><td>ResNet-32 + cw-CR</td><td></td><td>7.21</td></tr></table>
+
+# 6 CONCLUSION
+
+In this work, we have investigated five different penalty regularizers for manipulating statistical properties of DNN representations. The regularizers were conceived by examining optimal codewords of well-known channel coding problems, and the three statistical properties of sparsity, variance, and covariance were integrated into the regularizers along with the concept of class-wise regularization. It was found that many statistical properties including cross-covariance, co-adaptation, per-class variance, average number of active class per-unit, and the ratio of dead units can be manipulated. Each regularizer, however, tended to manipulate multiple properties at the same time, making it difficult to manipulate each property individually. While manipulation was shown to be possible and helpful for improving the performance of all three DNN classification problems that were investigated, it is still unclear if any statistical property of representation is generally helpful when strengthened. Due to the complicated nature of learning process where back-propagation affects not only the signal of interest but also other signals and irrelevant noise, it still remains an open question on how to establish procedures that generally improve learning of any deep learning problems.
+
+The contributions of this work can be summarized as follow. First, a complete set of very simple regularizers for controlling sparsity, variance, and covariance of representations was presented. Among them, VR, cw-VR, and cw-CR have been designed and used for the first time and they work very well. The visualizations clearly show that the new regularizers are effective for manipulating statistical properties of representations in new ways. Secondly, by analyzing statistical properties in a quantitative way, we have shown that none of the popular regualrizers works in a distinct way. Even the well-known dropout does not control co-adaptation(covariance) only. In fact, sparsity and class-wise variance are affected together by dropout, and therefore it is difficult to claim if indeed reduction in co-adaptation is why dropout works well. Thirdly, we have provided partial results on which statistical properties can be helpful or harmful for different learning tasks (tasks with more labels, with more complexity, etc.). This part needs to be further investigated to see if general rules can be derived.
+
+# ACKNOWLEDGMENTS
+
+To be added.
+
+# REFERENCES
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Soufiane Belharbi, Clement Chatelain, Romain Herault, and Sebastien Adam. Neural networks regularization through invariant features learning. arXiv preprint arXiv:1709.01867, 2017.
+
+Brian Cheung, Jesse A Livezey, Arjun K Bansal, and Bruno A Olshausen. Discovering hidden factors of variation in deep networks. arXiv preprint arXiv:1412.6583, 2014.
+
+Michael Cogswell, Faruk Ahmed, Ross Girshick, Larry Zitnick, and Dhruv Batra. Reducing overfitting in deep networks by decorrelating representations. 2016.
+
+Thomas M Cover and Joy A Thomas. Elements of information theory. John Wiley & Sons, 2012.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 315–323, 2011.
+
+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.
+
+Arthur E Hoerl and Robert W Kennard. Ridge regression: Biased estimation for nonorthogonal problems. Technometrics, 12(1):55–67, 1970.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+
+Zhuolin Jiang, Zhe Lin, and Larry S Davis. Learning a discriminative dictionary for sparse coding via label consistent $\mathbf { k }$ -svd. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1697–1704. IEEE, 2011.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Jun-Bao Li, Jeng-Shyang Pan, and Shu-Chuan Chu. Kernel class-wise locality preserving projection. Information Sciences, 178(7):1825–1835, 2008.
+
+Renjie Liao, Alex Schwing, Richard Zemel, and Raquel Urtasun. Learning deep parsimonious representations. In Advances in Neural Information Processing Systems, pp. 5076–5084, 2016.
+
+Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014.
+
+Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society. Series B (Methodological), pp. 267–288, 1996.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+# APPENDIX
+
+A PERFORMANCE OF POPULAR REGULARIZERS WHEN APPLIED TO EACH LAYER
+
+Table 9: Error performance of popular regularizers - applied to each layer   
+
+<table><tr><td rowspan="2">Layer</td><td rowspan="2">Baseline</td><td colspan="2">Penalty on weight</td><td colspan="2">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>All</td><td rowspan="6">3.06±0.15</td><td>2.90±0.08</td><td>2.96±0.09</td><td>4.08±0.06</td><td>2.69±0.06</td></tr><tr><td>Output</td><td>3.02±0.15</td><td>2.96±0.06</td><td>2.99±0.18</td><td>2.97±0.08</td></tr><tr><td>Layer 5</td><td>2.98±0.05</td><td>2.99±0.13</td><td>2.80±0.08</td><td>3.04±0.09</td></tr><tr><td>Layer 4</td><td>2.98±0.08</td><td>2.98±0.09</td><td>2.67±0.05</td><td>2.84±0.15</td></tr><tr><td>Layer 3</td><td>3.04±0.09</td><td>3.03±0.18</td><td>2.67±0.16</td><td>2.94±0.13</td></tr><tr><td>Layer 2</td><td>2.91±0.05</td><td>2.76±0.16</td><td>2.70±0.08</td><td>2.84±0.16</td></tr><tr><td>Layer 1</td><td></td><td>2.93±0.05</td><td>2.52±0.10</td><td>3.07±0.07</td><td>2.58±0.07</td></tr></table>
+
+# B EVALUATION OF STATISTICAL PROPERTIES
+
+Table 10: Evaluation of statistical properties (raw) - popular regularizers   
+
+<table><tr><td rowspan="2">Property</td><td rowspan="2">Baseline</td><td colspan="2"> Penalty on weight</td><td colspan="2">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>ΩL1-weight (all)</td><td>9795.03</td><td>7504.60</td><td>8220.21</td><td>9461.52</td><td>9488.60</td></tr><tr><td>ΩL2-weight (all)</td><td>607.46</td><td>459.85</td><td>502.71</td><td>576.60</td><td>792.24</td></tr><tr><td>ΩL1-rep</td><td>3.24 × 106</td><td>3.25 × 106</td><td>3.25 × 106</td><td>1.14 × 106</td><td>6.27 ×105</td></tr><tr><td>SvR</td><td>865.69</td><td>851.24</td><td>860.34</td><td>307.64</td><td>86.59</td></tr><tr><td>ScR</td><td>58178.00</td><td>54803.10</td><td>55650.20</td><td>8551.84</td><td>255.31</td></tr><tr><td>Ωcw-VR</td><td>2398.03</td><td>2327.79</td><td>2377.46</td><td>610.58</td><td>265.46</td></tr><tr><td>Ωcw-CR</td><td>63726.20</td><td>58891.60</td><td>60610.20</td><td>21795.60</td><td>193.26</td></tr></table>
+
+Table 11: Evaluation of statistical properties (raw) - representation regularizers   
+
+<table><tr><td rowspan="2">Property</td><td colspan="3">All classes</td><td colspan="2">Class-wise</td></tr><tr><td>L1-rep</td><td>VR</td><td>CR</td><td>Cw-VR</td><td>CW-CR</td></tr><tr><td>ΩL1-weight (all)</td><td>9975.62</td><td>9732.16</td><td>9826.06</td><td>9843.84</td><td>9772.89</td></tr><tr><td>ΩL2-weight (all)</td><td>727.22</td><td>645.03</td><td>665.57</td><td>813.20</td><td>853.98</td></tr><tr><td>ΩL1-rep</td><td>38183.20</td><td>3.06 × 105</td><td>3.39 × 105</td><td>1.28 × 105</td><td>2.11 × 105</td></tr><tr><td>ΩvR</td><td>6.26</td><td>7.85</td><td>8.43</td><td>1.78</td><td>3.40</td></tr><tr><td>ScR</td><td>0.80</td><td>2.55</td><td>2.55</td><td>0.19</td><td>0.64</td></tr><tr><td>Ωcw-VR</td><td>5.34</td><td>16.91</td><td>22.15</td><td>0.69</td><td>1.97</td></tr><tr><td>Ωcw-CR</td><td>0.17</td><td>1.53</td><td>2.00</td><td>8.83 × 10-3</td><td>0.04</td></tr></table>
+
+# C METRICS
+
+# Activated class and dead unit
+
+ReLU’s output becomes positive when the input has a positive value. In this work, we say a class is activated for a nueron if the probability of the neuron’s output being positive is above a threshold for the given class. We use the entire test dataset to check the probability, and threshold value of 0.9 is used for the evaluations. If many classes are activated for a neuron, it indicates that the neuron is used for representations of many classes. On the other hand, if only a single class is activated for a neuron, it indicates that the neuron is used for representations of only one class and kept zero for all the other classes. When the number of activated class is zero for a neuron, it indicates that the neuron does not carry any information and may be ignored. Such a neuron is called a dead unit. The equations below show how to calculate if a class $m$ is activated for a nueron $i , I$ is an indicator function, and $N _ { u }$ is the number of units in the layer.
+
+$$
+N u m \_ A c t \_ I n C l a s s ( i , m ) = \sum _ { n \in S _ { m } } I ( h _ { i , n } > 0 )
+$$
+
+$$
+A c t \_ C l a s s ( i , m ) = I ( \frac { N u m \_ A c t ( i , m ) } { | S _ { m } | } > t h r e s h o l d )
+$$
+
+# Average number of activated classes
+
+The number of activated classes can be calculated for each unit. Then, the average number of activated classes can be calculated over all units in the same layer. When $A v g \_ A c t \_ C l a s s$ is large for a regularizer, it means the regularizer tends to encourage many units to be used for representations. If the value is small, it indicates the regularizer makes only a small number of units to be coded in positive values for the representation.
+
+$$
+N u m . A c t . C l a s s ( i ) = \sum _ { m } A c t . C l a s s ( i , m )
+$$
+
+$$
+A v g \_ A c t \_ C l a s s = \frac { \sum _ { i } N u m \_ A c t \_ C l a s s ( i ) } { N _ { u } }
+$$
+
+# Ratio of dead units
+
+Typically, ’dead neuron’ is widely used to represent neurons that are not activated - output is zero all the time over all classes. To extend the concept of ‘activated class’, we define $A l l \_ C l a s s \_ D e a d ( i )$ and Ratio Dead Unit as below. When Ratio Dead Unit is large, it indicates many of the neurons can be removed without affecting the representation.
+
+$$
+A l l _ { - } C l a s s \_ D e a d ( i ) = I ( \sum _ { m } A c t _ { - } C l a s s ( i , m ) = 0 )
+$$
+
+$$
+R a t i o \_ D e a d \_ U n i t = \frac { \sum _ { i } A l l \_ C l a s s \_ D e a d ( i ) } { N _ { u } }
+$$
+
+# D VISUALIZATION OF REPRESENTATIONS
+
+![](images/053eb86fb678a8b4506a3e09e3b816b26e3ed5e343ec393f23ad8dcd0ecbdf1d.jpg)  
+Figure 3: Histograms of activation values for 10 regularizers. Best viewed in color.
+
+![](images/04567555fb206395296c7deddc68624614892bcf1e4ffd56ab6b84b24d93cb5a.jpg)  
+Figure 4: Scatter plots of activation values of two units (neurons) for 10 regularizers. Best viewed in color.

parse/train/rkQu4Wb0Z/rkQu4Wb0Z_content_list.json

@@ -0,0 +1,1432 @@
+[
+    {
+        "type": "text",
+        "text": "DNN REPRESENTATIONS AS CODEWORDS:MANIPULATING STATISTICAL PROPERTIES V I APENALTY REGULARIZATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            220,
+            398,
+            248
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            285,
+            544,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Performance of Deep Neural Network (DNN) heavily depends on the characteristics of hidden layer representations. Unlike the codewords of channel coding, however, the representations of learning cannot be directly designed or controlled. Therefore, we develop a family of penalty regularizers where each one aims to affect one of the representation’s statistical properties such as sparsity, variance, or covariance. The regularizers are extended to perform class-wise regularization, and the extension is found to provide an outstanding shaping capability. A variety of statistical properties are investigated for ten different regularization strategies including dropout and batch normalization, and several interesting findings are reported. Using the family of regularizers, performance improvements are confirmed for MNIST, CIFAR-100, and CIFAR-10 classification problems. But more importantly, our results suggest that understanding how to manipulate statistical properties of representations can be an important step toward understanding DNN, and that the role and effect of DNN regularizers need to be reconsidered. ",
+        "bbox": [
+            233,
+            318,
+            764,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            334,
+            559
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With a Deep Neural Network (DNN), information contained in the input data $x$ is transformed into multiple representations over multiple layers. Performance of machine learning tasks is known to heavily depend on the choice of representations over $p ( x )$ , but $p ( x )$ is almost always unknown and the representations cannot be directly controlled to match an arbitrary design even if $p ( x )$ was known. As of today, the best that can be done is to indirectly affect the representations by adding constraints, modifying cost function, and tuning learning process, etc. ",
+        "bbox": [
+            174,
+            575,
+            823,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In Shannon’s information theory, channel coding theory deals with the problem of reliably sending the maximum amount of information through a given channel $p ( y | x )$ (Cover & Thomas, 2012). Because the channel is known and fixed, coding becomes a design problem where one needs to design codebook, encoder, and decoder. Usually, the channel is used $n$ times in a sequence to send a codeword of length $n$ (expressed as $x ^ { n }$ ). A codebook is a collection of all codewords that can be chosen and sent to the channel, and each message $w$ with information of interest is mapped into one of the codewords during the design phase. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Because channel coding is a design problem, the optimal solutions are well understood for some of the important applications such as Gaussian channel and Binary Symmetric Channel (BSC). Gaussian channel is the most important continuous alphabet channel problem. It assumes that the received signal $y ^ { n }$ is a noisy version of $x ^ { n }$ , where the noise is independent of $x$ and additive with an i.i.d. Gaussian distribution over the $n$ symbols. Surprisingly, when $n \\to \\infty$ , the optimal codebook turns out to be a collection of codewords that are generated by randomly drawing numbers from a Gaussian distribution. Then, a codeword’s $n$ symbols form an i.i.d. Gaussian distribution (for instance, see Chap. 9 of Cover & Thomas (2012)). BSC is one of the most popular discrete alphabet channel problems, and $x$ can take a value of 0 or 1. The received signal $y$ is a corrupted version of $x$ where it is flipped with a fixed probability. For BSC, Hamming code is a well-known solution where redundant bits are included in $x ^ { n }$ to resist the corruption (for instance, see Chap. 7 of Cover & Thomas (2012)). The correction capability is dependent on the minimum Hamming distance among all pairs of two different codewords. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It would be helpful if the elegant channel coding theories can be applied to the design and control of DNN representation, but unfortunately the representation problem is clearly different from the channel coding problem. First of all, a learning problem does not have a fixed and known channel $p ( y ^ { n } | x ^ { n } )$ . Secondly, we can design and control the DNN model to use, but we do not have the luxury of explicitly designing codebook. Therefore, the representations can be formed in any way that is possible. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Nonetheless, we can attempt to gain insights and ideas from the established coding theory. In this work, we first recognize that the optimal solution to Gaussian channel problem has i.i.d. Gaussian codewords. Although it is unclear if forcing representations of a layer to have an i.i.d. Gaussian property will be helpful, we experiment the idea by expanding known penalty regularization strategies to include L1, variance, and covariance. L1 and covariance (Cogswell et al., 2016) have been studied before (individually), but with our best knowledge, variance of a unit (neuron) and using a combination of them have not been considered in the literature. Secondly, we recognize that only a single codeword is assigned to a message (label for learning problems) for a well designed codebook. When this idea is applied to learning problems via penalty regularization, the penalty term needs to be applied per-class such that we can shape the codeword of each label. Note that almost all of the existing penalty regularization strategies have been applied to all classes together. Thirdly, we recognize that Gaussian codebook and Hamming codebook are fundamentally different. A Gaussian codebook uses continuous alphabets in an uncorrelated manner over $n$ symbols, but Hamming codebook uses only binary values (0 and 1). With the difference, it is inevitable for Gaussian code to utilize long codewords (very large $n$ ) and probabilistically guarantee pair-wise distance, while it is essential for Hamming code to utilize carefully designed vector-space structures (orthogonality, null space, etc.) using relatively short codewords. Because we are often interested in a relatively small number of neurons for representations, we consider a regularization strategy where each label’s activation for a unit is ‘hardened’ (by cw-VR regularizer that is introduced later) such that the representation vector is closer to a binary codeword than an i.i.d. Gaussian codeword. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            338,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Regularization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            279,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The classical regularizers apply L2 (Hoerl & Kennard, 1970) and L1 (Tibshirani, 1996) penalties to the weights of models, and they are widely used for DNN as well. Wen et al. (2016) extended L1 regularizer by using group lasso to regularize the structures of DNN (i.e., filters, channels, filter shapes, and layer depth). Regularization has been applied to representations, too. Srivastava et al. (2014) devised dropout that randomly applies activation masking over the neurons. While dropout is applied in a multiplicative manner, Glorot et al. (2011) used L1 penalty regularization on the activations to encourage sparse representations. XCov proposed by Cheung et al. (2014) minimizes the covariance between autoencoding units and label encoding units of the same layer such that representations can be disentangled. DeCov, developed by Cogswell et al. (2016), is also a penalty regularizer and it minimizes the off-diagonals of a layer’s representation covariance matrix. DeCov reduces co-adaptation of units by encouraging units to be decorrelated. It is called CR (Covariance Regularizer) in this study for consistent naming. Statistics over mini-batch samples or in-layer activations have been used for regularization, too. Batch normalization proposed by Ioffe & Szegedy (2015) exploits mini-batch statistics to normalize activations. It was developed to accelerate training speed by preventing internal covariate shift, but it was also found to be a useful regularizer. In line with batch normalization, weight normalization, developed by Salimans & Kingma (2016), uses mini-batch statistics to normalize weight vectors. Layer normalization proposed by Ba et al. (2016) is a RNN version of batch normalization, where they compute the mean and variance used for normalization from all of the summed inputs to the neurons in a layer on a single training case. There are many other publications on DNN regularization techniques, but we still do not have a sufficient understanding on how they really work. A recent work by Zhang et al. (2016) shows that the traditional concept of controlling generalization error by regularizing the effective capacity cannot be applied to DNN. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Class-wise Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            896,
+            316,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "True class information is available for supervised learning problems. Traditionally, the class information has been used only for evaluating the correctness of predictions and the relevant cost function terms. Some of the recent works, however, have adopted the class-wise concept in the learning algorithm itself. In those works, class information is used as a switch or for emphasizing the discriminative aspects over different classes. As an example, Li et al. (2008) proposed a kernel learning method using class-wise information to model the manifold structure. They modify locality preserving projection to be class dependent. Jiang et al. (2011) added label consistent regularizers for learning a discriminative dictionary. As for DNN, a recent work by Liao et al. (2016) used a clustering based regularization that encourages parsimonious representations. In their work, similar representations in sample, spatial, and channel dimensions are clustered and used for regularization such that similar representations are encouraged to become even more similar. While their work can be applied to unsupervised as well as supervised problems, our work utilizes a much simpler method of directly using class labels during training to avoid $\\mathbf { k }$ -means like clustering. Another recent work by Belharbi et al. (2017) directly uses class labels to encourage similar representations per class as in our work. Their work, however, is based on sum of pair-wise distances among the mini-batch samples of the same labels, and therefore computationally more demanding. The cw-VR (classwise Variance Regularizer) and cw-CR (class-wise Covariance Regularizer) in this work are very simple penalty regularizers that were designed for the purpose of controlling statistical properties of representations. ",
+        "bbox": [
+            178,
+            910,
+            820,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            825,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 THREE STATISTICAL PROPERTIES AND CLASS-WISE REGULARIZATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            387,
+            795,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For channel coding problems, we can characterize the statistical properties of optimal codewords as discussed in Section 1. Our goal is to make DNN representation vectors to have such statistical properties and analyze their effects. Because an explicit design and control of representation vector is not possible for the learning problems, we utilize penalty regularizers to manipulate the statistical properties instead. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            497
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 THREE STATISTICAL PROPERTIES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            446,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Three of the most basic statistical properties are considered in this work - sparsity, variance, and covariance. Sparsity over layer $l$ ’s representation vector $\\mathbf { h } _ { l }$ has been extensively studied in the literature. For variance, we are referring to the variance of a unit’s activation values over mini-batch samples. When the variance is forced to be very small, the activation value needs to be close to the sample mean for all labels, and therefore the unit loses its discriminative power over multiple labels. While this is undesirable, regularizing variance turns out to be meaningful because the cross-entropy cost function prevents the variance becoming zero, and a healthy compromise can be achieved between cross-entropy and variance terms. This is similar to the situation of classic weight regularization, where the weights actually never become zero by regularization. For covariance, we calculate pair-wise covariance over the unit activations of a layer. When covariance is evaluated to be large for a pair of units (neurons) in the same layer, it indicates that the two are strongly correlated. This is undesirable if we are pursuing i.i.d. property over unit activations, and having a regularizer to control the level of correlation can be useful. ",
+        "bbox": [
+            173,
+            561,
+            825,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 CLASS-WISE REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            773,
+            429,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To pursue statistical properties for each class, we adopt the concept of class-wise learning. ",
+        "bbox": [
+            173,
+            805,
+            764,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For instance, it is undesirable if the variance becomes exactly zero for a unit’s activation as mentioned above. Variance of zero for a class, however, can be desirable because it simply states that a consistent activation value will be observed over all samples with the same class label. Note that overall variance over all labels can be still large while class-wise variance is zero - as long as interclass difference exists, the overall variance will not be zero. We combine this concept of class-wise regularization to the three concepts of sparsity, variance, and covariance. Analytical formulations can be found in the following section. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PENALTY LOSS FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            437,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide the model for calculating basic statistics and formulate the penalty loss functions that are used for regularization. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 BASIC STATISTICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            341,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For layer $l$ , the output activation vector of a linear filter followed by ReLU is defined as $\\mathbf { h } _ { l } \\ =$ $\\mathrm { m a x } ( \\bar { \\mathbf { W } } _ { l } ^ { \\top } \\mathbf { h } _ { l - 1 } + \\mathbf { b } _ { l } ^ { \\top } , 0 )$ . Because we will be focusing on layer $l$ for most of the explanations, we drop the layer index and $\\mathbf { h }$ is used to indicate $\\mathbf { h } _ { l }$ instead. Then, $h _ { i }$ is the ith element of $\\mathbf { h }$ (i.e. activation of $i$ th unit), and $w _ { k i }$ is the $( k , i )$ element of $\\mathbf { W }$ . ",
+        "bbox": [
+            174,
+            205,
+            825,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To use statistical properties of representations, we define mean of unit $i$ , $\\mu _ { i }$ , and covariance between unit $i$ and unit $j , c _ { i , j }$ , using the $N$ samples in each mini-batch. ",
+        "bbox": [
+            173,
+            268,
+            823,
+            297
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e248bfcc39f2aa6d2d9fcaec95e436cff661967620a9e591442a35934b18c89.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mu _ { i } = \\frac { 1 } { N } \\sum _ { n } h _ { i , n } } \\\\ { \\displaystyle c _ { i , j } = \\frac { 1 } { N } \\sum _ { n } ( h _ { i , n } - \\mu _ { i } ) ( h _ { j , n } - \\mu _ { j } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            304,
+            620,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $h _ { i , n }$ is the activation of unit $i$ for nth sample in the mini-batch. From equation (2), variance of $i$ unit can be written as below. ",
+        "bbox": [
+            171,
+            386,
+            826,
+            414
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b46b9052b4347f2e7ab5bdb0040256c17bc2808427571bca62ee04901ea2258.jpg",
+        "text": "$$\n\\nu _ { i } = c _ { i , i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            468,
+            425,
+            529,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When class-wise statistics need to be considered, we choose a single label $m$ and evaluate mean, covariance, and variance using only the data samples with label $m$ in the mini-batch. ",
+        "bbox": [
+            171,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/639d18158968b13dd364329ed33e6ff1ad5568a7ed0bdc81eb08299bfd1f7369.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mu _ { i } ^ { m } = \\frac { 1 } { \\vert S _ { m } \\vert } \\sum _ { n \\in S _ { m } } h _ { i , n } } \\\\ { \\displaystyle c _ { i , j } ^ { m } = \\frac { 1 } { \\vert S _ { m } \\vert } \\sum _ { n \\in S _ { m } } ( h _ { i , n } - \\mu _ { i } ^ { m } ) ( h _ { j , n } - \\mu _ { j } ^ { m } ) } \\\\ { \\displaystyle \\nu _ { i } ^ { m } = c _ { i , i } ^ { m } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            489,
+            642,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $S _ { m }$ is the set containing indexes of the samples whose label is $m$ , and $| S _ { m } |$ is the cardinality of the set $S _ { m }$ . ",
+        "bbox": [
+            173,
+            593,
+            825,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 PENALTY LOSS FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            403,
+            655
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using the notations in Section 3.1, the loss functions and their derivatives can be derived and summarized as in Table 1. L1-weight and L2-weight are well-known, and they impose L1 and L2 penalties on the weights, respectively. The rest in the table apply penalties on the representation. L1-rep is similar to L1-weight, but the penalty is applied to the representation h. Obviously, L2 can also be applied to the representation, but it is excluded in this study because it tends to perform worse than L1 when applied to representation. VR (Variance Regularization) calculates variance of each unit’s activation over mini-batch dataset and uses the calculated value as the penalty. CR (Cross-covariance Regularization) uses off-diagonal terms of the mini-batch covariance matrix of activations as the penalty term. As mentioned earlier, CR in this work is the same as DeCov presented by Cogswell et al. (2016), but we use the term CR for the consistency of naming. As in DeCov, we subtract variance terms and consider cross-covariance terms only (see penalty loss function in Table 1). cw-VR and cw-CR are similar to VR and CR, respectively, except that the values are calculated for each class using the mini-batch samples with the same class label. cw-L1-rep can be defined, but its penalty loss function turns out to be the same as L1-rep’s loss function. Therefore, cw-L1-rep is excluded in this study. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Interpretation of derivatives ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            882,
+            372,
+            896
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While the penalty functions were chosen from the three distinct statistical properties and class-wise concept, their derivatives show that some of them are closely related. For the derivatives of VR and ",
+        "bbox": [
+            174,
+            896,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/132dc3efb97c52018421cd93c47b43557718bf3fe86c5427e11eeeb151dde52d.jpg",
+        "table_caption": [
+            "Table 1: Penalty loss functions of regularizers "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Penalty loss function</td><td>Derivatives</td></tr><tr><td>ΩL1-weight =∑∑ |wkil ki</td><td>0SL1-weight = sign(Wki) wki</td></tr><tr><td>ΩL2-weight =∑∑ wi</td><td>L2-weight = 2Wki dwki</td></tr><tr><td>ki ΩL1-rep =∑∑Ihinl</td><td>SL1-rep = sign(hi,n) dhi，n</td></tr><tr><td>n i ΩvR =Mui</td><td>0vR 2 (hin-μi) Ohi，n N</td></tr><tr><td>i =∑∑(ci,j）²-∑(ui）² ΩCR</td><td>0ScR 2 £ Ci,j(hj，n-μj) Ohi，n N</td></tr><tr><td>i i -∑∑ Ωcw-VR u</td><td>ji 0Scw-VR 2 (hi，n- μm),n ∈ Sm Ohi，n |Sml</td></tr><tr><td>m i Ωcw-CR =∑(∑∑(ci,j)²-∑(ui)²)</td><td>0Scw-CR 2 £ c(hjn-μ），n ∈ Sm dhi，n |Sml ji</td></tr></table>",
+        "bbox": [
+            173,
+            128,
+            846,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "CR, it can be observed that they have similar structures. If VR’s derivative $\\frac { \\partial \\Omega _ { V R } } { \\partial h _ { i , n } }$ becomes zero for all $i$ , then CR’s derivative $\\frac { \\partial \\Omega _ { C R } } { \\partial h _ { i , n } }$ becomes zero as well. The vice versa does not hold, but the effects of VR and CR can be expected to be similar or at least related to each other for the learning process. In the same way, the relationship between cw-VR and cw-CR is the same as the relationship between VR and CR. Therefore, we can expect cw-VR and cw-CR to have similar effects, too. On the other hand, the derivative of L1-rep has a distinct formulation, and it can be expected to have a distinct effect on learning. ",
+        "bbox": [
+            173,
+            429,
+            826,
+            560
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There is another important effect that is not necessarily obvious from the derivative formulations. For L1-weight and L2-weight, the derivatives are dependent on the weights $w _ { k i }$ only, and they are independent of the activations $h _ { i , n }$ . Therefore, the weights need to become smaller to reduce the regularization penalty. For the other five representation regularizers, their derivatives are all dependent on activation $h _ { i , n }$ . So, a simple way to reduce the regularization penalties is to scale the activations to small values (instead of satisfying the balances among the terms in the equation to reach zero gradients and force the desired statistical properties). This scaling will not have any effect on prediction output as long as all the elements of $\\bar { \\mathbf { h } } ^ { l }$ are scaled together to $\\alpha \\mathbf { h } ^ { l }$ - the last softmax layer works as a normalization function for the output layer, and therefore the cross-entropy penalty term is not affected by such a scaling. This means that there is a chance for the learning algorithm to squash activations just so that representation regularization terms can be ignored. As we will see later, indeed activation squashing happens by learning, but the desired statistical properties are still sufficiently enforced. Nonetheless, it must be possible to design better penalty regularizers that are immune to activation squashing, and such regularizers might be much more effective for manipulating statistical properties of representations. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS - MNIST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            811,
+            408,
+            828
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we consider ten regularization strategies and compare them using the MNIST dataset (LeCun et al., 1998). We use a Multilayer Perceptron (MLP) with five hidden fully connected layers and an output layer. Each hidden layer has 100 units with Rectified Linear Unit (ReLU) activation function, and the output layer consists of 10 softmax units. All experiments (in this work) were carried out using TensorFlow 1.3. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/93c81cff207b3b4152f1158d7c289e49f749b327d0787eb222e9df205c34364f.jpg",
+        "table_caption": [
+            "Table 2: Error performance of popular regularizers (MNIST) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Layer</td><td rowspan=\"2\">Baseline</td><td colspan=\"2\">Penalty on weight</td><td colspan=\"2\">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>All</td><td>3.06±0.15</td><td>2.90±0.08</td><td>2.96±0.09</td><td>4.08±0.06</td><td>2.69±0.06</td></tr></table>",
+        "bbox": [
+            212,
+            127,
+            779,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/aa9ffe61d87542b98e4099a3fa54377288339099a3a6479230a0c83e0ed2cf1e.jpg",
+        "table_caption": [
+            "Table 3: Error performance of representation regularizers (MNIST) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Layer</td><td colspan=\"3\">All classes</td><td colspan=\"2\">Class-wise</td></tr><tr><td>L1-rep</td><td>VR</td><td>CR</td><td>cw-VR</td><td>cw-CR</td></tr><tr><td>Output</td><td>2.61±0.04</td><td>2.67±0.15</td><td>2.62±0.07</td><td>2.56±0.02</td><td>2.55±0.08</td></tr><tr><td>Layer 5</td><td>2.61±0.11</td><td>2.70±0.03</td><td>2.67±0.04</td><td>2.63±0.05</td><td>2.61±0.06</td></tr><tr><td>Layer 4</td><td>2.75±0.05</td><td>2.89±0.11</td><td>2.69±0.13</td><td>2.67±0.12</td><td>2.71±0.04</td></tr><tr><td>Layer 3</td><td>3.35±0.08</td><td>3.16±0.09</td><td>3.11±0.13</td><td>3.22±0.06</td><td>3.22±0.06</td></tr><tr><td>Layer 2</td><td>3.40±0.11</td><td>3.15±0.21</td><td>3.01±0.10</td><td>3.14±0.10</td><td>3.24±0.11</td></tr><tr><td>Layer 1</td><td>4.31±0.14</td><td>2.98±0.09</td><td>3.13±0.09</td><td>3.25±0.04</td><td>3.14±0.03</td></tr></table>",
+        "bbox": [
+            218,
+            210,
+            777,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a7d93217144d6623691238bbfe38e532355cf9864ec530b03dc3ebee9693d9bf.jpg",
+        "table_caption": [
+            "Table 4: Error performance of representation regularizers - multiple layers (MNIST) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>L1-rep</td><td>VR</td><td>CR</td><td>cw-VR</td><td>cw-CR</td></tr><tr><td>Output</td><td>2.61±0.04</td><td>2.67±0.15</td><td>2.62±0.07</td><td>2.56±0.02</td><td>2.55±0.08</td></tr><tr><td>Output, 5</td><td>2.48±0.12</td><td>2.67±0.11</td><td>2.43±0.08</td><td>2.46±0.07</td><td>2.55±0.10</td></tr><tr><td>Output, 5, 4</td><td>2.78±0.11</td><td>2.58±0.06</td><td>2.80±0.12</td><td>2.53±0.07</td><td>2.48±0.07</td></tr><tr><td>Output, 5, 4, 3</td><td>2.79±0.10</td><td>2.78±0.08</td><td>2.83±0.14</td><td>2.80±0.10</td><td>2.72±0.04</td></tr><tr><td>Output, 5,4, 3, 2</td><td>3.19±0.10</td><td>2.91±0.13</td><td>2.77±0.07</td><td>2.90±0.10</td><td>2.75±0.07</td></tr><tr><td>All</td><td>3.26±0.09</td><td>2.86±0.07</td><td>2.80±0.08</td><td>2.83±0.07</td><td>2.85±0.12</td></tr></table>",
+        "bbox": [
+            189,
+            364,
+            808,
+            464
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 PERFORMANCE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            387,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For each regularization term, the level of regularization was determined by tuning the penalty loss weight using a validation dataset and a grid search. Then, we trained each model five-times and calculated the test error performance as the average and one standard deviation over the five performance results. In Table 2 and Table 3, the results show that representation regularizers outperform the popular regularizers and that the representation strategies perform better when applied to upper layers of DNN. Interestingly, the best performance is achieved by applying representation regularization to the output layer as shown in Table 3. This might be because the regularizer directly affects only the regularizing layer and the layers below, or because manipulating statistical properties is more effective for the higher layer representations that have stronger or codeword-like structures. To better understand the effect of a layer, multiple layer results are shown in Table 4. The best performance is achieved when output layer is regularized together with one or two upper hidden layers. Among all the results in the three tables, CR performs best and achieves $2 . 4 3 \\%$ of error. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 STATISTICAL PROPERTIES OF 10 REGULARIZATION STRATEGIES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            714,
+            655,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use nine metrics to compare the statistical properties of the ten regularization strategies. Among the nine metrics, first seven of them are calculated by directly evaluating the penalty loss functions shown in Table 1. The raw evaluation values, however, are difficult to interpret because they have different scales. So, we normalize the metrics as following (see the raw evaluation values shown in Table 10 and Table 11). First, square-root is applied to L2-weight, VR, and CR because their units are quadratic, and square-root of square-root is applied to cw-VR and cw-CR because their units are quartic. Then, all the metrics of each regularizer are divided by the regularizer’s own $\\sqrt { \\Omega _ { L 2 - w e i g h t } }$ such that all are normalized with respect to its 2-norm weight values. Finally, all the metrics are normalized by baseline’s metrics and 100 is multiplied such that we can focus on the relative change in percentage compared to the baseline’s metrics. The remaining two metrics are the average number of activated classes per unit as the measure of sparsity and ratio of dead units, and they are explained in Appendix C. $\\Omega _ { L 1 - w e i g h t }$ and $\\Omega _ { L { 2 } - w e i g h t }$ are calculated from the weights of all layers excluding biases, and the others are calculated from layer 5’s activations using test dataset. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c33e9914b44de5f2ff3dc3bfd97fdc5b3f27e32151150eac71b1e89c81e7831c.jpg",
+        "table_caption": [
+            "Table 5: Evaluation of statistical properties (layer 5) - popular strategies "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Metric</td><td rowspan=\"2\">Baseline</td><td colspan=\"2\">Penalty on weight</td><td colspan=\"2\">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>ΩL1-weight (all)</td><td>100.00</td><td>88.05</td><td>92.25</td><td>99.14</td><td>84.82</td></tr><tr><td>ΩL2-weight (all)</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td></tr><tr><td>ΩL1-rep</td><td>100.00</td><td>115.28</td><td>110.26</td><td>36.11</td><td>16.94</td></tr><tr><td>ΩvR</td><td>100.00</td><td>113.97</td><td>109.58</td><td>61.18</td><td>27.69</td></tr><tr><td>ΩcR</td><td>100.00</td><td>111.55</td><td>107.51</td><td>39.35</td><td>5.80</td></tr><tr><td>Ωcw-VR</td><td>100.00</td><td>114.08</td><td>109.68</td><td>72.91</td><td>50.50</td></tr><tr><td>Ωcw-CR</td><td>100.00</td><td>112.68</td><td>108.55</td><td>78.49</td><td>20.54</td></tr><tr><td>Aug_Act_Class</td><td>5.24</td><td>5.54</td><td>5.35</td><td>4.60</td><td>2.48</td></tr><tr><td>Ratio_Dead_Unit</td><td>14%</td><td>5%</td><td>9%</td><td>0%</td><td>1%</td></tr></table>",
+        "bbox": [
+            210,
+            127,
+            787,
+            284
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/840d381a68996fb1ed47f25bf17574dfedb36be42d76e22222587c111ec9ddc9.jpg",
+        "table_caption": [
+            "Table 6: Evaluation of statistical properties (layer 5) - representation regularizers "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Metric</td><td colspan=\"3\">All classes</td><td colspan=\"2\">Class-wise</td></tr><tr><td>L1-rep</td><td>VR</td><td>CR</td><td>cw-VR</td><td>cw-CR</td></tr><tr><td>ΩL1-weight (all)</td><td>93.08</td><td>96.42</td><td>95.83</td><td>86.85</td><td>84.14</td></tr><tr><td>ΩL2-weight (all)</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td></tr><tr><td>ΩL1-rep</td><td>1.07</td><td>9.16</td><td>9.73</td><td>3.41</td><td>5.49</td></tr><tr><td>ΩvR</td><td>7.77</td><td>9.24</td><td>9.42</td><td>3.91</td><td>5.28</td></tr><tr><td>ΩCR</td><td>0.33</td><td>0.64</td><td>0.63</td><td>0.15</td><td>0.27</td></tr><tr><td>Ωcw-VR</td><td>19.85</td><td>28.12</td><td>29.61</td><td>11.25</td><td>14.27</td></tr><tr><td>Ωcw-CR</td><td>3.69</td><td>6.79</td><td>7.15</td><td>1.66</td><td>2.37</td></tr><tr><td>Avg_Act_Class</td><td>0.23</td><td>5.12</td><td>5.38</td><td>4.14</td><td>5.29</td></tr><tr><td>Ratio_Dead_Unit</td><td>77%</td><td>9%</td><td>5%</td><td>23%</td><td>7%</td></tr></table>",
+        "bbox": [
+            250,
+            324,
+            746,
+            481
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We can observe two distinct groups of regularizers by investigating Table 5 and Table 6. We can observe that the representation regularizers have much smaller values for the representation metrics. This is because the representation regularizers squash activations in the way described in Section 3.2. As mentioned in Section 3.2, VR and cw-VR are related to CR and cw-CR, respectively. We can see that their values of metrics are similar to each other. Despite this similarity of the five representation regularization, L1-rep and cw-VR have unique characteristics. L1-rep obviously enforces sparsity and causes much more dead units than the others. The regularizer cw-VR always shows the smallest metric values among four strategies (VR, CR, cw-VR, and cw-CR). This can be an evidence of the four regularizers’ close relationship. The metric values of dropout and batch normalization (BN) are located somewhere between baseline and representation regularizers. They cause similar effects on representation metrics as the representation regularizers, but much less effect are observed. It is also interesting to note that both dropout and BN have only $0 \\sim 1 \\%$ of dead units (neurons). Dropout and BN are implicit methods in the sense that they do not target any particular statistical property, but they certainly seem to have distinct effects compared to the other regularizers. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 VISUALIZATION OF REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            482,
+            736
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Due to activation squashing, metrics of statistical properties can become misleading. Therefore, we visualize the representation of Layer 5 to more intuitively understand the statistical properties that are affected by the regularizers. Samples for three regularizers are shown in Figure 1 and Figure 2, and all figures for the ten regularizers are shown in appendix (Figure 3 and Figure 4). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Histogram of a single unit ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            813,
+            356,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first visualize the distribution of activation per unit in Figure 1 to observe sparsity and variance properties. Activation histograms were generated by using 10,000 test data, and each color corresponds to a different class. Since activations are generated as the output of ReLU activation function, many have zero value that can distort the histogram. We, therefore, excluded zeros from activations when drawing the histogram plots. In Figure 1(a), it can be seen that baseline has a large class-wise variance and inter-class overlaps. The histogram of cw-VR in (b), however, shows the effect of separating the classes because class-wise variance is significantly reduced. For each class, the activation is ‘hardened’. L1-rep in (c) can be confirmed to have only one class that is activated, and this confirms the sparsity. As described in Table 6, Avg Act Class of L1-rep is close to zero, so most of its histograms show very few active samples. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb2543fb65c0f8b3c3294b37a3bd7808d7ac7c0a603d8eb5c2a1b7bad22a2949.jpg",
+        "image_caption": [
+            "Figure 1: Histogram of a sample nueron’s activation values over test dataset. The sample was chosen from $\\mathbf { h } _ { 5 }$ . Compared to baseline, cw-VR clearly shows non-overlapping distributions for different labels. L1-rep shows a similar distribution shape as in the baseline, but only a single label is activated in this example. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            172,
+            805,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Scatter plot of a pair of units ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            401,
+            377,
+            415
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To show the relationship between two representation units, we randomly chose two units from a representation vector $\\mathbf { h } _ { 5 }$ and drew a scatter plot of their activation values for the test dataset. As shown in Figure 2, baseline shows a modest linearity, which is consistent with the high covariance value. Since CR in (b) reduces cross-covariance per unit, it can be seen that overall linearity is significantly reduced compared to the baseline and the randomly chosen pair of units becomes almost independent. In the same way, cw-CR has reduced class-wise cross-covariance. Furthermore, its class-wise variance is small and thus end up having small ball-shaped concentrations of points. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea64bbe4ead1da5e497615fc4db2dae317c28ae55693fc4472086360c1d21589.jpg",
+        "image_caption": [
+            "Figure 2: Scatter plot of activation values of randomly chosen two units from $\\mathbf { h } _ { 5 }$ . Compared to baseline, CR has clearly less correlation indicating less co-adaptation. cw-CR also shows low coadaptation, but it has smaller ball shapes per label because of the low class-wise variance. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            532,
+            818,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS - CIFAR-10/100 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            472,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While performance improvement is not the primary focus of this work, we provide additional test results with performance evaluations and show that the representation regularizers are useful for pushing the accuracy performance to the next level. In particular, we provide additional test results for CIFAR-100 and CIFAR-10 datasets (Krizhevsky & Hinton, 2009). For CIFAR-100, we have chosen a toy CNN architecture to confirm performance improvement of representation regularizers. Concurrently using two of the regularizers is experimented as well. For CIFAR-10, we have tested representation regularizers using Residual Network (ResNet) that is known as one of the best performing deep neural networks for image data. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/853f489950310bec7e3cf346ef3ee3fedf02f98342ca1e2a70f2d463a089b22f.jpg",
+        "table_caption": [
+            "Table 7: Error performance of regularizers (CIFAR-100) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Regularizer</td><td>Train error</td><td>Test error</td></tr><tr><td>Baseline</td><td>None</td><td>25.50</td><td>56.02</td></tr><tr><td rowspan=\"2\">Penalty on weight</td><td>L1-weight</td><td>18.16</td><td>55.99</td></tr><tr><td>L2-weight Dropout (fc)</td><td>33.75 28.02</td><td>54.93 55.28</td></tr><tr><td rowspan=\"2\" colspan=\"2\">Implicit method</td><td>Dropout (all) 79.28 28.28</td><td>80.08 55.33</td></tr><tr><td>BN (fc) BN (all) L1-rep 98.93</td><td>8.63 57.82 99.00</td></tr><tr><td rowspan=\"6\">Penalty on representation</td><td rowspan=\"2\">Single</td><td>VR CR cw-VR</td><td>27.02 53.66</td></tr><tr><td>33.24 22.85</td><td>54.67 54.15</td></tr><tr><td>cW-CR VR+CR</td><td>27.84</td><td>53.78</td></tr><tr><td></td><td>13.88</td><td>54.68</td></tr><tr><td>VR+cw-VR</td><td>19.43</td><td>56.12</td></tr><tr><td>VR+cw-CR</td><td></td><td></td></tr><tr><td rowspan=\"8\">Combination</td><td></td><td>28.53</td><td>54.94</td></tr><tr><td>CR+cw-VR</td><td>21.11</td><td></td></tr><tr><td>CR + cw-CR</td><td></td><td>53.30</td></tr><tr><td>cw-VR+ cW-CR</td><td>18.05 25.77</td><td>54.75</td></tr><tr><td></td><td>98.93</td><td>55.64</td></tr><tr><td>L1-rep + VR</td><td></td><td>99.00</td></tr><tr><td>L1-rep + CR</td><td>98.93</td><td>99.00</td></tr><tr><td>L1-rep + cw-VR L1-rep + cw-CR</td><td>98.93 98.93</td><td>99.00 99.00</td></tr></table>",
+        "bbox": [
+            230,
+            127,
+            772,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            478,
+            823,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.1 COMBINING MULTIPLE STRATEGIES: CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            527,
+            558,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We use a toy CNN network for experimenting with CIFAR-100. The CNN network consists of four convolution layers and a fully connected layer, all with 100 hidden units. ReLU is used as the activation function. The second, third, and fourth convolution layers are followed by a max pooling layer. The last 10,000 instances of 50,000 training data were used as the validation data. Using the validation data, validation performance was evaluated for the regularizer weight values of $\\{ 0 . 1 , \\bar { 0 } . 0 1$ , $0 . 0 0 1 , 0 . 0 0 0 1 \\}$ . The best weight value was found for each regularizer, and the test performance was evaluated for the fixed weight values. For representation regularizers, regularization was applied to the fully connected layer. The performance results are shown in Table 7. From the table, it can be seen that the test error is improved from baseline $5 6 . 0 2 \\%$ to $5 3 . 6 6 \\%$ by using a single regularizer (VR) and to $5 3 . 3 0 \\%$ by using two regularizers (CR and cw-VR). Therefore, $2 . 7 2 \\%$ of improvement is achieved by the best performing regularizer combination. Aside from the performance improvement, it is interesting to observe that L1-rep consistently fails to train for the CIFAR-100 data. With 100 labels, too much sparsity might hurt the performance. This is a plausible hypothesis considering that we have only 100 neurons to encode 100 labels. A shared use of neurons over multiple classes might be a better direction to pursue. In general, the relationship between the number of labels and the desired statistical properties of representation remains a topic to be studied. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 PERFORMANCE IMPROVEMENT OF RESNET-32 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            797,
+            537,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ResNet was first proposed by He et al. (2016). ResNet consists of multiple basic blocks that are serially connected, and shortcut connections to force residuals to be calculated. We apply five regularization strategies without modifying the ResNet-32 architecture. Regularization was applied to the output layer only. Experimental results in Table 8 show that performance is improved over the state-of-the-art ResNet-32 model, and cw-VR shows the best performance. This indicates that representation regularizers are compatible with ResNet, and most likely also with other state-of-the-art models. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/898f52b824510a5800b6815dd35c635ceb8c56e9ed6384ef7b19f723933c579c.jpg",
+        "table_caption": [
+            "Table 8: Error performance of regularizers on ResNet-32 (CIFAR-10) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>He et al.</td><td>Ours</td></tr><tr><td>ResNet-32</td><td>7.51</td><td>7.39</td></tr><tr><td rowspan=\"3\">ResNet-32 +L1-rep ResNet-32 + VR ResNet-32+CR</td><td>7.27</td><td></td></tr><tr><td></td><td>7.22</td></tr><tr><td></td><td>7.27</td></tr><tr><td>ResNet-32+cw-VR</td><td></td><td>7.17</td></tr><tr><td>ResNet-32 + cw-CR</td><td></td><td>7.21</td></tr></table>",
+        "bbox": [
+            356,
+            127,
+            640,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            252,
+            318,
+            267
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have investigated five different penalty regularizers for manipulating statistical properties of DNN representations. The regularizers were conceived by examining optimal codewords of well-known channel coding problems, and the three statistical properties of sparsity, variance, and covariance were integrated into the regularizers along with the concept of class-wise regularization. It was found that many statistical properties including cross-covariance, co-adaptation, per-class variance, average number of active class per-unit, and the ratio of dead units can be manipulated. Each regularizer, however, tended to manipulate multiple properties at the same time, making it difficult to manipulate each property individually. While manipulation was shown to be possible and helpful for improving the performance of all three DNN classification problems that were investigated, it is still unclear if any statistical property of representation is generally helpful when strengthened. Due to the complicated nature of learning process where back-propagation affects not only the signal of interest but also other signals and irrelevant noise, it still remains an open question on how to establish procedures that generally improve learning of any deep learning problems. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The contributions of this work can be summarized as follow. First, a complete set of very simple regularizers for controlling sparsity, variance, and covariance of representations was presented. Among them, VR, cw-VR, and cw-CR have been designed and used for the first time and they work very well. The visualizations clearly show that the new regularizers are effective for manipulating statistical properties of representations in new ways. Secondly, by analyzing statistical properties in a quantitative way, we have shown that none of the popular regualrizers works in a distinct way. Even the well-known dropout does not control co-adaptation(covariance) only. In fact, sparsity and class-wise variance are affected together by dropout, and therefore it is difficult to claim if indeed reduction in co-adaptation is why dropout works well. Thirdly, we have provided partial results on which statistical properties can be helpful or harmful for different learning tasks (tasks with more labels, with more complexity, etc.). This part needs to be further investigated to see if general rules can be derived. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            669,
+            326,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To be added. ",
+        "bbox": [
+            176,
+            693,
+            258,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            285,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            171,
+            752,
+            823,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Soufiane Belharbi, Clement Chatelain, Romain Herault, and Sebastien Adam. Neural networks regularization through invariant features learning. arXiv preprint arXiv:1709.01867, 2017. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brian Cheung, Jesse A Livezey, Arjun K Bansal, and Bruno A Olshausen. Discovering hidden factors of variation in deep networks. arXiv preprint arXiv:1412.6583, 2014. ",
+        "bbox": [
+            173,
+            830,
+            821,
+            859
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Cogswell, Faruk Ahmed, Ross Girshick, Larry Zitnick, and Dhruv Batra. Reducing overfitting in deep networks by decorrelating representations. 2016. ",
+        "bbox": [
+            173,
+            869,
+            820,
+            898
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas M Cover and Joy A Thomas. Elements of information theory. John Wiley & Sons, 2012. ",
+        "bbox": [
+            173,
+            909,
+            808,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 315–323, 2011. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "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,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arthur E Hoerl and Robert W Kennard. Ridge regression: Biased estimation for nonorthogonal problems. Technometrics, 12(1):55–67, 1970. ",
+        "bbox": [
+            171,
+            205,
+            823,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015. ",
+        "bbox": [
+            176,
+            244,
+            825,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhuolin Jiang, Zhe Lin, and Larry S Davis. Learning a discriminative dictionary for sparse coding via label consistent $\\mathbf { k }$ -svd. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1697–1704. IEEE, 2011. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            347,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun-Bao Li, Jeng-Shyang Pan, and Shu-Chuan Chu. Kernel class-wise locality preserving projection. Information Sciences, 178(7):1825–1835, 2008. ",
+        "bbox": [
+            174,
+            409,
+            820,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Renjie Liao, Alex Schwing, Richard Zemel, and Raquel Urtasun. Learning deep parsimonious representations. In Advances in Neural Information Processing Systems, pp. 5076–5084, 2016. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society. Series B (Methodological), pp. 267–288, 1996. ",
+        "bbox": [
+            173,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016. ",
+        "bbox": [
+            174,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016. ",
+        "bbox": [
+            173,
+            676,
+            823,
+            707
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A PERFORMANCE OF POPULAR REGULARIZERS WHEN APPLIED TO EACH LAYER ",
+        "bbox": [
+            176,
+            142,
+            790,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/b752f48b0a5cbd14b3caf9d7c9ada3d74ea997c9d904867115838b5ec05d9ba9.jpg",
+        "table_caption": [
+            "Table 9: Error performance of popular regularizers - applied to each layer "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Layer</td><td rowspan=\"2\">Baseline</td><td colspan=\"2\">Penalty on weight</td><td colspan=\"2\">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>All</td><td rowspan=\"6\">3.06±0.15</td><td>2.90±0.08</td><td>2.96±0.09</td><td>4.08±0.06</td><td>2.69±0.06</td></tr><tr><td>Output</td><td>3.02±0.15</td><td>2.96±0.06</td><td>2.99±0.18</td><td>2.97±0.08</td></tr><tr><td>Layer 5</td><td>2.98±0.05</td><td>2.99±0.13</td><td>2.80±0.08</td><td>3.04±0.09</td></tr><tr><td>Layer 4</td><td>2.98±0.08</td><td>2.98±0.09</td><td>2.67±0.05</td><td>2.84±0.15</td></tr><tr><td>Layer 3</td><td>3.04±0.09</td><td>3.03±0.18</td><td>2.67±0.16</td><td>2.94±0.13</td></tr><tr><td>Layer 2</td><td>2.91±0.05</td><td>2.76±0.16</td><td>2.70±0.08</td><td>2.84±0.16</td></tr><tr><td>Layer 1</td><td></td><td>2.93±0.05</td><td>2.52±0.10</td><td>3.07±0.07</td><td>2.58±0.07</td></tr></table>",
+        "bbox": [
+            209,
+            233,
+            789,
+            361
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B EVALUATION OF STATISTICAL PROPERTIES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            410,
+            562,
+            425
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/b602047d428c8d98dd68286b15cb061ed28ef70f8194b40e7e625551988e4427.jpg",
+        "table_caption": [
+            "Table 10: Evaluation of statistical properties (raw) - popular regularizers "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Property</td><td rowspan=\"2\">Baseline</td><td colspan=\"2\"> Penalty on weight</td><td colspan=\"2\">Implicit method</td></tr><tr><td>L1-weight</td><td>L2-weight</td><td>Dropout</td><td>BN</td></tr><tr><td>ΩL1-weight (all)</td><td>9795.03</td><td>7504.60</td><td>8220.21</td><td>9461.52</td><td>9488.60</td></tr><tr><td>ΩL2-weight (all)</td><td>607.46</td><td>459.85</td><td>502.71</td><td>576.60</td><td>792.24</td></tr><tr><td>ΩL1-rep</td><td>3.24 × 106</td><td>3.25 × 106</td><td>3.25 × 106</td><td>1.14 × 106</td><td>6.27 ×105</td></tr><tr><td>SvR</td><td>865.69</td><td>851.24</td><td>860.34</td><td>307.64</td><td>86.59</td></tr><tr><td>ScR</td><td>58178.00</td><td>54803.10</td><td>55650.20</td><td>8551.84</td><td>255.31</td></tr><tr><td>Ωcw-VR</td><td>2398.03</td><td>2327.79</td><td>2377.46</td><td>610.58</td><td>265.46</td></tr><tr><td>Ωcw-CR</td><td>63726.20</td><td>58891.60</td><td>60610.20</td><td>21795.60</td><td>193.26</td></tr></table>",
+        "bbox": [
+            186,
+            484,
+            810,
+            675
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/a4d0c3ad246321eb148a494337b3b62e3a986416894627109277f66e9b61e068.jpg",
+        "table_caption": [
+            "Table 11: Evaluation of statistical properties (raw) - representation regularizers "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Property</td><td colspan=\"3\">All classes</td><td colspan=\"2\">Class-wise</td></tr><tr><td>L1-rep</td><td>VR</td><td>CR</td><td>Cw-VR</td><td>CW-CR</td></tr><tr><td>ΩL1-weight (all)</td><td>9975.62</td><td>9732.16</td><td>9826.06</td><td>9843.84</td><td>9772.89</td></tr><tr><td>ΩL2-weight (all)</td><td>727.22</td><td>645.03</td><td>665.57</td><td>813.20</td><td>853.98</td></tr><tr><td>ΩL1-rep</td><td>38183.20</td><td>3.06 × 105</td><td>3.39 × 105</td><td>1.28 × 105</td><td>2.11 × 105</td></tr><tr><td>ΩvR</td><td>6.26</td><td>7.85</td><td>8.43</td><td>1.78</td><td>3.40</td></tr><tr><td>ScR</td><td>0.80</td><td>2.55</td><td>2.55</td><td>0.19</td><td>0.64</td></tr><tr><td>Ωcw-VR</td><td>5.34</td><td>16.91</td><td>22.15</td><td>0.69</td><td>1.97</td></tr><tr><td>Ωcw-CR</td><td>0.17</td><td>1.53</td><td>2.00</td><td>8.83 × 10-3</td><td>0.04</td></tr></table>",
+        "bbox": [
+            196,
+            715,
+            802,
+            906
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C METRICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Activated class and dead unit ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            380,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ReLU’s output becomes positive when the input has a positive value. In this work, we say a class is activated for a nueron if the probability of the neuron’s output being positive is above a threshold for the given class. We use the entire test dataset to check the probability, and threshold value of 0.9 is used for the evaluations. If many classes are activated for a neuron, it indicates that the neuron is used for representations of many classes. On the other hand, if only a single class is activated for a neuron, it indicates that the neuron is used for representations of only one class and kept zero for all the other classes. When the number of activated class is zero for a neuron, it indicates that the neuron does not carry any information and may be ignored. Such a neuron is called a dead unit. The equations below show how to calculate if a class $m$ is activated for a nueron $i , I$ is an indicator function, and $N _ { u }$ is the number of units in the layer. ",
+        "bbox": [
+            173,
+            147,
+            825,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/598676038b269908ef6f4fada5b9e380a817cfbb46154ae9f8ad173a5471a657.jpg",
+        "text": "$$\nN u m \\_ A c t \\_ I n C l a s s ( i , m ) = \\sum _ { n \\in S _ { m } } I ( h _ { i , n } > 0 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            303,
+            656,
+            337
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/51f414822efc32c8f62e8cafe3870777bc410a97a93a2ceb6b2555e79540c9d2.jpg",
+        "text": "$$\nA c t \\_ C l a s s ( i , m ) = I ( \\frac { N u m \\_ A c t ( i , m ) } { | S _ { m } | } > t h r e s h o l d )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            354,
+            676,
+            388
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Average number of activated classes ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            419,
+            426,
+            433
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The number of activated classes can be calculated for each unit. Then, the average number of activated classes can be calculated over all units in the same layer. When $A v g \\_ A c t \\_ C l a s s$ is large for a regularizer, it means the regularizer tends to encourage many units to be used for representations. If the value is small, it indicates the regularizer makes only a small number of units to be coded in positive values for the representation. ",
+        "bbox": [
+            176,
+            433,
+            825,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e5859945064e0c0ecb5c69c1d1404bde5b4b188d74ca3dc54d6419ce9ed6f24.jpg",
+        "text": "$$\nN u m . A c t . C l a s s ( i ) = \\sum _ { m } A c t . C l a s s ( i , m )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            517,
+            648,
+            551
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de43250c1e83cc52b615425f9857de914a0df75c86f98b5ad3552e1129b99e72.jpg",
+        "text": "$$\nA v g \\_ A c t \\_ C l a s s = \\frac { \\sum _ { i } N u m \\_ A c t \\_ C l a s s ( i ) } { N _ { u } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            566,
+            648,
+            602
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ratio of dead units ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            308,
+            645
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Typically, ’dead neuron’ is widely used to represent neurons that are not activated - output is zero all the time over all classes. To extend the concept of ‘activated class’, we define $A l l \\_ C l a s s \\_ D e a d ( i )$ and Ratio Dead Unit as below. When Ratio Dead Unit is large, it indicates many of the neurons can be removed without affecting the representation. ",
+        "bbox": [
+            176,
+            646,
+            823,
+            702
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c93a296a9afa7335c72975e73394cba746569b5f7c29172c9da460d8bef5a986.jpg",
+        "text": "$$\nA l l _ { - } C l a s s \\_ D e a d ( i ) = I ( \\sum _ { m } A c t _ { - } C l a s s ( i , m ) = 0 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            717,
+            673,
+            751
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ab309f5a5ce232ca365dc03f20a653abf2b8b1a4f232bd6af24cff98d6ab497.jpg",
+        "text": "$$\nR a t i o \\_ D e a d \\_ U n i t = \\frac { \\sum _ { i } A l l \\_ C l a s s \\_ D e a d ( i ) } { N _ { u } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            767,
+            655,
+            801
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D VISUALIZATION OF REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            534,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/053eb86fb678a8b4506a3e09e3b816b26e3ed5e343ec393f23ad8dcd0ecbdf1d.jpg",
+        "image_caption": [
+            "Figure 3: Histograms of activation values for 10 regularizers. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            165,
+            725,
+            767
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/04567555fb206395296c7deddc68624614892bcf1e4ffd56ab6b84b24d93cb5a.jpg",
+        "image_caption": [
+            "Figure 4: Scatter plots of activation values of two units (neurons) for 10 regularizers. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            135,
+            741,
+            844
+        ],
+        "page_idx": 14
+    }
+]

parse/train/rkgKBhA5Y7/rkgKBhA5Y7.md

@@ -0,0 +1,415 @@
+# THERE ARE MANY CONSISTENT EXPLANATIONS OF UNLABELED DATA: WHY YOU SHOULD AVERAGE
+
+Ben Athiwaratkun, Marc Finzi, Pavel Izmailov, Andrew Gordon Wilson {pa338, maf388, pi49, andrew}@cornell.edu Cornell University
+
+# Abstract
+
+Presently the most successful approaches to semi-supervised learning are based on consistency regularization, whereby a model is trained to be robust to small perturbations of its inputs and parameters. To understand consistency regularization, we conceptually explore how loss geometry interacts with training procedures. The consistency loss dramatically improves generalization performance over supervisedonly training; however, we show that SGD struggles to converge on the consistency loss and continues to make large steps that lead to changes in predictions on the test data. Motivated by these observations, we propose to train consistencybased methods with Stochastic Weight Averaging (SWA), a recent approach which averages weights along the trajectory of SGD with a modified learning rate schedule. We also propose fast-SWA, which further accelerates convergence by averaging multiple points within each cycle of a cyclical learning rate schedule. With weight averaging, we achieve the best known semi-supervised results on CIFAR-10 and CIFAR-100, over many different quantities of labeled training data. For example, we achieve $5 . 0 \%$ error on CIFAR-10 with only 4000 labels, compared to the previous best result in the literature of $6 . 3 \%$ .
+
+# 1 INTRODUCTION
+
+Recent advances in deep unsupervised learning, such as generative adversarial networks (GANs) (Goodfellow et al., 2014), have led to an explosion of interest in semi-supervised learning. Semisupervised methods make use of both unlabeled and labeled training data to improve performance over purely supervised methods. Semi-supervised learning is particularly valuable in applications such as medical imaging, where labeled data may be scarce and expensive (Oliver et al., 2018).
+
+Currently the best semi-supervised results are obtained by consistency-enforcing approaches (Bachman et al., 2014; Laine and Aila, 2017; Tarvainen and Valpola, 2017; Miyato et al., 2017; Park et al., 2017). These methods use unlabeled data to stabilize their predictions under input or weight perturbations. Consistency-enforcing methods can be used at scale with state-of-the-art architectures. For example, the recent Mean Teacher (Tarvainen and Valpola, 2017) model has been used with the Shake-Shake (Gastaldi, 2017) architecture and has achieved the best semi-supervised performance on the consequential CIFAR benchmarks.
+
+This paper is about conceptually understanding and improving consistency-based semi-supervised learning methods. Our approach can be used as a guide for exploring how loss geometry interacts with training procedures in general. We provide several novel observations about the training objective and optimization trajectories of the popular ⇧ (Laine and Aila, 2017) and Mean Teacher (Tarvainen and Valpola, 2017) consistency-based models. Inspired by these findings, we propose to improve SGD solutions via stochastic weight averaging (SWA) (Izmailov et al., 2018), a recent method that averages weights of the networks corresponding to different training epochs to obtain a single model with improved generalization. On a thorough empirical study we show that this procedure achieves the best known semi-supervised results on consequential benchmarks. In particular:
+
+We show in Section 3.1 that a simplified ⇧ model implicitly regularizes the norm of the Jacobian of the network outputs with respect to both its inputs and its weights, which in turn encourages flatter solutions. Both the reduced Jacobian norm and flatness of solutions have been related to generalization in the literature (Sokolic et al. ´ , 2017; Novak et al., 2018; Chaudhari et al.,
+
+2016; Schmidhuber and Hochreiter, 1997; Keskar et al., 2017; Izmailov et al., 2018). Interpolating between the weights corresponding to different epochs of training we demonstrate that the solutions of ⇧ and Mean Teacher models are indeed flatter along these directions (Figure 1b).
+
+• In Section 3.2, we compare the training trajectories of the ⇧, Mean Teacher, and supervised models and find that the distances between the weights corresponding to different epochs are much larger for the consistency based models. The error curves of consistency models are also wider (Figure 1b), which can be explained by the flatness of the solutions discussed in section 3.1. Further we observe that the predictions of the SGD iterates can differ significantly between different iterations of SGD.
+
+• We observe that for consistency-based methods, SGD does not converge to a single point but continues to explore many solutions with high distances apart. Inspired by this observation, we propose to average the weights corresponding to SGD iterates, or ensemble the predictions of the models corresponding to these weights. Averaging weights of SGD iterates compensates for larger steps, stabilizes SGD trajectories and obtains a solution that is centered in a flat region of the loss (as a function of weights). Further, we show that the SGD iterates correspond to models with diverse predictions – using weight averaging or ensembling allows us to make use of the improved diversity and obtain a better solution compared to the SGD iterates. In Section 3.3 we demonstrate that both ensembling predictions and averaging weights of the networks corresponding to different training epochs significantly improve generalization performance and find that the improvement is much larger for the $\Pi$ and Mean Teacher models compared to supervised training. We find that averaging weights provides similar or improved accuracy compared to ensembling, while offering the computational benefits and convenience of working with a single model. Thus, we focus on weight averaging for the remainder of the paper.
+
+• Motivated by our observations in Section 3 we propose to apply Stochastic Weight Averaging (SWA) (Izmailov et al., 2018) to the $\Pi$ and Mean Teacher models. Based on our results in Section 3.3 we propose several modifications to SWA in Section 4. In particular, we propose fast-SWA, which (1) uses a learning rate schedule with longer cycles to increase the distance between the weights that are averaged and the diversity of the corresponding predictions; and (2) averages weights of multiple networks within each cycle (while SWA only averages weights corresponding to the lowest values of the learning rate within each cycle). In Section 5, we show that fast-SWA converges to a good solution much faster than SWA.
+
+• Applying weight averaging to the $\Pi$ and Mean Teacher models we improve the best reported results on CIFAR-10 for $1 k$ , $2 k$ , $4 k$ and $1 0 k$ labeled examples, as well as on CIFAR-100 with $1 0 k$ labeled examples. For example, we obtain $5 . 0 \%$ error on CIFAR-10 with only $4 k$ labels, improving the best result reported in the literature (Tarvainen and Valpola, 2017) by $1 . 3 \%$ . We also apply weight averaging to a state-of-the-art domain adaptation technique (French et al., 2018) closely related to the Mean Teacher model and improve the best reported results on domain adaptation from CIFAR-10 to STL from $1 9 . 9 \%$ to $1 6 . { \bar { 8 } } \%$ error.
+
+• We release our code at https://github.com/benathi/fastswa-semi-sup
+
+# 2 BACKGROUND
+
+# 2.1 CONSISTENCY BASED MODELS
+
+We briefly review semi-supervised learning with consistency-based models. This class of models encourages predictions to stay similar under small perturbations of inputs or network parameters. For instance, two different translations of the same image should result in similar predicted probabilities. The consistency of a model (student) can be measured against its own predictions (e.g. ⇧ model) or predictions of a different teacher network (e.g. Mean Teacher model). In both cases we will say a student network measures consistency against a teacher network.
+
+Consistency Loss In the semi-supervised setting, we have access to labeled data $\begin{array} { r l } { \mathcal { D } _ { L } } & { { } = } \end{array}$ $\{ ( x _ { i } ^ { L } , y _ { i } ^ { L } ) \} _ { i = 1 } ^ { \tilde { N } _ { L } }$ , and unlabeled data $\mathcal { D } _ { U } = \{ x _ { i } ^ { U } \} _ { i = 1 } ^ { N _ { U } }$ .
+
+Given two perturbed inputs $x ^ { \prime } , x ^ { \prime \prime }$ of $x$ and the perturbed weights $\boldsymbol { w } _ { f } ^ { \prime }$ and $\boldsymbol { w _ { g } ^ { \prime } }$ , the consistency loss penalizes the difference between the student’s predicted probablities $f ( x ^ { \prime } ; w _ { f } ^ { \prime } )$ and the teacher’s $g ( x ^ { \prime \prime } ; w _ { g } ^ { \prime } )$ . This loss is typically the Mean Squared Error or $\mathrm { K L }$ divergence:
+
+$$
+\ell _ { \mathrm { c o n s } } ^ { \mathrm { M S E } } ( w _ { f } , x ) = \| f ( x ^ { \prime } ; w _ { f } ^ { \prime } ) - g ( x ^ { \prime \prime } , w _ { g } ^ { \prime } ) \| ^ { 2 } \mathrm { o r } \ell _ { \mathrm { c o n s } } ^ { \mathrm { K L } } ( w _ { f } , x ) = \mathrm { K L } ( f ( x ^ { \prime } ; w _ { f } ^ { \prime } ) | | g ( x ^ { \prime \prime } , w _ { g } ^ { \prime } ) ) .
+$$
+
+The total loss used to train the model can be written as
+
+$$
+L ( w _ { f } ) = \underbrace { \sum _ { ( x , y ) \in \mathcal { D } _ { L } } \ell _ { \mathrm { C E } } ( w _ { f } , x , y ) } _ { L _ { \mathrm { C E } } } + \lambda \underbrace { \sum _ { x \in \mathcal { D } _ { L } \cup \mathcal { D } _ { U } } \ell _ { \mathrm { c o n s } } ( w _ { f } , x ) } _ { L _ { \mathrm { c o n s } } } ,
+$$
+
+where for classification $L _ { \mathrm { C E } }$ is the cross entropy between the model predictions and supervised training labels. The parameter $\lambda > 0$ controls the relative importance of the consistency term in the overall loss.
+
+⇧ Model The $\Pi$ model, introduced in Laine and Aila (2017) and Sajjadi et al. (2016), uses the student model $f$ as its own teacher. The data (input) perturbations include random translations, crops, flips and additive Gaussian noise. Binary dropout (Srivastava et al., 2014) is used for weight perturbation.
+
+Mean Teacher Model The Mean Teacher model (MT) proposed in Tarvainen and Valpola (2017) uses the same data and weight perturbations as the $\Pi$ model; however, the teacher weights $w ^ { g }$ are the exponential moving average (EMA) of the student weights $w ^ { f }$ : $w _ { g } ^ { k } = \alpha \cdot w _ { g . } ^ { k - 1 } + ( \breve { 1 } - \alpha ) \cdot w _ { f } ^ { k }$ . The decay rate $\alpha$ is usually set between 0.9 and 0.999. The Mean Teacher model has the best known results on the CIFAR-10 semi-supervised learning benchmark (Tarvainen and Valpola, 2017).
+
+Other Consistency-Based Models Temporal Ensembling (TE) (Laine and Aila, 2017) uses an exponential moving average of the student outputs as the teacher outputs in the consistency term for training. Another approach, Virtual Adversarial Training (VAT) (Miyato et al., 2017), enforces the consistency between predictions on the original data inputs and the data perturbed in an adversarial direction $x ^ { \prime } = x + \epsilon r _ { \mathrm { a d v } }$ , where $\begin{array} { r } { r _ { \mathrm { a d v } } = \arg \operatorname* { m a x } _ { r : \| r \| = 1 } \mathbf { K L } [ f ( x , w ) \| f ( x + \xi r , w ) ] } \end{array}$ .
+
+# 3 UNDERSTANDING CONSISTENCY-ENFORCING MODELS
+
+In Section 3.1, we study a simplified version of the $\Pi$ model theoretically and show that it penalizes the norm of the Jacobian of the outputs with respect to inputs, as well as the eigenvalues of the Hessian, both of which have been related to generalization (Sokolic et al. ´ , 2017; Novak et al., 2018; Dinh et al., 2017a; Chaudhari et al., 2016). In Section 3.2 we empirically study the training trajectories of the ⇧ and MT models and compare them to the training trajectories in supervised learning. We show that even late in training consistency-based methods make large training steps, leading to significant changes in predictions on test. In Section 3.3 we show that averaging weights or ensembling predictions of the models proposed by SGD at different training epochs can lead to substantial gains in accuracy and that these gains are much larger for $\Pi$ and MT than for supervised training.
+
+# 3.1 SIMPLIFIED ⇧ MODEL PENALIZES LOCAL SHARPNESS
+
+Penalization of the input-output Jacobian norm. Consider a simple version of the $\Pi$ model, where we only apply small additive perturbations to the student inputs: $x ^ { \prime } = x + \epsilon z$ , $z \sim \mathcal { N } ( 0 , I )$ with $\epsilon \ll 1$ , and the teacher input is unchanged: $x ^ { \prime \prime } = x$ .1 Then the consistency loss $\ell _ { c o n s }$ (Eq. 1) becomes $\ell _ { c o n s } ( w , x , \epsilon ) = \| f ( w , x + \epsilon z ) - f ( w , x ) \| ^ { 2 }$ . Consider the estimator $\hat { Q } \ =$ $\begin{array} { r l } { } & { { } \operatorname* { l i m } _ { \epsilon \to 0 } \frac { 1 } { \epsilon ^ { 2 } } \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \ell _ { c o n s } ( w , x _ { i } , \epsilon ) } \end{array}$ . We show in Section A.5 that
+
+$$
+\mathbb { E } [ \hat { Q } ] = \mathbb { E } _ { x } [ \| J _ { x } \| _ { F } ^ { 2 } ] \quad \mathrm { a n d } \quad \mathrm { V a r } [ \hat { Q } ] = \frac { 1 } { m } \bigg ( \mathrm { V a r } [ \| J _ { x } \| _ { F } ^ { 2 } ] + 2 \mathbb { E } [ \| J _ { x } ^ { T } J _ { x } \| _ { F } ^ { 2 } ] \bigg ) ,
+$$
+
+where $J _ { x }$ is the Jacobian of the network’s outputs with respect to its inputs evaluated at $x$ , $\| \cdot \| _ { F }$ represents Frobenius norm, and the expectation $\mathbb { E } _ { x }$ is taken over the distribution of labeled and unlabeled data. That is, $\hat { Q }$ is an unbiased estimator of $\mathbb { E } _ { x } [ \| J _ { x } \| _ { F } ^ { 2 } ]$ with variance controlled by the minibatch size $m$ . Therefore, the consistency loss implicitly penalizes $\mathbb { E } _ { x } [ \| J _ { x } \| _ { F } ^ { 2 } ]$ .
+
+The quantity $| | J _ { x } | | _ { F }$ has been related to generalization both theoretically (Sokolic et al. ´ , 2017) and empirically (Novak et al., 2018). For linear models $f ( x ) = W x$ , penalizing $| | J _ { x } | | _ { F }$ exactly corresponds to weight decay, also known as $L _ { 2 }$ regularization, since for linear models $J _ { x } = W$ , and $\| W \| _ { F } ^ { 2 } = \| \mathbf { v e c } ( W ) \| _ { 2 } ^ { 2 }$ . Penalizing $\mathbb { E } _ { x } [ \| J _ { x } \| _ { F } ^ { 2 } ]$ is also closely related to the graph based (manifold) regularization in Zhu et al. (2003) which uses the graph Laplacian to approximate $\mathbb { E } _ { x } [ \lVert \nabla _ { \mathcal { M } } f \rVert ^ { 2 } ]$ for nonlinear models, making use of the manifold structure of unlabeled data.
+
+Isotropic perturbations investigated in this simplified $\Pi$ model will not in general lie along the data manifold, and it would be more pertinent to enforce consistency to perturbations sampled from the space of natural images. In fact, we can interpret consistency with respect to standard data augmentations (which are used in practice) as penalizing the manifold Jacobian norm in the same manner as above. See Section A.5 for more details.
+
+Penalization of the Hessian’s eigenvalues. Now, instead of the input perturbation, consider the weight perturbation $w ^ { \prime } = w + \epsilon z$ . Similarly, the consistency loss is an unbiased estimator for $\mathbb { E } _ { x } [ \bar { | | } J _ { w } \bar { | | } _ { F } ^ { 2 } ]$ , where $J _ { w }$ is the Jacobian of the network outputs with respect to the weights $w$ . In Section A.6 we show that for the MSE loss, the expected trace of the Hessian of the loss $\mathbb { E } _ { x } [ \mathrm { t r } ( H ) ]$ can be decomposed into two terms, one of which is $\mathbb { E } _ { x } [ \| J _ { w } \| _ { F } ^ { 2 } ]$ . As minimizing the consistency loss of a simplified $\Pi$ model penalizes $\mathbb { E } _ { x } [ \lVert J _ { w } \rVert _ { F } ^ { 2 } ]$ , it also penalizes $\mathbb { E } _ { x } [ \mathrm { t r } ( H ) ]$ . As pointed out in Dinh et al. (2017a) and Chaudhari et al. (2016), the eigenvalues of $H$ encode the local information about sharpness of the loss for a given solution $w$ . Consequently, the quantity $\operatorname { t r } ( H )$ which is the sum of the Hessian eigenvalues is related to the notion of sharp and flat optima, which has recently gained attention as a proxy for generalization performance (see e.g. Schmidhuber and Hochreiter, 1997; Keskar et al., 2017; Izmailov et al., 2018). Thus, based on our analysis, the consistency loss in the simplified ⇧ model encourages flatter solutions.
+
+# 3.2 ANALYSIS OF SOLUTIONS ALONG SGD TRAJECTORIES
+
+In the previous section we have seen that in a simplified ⇧ model, the consistency loss encourages lower input-output Jacobian norm and Hessian’s eigenvalues, which are related to better generalization. In this section we analyze the properties of minimizing the consistency loss in a practical setting. Specifically, we explore the trajectories followed by SGD for the consistency-based models and compare them to the trajectories in supervised training.
+
+![](images/29efbaf1fbeefa11b529107b49212f2ff0277644d188104e61c19e56584ee44c.jpg)  
+Figure 1: (a): The evolution of the gradient norm for the consistency regularization term (Cons) and the cross-entropy term (CE) in the ⇧, MT, and standard supervised (CE only) models during training. $\mathbf { ( b ) }$ : Train and test errors along rays connecting two SGD solutions for each respective model. (c) and (d): Comparison of errors along rays connecting two SGD solutions, random rays, and adversarial rays for the $\Pi$ and supervised models. See Section A.1 for the analogous Mean Teacher model’s plot.
+
+We train our models on CIFAR-10 using $4 k$ labeled data for 180 epochs. The ⇧ and Mean Teacher models use $4 6 k$ data points as unlabeled data (see Sections A.8 and A.9 for details). First, in Figure 1a we visualize the evolution of norms of the gradients of the cross-entropy term $\Vert \nabla L _ { \mathrm { C E } } \Vert$ and consistency term $\| \nabla L _ { \mathrm { c o n s } } \|$ along the trajectories of the $\Pi$ , MT, and standard supervised models (using CE loss only). We observe that $\| \nabla L _ { \mathrm { C o n s } } \|$ remains high until the end of training and dominates the gradient $\Vert \nabla L _ { \mathrm { C E } } \Vert$ of the cross-entropy term for the $\Pi$ and MT models. Further, for both the $\Pi$ and MT models, $\left. \nabla L _ { \mathrm { C o n s } } \right.$ is much larger than in supervised training implying that the $\Pi$ and MT models are making substantially larger steps until the end of training. These larger steps suggest that rather than converging to a single minimizer, SGD continues to actively explore a large set of solutions when applied to consistency-based methods.
+
+For further understand this observation, we analyze the behavior of train and test errors in the region of weight space around the solutions of the $\Pi$ and Mean Teacher models. First, we consider the onedimensional rays $\phi ( t ) = t \cdot w _ { 1 8 0 } + ( 1 - t ) w _ { 1 7 0 }$ , $t \geq 0$ , connecting the weight vectors $w _ { 1 7 0 }$ and $w _ { 1 8 0 }$ corresponding to epochs 170 and 180 of training. We visualize the train and test errors (measured on the labeled data) as functions of the distance from the weights $w _ { 1 7 0 }$ in Figure 1b. We observe that the distance between the weight vectors $w _ { 1 7 0 }$ and $w _ { 1 8 0 }$ is much larger for the semi-supervised methods compared to supervised training, which is consistent with our observation that the gradient norms are larger which implies larger steps during optimization in the $\Pi$ and MT models. Further, we observe that the train and test error surfaces are much wider along the directions connecting $w _ { 1 7 0 }$ and $w _ { 1 8 0 }$ for the consistency-based methods compared to supervised training. One possible explanation for the increased width is the effect of the consistency loss on the Jacobian of the network and the eigenvalues of the Hessian of the loss discussed in Section 3.1. We also observe that the test errors of interpolated weights can be lower than errors of the two SGD solutions between which we interpolate. This error reduction is larger in the consistency models (Figure 1b).
+
+We also analyze the error surfaces along random and adversarial rays starting at the SGD solution $w _ { 1 8 0 }$ for each model. For the random rays we sample 5 random vectors $d$ from the unit sphere and calculate the average train and test errors of the network with weights $w _ { t _ { 1 } } + s d$ for $s \in [ 0 , 3 0 ]$ . With adversarial rays we evaluate the error along the directions of the fastest ascent of test or train loss $\begin{array} { r } { d _ { a d v } = \frac { \nabla L _ { C E } } { | | \nabla L _ { C E } | | } } \end{array}$ . We observe that while the solutions of the $\Pi$ and MT models are much wider than supervised training solutions along the SGD-SGD directions (Figure 1b), their widths along random and adversarial rays are comparable (Figure 1c, 1d)
+
+We analyze the error along SGD-SGD rays for two reasons. Firstly, in fast-SWA we are averaging solutions traversed by SGD, so the rays connecting SGD iterates serve as a proxy for the space we average over. Secondly, we are interested in evaluating the width of the solutions that we explore during training which we expect will be improved by the consistency training, as discussed in Section 3.1 and A.6. We expect width along random rays to be less meaningful because there are many directions in the parameter space that do not change the network outputs (Dinh et al., 2017b; GurAri et al., 2018; Sagun et al., 2017). However, by evaluating SGD-SGD rays, we can expect that these directions corresponds to meaningful changes to our model because individual SGD updates correspond to directions that change the predictions on the training set. Furthermore, we observe that different SGD iterates produce significantly different predictions on the test data.
+
+Neural networks in general are known to be resilient to noise, explaining why both MT, ⇧ and supervised models are flat along random directions (Arora et al., 2018). At the same time neural networks are susceptible to targeted perturbations (such as adversarial attacks). We hypothesize that we do not observe improved flatness for semi-supervised methods along adversarial rays because we do not choose our input or weight perturbations adversarially, but rather they are sampled from a predefined set of transformations.
+
+Additionally, we analyze whether the larger optimization steps for the $\Pi$ and MT models translate into higher diversity in predictions. We define diversity of a pair of models $w _ { 1 } , w _ { 2 }$ as Diversity $( w _ { 1 } , w _ { 2 } ) =$ $\begin{array} { r } { \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathbb { 1 } [ y _ { i } ^ { ( w _ { 1 } ) } \neq y _ { i } ^ { ( w _ { 2 } ) } ] } \end{array}$ , the fraction of test samples where the predicted labels between the two models differ. We found that for the $\Pi$ and MT models, the Diversity $( w _ { 1 7 0 } , w _ { 1 8 0 } )$ is $7 . 1 \%$ and $6 . 1 \%$ of the test data points respectively, which is much higher than $3 . 9 \%$ in supervised learning. The increased diversity in the predictions of the networks traversed by SGD supports our conjecture that for the $\Pi$ and MT models SGD struggles to converge to a single solution and continues to actively explore the set of plausible solutions until the end of training.
+
+# 3.3 ENSEMBLING AND WEIGHT AVERAGING
+
+In Section 3.2, we observed that the $\Pi$ and MT models continue taking large steps in the weight space at the end of training. Not only are the distances between weights larger, we observe these models to have higher diversity. In this setting, using the last SGD iterate to perform prediction is not ideal since many solutions explored by SGD are equally accurate but produce different predictions.
+
+Ensembling. In Section 3.2 we showed that the diversity in predictions is significantly larger for the $\Pi$ and Mean Teacher models compared to purely supervised learning. The diversity of these iterates suggests that we can achieve greater benefits from ensembling. We use the same CNN architecture and hyper-parameters as in Section 3.2 but extend the training time by doing 5 learning rate cycles of 30 epochs after the normal training ends at epoch 180 (see A.8 and A.9 for details). We sample random pairs of weights $w _ { 1 }$ , $w _ { 2 }$ from epochs 180, $^ { 1 8 3 , \dots , 3 3 0 }$ and measure the error reduction from ensembling these pairs of models, $\begin{array} { r } { C _ { \mathrm { e n s } } \equiv \frac { 1 } { 2 } \mathrm { E r r } ( w _ { 1 } ) + \frac { 1 } { 2 } \mathrm { E r r } ( w _ { 2 } ) - \mathrm { E r r } \left( \mathrm { E n s e m b l e } ( w _ { 1 } , w _ { 2 } ) \right) } \end{array}$ . In Figure 2c we visualize $C _ { \mathrm { e n s } }$ , against the diversity of the corresponding pair of models. We observe a strong correlation between the diversity in predictions of the constituent models and ensemble performance, and therefore $C _ { \mathrm { e n s } }$ is substantially larger for $\Pi$ and Mean Teacher models. As shown in Izmailov et al. (2018), ensembling can be well approximated by weight averaging if the weights are close by.
+
+Weight Averaging. First, we experiment on averaging random pairs of weights at the end of training and analyze the performance with respect to the weight distances. Using the the same pairs from above, we evaluate the performance of the model formed by averaging the pairs of weights, $\begin{array} { r } { C _ { a v g } ( w _ { 1 } , w _ { 2 } ) \equiv \frac { 1 } { 2 } \mathrm { E r r } ( w _ { 1 } ) + \frac { \hat { 1 } } { 2 } \mathrm { E r r } ( w _ { 2 } ) - \mathrm { E r r } \left( \frac { 1 } { 2 } w _ { 1 } + \frac { 1 } { 2 } w _ { 2 } \right) } \end{array}$ . Note that $C _ { a v g }$ is a proxy for convexity: if $C _ { a v g } ( w _ { 1 } , w _ { 2 } ) \geq 0$ for any pair of points $w _ { 1 }$ , $w _ { 2 }$ , then by Jensen’s inequality the error function is convex (see the left panel of Figure 2). While the error surfaces for neural networks are known to be highly non-convex, they may be approximately convex in the region traversed by SGD late into training (Goodfellow et al., 2015). In fact, in Figure 2b, we find that the error surface of the SGD trajectory is approximately convex due to $C _ { a v g } ( w _ { 1 } , w _ { 2 } )$ being mostly positive. Here we also observe that the distances between pairs of weights are much larger for the $\Pi$ and MT models than for the supervised training; and as a result, weight averaging achieves a larger gain for these models.
+
+In Section 3.2 we observed that for the $\Pi$ and Mean Teacher models SGD traverses a large flat region of the weight space late in training. Being very high-dimensional, this set has most of its volume concentrated near its boundary. Thus, we find SGD iterates at the periphery of this flat region (see Figure 2d). We can also explain this behavior via the argument of (Mandt et al., 2017). Under certain assumptions SGD iterates can be thought of as samples from a Gaussian distribution centered at the minimum of the loss, and samples from high-dimensional Gaussians are known to be concentrated on the surface of an ellipse and never be close to the mean. Averaging the SGD iterates (shown in red in Figure 2d) we can move towards the center (shown in blue) of the flat region, stabilizing the SGD trajectory and improving the width of the resulting solution, and consequently improving generalization.
+
+![](images/dfaa3df25410cdf64c013c726668759e2120f0be634d150a5324881264838c2d.jpg)  
+Figure 2: (a): Illustration of a convex and non-convex function and Jensen’s inequality. (b): Scatter plot of the decrease in error $C _ { \mathrm { a v g } }$ for weight averaging versus distance. (c): Scatter plot of the decrease in error $C _ { \mathrm { e n s } }$ for prediction ensembling versus diversity. (d): Train error surface (orange) and Test error surface (blue). The SGD solutions (red dots) around a locally flat minimum are far apart due to the flatness of the train surface (see Figure 1b) which leads to large error reduction of the SWA solution (blue dot).
+
+We observe that the improvement $C _ { \mathrm { a v g } }$ from weight averaging $( 1 . 2 \pm 0 . 2 \%$ over MT and $\Pi$ pairs) is on par or larger than the benefit $C _ { \mathrm { e n s } }$ of prediction ensembling $( 0 . 9 \pm 0 . 2 \% )$ The smaller gain from ensembling might be due to the dependency of the ensembled solutions, since they are from the same SGD run as opposed to independent restarts as in typical ensembling settings. For the rest of the paper, we focus attention on weight averaging because of its lower costs at test time and slightly higher performance compared to ensembling.
+
+![](images/51e63d83e7f246d913c18de2b9a2986e98ef9bd679b844a5db73d778d97c87ef.jpg)  
+Figure 3: Left: Cyclical cosine learning rate schedule and SWA and fast-SWA averaging strategies. Middle: Illustration of the solutions explored by the cyclical cosine annealing schedule on an error surface. Right: Illustration of SWA and fast-SWA averaging strategies. fast-SWA averages more points but the errors of the averaged points, as indicated by the heat color, are higher.
+
+# 4 SWA AND FAST-SWA
+
+In Section 3 we analyzed the training trajectories of the ⇧, MT, and supervised models. We observed that the $\Pi$ and MT models continue to actively explore the set of plausible solutions, producing diverse predictions on the test set even in the late stages of training. Further, in section 3.3 we have seen that averaging weights leads to significant gains in performance for the ⇧ and MT models. In particular these gains are much larger than in supervised setting.
+
+Stochastic Weight Averaging (SWA) (Izmailov et al., 2018) is a recent approach that is based on averaging weights traversed by SGD with a modified learning rate schedule. In Section 3 we analyzed averaging pairs of weights corresponding to different epochs of training and showed that it improves the test accuracy. Averaging multiple weights reinforces this effect, and SWA was shown to significantly improve generalization performance in supervised learning. Based on our results in section 3.3, we can expect even larger improvements in generalization when applying SWA to the ⇧ and MT models.
+
+SWA typically starts from a pre-trained model, and then averages points in weight space traversed by SGD with a constant or cyclical learning rate. We illustrate the cyclical cosine learning rate schedule in Figure 3 (left) and the SGD solutions explored in Figure 3 (middle). For the first $\ell \leq \ell _ { 0 }$ epochs the network is pre-trained using the cosine annealing schedule where the learning rate at epoch $i$ is set equal to $\eta ( \bar { i } ) = 0 . 5 \cdot \eta _ { 0 } ( 1 + \cos { ( \pi \cdot i / \ell _ { 0 } ) } )$ . After $\ell$ epochs, we use a cyclical schedule, repeating the learning rates from epochs $[ \ell - c , \ell ]$ , where $c$ is the cycle length. SWA collects the networks corresponding to the minimum values of the learning rate (shown in green in Figure 3, left) and averages their weights. The model with the averaged weights $w _ { \mathrm { S W A } }$ is then used to make predictions. We propose to apply SWA to the student network both for the $\Pi$ and Mean Teacher models. Note that the SWA weights do not interfere with training.
+
+Originally, Izmailov et al. (2018) proposed using cyclical learning rates with small cycle length for SWA. However, as we have seen in Section 3.3 (Figure 2, left) the benefits of averaging are the most prominent when the distance between the averaged points is large. Motivated by this observation, we instead use longer learning rate cycles $c$ . Moreover, SWA updates the average weights only once per cycle, which means that many additional training epochs are needed in order to collect enough weights for averaging. To overcome this limitation, we propose fast-SWA, a modification of SWA that averages networks corresponding to every $k < c$ epochs starting from epoch $\ell - c$ . We can also average multiple weights within a single epoch setting $k < 1$ .
+
+Notice that most of the models included in the fast-SWA average (shown in red in Figure 3, left) have higher errors than those included in the SWA average (shown in green in Figure 3, right) since they are obtained when the learning rate is high. It is our contention that including more models in the fast-SWA weight average can more than compensate for the larger errors of the individual models.
+
+Indeed, our experiments in Section 5 show that fast-SWA converges substantially faster than SWA and has lower performance variance. We analyze this result theoretically in Section A.7).
+
+# 5 EXPERIMENTS
+
+We evaluate the $\Pi$ and MT models (Section 4) on CIFAR-10 and CIFAR-100 with varying numbers of labeled examples. We show that fast-SWA and SWA improve the performance of the ⇧ and MT models, as we expect from our observations in Section 3. In fact, in many cases fast-SWA improves on the best results reported in the semi-supervised literature. We also demonstrate that the preposed fast-SWA obtains high performance much faster than SWA. We also evaluate SWA applied to a consistency-based domain adaptation model (French et al., 2018), closely related to the MT model, for adapting CIFAR-10 to STL. We improve the best reported test error rate for this task from $1 9 . 9 \%$ to $1 6 . 8 \%$ .
+
+We discuss the experimental setup in Section 5.1. We provide the results for CIFAR-10 and CIFAR100 datasets in Section 5.2 and 5.3. We summarize our results in comparison to the best previous results in Section 5.4. We show several additional results and detailed comparisons in Appendix A.2. We provide analysis of train and test error surfaces of fast-SWA solutions along the directions connecting fast-SWA and SGD in Section A.1.
+
+# 5.1 SETUP
+
+We evaluate the weight averaging methods SWA and fast-SWA on different network architectures and learning rate schedules. We are able to improve on the base models in all settings. In particular, we consider a 13-layer CNN and a 12-block (26-layer) Residual Network (He et al., 2015) with ShakeShake regularization (Gastaldi, 2017), which we refer to simply as CNN and Shake-Shake respectively (see Section A.8 for details on the architectures). For training all methods we use the stochastic gradient descent (SGD) optimizer with the cosine annealing learning rate described in Section 4. We use two learning rate schedules, the short schedule with $\ell = 1 8 0 , \ell _ { 0 } = 2 1 0 , c = 3 0$ , similar to the experiments in Tarvainen and Valpola (2017), and the long schedule with $\ell = 1 5 0 0 , \ell _ { 0 } = 1 8 0 0 , c =$ 200, similar to the experiments in Gastaldi (2017). We note that the long schedule improves the performance of the base models compared to the short schedule; however, SWA can still further improve the results. See Section A.9 of the Appendix for more details on other hyperparameters. We repeat each CNN experiment 3 times with different random seeds to estimate the standard deviations for the results in the Appendix.
+
+# 5.2 CIFAR-10
+
+![](images/eb5408083dd88ccc9674053056855bb7c16df371ae47a83be9d487f6be8a39a3.jpg)  
+Figure 4: Prediction errors of $\Pi$ and MT models with and without fast-SWA. (a) CIFAR-10 with CNN (b) CIFAR-100 with CNN. $5 0 k +$ and $5 0 k + \ast$ correspond to $5 0 k { + } 5 0 0 k$ and $5 0 k { + } 2 3 7 k ^ { * }$ settings (c) CIFAR-10 with ResNet $^ +$ Shake-Shake using the short schedule (d) CIFAR-10 with ResNet $^ +$ Shake-Shake using the long schedule.
+
+We evaluate the proposed fast-SWA method using the $\Pi$ and MT models on the CIFAR-10 dataset (Krizhevsky). We use $5 0 k$ images for training with $1 k$ , $2 k$ , $4 k$ , $1 0 k$ and $5 0 k$ labels and report the top-1 errors on the test set $1 0 k$ images). We visualize the results for the CNN and Shake-Shake architectures in Figures 4a, 4c, and 4d. For all quantities of labeled data, fast-SWA substantially improves test accuracy in both architectures. Additionally, in Tables 2, 4 of the Appendix we provide a thorough comparison of different averaging strategies as well as results for VAT (Miyato et al., 2017), TE (Laine and Aila, 2016), and other baselines.
+
+Note that we applied fast-SWA for VAT as well which is another popular approach for semi-supervised learning. We found that the improvement on VAT is not drastic – our base implementation obtains $1 1 . 2 6 \%$ error where fast-SWA reduces it to $1 0 . 9 7 \%$ (see Table 2 in Section A.2). It is possible that the solutions explored by VAT are not as diverse as in $\Pi$ and MT models due to VAT loss function. Throughout the experiments, we focus on the $\Pi$ and MT models as they have been shown to scale to powerful networks such as Shake-Shake and obtained previous state-of-the-art performance.
+
+In Figure 5 (left), we visualize the test error as a function of iteration using the CNN. We observe that when the cyclical learning rate starts after epoch $\ell = 1 8 0$ , the base models drop in performance due to the sudden increase in learning rate (see Figure 3 left). However, fast-SWA continues to improve while collecting the weights corresponding to high learning rates for averaging. In general, we also find that the cyclical learning rate improves the base models beyond the usual cosine annealing schedule and increases the performance of fast-SWA as training progresses. Compared to SWA, we also observe that fast-SWA converges substantially faster, for instance, reducing the error to $1 0 . 5 \%$ at epoch 200 while SWA attains similar error at epoch 350 for CIFAR- $1 0 4 k$ labels (Figure 5 left). We provide additional plots in Section A.2 showing the convergence of the ⇧ and MT models in all label settings, where we observe similar trends that fast-SWA results in faster error reduction.
+
+We also find that the performance gains of fast-SWA over base models are higher for the ⇧ model compared to the MT model, which is consistent with the convexity observation in Section 3.3 and Figure 2. In the previous evaluations (see e.g. Oliver et al., 2018; Tarvainen and Valpola, 2017), the ⇧ model was shown to be inferior to the MT model. However, with weight averaging, fast-SWA reduces the gap between ⇧ and MT performance. Surprisingly, we find that the $\Pi$ model can outperform MT after applying fast-SWA with moderate to large numbers of labeled points. In particular, the ⇧+fast-SWA model outperforms MT+fast-SWA on CIFAR-10 with $4 k$ , $1 0 k$ , and $5 0 k$ labeled data points for the Shake-Shake architecture.
+
+![](images/c08cec894ffe7ef71ac77e04adc5b480c337f113ce5e7c425c3ca73b3f8996f6.jpg)  
+Figure 5: Prediction errors of base models and their weight averages (fast-SWA and SWA) for CNN on (left) CIFAR-10 with $4 k$ labels, (middle) CIFAR-100 with $1 0 k$ labels, and (right) CIFAR-100 $5 0 k$ labels and extra $5 0 0 k$ unlabeled data from Tiny Images (Torralba et al., 2008).
+
+5.3 CIFAR-100 AND EXTRA UNLABELED DATA
+
+We evaluate the $\Pi$ and MT models with fast-SWA on CIFAR-100. We train our models using 50000 images with $1 0 k$ and $5 0 k$ labels using the 13-layer CNN. We also analyze the effect of using the Tiny Images dataset (Torralba et al., 2008) as an additional source of unlabeled data.
+
+The Tiny Images dataset consists of 80 million images, mostly unlabeled, and contains CIFAR-100 as a subset. Following Laine and Aila (2016), we use two settings of unlabeled data, $5 0 k { + } 5 0 0 k$ and $5 0 k { + } 2 3 7 k ^ { * }$ where the $5 0 k$ images corresponds to CIFAR-100 images from the training set and the $+ 5 0 0 k$ or $+ 2 3 7 k ^ { * }$ images corresponds to additional $5 0 0 k$ or $2 3 7 k$ images from the Tiny Images dataset. For the $2 3 7 k ^ { * }$ setting, we select only the images that belong to the classes in CIFAR-100, corresponding to 237203 images. For the $5 0 0 k$ setting, we use a random set of $5 0 0 k$ images whose classes can be different from CIFAR-100. We visualize the results in Figure 4b, where we again observe that fast-SWA substantially improves performance for every configuration of the number of labeled and unlabeled data. In Figure 5 (middle, right) we show the errors of MT, SWA and fast-SWA as a function of iteration on CIFAR-100 for the $1 0 k$ and $5 0 k { + } 5 0 0 k$ label settings. Similar to the CIFAR-10 experiments, we observe that fast-SWA reduces the errors substantially faster than SWA.
+
+We provide detailed experimental results in Table 3 of the Appendix and include preliminary results using the Shake-Shake architecture in Table 5, Section A.2.
+
+# 5.4 ADVANCING STATE-OF-THE-ART
+
+We have shown that fast-SWA can significantly improve the performance of both the $\Pi$ and MT models. We provide a summary comparing our results with the previous best results in the literature in Table 1, using the 13-layer CNN and the Shake-Shake architecture that had been applied previously. We also provide detailed results the Appendix A.2.
+
+Table 1: Test errors against current state-of-the-art semi-supervised results. The previous best numbers are obtained from (Tarvainen and Valpola, 2017) 1, (Park et al., $2 0 1 7 ) ^ { 2 }$ , (Laine and Aila, $2 0 1 6 ) ^ { 3 }$ and (Luo et al., $2 0 1 8 ) ^ { 4 }$ . CNN denotes performance on the benchmark 13-layer CNN (see A.8). Rows marked † use the Shake-Shake architecture. The result marked ‡ are from $\Pi +$ fast-SWA, where the rest are based on $\mathbf { M T } +$ fast-SWA. The settings $5 0 k { + } 5 0 0 k$ and $5 0 k { + } 2 3 7 k ^ { * }$ use additional $5 0 0 k$ and $2 3 7 k$ unlabeled data from the Tiny Images dataset (Torralba et al., 2008) where ⇤ denotes that we use only the images that correspond to CIFAR-100 classes.   
+
+<table><tr><td rowspan="2">Dataset No. of Images</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td></tr><tr><td>50k 1k</td><td>50k 2k</td><td>50k 4k</td><td>50k 10k</td><td>50k+500k 50k</td><td>50k+237k* 50k</td></tr><tr><td>No. of Labels Previous Best CNN Ours CNN</td><td>18.414</td><td>13.644</td><td>9.22</td><td>38.653</td><td>23.623</td><td>23.793</td></tr><tr><td rowspan="2">Previous Best† Ourst</td><td>15.58</td><td>11.02</td><td>9.05</td><td>33.62</td><td>21.04</td><td>20.98</td></tr><tr><td>6.6</td><td>5.7</td><td>6.281 5.0</td><td>28.0</td><td>19.3</td><td>17.7</td></tr></table>
+
+# 5.5 PRELIMINARY RESULTS ON DOMAIN ADAPTATION
+
+Domain adaptation problems involve learning using a source domain $X _ { s }$ equipped with labels $Y _ { s }$ and performing classification on the target domain $X _ { t }$ while having no access to the target labels at training time. A recent model by French et al. (2018) applies the consistency enforcing principle for domain adaptation and achieves state-of-the-art results on many datasets. Applying fast-SWA to this model on domain adaptation from CIFAR-10 to STL we were able to improve the best results reported in the literature from $1 9 . 9 \%$ to $1 6 . 8 \%$ . See Section A.10 for more details on the domain adaptation experiments.
+
+# 6 DISCUSSION
+
+Semi-supervised learning is crucial for reducing the dependency of deep learning on large labeled datasets. Recently, there have been great advances in semi-supervised learning, with consistency regularization models achieving the best known results. By analyzing solutions along the training trajectories for two of the most successful models in this class, the $\Pi$ and Mean Teacher models, we have seen that rather than converging to a single solution SGD continues to explore a diverse set of plausible solutions late into training. As a result, we can expect that averaging predictions or weights will lead to much larger gains in performance than for supervised training. Indeed, applying a variant of the recently proposed stochastic weight averaging (SWA) we advance the best known semi-supervised results on classification benchmarks.
+
+While not the focus of our paper, we have also shown that weight averaging has great promise in domain adaptation (French et al., 2018). We believe that application-specific analysis of the geometric properties of the training objective and optimization trajectories will further improve results over a wide range of application specific areas, including reinforcement learning with sparse rewards, generative adversarial networks (Yazıcı et al., 2018), or semi-supervised natural language processing.
+
+REFERENCES   
+S. Arora, R. Ge, B. Neyshabur, and Y. Zhang. Stronger generalization bounds for deep nets via a compression approach. In ICML, 2018.   
+H. Avron and S. Toledo. Randomized algorithms for estimating the trace of an implicit symmetric positive semi-definite matrix. Journal of the ACM, 58(2):1–34, Apr. 2011. ISSN 00045411. doi: 10.1145/1944345.1944349.   
+P. Bachman, O. Alsharif, and D. Precup. Learning with pseudo-ensembles. In Advances in Neural Information Processing Systems, pages 3365–3373, 2014.   
+P. Chaudhari, A. Choromanska, S. Soatto, Y. LeCun, C. Baldassi, C. Borgs, J. Chayes, L. Sagun, and R. Zecchina. Entropy-SGD: Biasing Gradient Descent Into Wide Valleys. arXiv:1611.01838 [cs, stat], Nov. 2016. arXiv: 1611.01838.   
+L. Dinh, R. Pascanu, S. Bengio, and Y. Bengio. Sharp Minima Can Generalize For Deep Nets. arXiv:1703.04933 [cs], Mar. 2017a.   
+L. Dinh, R. Pascanu, S. Bengio, and Y. Bengio. Sharp minima can generalize for deep nets. In ICML, 2017b.   
+G. French, M. Mackiewicz, and M. Fisher. Self-ensembling for visual domain adaptation. In International Conference on Learning Representations, 2018.   
+X. Gastaldi. Shake-shake regularization. CoRR, abs/1705.07485, 2017.   
+I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.   
+I. Goodfellow, O. Vinyals, and A. Saxe. Qualitatively characterizing neural network optimization problems. International Conference on Learning Representations, 2015.   
+G. Gur-Ari, D. A. Roberts, and E. Dyer. Gradient descent happens in a tiny subspace. In CoRR, 2018.   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015.   
+P. Izmailov, D. Podoprikhin, T. Garipov, D. Vetrov, and A. G. Wilson. Averaging weights leads to wider optima and better generalization. arXiv preprint arXiv:1803.05407, 2018.   
+N. S. Keskar, D. Mudigere, J. Nocedal, M. Smelyanskiy, and P. T. P. Tang. On large-batch training for deep learning: Generalization gap and sharp minima. ICLR, 2017.   
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. ICLR, 2015.   
+A. Krizhevsky. Learning Multiple Layers of Features from Tiny Images. page 60.   
+S. Laine and T. Aila. Temporal Ensembling for Semi-Supervised Learning. arXiv:1610.02242 [cs], Oct. 2016.   
+S. Laine and T. Aila. Temporal ensembling for semi-supervised learning. International Conference on Learning Representations, 2017.   
+I. Loshchilov and F. Hutter. SGDR: stochastic gradient descent with restarts. CoRR, abs/1608.03983, 2016.   
+Y. Luo, J. Zhu, M. Li, Y. Ren, and B. Zhang. Smooth neighbors on teacher graphs for semi-supervised learning. In CVPR, 2018.   
+S. Mandt, M. D. Hoffman, and D. M. Blei. Stochastic gradient descent as approximate bayesian inference. arXiv preprint arXiv:1704.04289, 2017.   
+T. Miyato, S. Maeda, M. Koyama, and S. Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. CoRR, abs/1704.03976, 2017.   
+R. Novak, Y. Bahri, D. A. Abolafia, J. Pennington, and J. Sohl-Dickstein. Sensitivity and generalization in neural networks: an empirical study. ICLR, 2018.   
+A. Oliver, A. Odena, C. Raffel, E. D. Cubuk, and I. J. Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms. ICLR Workshop, 2018.   
+S. Park, J.-K. Park, S.-J. Shin, and I.-C. Moon. Adversarial Dropout for Supervised and Semisupervised Learning. arXiv:1707.03631 [cs], July 2017. arXiv: 1707.03631.   
+L. Sagun, U. Evci, V. U. Güney, Y. Dauphin, and L. Bottou. Empirical analysis of the hessian of over-parametrized neural networks. CoRR, 2017.   
+M. Sajjadi, M. Javanmardi, and T. Tasdizen. Regularization With Stochastic Transformations and Perturbations for Deep Semi-Supervised Learning. arXiv:1606.04586 [cs], June 2016. arXiv: 1606.04586.   
+J. Schmidhuber and S. Hochreiter. Flat minima. Neural Computation, 1997.   
+R. Shu, H. Bui, H. Narui, and S. Ermon. A DIRT-t approach to unsupervised domain adaptation. In International Conference on Learning Representations, 2018.   
+J. Sokolic, R. Giryes, G. Sapiro, and M. R. Rodrigues. Robust large margin deep neural networks. ´ IEEE Transactions on Signal Processing, 65(16):4265–4280, 2017.   
+N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1): 1929–1958, 2014.   
+A. Tarvainen and H. Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NIPS, 2017.   
+A. Torralba, R. Fergus, and W. T. Freeman. 80 million tiny images: A large data set for nonparametric object and scene recognition. IEEE Trans. Pattern Anal. Mach. Intell., 30(11):1958–1970, 2008.   
+Y. Yazıcı, C.-S. Foo, S. Winkler, K.-H. Yap, G. Piliouras, and V. Chandrasekhar. The Unusual Effectiveness of Averaging in GAN Training. ArXiv, 2018.   
+X. Zhu, Z. Ghahramani, and J. Lafferty. Semi-Supervised Learning Using Gaussian Fields and Harmonic Functions. ICML, 2003.
+
+# A APPENDIX
+
+# A.1 ADDITIONAL PLOTS
+
+![](images/a1ca95b2a0626225a9995ea3afc7eaaef08f08755943c1c19859a575711fdfab.jpg)  
+Figure 6: All plots are a obtained using the 13-layer CNN on CIFAR-10 with $4 k$ labeled and $4 6 k$ unlabeled data points unless specified otherwise. Left: Test error as a function of distance along random rays for the $\Pi$ model with 0, $4 k$ , $1 0 k$ , $2 0 k$ or $4 6 k$ unlabeled data points, and standard fully supervised training which uses only the cross entropy loss. All methods use $4 k$ labeled examples. Middle: Train and test errors along rays connecting SGD solutions (showed with circles) to SWA solutions (showed with squares) for each respective model. Right: Comparison of train and test errors along rays connecting two SGD solutions, random rays, and adversarial rays for the Mean Teacher model.
+
+In this section we provide several additional plots visualizing the train and test error along different types of rays in the weight space. The left panel of Figure 6 shows how the behavior of test error changes as we add more unlabeled data points for the ⇧ model. We observe that the test accuracy improves monotonically, but also the solutions become narrower along random rays.
+
+The middle panel of Figure 6 visualizes the train and test error behavior along the directions connecting the fast-SWA solution (shown with squares) to one of the SGD iterates used to compute the average (shown with circles) for ⇧, MT and supervised training. Similarly to Izmailov et al. (2018) we observe that for all three methods fast-SWA finds a centered solution, while the SGD solution lies near the boundary of a wide flat region. Agreeing with our results in section 3.2 we observe that for $\Pi$ and Mean Teacher models the train and test error surfaces are much wider along the directions connecting the fast-SWA and SGD solutions than for supervised training.
+
+In the right panel of Figure 6 we show the behavior of train and test error surfaces along random rays, adversarial rays and directions connecting the SGD solutions from epochs 170 and 180 for the Mean Teacher model (see section 3.2).
+
+![](images/3488f816a32e2839f8de1167b57f7c40744f1a59a2e500325dd19f66ff935520.jpg)  
+Figure 7: (Left): The evolution of the gradient covariance trace in the $\Pi$ , MT, and supervised models during training. (Middle): Scatter plot of the decrease in error $C _ { a v g }$ for weight averaging versus diversity. (Right): Scatter plot of the distance between pairs of weights versus diversity in their predictions.
+
+In the left panel of Figure 7 we show the evolution of the trace of the gradient of the covariance of the loss
+
+$$
+\mathrm { t r } \cos ( \nabla _ { \boldsymbol { w } } L ( \boldsymbol { w } ) ) = \mathbb { E } \| \nabla _ { \boldsymbol { w } } L ( \boldsymbol { w } ) - \mathbb { E } \nabla _ { \boldsymbol { w } } L ( \boldsymbol { w } ) \| ^ { 2 }
+$$
+
+for the ⇧, MT and supevised training. We observe that the variance of the gradient is much larger for the ⇧ and Mean Teacher models compared to supervised training.
+
+In the middle and right panels of figure 7 we provide scatter plots of the improvement $C$ obtained from averaging weights against diversity and diversity against distance. We observe that diversity is highly correlated with the improvement $C$ coming from weight averaging. The correlation between distance and diversity is less prominent.
+
+# A.2 DETAILED RESULTS
+
+In this section we report detailed results for the $\Pi$ and Mean Teacher models and various baselines on CIFAR-10 and CIFAR-100 using the 13-layer CNN and Shake-Shake.
+
+The results using the 13-layer CNN are summarized in Tables 2 and 3 for CIFAR-10 and CIFAR-100 respectively. Tables 4 and 5 summarize the results using Shake-Shake on CIFAR-10 and CIFAR100. In the tables ⇧ EMA is the same method as $\Pi$ , where instead of SWA we apply Exponential Moving Averaging (EMA) for the student weights. We show that simply performing EMA for the student network in the ⇧ model without using it as a teacher (as in MT) typically results in a small improvement in the test error.
+
+Figures 8 and 9 show the performance of the $\Pi$ and Mean Teacher models as a function of the training epoch for CIFAR-10 and CIFAR-100 respectively for SWA and fast-SWA.
+
+Table 2: CIFAR-10 semi-supervised errors on test set with a 13-layer CNN. The epoch numbers are reported in parenthesis. The previous results shown in the first section of the table are obtained from Tarvainen and Valpola (2017) 1, Park et al. $( 2 0 1 7 ) ^ { 2 }$ , Laine and Aila $\left( 2 0 1 6 \right) ^ { 3 }$ , Miyato et al. $( 2 0 1 7 ) ^ { 4 }$ .   
+
+<table><tr><td>Number of labels</td><td>1000</td><td>2000</td><td>4000</td><td>10000</td><td>50000</td></tr><tr><td>TE3</td><td></td><td></td><td>12.16 ± 0.31</td><td></td><td>5.60 ± 0.15</td></tr><tr><td>Supervised-onlyl</td><td>46.43 ± 1.21</td><td>33.94 ± 0.73</td><td>20.66 ± 0.57</td><td></td><td>5.82 ± 0.15</td></tr><tr><td></td><td>27.36 ± 1.20</td><td>18.02 ± 0.60</td><td>13.20 ± 0.27</td><td></td><td>6.06 ± 0.15</td></tr><tr><td>MT1</td><td>21.55 ±1.48</td><td>15.73 ± 0.31</td><td>12.31 ± 0.28</td><td></td><td>5.94 ± 0.15</td></tr><tr><td>VAdD3</td><td></td><td></td><td>9.22 ± 0.10</td><td></td><td>4.40 ± 0.12</td></tr><tr><td>VAT + EntMin4</td><td></td><td></td><td>10.55</td><td></td><td></td></tr><tr><td>MT</td><td>18.78 ± 0.31</td><td>14.43 ± 0.20</td><td>11.41 ± 0.27</td><td>8.74 ± 0.30</td><td>5.98 ± 0.21</td></tr><tr><td>MT+ fast-SWA (180)</td><td>18.19 ± 0.38</td><td>13.46 ± 0.30</td><td>10.67 ± 0.18</td><td>8.06 ± 0.12</td><td>5.90 ± 0.03</td></tr><tr><td>MT + fast-SWA (240)</td><td>17.81 ± 0.37</td><td>13.00 ± 0.31</td><td>10.34 ± 0.14</td><td>7.73 �� 0.10</td><td>5.55 ± 0.03</td></tr><tr><td>MT + SWA (240)</td><td>18.38 ± 0.29</td><td>13.86 ± 0.64</td><td>10.95 ± 0.21</td><td>8.36 ± 0.50</td><td>5.75 ± 0.29</td></tr><tr><td>MT + fast-SWA (480)</td><td>16.84 ± 0.62</td><td>12.24 ± 0.31</td><td>9.86 ± 0.27</td><td>7.39 ± 0.14</td><td>5.14 ± 0.07</td></tr><tr><td>MT + SWA (480)</td><td>17.48 ± 0.13</td><td>13.09 ± 0.80</td><td>10.30 ± 0.21</td><td>7.78 ± 0.49</td><td>5.31 ± 0.43</td></tr><tr><td>MT+ fast-SWA (1200)</td><td>15.58 ± 0.12</td><td>11.02 ± 0.23</td><td>9.05 ± 0.21</td><td>6.92 ± 0.07</td><td>4.73 ± 0.18</td></tr><tr><td>MT + SWA (1200)</td><td>15.59 ± 0.77</td><td>11.42 ± 0.33</td><td>9.38 ± 0.28</td><td>7.04 ± 0.11</td><td>5.11 ± 0.35</td></tr><tr><td>ⅡI</td><td>21.85 ± 0.69</td><td>16.10 ± 0.51</td><td>12.64 ± 0.11</td><td>9.11 ± 0.21</td><td>6.79 ± 0.22</td></tr><tr><td>II EMA</td><td>21.70 ± 0.57</td><td>15.83 ± 0.55</td><td>12.52 ± 0.16</td><td>9.06 ± 0.15</td><td>6.66 ± 0.20</td></tr><tr><td>II + fast-SWA (180)</td><td>20.79 ± 0.38</td><td>15.12 ± 0.44</td><td>11.91 ± 0.06</td><td>8.83 ± 0.32</td><td>6.42 ± 0.09</td></tr><tr><td>II + fast-SWA (240)</td><td>20.04 ± 0.41</td><td>14.77 ± 0.15</td><td>11.61 ± 0.06</td><td>8.45 ± 0.28</td><td>6.14 ± 0.11</td></tr><tr><td>II + SWA (240)</td><td>21.37 ± 0.64</td><td>15.38 ± 0.85</td><td>12.05 ± 0.40</td><td>8.58 ± 0.41</td><td>6.36 ± 0.55</td></tr><tr><td>II + fast-SWA (480)</td><td>19.11 ± 0.29</td><td>13.88 ± 0.30</td><td>10.91 ± 0.15</td><td>7.91 ± 0.21</td><td>5.53 ± 0.07</td></tr><tr><td>II + SWA (480)</td><td>20.06 ± 0.64</td><td>14.53 ± 0.81</td><td>11.35 ± 0.42</td><td>8.04 ± 0.37</td><td>5.77 ± 0.51</td></tr><tr><td>II + fast-SWA (1200)</td><td>17.23 ± 0.34</td><td>12.61 ± 0.18</td><td>10.07 ± 0.27</td><td>7.28 ± 0.23</td><td>4.72 ± 0.04</td></tr><tr><td>II + SWA (1200)</td><td>17.70 ± 0.25</td><td>12.59 ± 0.29</td><td>10.73 ± 0.39</td><td>7.13 ± 0.23</td><td>4.99 ± 0.41</td></tr><tr><td>VAT</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VAT+SWA</td><td></td><td></td><td>11.99</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td>11.16</td><td></td><td></td></tr><tr><td>VAT+ EntMin</td><td></td><td></td><td>11.26</td><td></td><td></td></tr><tr><td>VAT + EntMin + SWA</td><td></td><td></td><td>10.97</td><td></td><td></td></tr></table>
+
+Table 3: CIFAR-100 semi-supervised errors on test set. All models are trained on a 13-layer CNN. The epoch numbers are reported in parenthesis. The previous results shown in the first section of the table are obtained from (Laine and Aila, $2 0 1 6 ) ^ { 3 }$ .   
+
+<table><tr><td>Number of labels</td><td>10k</td><td>50k</td><td>50k +500k</td><td>50k+237k*</td></tr><tr><td>Supervised-only3</td><td>44.56 ± 0.30</td><td>26.42 ± 0.17</td><td></td><td></td></tr><tr><td>II model3</td><td>39.19 ± 0.54</td><td>26.32 ± 0.04</td><td>25.79 ± 0.17</td><td>25.43 ± 0.17</td></tr><tr><td>Temporal Ensembling3</td><td>38.65 ± 0.51</td><td>26.30 ± 0.15</td><td>23.62 ± 0.17</td><td>23.79 ± 0.17</td></tr><tr><td>MT (180) MT + fast-SWA (180)</td><td>35.96 ± 0.77</td><td>23.37 ± 0.16</td><td>23.18 ± 0.06</td><td>23.18 ± 0.24</td></tr><tr><td>MT + SWA (240)</td><td>34.54 ± 0.48 35.59 ± 1.45</td><td>21.93 ± 0.16 23.17 ± 0.86</td><td>21.04 ± 0.16 22.00 ± 0.23</td><td>21.09 ± 0.12 21.59 ± 0.22</td></tr><tr><td>MT + fast-SWA (240)</td><td>34.10 ± 0.31</td><td>21.84 ± 0.12</td><td>21.16 ± 0.21</td><td>21.07 ± 0.21</td></tr><tr><td>MT + SWA (1200)</td><td>34.90 ± 1.51</td><td>22.58 ± 0.79</td><td>21.47 ± 0.29</td><td>21.27 ± 0.09</td></tr><tr><td>MT + fast-SWA (1200)</td><td></td><td>21.52 ± 0.12</td><td></td><td></td></tr><tr><td></td><td>33.62 ± 0.54</td><td></td><td>21.04 ± 0.04</td><td>20.98 ± 0.36</td></tr><tr><td>I (180)</td><td>38.13 ± 0.52</td><td>24.13 ± 0.20</td><td>24.26 ± 0.15</td><td>24.10 ± 0.07</td></tr><tr><td>II + fast-SWA (180)</td><td>35.59 ± 0.62</td><td>22.08 ± 0.21</td><td>21.40 ± 0.19</td><td>21.28 ± 0.20</td></tr><tr><td>II + SWA (240)</td><td>36.89 ± 1.51</td><td>23.23 ± 0.70</td><td>22.17 ± 0.19</td><td>21.65 ± 0.13</td></tr><tr><td>II + fast-SWA (240)</td><td>35.14 ± 0.71</td><td>22.00 ± 0.21</td><td>21.29 ± 0.27</td><td>21.22 ± 0.04</td></tr><tr><td>II + SWA (1200)</td><td>35.35 ± 1.15</td><td>22.53 ± 0.64</td><td>21.53 ± 0.13</td><td>21.26 ± 0.34</td></tr><tr><td>II + fast-SWA (1200)</td><td>34.25 ± 0.16</td><td>21.78 ± 0.05</td><td>21.19 ± 0.05</td><td>20.97 ± 0.08</td></tr></table>
+
+Table 4: CIFAR-10 semi-supervised errors on test set. All models use Shake-Shake Regularization (Gastaldi, 2017) $^ +$ ResNet-26 (He et al., 2015).   
+
+<table><tr><td>Number of labels</td><td>1000 2000</td><td>4000</td><td>10000</td><td></td><td>50000</td></tr><tr><td>Short Schedule (l = 180) MTt (Tarvainen and Valpola, 2017)</td><td></td><td></td><td>6.28</td><td></td><td></td></tr><tr><td>MT (180) MT + SWA (240) MT + fast-SWA (240)</td><td>10.2 9.7 9.6 7.6</td><td>8.0 7.7 7.4 6.4</td><td>7.1 6.2 6.2</td><td>5.8 4.9 4.9 4.6</td><td>3.9 3.4 3.2</td></tr><tr><td>MT + SWA (1200) MT+ fast-SWA (1200) II (180) II + SWA (240) II + fast-SWA (240) II + SWA (1200) I + fast-SWA (1200)</td><td>7.5 12.3 11.0 11.2 8.2 8.0</td><td>6.3 9.1 8.3 8.2 6.7 6.5</td><td>5.8 7.5 6.7 6.7 5.7 5.5</td><td>4.5 6.4 5.5 5.5 4.2</td><td>3.1 3.8 3.3 3.3 3.1</td></tr><tr><td>Long Schedule (l = 1500)</td><td></td><td></td><td></td><td>4.0</td><td>3.1</td></tr><tr><td>Supervised-only (Gastaldi,2017)</td><td></td><td></td><td></td><td></td><td>2.86</td></tr><tr><td>MT (1500)</td><td>7.5 6.4</td><td>6.5</td><td>6.0</td><td>5.0</td><td>3.5</td></tr><tr><td>MT + fast-SWA (1700)</td><td>6.9</td><td>5.8</td><td>5.2</td><td>3.8 4.2</td><td>3.4</td></tr><tr><td>MT + SWA (1700)</td><td></td><td>5.9</td><td>5.5</td><td></td><td>3.2</td></tr><tr><td>MT + fast-SWA (3500)</td><td>6.6</td><td>5.7</td><td>5.1</td><td>3.9</td><td>3.1</td></tr><tr><td>MT + SWA (3500)</td><td>6.7</td><td>5.8</td><td>5.2</td><td>3.9</td><td>3.1</td></tr><tr><td>II (1500)</td><td>8.5</td><td>7.0</td><td>6.3</td><td>5.0</td><td></td></tr><tr><td></td><td>7.5</td><td>6.2</td><td>5.2</td><td>4.0</td><td>3.4</td></tr><tr><td>II + fast-SWA (1700)</td><td></td><td></td><td></td><td></td><td>3.1</td></tr><tr><td>II + SWA (1700)</td><td>7.8</td><td>6.4</td><td>5.6</td><td>4.4</td><td>3.2</td></tr><tr><td>II + fast-SWA (3500)</td><td>7.4</td><td>6.0</td><td>5.0</td><td>3.8</td><td>3.0</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>II + SWA (3500)</td><td>7.9</td><td>6.2</td><td>5.1</td><td>4.0</td><td>3.0</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 5: CIFAR-100 semi-supervised errors on test set. Our models use Shake-Shake Regularization (Gastaldi, 2017) $^ +$ ResNet-26 (He et al., 2015).   
+
+<table><tr><td>Number of labels</td><td>10k</td><td>50k</td><td>50k + 500k</td><td>50k+237k*</td></tr><tr><td>TE (CNN) (Laine and Aila, 2016)</td><td>38.65 ± 0.51</td><td>26.30 ± 0.15</td><td>23.62 ± 0.17</td><td>23.79 ± 0.17</td></tr><tr><td>Short Schedule (l = 180)</td><td></td><td></td><td></td><td></td></tr><tr><td>MT (180)</td><td>29.4</td><td>19.5</td><td>21.9</td><td>19.0</td></tr><tr><td>MT + fast-SWA (180)</td><td>28.9</td><td>19.3</td><td>19.7</td><td>18.3</td></tr><tr><td>MT + SWA (240)</td><td>28.4</td><td>18.8</td><td>19.9</td><td>17.9</td></tr><tr><td>MT + fast-SWA (240)</td><td>28.1</td><td>18.8</td><td>19.5</td><td>17.9</td></tr><tr><td>MT + SWA (300)</td><td>28.1</td><td>18.5</td><td>18.9</td><td>17.5</td></tr><tr><td>MT + fast-SWA (300)</td><td>28.0</td><td>18.4</td><td>19.3</td><td>17.7</td></tr></table>
+
+![](images/9ad0ecd974df4e3fd730a33484858190944466b4e3c1cc4b4b63089041abeaf8.jpg)  
+Figure 8: Test errors as a function of training epoch for baseline models, SWA and fast-SWA on CIFAR-10 trained using $1 k$ , $2 k$ , $4 k$ , and $1 0 k$ labels for (top) the MT model (bottom) the ⇧ model. All models are trained using the 13-layer CNN.
+
+![](images/8b4b83b78db5ca1275e52aab80896f82053eb2592b47f833be0be1cd5b5e5681.jpg)  
+Figure 9: Test errors versus training epoch for baseline models, SWA and fast-SWA on CIFAR-100 trained using $1 0 k$ , $5 0 k$ , $5 0 k { + } 5 0 0 k$ , and $5 0 k { + } 2 3 7 k ^ { * }$ labels for (top) the MT model (bottom) the ⇧ model. All models are trained using the 13-layer CNN.
+
+# A.3 EFFECT OF LEARNING RATE SCHEDULES
+
+The only hyperparameter for the fast-SWA setting is the cycle length $c$ . We demonstrate in Figure 10a that fast-SWA’s performance is not sensitive to $c$ over a wide range of $c$ values. We also demonstrate the performance for constant learning schedule. fast-SWA with cyclical learning rates generally converges faster due to higher variety in the collected weights.
+
+![](images/7027dd7c8a8d3f9fea2497da4ed35a47295674833e7bc9a4af7f1b0d4dde1e0a.jpg)  
+Figure 10: The plots are generated using the MT model with CNN trained on CIFAR-10. We randomly select $5 k$ of the $5 0 k$ train images as a validation set. The remaining $4 5 k$ images are splitted into $4 k$ labeled and $4 1 k$ unlabeled data points. (a) Validation accuracy as a function of training epoch for different cycle lengths $c$ (b) fast-SWA with constant learning rate. The “learning rate epoch” corresponds to the epoch in the unmodified cosine annealing schedule (Figure 3, left) at which the learning rate is evaluated. We use this fixed learning rate for all epochs $i \geq \ell$ .
+
+# A.4 EMA VERSUS SWA AS A TEACHER
+
+The MT model uses an exponential moving average (EMA) of the student weights as a teacher in the consistency regularization term. We consider two potential effects of using EMA as a teacher: first, averaging weights improves performance of the teacher for the reasons discussed in Sections 3.2, 3.3; second, having a better teacher model leads to better student performance which in turn further improves the teacher. In this section we try to separate these two effects. We apply EMA to the ⇧ model in the same way in which we apply fast-SWA instead of using EMA as a teacher and compare the resulting performance to the Mean Teacher. Figure 11 shows the improvement in error-rate obtained by applying EMA to the ⇧ model in different label settings. As we can see while EMA improves the results over the baseline ⇧ model, the performance of ⇧-EMA is still inferior to that of the Mean Teacher method, especially when the labeled data is scarce. This observation suggests that the improvement of the Mean Teacher over the ⇧ model can not be simply attributed to EMA improving the student performance and we should take the second effect discussed above into account.
+
+Like SWA, EMA is a way to average weights of the networks, but it puts more emphasis on very recent models compared to SWA. Early in training when the student model changes rapidly EMA significantly improves performance and helps a lot when used as a teacher. However once the student model converges to the vicinity of the optimum, EMA offers little gain. In this regime SWA is a much better way to average weights. We show the performance of SWA applied to ⇧ model in Figure 11 (left).
+
+![](images/9ce59d666ed4cce3b9b971deca72da32c3d3f8740f3a2c41f0a71ef287179b00.jpg)  
+Figure 11: (left) Comparison of different averaging methods. The y axis corresponds to the increased error with respect to the MT model with fast-SWA solution (which has $y = 0$ ). All numbers are taken from epoch 180. (right) The effects of using SWA as a teacher. W-T model corresponds to the performance of a model with weight W using a model with a teacher being T.
+
+Since SWA performs better than EMA, we also experiment with using SWA as a teacher instead of EMA. We start with the usual MT model pretrained until epoch 150. Then we switch to using SWA as a teacher at epoch 150. In Figure 11 (right), our results suggest that using SWA as a teacher performs on par with using EMA as a teacher. We conjecture that once we are at a convex region of test error close to the optimum (epoch 150), having a better teacher doesn’t lead to substantially improved performance. It is possible to start using SWA as a teacher earlier in training; however, during early epochs where the model undergoes rapid improvement EMA is more sensible than SWA as we discussed above.
+
+# A.5 CONSISTENCY LOSS APPROXIMATES JACOBIAN NORM
+
+Estimator mean and variance: In the simplified $\Pi$ model with small additive data perturbations that are normally distributed, $z \sim \mathcal { N } ( 0 , I )$ ,
+
+$$
+\begin{array} { r } { \hat { Q } = \underset { \epsilon \to 0 } { \operatorname* { l i m } } \frac { 1 } { \epsilon ^ { 2 } } \frac { 1 } { m } \displaystyle \sum _ { i = 1 } ^ { m } \ell _ { c o n s } ( w , x _ { i } , \epsilon ) = \frac { 1 } { m } \displaystyle \sum _ { i = 1 } ^ { m } \underset { \epsilon \to 0 } { \operatorname* { l i m } } \frac { 1 } { \epsilon ^ { 2 } } \| f ( w , x _ { i } + \epsilon z _ { i } ) - f ( w , x _ { i } ) \| ^ { 2 } } \end{array}
+$$
+
+Taylor expanding $\ell _ { c o n s }$ in $\epsilon$ , we obtain $\ell _ { c o n s } ( w , x , \epsilon ) = \epsilon ^ { 2 } z ^ { T } J _ { x } ^ { T } J _ { x } z + O ( \epsilon ^ { 4 } )$ , where $J _ { x }$ is the Jacobian of the network outputs $f$ with respect to the input at a particular value of $x$ . Therefore,
+
+$$
+\begin{array} { r } { \hat { Q } _ { i } = \underset { \epsilon  0 } { \operatorname* { l i m } } \frac { 1 } { \epsilon ^ { 2 } } \ell _ { c o n s } ( w , x _ { i } , \epsilon ) = z _ { i } ^ { T } J ( x _ { i } ) ^ { T } J ( x _ { i } ) z _ { i } . } \end{array}
+$$
+
+We can now recognize this term as a one sample stochastic trace estimator for $\operatorname { t r } ( J ( x _ { i } ) ^ { T } J ( x _ { i } ) )$ with a Gaussian probe variable $z _ { i }$ ; see Avron and Toledo (2011) for derivations and guarantees on stochastic trace estimators.
+
+$$
+\mathbb { E } _ { z } [ \hat { Q } _ { i } ] = \mathrm { t r } \left( J ( x _ { i } ) ^ { T } J ( x _ { i } ) \mathbb { E } [ z _ { i } z _ { i } ^ { T } ] \right) = \| J ( x _ { i } ) \| _ { F } ^ { 2 } .
+$$
+
+Taking an expectation over the $m$ samples of $x$ , we get $\mathbb { E } [ \hat { Q } ] = \mathbb { E } _ { x } [ \| J _ { x } \| _ { F } ^ { 2 }$ .
+
+In general if we have $m$ samples of $x$ and $n$ sampled perturbations for each $x$ , then for a symmetric matrix $A$ with $z _ { i k } \stackrel { i i d } { \sim } N ( 0 , I )$ and independent $x _ { i } \stackrel { i i d } { \sim } p ( x )$ ,
+
+the estimator
+
+$$
+\begin{array} { l } { { \displaystyle \hat { Q } = \frac { 1 } { m } \sum _ { i } ^ { m } \frac { 1 } { n } \sum _ { k } ^ { n } z _ { i k } ^ { T } A ( x _ { i } ) z _ { i k } \quad \mathrm { ~ h a s ~ v a r i a n c e ~ } } } \\ { { \displaystyle ~ \mathrm { V a r } [ \hat { Q } ] = \frac { 1 } { m } \biggl ( \mathrm { V a r } [ \mathrm { t r } ( A ) ] + \frac { 2 } { n } \mathbb { E } [ \mathrm { t r } ( A ^ { 2 } ) ] \biggr ) . } } \end{array}
+$$
+
+Proof: Let $q _ { i k } \equiv z _ { i k } ^ { T } A ( x _ { i } ) z _ { i k }$ . It is easy to show that for fixed $x$ , $\mathbb { E } _ { z } [ q _ { 1 1 } | x _ { 1 } ] = 2 \mathrm { t r } ( A ( x _ { 1 } ) ^ { 2 } ) +$ $\operatorname { t r } ( A ( x _ { 1 } ) ) ^ { 2 }$ , (see e.g. Avron and Toledo, 2011). Note that $\mathbb { E } _ { z _ { 1 } , z _ { 2 } } [ q _ { i 1 } q _ { i 2 } | x _ { i } ] = \operatorname { t r } ( A ( x _ { i } ) ) ^ { 2 }$ . Since $\textstyle { \left\{ { \frac { 1 } { n } } \sum _ { k } ^ { n } q _ { i k } \right\} _ { i = 1 } ^ { m } }$ are i.i.d random variables,
+
+$$
+\mathrm { V a r } \bigl [ \frac { 1 } { m } \sum _ { i } ^ { m } \frac { 1 } { n } \sum _ { k } ^ { n } q _ { i k } \bigr ] = \frac { 1 } { m } \mathrm { V a r } \bigl [ \frac { 1 } { n } \sum _ { k } ^ { n } q _ { 1 k } \bigr ] ,
+$$
+
+whereas this does not hold for the opposite ordering of the sum.
+
+$$
+{ \begin{array} { r l } { \displaystyle \left[ \left( { \frac { 1 } { n } } \sum _ { k } ^ { n } q _ { 1 k } \right) ^ { 2 } \right] = \mathbb { E } _ { x _ { 1 } } \mathbb { E } _ { \xi \ z } { \Bigg [ } { \frac { 1 } { n ^ { 2 } } } \sum _ { l } ^ { n } \sum _ { k } ^ { n } q _ { i l } q _ { i k } { \big | } \{ x \} { \Bigg ] } } \\ { \displaystyle } & { = \mathbb { E } _ { x _ { 1 } } \mathbb { E } _ { \{ z \} } { \Bigg [ } { \frac { n } { n ^ { 2 } } } q _ { 1 1 } ^ { 2 } + { \frac { n ( n - 1 ) } { n ^ { 2 } } } q _ { 1 1 } q _ { 1 2 } { \big | } \{ x \} { \Bigg ] } } \\ { \displaystyle } & { = \mathbb { E } _ { x } { \Bigg [ } { \frac { 1 } { n } } { \big ( } 2 \mathrm { t r } ( A ^ { 2 } ) + \mathrm { t r } ( A ) ^ { 2 } { \big ) } + { \big ( } 1 - { \frac { 1 } { n } } \mathrm { ) t r } ( A ) ^ { 2 } { \Bigg ] } = { \Bigg ( } \mathbb { E } _ { x } [ \mathrm { t r } ( A ) ^ { 2 } ] + { \frac { 2 } { n } } \mathbb { E } _ { x } [ \mathrm { t r } ( A ^ { 2 } ) ] { \Bigg ) } } \end{array} }
+$$
+
+Plugging in $A = J ^ { T } J$ and $n = 1$ , we get
+
+$$
+\mathrm { V a r } [ \hat { Q } ] = \frac { 1 } { m } \bigg ( \mathrm { V a r } [ \| J _ { x } \| _ { F } ^ { 2 } ] + 2 \mathbb { E } [ \| J _ { x } ^ { T } J _ { x } \| _ { F } ^ { 2 } ] \bigg ) .
+$$
+
+Non-isotropic perturbations along data manifold Consistency regularization with natural perturbations such as image translation can also be understood as penalizing a Jacobian norm as in Section 3.1. For example, consider perturbations sampled from a normal distribution on the tangent space, $z \sim P ( x ) \mathcal { N } ( \bar { 0 , } I )$ where $\dot { P ( x ) } = P ( x ) ^ { 2 }$ is the orthogonal projection matrix that projects down from $\mathbb { R } ^ { d }$ to $T _ { x } ( \mathcal { M } )$ , the tangent space of the image manifold at $x$ . Then the consistency regularization penalizes the Laplacian norm of the network on the manifold (with the inherited metric from $\mathbb { R } ^ { d }$ ). $\bar { \mathbb { E } } [ z ] = 0$ and $\mathbb { E } [ z z ^ { T } ] = P P ^ { T } ( = ) P ^ { 2 } = P$ which follows if $P$ is an orthogonal projection matrix. Then,
+
+$$
+\begin{array} { r } { \mathbb E [ z ^ { T } J ^ { T } J z ] = \mathrm { t r } ( J ^ { T } J P P ^ { T } ) = \mathrm { t r } ( P ^ { T } J ^ { T } J P ) = \mathrm { t r } ( J _ { \mathcal { M } } ^ { T } J _ { \mathcal { M } } ) = \| J _ { \mathcal { M } } \| _ { F } ^ { 2 } . } \end{array}
+$$
+
+We view the standard data augmentations such as random translation (that are applied in the $\Pi$ and MT models) as approximating samples of nearby elements of the data manifold and therefore differences $x ^ { \prime } - x$ approximate elements of its tangent space.
+
+A.6 RELATIONSHIP BETWEEN $\mathbb { E } _ { x } [ \| J _ { w } \| _ { F } ^ { 2 } ]$ AND RANDOM RAY SHARPNESS
+
+In the following analysis we review an argument for why smaller $\mathbb { E } _ { x } [ \| J _ { w } \| _ { F } ^ { 2 } ]$ , implies broader optima. To keep things simple, we focus on the MSE loss, but in principle a similar argument should apply for the Cross Entropy and the Error rate. For a single data point $x$ and one hot vector $y$ with $k$ classes, the hessian of $\underline { { \ell } } _ { M S E } ( w ) = \| f ( x , w ) - y \| ^ { 2 }$ can be decomposed into two terms, the Gauss-Newton matrix $G = J _ { w } ^ { T } J _ { w }$ and a term which depends on the labels.
+
+$$
+H ( w , x , y ) = \nabla ^ { 2 } \ell _ { M S E } ( w ) = J _ { w } ^ { T } J _ { w } + \sum _ { i = 1 } ^ { k } ( \nabla ^ { 2 } f _ { i } ) ( f _ { i } ( x ) - y _ { i } ) ,
+$$
+
+$$
+\mathrm { t r } ( H ) = \| J _ { w } \| _ { F } ^ { 2 } + \underbrace { \sum _ { i = 1 } ^ { k } \mathrm { t r } ( \nabla ^ { 2 } f _ { i } ) ( f _ { i } ( x ) - y _ { i } ) } _ { \alpha ( x , y ) }
+$$
+
+Thus $\operatorname { t r } ( H )$ is also the sum of two terms, $\| J _ { w } \| _ { F } ^ { 2 }$ and $\alpha$ . As the solution improves, the relative size of $\alpha$ goes down. In terms of random ray sharpness, consider the expected MSE loss, or risk, $R _ { \mathrm { M S E } } ( w ) \stackrel { - } { = } \mathbb { E } _ { ( x , y ) } \Vert f ( x , w ) - y \Vert ^ { 2 }$ along random rays. Let $d$ be a random vector sampled from the unit sphere and $s$ is the distance along the random ray. Evaluating the risk on a random ray, and Taylor expanding in $s$ we have
+
+$$
+R _ { \mathrm { M S E } } ( w + s d ) = R _ { \mathrm { M S E } } ( w ) + s d ^ { T } \mathbb { E } _ { ( x , y ) } [ J _ { w } ^ { T } ( f - y ) ] + ( 1 / 2 ) s ^ { 2 } d ^ { T } \mathbb { E } _ { ( x , y ) } [ H ] d + O ( s ^ { 3 } )
+$$
+
+Since $d$ is from the unit sphere, $\mathbb { E } [ d ] = 0$ and $\mathbb { E } [ d d ^ { T } ] = I / p$ where $p$ is the dimension. Averaging over the rays, $d \sim \operatorname { U n i f } ( { \bar { S ^ { p - 1 } } } )$ , we have
+
+$\mathfrak { L } _ { d } [ R _ { \mathrm { M S E } } ( w + s d ) ] - R _ { \mathrm { M S E } } ( w ) = \frac { s ^ { 2 } } { 2 p } \mathbb { E } _ { x } [ \mathrm { t r } ( H ) ] + O ( s ^ { 4 } ) = \frac { s ^ { 2 } } { 2 p } \mathbb { E } _ { x } [ \| J _ { w } \| _ { F } ^ { 2 } ] + \frac { s ^ { 2 } } { 2 p } \mathbb { E } _ { ( x , y ) } [ \alpha ( x , y ) ] + O ( s ^ { 4 } )$ All of the odd terms vanish because of the reflection symmetry of the unit sphere. This means that locally, the sharpness of the optima (as measured by random rays) can be lowered by decreasing $\mathbb { E } _ { x } [ \| \dot { J } _ { w } \| _ { F } ^ { 2 } ]$ .
+
+# A.7 INCLUDING HIGH LEARNING RATE ITERATES INTO SWA
+
+As discussed in Mandt et al. (2017), under certain assumptions SGD samples from a Gaussian distribution centered at the optimum of the loss $w _ { 0 }$ with covariance proportional to the learning rate. Suppose then that we have $n$ weights sampled at learning rate $\eta _ { 1 }$ , $w _ { i } ^ { ( 1 ) } \stackrel { i i d } { \sim } \mathcal { N } ( w _ { 0 } , \eta _ { 1 } \Sigma )$ and $m$ weights sampled with the higher learning rate $\eta _ { 2 }$ , $w _ { j } ^ { ( 2 ) } \stackrel { i i d } { \sim } \mathcal { N } ( w _ { 0 } , \eta _ { 2 } \Sigma )$ . For the SWA estimator $\begin{array} { r } { \hat { w } _ { \mathrm { S W A } } = \frac { 1 } { n } \sum _ { i } w _ { i } ^ { ( 1 ) } , \mathbb { E } [ \| \hat { w } _ { \mathrm { S W A } } - w _ { 0 } \| ^ { 2 } ] = \mathrm { t r } ( \mathrm { C o v } ( \hat { w } _ { \mathrm { S W A } } ) ) = \frac { \eta _ { 1 } } { n } \mathrm { t r } ( \Sigma ) } \end{array}$ . But if we include the high variance points in the average, as in fast-SWA, wˆfSWA = 1n+m  $\begin{array} { r } { \hat { w } _ { \mathrm { f S W A } } = \frac { 1 } { n + m } \big ( \sum _ { i } w _ { i } ^ { ( 1 ) } + \sum _ { j } w _ { j } ^ { ( 2 ) } \big ) } \end{array}$ , then $\begin{array} { r } { \mathbb { E } [ \| \hat { w } _ { \mathrm { f S W A } } - w _ { 0 } \| ^ { 2 } ] = \frac { n \eta _ { 1 } + m \eta _ { 2 } } { ( n + m ) ^ { 2 } } \mathrm { t r } ( \Sigma ) } \end{array}$ . If $\begin{array} { r } { \frac { n \eta _ { 1 } + m \eta _ { 2 } } { ( n + m ) ^ { 2 } } < \frac { \eta _ { 1 } } { n } } \end{array}$ then including the high learning rate points decreases the MSE of the estimator for $\begin{array} { r } { m > n \bigl ( \frac { \eta _ { 2 } } { \eta _ { 1 } } - 2 \bigr ) } \end{array}$ . If we include enough points, we will still improve the estimate.
+
+# A.8 NETWORK ARCHITECTURES
+
+In the experiments we use two DNN architectures – 13 layer CNN and Shake-Shake. The architecture of 13-layer CNN is described in Table 6. It closely follows the architecture used in (Laine and Aila, 2017; Miyato et al., 2017; Tarvainen and Valpola, 2017). We re-implement it in PyTorch and removed the Gaussian input noise, since we found having no such noise improves generalization. For Shake-Shake we use $2 6 { - } 2 \mathrm { x } 9 6 \mathrm { d }$ Shake-Shake regularized architecture of Gastaldi (2017) with 12 residual blocks.
+
+Table 6: A 13-layer convolutional neural networks for the CNN experiments (CIFAR-10 and CIFAR-100) in Section 5.2 and 5.3. Note that the difference from the architecture used in Tarvainen and Valpola (2017) is that we removed a Gaussian noise layer after the horizontal flip.   
+
+<table><tr><td>Layer Input</td><td>Hyperparameters</td></tr><tr><td>Translation Horizontal flip Convolutional Convolutional Convolutional Pooling Dropout Convolutional Convolutional Convolutional Pooling Dropout Convolutional</td><td>32 × 32 RGB image Randomly{△x,△y} ~[-4,4] Randomly p = 0.5 128 filters,3 × 3, same padding 128 filters, 3 × 3, same padding 128 filters,3 × 3, same padding Maxpool 2 × 2 p = 0.5 256 filters,3 × 3, same padding 256 filters,3 × 3, same padding 256 filters,3 × 3,same padding</td></tr></table>
+
+# A.9 HYPERPARAMETERS
+
+We consider two different schedules. In the short schedule we set the cosine half-period $\ell _ { 0 } = 2 1 0$ and training length $\ell = 1 8 0$ , following the schedule used in Tarvainen and Valpola (2017) in Shake-Shake experiments. For our Shake-Shake experiments we also report results with long schedule where we set $\ell = 1 8 0 0 , \ell _ { 0 } = 1 5 0 0$ following Gastaldi (2017). To determine the initial learning rate $\eta _ { 0 }$ and the cycle length $c$ we used a separate validation set of size 5000 taken from the unlabeled data. After determining these values, we added the validation set to the unlabeled data and trained again. We reuse the same values of $\eta _ { 0 }$ and $c$ for all experiments with different numbers of labeled data for both $\Pi$ model and Mean Teacher for a fixed architecture (13-layer CNN or Shake-Shake). For the short schedule we use cycle length $c = 3 0$ and average models once every $k = 3$ epochs. For long schedule we use $c = 2 0 0$ , $k = 2 0$ .
+
+In all experiments we use stochastic gradient descent optimizer with Nesterov momentum (Loshchilov and Hutter, 2016). In fast-SWA we average every the weights of the models corresponding to every third epoch. In the $\Pi$ model, we back-propagate the gradients through the student side only (as opposed to both sides in (Laine and Aila, 2016)). For Mean Teacher we use $\alpha = 0 . 9 7$ decay rate in the Exponential Moving Average (EMA) of the student’s weights. For all other hyper-parameters we reuse the values from Tarvainen and Valpola (2017) unless mentioned otherwise.
+
+Like in Tarvainen and Valpola (2017), we use $\| \cdot \| ^ { 2 }$ for divergence in the consistency loss. Similarly, we ramp up the consistency cost $\lambda$ over the first 5 epochs from 0 up to it’s maximum value of 100 as done in Tarvainen and Valpola (2017). We use cosine annealing learning rates with no learning rate ramp up, unlike in the original MT implementation (Tarvainen and Valpola, 2017). Note that this is similar to the same hyperparameter settings as in Tarvainen and Valpola (2017) for $\mathrm { R e s N e t } ^ { 2 }$ . We note that we use the exact same hyperparameters for the ⇧ and MT models in each experiment setting. In contrast to the original implementation in Tarvainen and Valpola (2017) of CNN experiments, we use SGD instead of Adam.
+
+Understanding Experiments in Sections 3.2, 3.3 We use the 13-layer CNN with the short learning rate schedule. We use a total batch size of 100 for CNN experiments with a labeled batch size of 50 for the ⇧ and Mean Teacher models. We use the maximum learning rate $\eta _ { 0 } = 0 . 1$ . For Section 3.2 we run SGD only for 180 epochs, so 0 learning rate cycles are done. For Section 3.3 we additionally run 5 learning rate cycles and sample pairs of SGD iterates from epochs 180-330 corresponding to these cycles.
+
+CIFAR-10 CNN Experiments We use a total batch size of 100 for CNN experiments with a labeled batch size of 50. We use the maximum learning rate $\eta _ { 0 } = 0 . 1$ .
+
+CIFAR-10 ResNet $^ +$ Shake-Shake We use a total batch size of 128 for ResNet experiments with a labeled batch size of 31. We use the maximum learning rate $\eta _ { 0 } = 0 . 0 5$ for CIFAR-10. This applies for both the short and long schedules.
+
+CIFAR-100 CNN Experiments We use a total batch size of 128 with a labeled batch size of 31 for $1 0 k$ and $5 0 k$ label settings. For the settings $5 0 k { + } 5 0 0 k$ and $5 0 k { + } 2 3 7 k ^ { * }$ , we use a labeled batch size of 64. We also limit the number of unlabeled images used in each epoch to $1 0 0 k$ images. We use the maximum learning rate $\eta _ { 0 } = 0 . 1$ .
+
+CIFAR-100 ResNet $^ +$ Shake-Shake We use a total batch size of 128 for ResNet experiments with a labeled batch size of 31 in all label settings. For the settings $5 0 k { + } 5 0 0 k$ and $5 0 k { + } 2 3 7 k ^ { * }$ , we also limit the number of unlabeled images used in each epoch to $1 0 0 k$ images. We use the maximum learning rate $\eta _ { 0 } = 0 . 1$ . This applies for both the short and long schedules.
+
+# A.10 DOMAIN ADAPTATION
+
+We apply fast-SWA to the best experiment setting $\mathbf { M T + C T + T F A }$ for CIFAR-10 to STL according to French et al. (2018). This setting involves using confidence thresholding (CT) and also an augmentation scheme with translation, flipping, and affine transformation (TFA).
+
+We modify the optimizer to use SGD instead of Adam (Kingma and Ba, 2015) and use cosine annealing schedule with $\ell _ { 0 } = 6 0 0 , \ell = 5 5 0$ , $c = 5 0$ . We experimented with two fast-SWA methods: averaging weights once per epoch and averaging once every iteration, which is much more frequent that averaging every epoch as in the semi-supervised case. Interestingly, we found that for this task averaging the weights in the end of every iteration in fast-SWA converges significantly faster than averaging once per epoch and results in better performance. We report the results in Table 7.
+
+We observe that averaging every iteration converges much faster (600 epochs instead of 3000) and results in better test accuracy. In our experiments with semi-supervised learning averaging more often than once per epoch didn’t improve convergence or final results. We hypothesize that the improvement from more frequent averaging is a result of specific geometry of the loss surfaces and training trajectories in domain adaptation. We leave further analysis of applying fast-SWA to domain adaptation for future work.
+
+Implementation Details We use the public code3 of French et al. (2018) to train the model and apply fast-SWA. While the original implementation uses Adam (Kingma and Ba, 2015), we use stochastic gradient descent with Nesterov momentum and cosine annealing learning rate with $\ell _ { 0 } =$ $6 0 0 , \ell = 5 5 0 , c = 1 0 0$ and $k = 1 0 0$ . We use the maximum learning rate $\eta _ { 0 } = 0 . 1$ and momentum
+
+Table 7: Domain Adaptation from CIFAR-10 to STL. VADA results are from (Shu et al., 2018) and the original $\mathrm { S E ^ { * } }$ is from French et al. (2018). SE is the score with our implementation without fast-SWA. fast-SWA 1 performs averaging every epoch and the final result is obtained at epoch 3000. fast-SWA 2 performs the averaging every iteration and the final result is obtained at epoch 600.   
+
+<table><tr><td>Method</td><td>VADA</td><td>SE*</td><td>SE</td><td>SE+fast-SWA1SE+fast-SWA 2</td><td>2</td></tr><tr><td>Test Error</td><td>20.0</td><td>19.9</td><td>18.1</td><td>17.1</td><td>16.8</td></tr></table>
+
+0.9 with weight decay of scale $2 \times 1 0 ^ { - 4 }$ . We use the data augmentation setting $\mathbf { M T + C F + T F A }$ i n Table 1 of French et al. (2018) and apply fast-SWA. The result reported is from epoch 4000.

parse/train/rkxJus0cFX/rkxJus0cFX.md

@@ -0,0 +1,210 @@
+# REDSYNC : REDUCING SYNCHRONIZATION TRAFFIC FOR DISTRIBUTED DEEP LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Data parallelism has become a dominant method to scale Deep Neural Network (DNN) training across multiple nodes. Since the synchronization of the local models or gradients can be a bottleneck for large-scale distributed training, compressing communication traffic has gained widespread attention recently. Among several recent proposed compression algorithms, Residual Gradient Compression (RGC) is one of the most successful approaches—it can significantly compress the transmitting message size $0 . 1 \%$ of the gradient size) of each node and still preserve accuracy. However, the literature on compressing deep networks focuses almost exclusively on achieving good compression rate, while the efficiency of RGC in real implementation has been less investigated. In this paper, we develop an RGC method that achieves significant training time improvement in real-world multi-GPU systems. Our proposed RGC system design called RedSync, introduces a set of optimizations to reduce communication bandwidth while introducing limited overhead. We examine the performance of RedSync on two different multiple GPU platforms, including a supercomputer and a multi-card server. Our test cases include image classification on Cifar10 and ImageNet, and language modeling tasks on Penn Treebank and Wiki2 datasets. For DNNs featured with high communication to computation ratio, which has long been considered with poor scalability, RedSync shows significant performance improvement.
+
+# 1 INTRODUCTION
+
+For training large-scale deep neural networks (DNNs) on multiple computing nodes, data parallelism has emerged as the most popular choice due to its simplicity and effectiveness (Dean et al. (2012); Recht et al. (2011)). However, the communication bandwidth of network fabric has become the bottleneck limiting data parallel performance. On one hand, models of DNNs, which already contain tens to hundreds of layers and totaling 10-20 million parameters today, continue to grow bigger. Therefore, the requirement of communicating model parameter updates among all computing nodes poses a higher challenge to network bandwidth. On the other hand, the development of DNN training accelerators has shifted the bottleneck of training towards communication across models. As the evolution of the inter-connected network bandwidth is not as fast as computing hardware, synchronization overhead has become the bottleneck of data parallelism on distributed systems using new computing hardware.
+
+Many recent studies focused on reducing the communication cost between nodes by reducing the size of the gradients to be transmitted. One line of work (Seide et al. (2014); Alistarh et al. (2017); Wen et al. (2017)) propose to quantize the gradients to low-precision values. Considering compression ratio (ratio of compressed gradients size to their original size) achieved by quantization is limited, another line of research orthogonal to quantization is to sparsify communication gradients and restrict weight-updates to a small subset of parameters. Residual Gradient Compression (RGC) method (Strom (2015); Aji & Heafield (2017); Chen et al. (2017); Lin et al. (2017); Sattler et al. (2018)) is currently the most promising pruning method to achieve good compression ratio while ensuring no loss of training accuracy. It transmits only a small subset of gradients and maintains the remaining gradients locally as residuals to be added to gradients of the next iteration. The first RGC implementation is proposed by Strom (2015) and uses a threshold-based method to only send gradients larger than a predefined constant threshold for fully-connected layers. Considering a predefined threshold is hard to be chosen appropriately, Aji & Heafield (2017) improve the robustness of RGC by selecting top $1 \%$ gradients to communicate according to their magnitude. Because these two implementations are tuned for some specific network structures, applying them to other DNNs will lead to accuracy loss as indicated in Chen et al. (2017). Based on their work, the latest RGC variants, such as (Sattler et al. (2018); Chen et al. (2017); Lin et al. (2017)), are able to achieve a $0 . 1 \%$ compression ratio on local gradients while ensuring almost no loss of model accuracy on a variety of DNN structures after introducing some key modifications.
+
+Despite of good model accuracy achieved with simulation experiments, no recent studies have discussed the potential performance gain after integrating the latest RCG methods to real distributed training system, especially to the multi-GPU systems equipped with high-quality network infrastructures. The challenges of applying RGC to distributed GPU systems come from two aspects. First, there is no efficient compression algorithm proposed for RGC method. According to our experimental results, selecting top- $0 . 1 \%$ elements with the state-of-the-art GPU-based top- $\mathbf { \nabla \cdot k }$ algorithm are so expensive that the overhead of compression is much higher than the benefits of network bandwidth reduction. Second, synchronization of sparse data structures is nontrivial to be supported with existing efficient communication libraries, such as Message Passing Interface (MPI), which are designed for dense data structures.
+
+Targeting multi-GPU systems, a highly-efficient RGC implementation called RedSync is proposed. Our contributions are listed as follows:
+
+• We combined pruning and quantization techniques together to compress transmitting gradients. A set of parallel-friendly top- $0 . 1 \%$ selection methods are designed to support pruning operations inside GPU device memory, which are orders of magnitude faster than the stateof-the-art GPU-based top-k selection method. Considering the distribution characteristics of communication data, we apply allgather operation using MPI for a sparse synchronization scheme. A cost model is derived to analyze both communication cost and calculation overhead. Based on it, we pointed out potential performance gain and the bottleneck of our implementation. RedSync is able to ensure almost no accuracy loss to train a set of DNNs after integrating with the latest algorithm improvements. This is the first work, as far as we known, to evaluate the performance of RGC method on the scale of 128 GPUs. RedSync provides significant performance improvements for communication-intensive networks, like VGG, AlexNet and some LSTMs.
+
+# 2 DESIGN AND IMPLEMENTATION OF REDSYNC
+
+We first give an overview of a simple RGC workflow used in RedSync (see more details in Algorithm 1). We denote a DNN model as $f ( \mathbf { w } )$ , where $\mathbf { w }$ is the vector of parameters. We assume a system has $N$ workers. Each worker, say the $k$ -th worker, holds a local dataset $\chi _ { k } ^ { t }$ at iteration $t$ with size $b$ and a local copy of the global weight w. Synchronous SGD method is adopted in RedSync. At each iteration, node $k$ computes the gradient $G ^ { k }$ using local data, where $G _ { j } ^ { k }$ indicates gradients of layer $j$ . Each node also maintains a residual $V ^ { k }$ , which is initialized as 0 and used to accumulate untransmitted gradient from previous iterations. After added with latest gradient, a subset of residuals is selected as the communication-set, and is compressed into sparse data structures. The select operation in Algorithm 1 chooses more important elements based on magnitude. Those selected elements (denoted ask Masks) are synchronized among all the nodes using allreduce operations, which is able to take advantage of the highly-optimized allreduce operation on HPC systems (Thakur et al. (2005)). Synchronous SGD
+
+# Algorithm 1 Residual Gradient Compression
+
+Input: node id $k$ , the number of node $N$   
+Input: dataset $\chi$   
+Input: mini batch size $^ { b }$ per node   
+Input: initial model $w \stackrel { \cdot } { = } w [ 0 ] , . . . , w [ \# l a y e r ]$   
+Input: compression ratio $D$ $\mathbf { \hat { \boldsymbol { V } } } ^ { k } \gets 0$ for $t = 0 , 1 , . . . m a x . i t e r \ \mathbf { d o }$ sample $b$ elements as $\chi _ { k } ^ { t }$ $G ^ { k } \dot { \mathbf { \Omega } }  \nabla \ f ( \chi _ { k } ^ { t } \ ; \ \mathbf { w } )$ by forward and backward propagation for $j = \# l a y e r$ , $\# l a y e r - 1 , . . . , 0$ do ${ V } _ { j } ^ { k } { + } = G _ { j } ^ { k }$ Masks select $( V _ { j } ^ { k } , D )$ Gkj ← Allreduce(compress(V kj · Masks)) V kj ← V kj  (1 - Masks) end for w ← SGD(w, decompress $( G ^ { k } ) _ { \ l } ^ { \ l }$ ) end for
+
+![](images/d37f0f10ce77164fe591a6b4c00fec54fc1f9f2660bb92d8eb3cf87d0d7b8867.jpg)  
+Figure 1: Performance of four communication-set selection methods under message sizes. Elements in the data list are generated randomly from a standard uniform distribution. Comm. illustrates the time taken to synchronize the message through a network with a peak bandwidth of 3.5GBps by allreduce operation. Performance is measured as total time cost for 100 times independent operations.
+
+implemented with allreduce has been widely adopted in state-of-the-art large-scale CNN training tasks (Goyal et al. (2017) and You et al. (2017)). Remaining elements outside the communicationset are assigned as new residuals of the next iteration. The workflow of this algorithm is the same as an RGC variant called Deep Gradient Compression Method mentioned Lin et al. (2017). In the following, we details our contribution in implementations of select, Allreduce and decompress to make this workflow efficient in practice.
+
+# 2.1 PARALLEL-FRIENDLY COMPRESSION
+
+The efficiency of communication-set selection method is critical for the RGC system’s overall performance. Since a predefined threshold is difficult to determine, recent work (Lin et al. (2017); Sattler et al. (2018)) suggest to select top $0 . 1 \%$ elements from residuals of each layer as the communication-set. However, the top- $0 . 1 \%$ selection is nontrivial to be implemented on GPU. One of the most efficient top- $k$ selection methods designed for GPU can be implemented based on radixSelect algorithm (Alabi et al. (2012)), which determines each bit of the $k$ -th largest element by scan and scatter. Serial scan (Sengupta et al. (2007)) and scatter operations are extremely timeconsuming. As shown in Figure 1, the computation time for top- $0 . 1 \%$ with radixSelect on a Titan X GPU sometimes is even slightly higher than the time for synchronizing these parameters through a 3.5 GBps network. To avoid performing a top- $0 . 1 \%$ operation on a large number of parameters, we propose two communication-set selection algorithms called trimmed top- $k$ selection and threshold binary search selection, which are more efficient on GPUs.
+
+Trimmed top- $k$ selection. Observing that the distribution of residuals is usually similar to a normal distribution, we can use statistical features to remove most of the smaller elements and limit radixSelect operation on a relatively small subset. As shown in Algorithm 2, we first calculate the mean and maximum of residuals’ absolute values of this layer. A relative large threshold value is chosen according to mean and maximum value, for example, $0 . 8 \times ( m a x - m e a n ) + m e a n$ . Operation count nonzero gets the number of elements whose absolute values are greater than the threshold. If the number is smaller than $k$ (the number of top- $0 . 1 \%$ elements ), we dynamically decrease the threshold until we find the number of parameters whose absolute value above the threshold is larger than $k$ . Then we trim all elements that are less than the threshold and perform a top- $k$ selection operation using radixSelect on the remaining elements. Operation mean, max and count nonzero can all be efficiently implemented with a single reduction operation. nonzero indices is a typical stream compaction problem, which uses just one scan operation as its backbone (Sengupta et al. (2006)).
+
+Threshold binary search selection. For some layers with very large numbers of parameter elements, even conducting radixSelect on a small subset of elements will still be a very time-consuming operation. In order to completely avoid using radixSelect operation on GPU, we propose a method to select approximate top- $0 . 1 \%$ elements as communication-set. Instead of identifying the kth (top $0 . 1 \%$ th) largest element, we search for a threshold to make it between the $k$ th to $2 k$ th largest element, and then select elements larger than the threshold as communication-set. In this case, at least $0 . 1 \%$ largest elements are included in the communication-set. As shown in Algorithm 3, we use a binary search algorithm to find such a threshold. To avoid excessive searching, it will always be terminated when the difference of left bound and right bound is less than a small value $\epsilon$ .
+
+<table><tr><td>Algorithm2 trimmed top-k Selection</td><td>Algorithm 3 Top-k selection with threshold bi-</td></tr><tr><td>Input: tensor to be compressed X</td><td>nary search selection</td></tr><tr><td>Input:number of elements remained k</td><td>Input: tensor to be compressed X</td></tr><tr><td>Output:&lt;indice,values &gt; 1:mean ← mean(abs(X))</td><td>Input: number of elements remained k</td></tr><tr><td>2:max ←max(abs(X))</td><td>Input:Termination condition parameter é</td></tr><tr><td>3:∈←0.2</td><td>Output:&lt;indice,values &gt;</td></tr><tr><td>4:ratio←(1-∈)</td><td>1:mean ← mean(abs(X)); max ← max(abs(X))</td></tr><tr><td>5:</td><td>l←0.0;r ←1.0; threshold=0.0</td></tr><tr><td>nnz=count_nonzero(abs(X)&gt;threshold) 6: while nnz &gt;k do</td><td>whiler-l&gt;εdo</td></tr><tr><td></td><td>ratio=l+(r-l)/2</td></tr><tr><td>7: threshold←mean+ratio× (max-mean)</td><td>threshold← mean+ratio × (max-mean)</td></tr><tr><td>8: nnz=count_nonzero(abs(X)&gt;threshold)</td><td>nnz=count_nonzero(abs(X)&gt; threshold)</td></tr><tr><td>9: ratio=ratio-e</td><td>if nnz &gt;k and 2k &gt;nnz then</td></tr><tr><td>10:end while</td><td>break</td></tr><tr><td>11:indice ←nonzero_indices(abs(X) &gt;threshold))</td><td>else if nnz&lt;k/2 then</td></tr><tr><td>12:values ← Xlindice]</td><td>r=threshold</td></tr><tr><td></td><td>else</td></tr><tr><td></td><td>l=threshold</td></tr><tr><td></td><td>12: end if</td></tr><tr><td></td><td>13: 14: end while</td></tr><tr><td></td><td>15: indice ← nonzero_indices(abs(X)&gt; threshold))</td></tr><tr><td></td><td>16:values← X[indice]</td></tr></table>
+
+For layers with large sizes, such as the first fully-connected layer in VGG16 and softmax layer in LSTM, the time for count nonzero operation is still not negligible. We further improve the efficiency of the selection algorithm by reducing the number of count nonzero operations. We recommend that, after a threshold binary search for this layer, the threshold element can be reused in the next few iterations. The interval of search is empirically set to 5, and the selection algorithm introduces only one nonzero count overhead on average.
+
+In Figure 1, we compared the time cost of different selection approaches on parameter lists of different sizes. Compared with directly performing radixSelect, both proposed methods significantly reduce the selection time for large sizes. For top- $0 . 1 \%$ selection on 64MB elements, trimmed top- $\mathbf { \nabla } \cdot \mathbf { k }$ and sampled threshold binary search selection are 38.13 and $1 6 . 1 7 \ \times$ faster than radixSelect. In practice, we dynamically choose compression strategies: For smaller parameter sets such as biases and batch norm layers, we do not compress residuals or directly use radixSelect to select top- $0 . 1 \%$ significant elements. Trimmed top-k selection is suitable for parameters of middle size layers, like convolutional layers, because it can ensure the compression ratio to be exactly $0 . 1 \%$ and introduce no extra communication bandwidth requirements. Threshold binary search based selection is suitable for large size layers, like hidden layers and softmax layers in LSTMs, for which the compression cost is more critical to be optimized than the communication cost.
+
+# 2.1.1 QUANTIZATION OF COMPRESSED RESIDUALS
+
+Compressed residuals should include $k$ indices and $k$ values. We further investigate the possibility of quantizing these values. By setting the values of all elements of the same sign in the communicationset to their mean, we can almost eliminate the communication bandwidth requirement of value information transmitting by using only one floating-point number instead of $k$ . In order to facilitate quantization compression, we slightly modify our select method to ensure that elements in the communication-set are all of the same sign. It can be achieved by choosing the largest $k$ elements and the smallest $k$ elements as communication-set in turns. In other words, if we select the largest $k$ elements (all positive numbers) in this layer as the communication-set at current iteration, we will choose smallest $k$ elements (all negative numbers) as the communication-set for the next iteration. It is worth noting that sampled threshold binary search selection cannot be used with quantization. In addition, we do not quantify the output layer of the DNN, in order to distinguish the correct classification information.
+
+# 2.2 SPARSE SYNCHRONIZATION AND DECOMPRESSION
+
+Synchronization of dense gradient structures in traditional distributed DNN systems can be simply implemented with an allreduce operation, which has been well-studied on multiple-GPU systems (Awan et al. (2017)). However, the design of a sparse allreduce in a distributed setting is not as simple because each worker may contribute different non-zero indices in its compressed residuals.
+
+According to our observation, there are very few overlapping indices of the communication-set distribution of different nodes. For example, training VGG16 on Cifar10 dataset using 16 GPUs with a compression ratio as $0 . 1 \%$ for each node, the averaged compression ratio of synchronized residuals of all nodes is $1 . 5 5 \%$ . We utilize the allgather operation, an operation in which the data contributed by each node is gathered at all nodes, to implement sparse allreduce. The message representing compressed residuals of each node should include the information of indices and values of elements in communication-set. When using threshold binary search selection, the length of each node’s message is different. As a result, the packaged message should also include an initial element, which indicates the length of the compressed elements. Instead of using two allgather operations for indices and values message separately, we package the indices and values into a single message to reduce latency.
+
+After finishing the allgather operation, each node collects $N$ compressed residuals of this layer from all the other nodes. We add the compressed residuals to the corresponding weights in the local model after scaling with the learning rate. It can be seen as an operation that adds a sparse array to a dense array, which has been fully-optimized in Level 1 function axpyi() of cuSparse library on GPU.
+
+# 2.3 OTHER TECHNIQUES
+
+RedSync implements a set of algorithm improvement techniques proposed in Lin et al. (2017). We details momentum correction, momentum factor masking and our modification to warmup training in Appendix C, as well as local gradient clipping in Appendix B.
+
+# 2.4 PERFORMANCE MODEL FOR RGC COMMUNICATION
+
+To analyze the potential performance gain of sparse synchronization, we adopt a widely-used performance model to estimate the communication cost in terms of latency and bandwidth used. We assume that the time taken to send a message between any two nodes can be modeled as $\alpha + n \beta$ , where $\alpha$ is the latency (or startup time) per message, independent of message size, $\beta$ is the transfer time per byte, and $n$ is the number of bytes transferred. The node’s network interface is assumed to be single ported; i.e. at most one message can be sent and one message can be received simultaneously. $M$ is the number of elements in residuals of current layer. $D$ is the compression ratio. In the case of reduction operations, we assume that $\gamma _ { 2 }$ is the computational cost for performing the reduction operation for a message of size $M$ , and $\gamma _ { 1 }$ is the cost to decompress the collected sparse message of size $M$ . For the case where the compression ratio of each node is different, which is always true for the binary search method, $D$ represents the average compression ratio of all nodes.
+
+Suppose that we use recursive doubling for allgather and Rabenseifners algorithm mentioned in Thakur et al. (2005) for allreduce communication. The cost of quantized sparse and dense synchronization is illustrated Equation 1 and 2, respectively. The derivations are left in Appendix A.
+
+$$
+T _ { s p a r s e } = T _ { s e l e c t } + \log ( p ) \alpha + ( p - 1 ) ( M D ) \beta + p \gamma _ { 1 } \quad T _ { d e n s e } = 2 \log ( p ) \alpha + 2 \frac { p - 1 } { p } M \beta + \frac { p - 1 } { p } \gamma _ { 2 }
+$$
+
+As implicated by the performance model, the compression rate for the model is not equal to the compression rate for communication bandwidth. The bandwidth term of sparse synchronization is $( p - 1 ) D M \beta$ , which is proportional to the number of nodes $p$ . Even if the sparseness $D$ is $0 . 1 \%$ for all $p$ node, when $p$ is 128, the communication bandwidth for sparse synchronization will be $12 . 8 \%$ of dense synchronization rather than $0 . 1 \%$ of dense synchronization. Second, the overhead of reduction may be a new bottleneck when scaling RedSync to larger scale. The last term $p \gamma _ { 1 }$ in Eq. 1 indicates that the overhead to do reduction also increases linearly with the number of nodes $p$ . However, in Eq. 2, reduction overhead almost does not increase with number of nodes.
+
+# 3 EXPERIMENTAL RESULTS
+
+# 3.1 SETUPS
+
+We tested the accuracy and performance of our proposed implementation on two different multiGPU systems, including a world’s top GPU supercomputer and a multi-GPU server. Muradin is a
+
+![](images/e6f25b2f1217e969175533d70fb9b7f7669cce2afe8225a43f1009345eea8b10.jpg)  
+Figure 2: Left : top-1 validation accuracy vs number of epochs of training VGG16 on Cifar10 (4 GPUs, total batch size $=$ 256). Center : top-1 validation accuracy vs number of epochs of training ResNet50 on ImageNet (8 GPUs, total batch size $= 2 5 6$ ). Right : Perplexity vs number of epochs of training LSTM on PTB (4 GPUs, total batch size $= 2 0$ ).
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Size</td><td rowspan=1 colspan=1>Gflop</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>RGC</td><td rowspan=1 colspan=1>qRGC</td></tr><tr><td rowspan=2 colspan=1>Cifar10</td><td rowspan=1 colspan=1>ResNet44</td><td rowspan=1 colspan=1>2.65</td><td rowspan=1 colspan=1>0.20</td><td rowspan=1 colspan=1>7.48%</td><td rowspan=1 colspan=1>7.17%</td><td rowspan=1 colspan=1>7.87%</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>59</td><td rowspan=1 colspan=1>0.31</td><td rowspan=1 colspan=1>8.31%</td><td rowspan=1 colspan=1>8.45%</td><td rowspan=1 colspan=1>8.13%</td></tr><tr><td rowspan=3 colspan=1>ImageNet</td><td rowspan=1 colspan=1>AlexNet</td><td rowspan=1 colspan=1>233</td><td rowspan=1 colspan=1>0.72</td><td rowspan=1 colspan=1>44.73%</td><td rowspan=1 colspan=1>44.91%</td><td rowspan=1 colspan=1>44.80%</td></tr><tr><td rowspan=1 colspan=1>ResNet50</td><td rowspan=1 colspan=1>103</td><td rowspan=1 colspan=1>8.22</td><td rowspan=1 colspan=1>24.07%</td><td rowspan=1 colspan=1>23.98%</td><td rowspan=1 colspan=1>23.85%</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>528</td><td rowspan=1 colspan=1>15.5</td><td rowspan=1 colspan=1>29.5%</td><td rowspan=1 colspan=1>29.1%</td><td rowspan=1 colspan=1>29.3%</td></tr><tr><td rowspan=1 colspan=1>PTB</td><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>204</td><td rowspan=1 colspan=1>2.52</td><td rowspan=1 colspan=1>75.86</td><td rowspan=1 colspan=1>75.14</td><td rowspan=1 colspan=1>74.69</td></tr><tr><td rowspan=1 colspan=1>Wiki2</td><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>344</td><td rowspan=1 colspan=1>2.52</td><td rowspan=1 colspan=1>88.23</td><td rowspan=1 colspan=1>88.01</td><td rowspan=1 colspan=1>87.84</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=6>Batch Size   128  256   512   1024   2048</td></tr><tr><td rowspan=1 colspan=6>ResNet44</td></tr><tr><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>7.09</td><td rowspan=1 colspan=1>7.48</td><td rowspan=1 colspan=1>8.18</td><td rowspan=1 colspan=1>10.02</td><td rowspan=1 colspan=1>16.8</td></tr><tr><td rowspan=1 colspan=1>RGC</td><td rowspan=1 colspan=1>6.40</td><td rowspan=1 colspan=1>7.17</td><td rowspan=1 colspan=1>7.471</td><td rowspan=1 colspan=1>10.13</td><td rowspan=1 colspan=1>10.87</td></tr><tr><td rowspan=1 colspan=1>qRGC</td><td rowspan=1 colspan=1>7.06</td><td rowspan=1 colspan=1>7.87</td><td rowspan=1 colspan=1>7.62</td><td rowspan=1 colspan=1>11.86</td><td rowspan=1 colspan=1>10.83</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>7.74</td><td rowspan=1 colspan=1>8.31</td><td rowspan=1 colspan=1>9.06</td><td rowspan=1 colspan=1>9.49</td><td rowspan=1 colspan=1>10.09</td></tr><tr><td rowspan=1 colspan=1>RGC</td><td rowspan=1 colspan=1>7.43</td><td rowspan=1 colspan=1>8.45</td><td rowspan=1 colspan=1>9.31</td><td rowspan=1 colspan=1>9.90</td><td rowspan=1 colspan=1>11.12</td></tr><tr><td rowspan=1 colspan=1>qRGC</td><td rowspan=1 colspan=1>8.17</td><td rowspan=1 colspan=1>8.13</td><td rowspan=1 colspan=1>9.09</td><td rowspan=1 colspan=1>9.97</td><td rowspan=1 colspan=1>9.81</td></tr></table>
+
+Table 1: Results of RGC are achieved by non-quantized RGC method, and results of qRGC are achieved from quantized RGC method using RedSync. The left table : Accuracy results for various networks. Size indicates the model size in MB. GFlop shows Giga Floating-Point Operations required for a forward pass using a single input sample. Accuracy of CNNs was measured as top-1 validation errors, and accuracy of LSTMs is measured as perplexity on validating dataset. Results on Cifar10 were measured using 4 nodes with batch-size as 64 for each node. Results on ImageNet were measured using 6 nodes with batch-size as 32 for each node. Results of LSTM were measured using 4 nodes with batch-size as 5 for each node. The right table: Test errors of RCG and SGD methods under different batch sizes on Cifar10.
+
+server with eight GPUs in the same node. It is equipped with one Intel(R) Xeon(R) CPU E5-2640 v4 and 8 TITAN Vs, which is connected to the CPU through PCI-E 3.0. Piz Daint is a GPU supercomputer. Each node of it includes two Intel Xeon E5-2690v3 CPUs and one NVIDIA Tesla P100 GPUs. In total, there are 5320 nodes connected by Aries interconnect with Dragonfly topology. We used pytorch v4.0 to conduct basic DNN training operations. For communication library, horovod an MPI wrapper upon pytorch, is used to provide collective communication operations. Horovod was compiled with OpenMPI v3.1 with cuda-aware supported on both systems.
+
+We tested our performance on two major types of mainstream deep learning applications. For Image Classification tasks, we studied ResNet-44 and VGG16 on Cifar10 (Krizhevsky & Hinton (2009)), AlexNet, VGG16 and ResNet-50 on ImageNet (Deng et al. (2009)). For all CNNs, we used Nesterov’s momentum SGD as optimizer. We used the same learning rate strategies as the SGD for the RGC methods. Warm-up technique was applied to the first 5 epochs of ResNet50 and VGG16 for both SGD and RGC. For Language Modeling tasks, we picked two datasets for evaluation. The Penn Treebank corpus (PTB) dataset consists of 923,000 training, 73,000 validation and 82,000 test words (Marcus et al. (1993)). The WikiText language modeling dataset is a collection of over 100 million tokens extracted from the set of verified Good and Featured articles on Wikipedia (Merity et al. (2016)). It consists 2,088,628 training, 217,646 and 245,569 test words. We adopted a 2-layer LSTM language model architecture with 1500 hidden units per layer (Press & Wolf (2016)) to evaluate both datasets. We tied the weights of encoder and decoder and use vanilla SGD with gradient clipping. Learning rate decays when no improvement has been made in validation loss.
+
+# 3.2 EVALUATION OF ACCURACY
+
+We examined the convergence of RedSycn on the datasets mentioned before. For the Cifar10 dataset, we used two CNNs, i.e. ResNet44 and VGG16, as test cases. Both DNNs were tested on 4 GPUs, and the total mini-batch size is 256. On the ImageNet dataset, we tested AlexNet, ResNet50, and
+
+VGG16. On the PTB and Wiki2 dataset, we examined the perplexity of the 2-layer LSTM mentioned before.
+
+Figure 2 shows the validation error of RGC and quantized RGC provided by RedSync on three test cases compared with original SGD. More comprehensive results are shown in the left side of Table 1. We also tested the sensitivity of the RGC method to large training data batch size. As shown in the right side of Table 1 when increasing the batch size to 2048, RedSync got no loss of accuracy compared to the original SGD.
+
+# 3.3 EVALUATION OF SCALABILITY AND SPEED
+
+Next we tested the performance and scalability of RedSync as number of GPUs grow. Fig. 5 illustrates scalability of RedSync on Piz Daint with four test cases. Fig. 3 and Fig. 4 show the performance of RedSync on Muradin with six test cases. We compared RedSync and its quantization version Quantized-RedSync with a baseline data parallel implementation provided by horovod. Data was collected by averaging training time in 1000 training iterations. We used trimmed top-k algorithm to compress layers in CNNs larger than 128KB and used threshold binary search algorithm for hidden layers and the softmax layer for LSTM. Fig. 6 illustrates the cost of different parts using RedSync when scaling it to 128 GPUs on Piz Daint. Our observations are summarized as follows.
+
+1. Using our parallel-friendly selection methods for compression is critical for system overall performance. In Fig. 3 and Fig. 4, we added an RGC implementation called pure RGC, which uses radixSelect to select top $0 . 1 \%$ elements as communication-set rather than our proposed methods. The performance of pure $R G C$ is even slower than the baseline version, because compression time is too long.
+
+2. RedSync is suitable for accelerating data parallel training on DNNs with high communication to computation ratio. For VGG16, AlexNet and LSTM, although performance of RedSync on a single GPU is not as good as baseline version due to compression and decompression overhead, RedSync can achieve significant speedup with more than 2 GPUs. However, we observed no performance gain for ResNet50 both on Piz Daint and Muradin. As implicated in Table 1, the ratio of computation to communication of ResNet50 is the highest in the DNNs we investigated. On large scale, most of time during ResNet50 training with RedSync is wasted on decompression phase, as shown in Fig. 6, which overdrafts the benefit of communication bandwidth reduction.
+
+3. The scalability curve of RedSync on Piz Daint shows a concave shape. For example, as shown in Fig. 5, RedSync gets a better speedup to baseline version on 32 GPUs than 128 GPUs for AlexNet. It is because that communication bandwidth requirement and decompression overhead both grow linearly with the number of GPU in use. Such phenomenon verifies our analysis using communication performance model.
+
+4. Quantized-RedSync always achieves better performance than RedSync for CNNs. However, for LSTM training on small scale, Quantized-RedSync achieves worse performance than RedSync. This is due to the balance of communication and computational overhead. CNN adopts trimmed top- $\mathbf { \nabla } \cdot \mathbf { k }$ as the communication-set selection method and its quantized version has similar computation cost. As shown in Fig. 6, no significant difference of selection cost in CNN training. Therefore, the reducing of communication cost by quantization improves the system’s overall performance. As for LSTMs, they use sampled threshold binary search as selection for non-quantized RedSync, but use threshold binary search for quantized RedSync. Sampled selection is much more faster. Therefore, on small-scale, RedSync has better performance than Quantized-RedSync due to less selection overhead. When scaling to more than 16 GPUs, benefit from the reduction of communication compensates for the cost of the communication-set selection.
+
+# 4 CONCLUSION
+
+This paper proposes a distributed implementation called RedSync to accelerate data parallel DNN training by utilizing a type of gradient sparsification method named as Residual Gradient Compression (RGC). We solved two major obstacles to implement RGC on multi-GPU systems $:$ high overhead of compression using GPU and lack of support for collective communication implementation for sparse data structures. We tested the performance of RedSync on two GPU platforms, including a supercomputer system and a multi-GPU server. For AlexNet, VGG16, and LSTM, we observed significant speedup for large-scale DNN training.
+
+![](images/7ffecbe560b70a61fba10e3d4a1f6fdebf4d7351b8d7ae8f0a5e7cfaeb9d6e88.jpg)  
+Figure 3: Scalability of RedSync for CNNs training on ImageNet using Muradin.
+
+![](images/54be3dc109e4f6eb4bc68e4df07aa139ded23fbb56eeab3b2fc3f1418f6fb3c6.jpg)  
+Figure 4: Scalability of RedSync for LSTM on PTB and Wiki2 datasets. Scalability of RedSync for LSTM VGG16 on Muradin.
+
+![](images/a4be5f9491c9224318eb7e46081f9ffaef2f8069e6b7db65a8c4cf80fa1eeecf.jpg)  
+Figure 5: Scalability of RedSync for CNNs with ImageNet and LSTM with PTB on Piz Daint.
+
+![](images/c5839fafb3f3a50fc6f486ea0c3e51bffc6489ed7e4f840300b64a9f425d522d.jpg)  
+Figure 6: The time cost of different parts in RedSync on Piz Daint. Time is the average 10 iterations cost. For each two column group, the left column illustrates time decomposition for RedSync and right column illustrates time decomposition for quantized RedSync.
+
+# REFERENCES
+
+Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. arXiv preprint arXiv:1704.05021, 2017.
+
+Tolu Alabi, Jeffrey D Blanchard, Bradley Gordon, and Russel Steinbach. Fast k-selection algorithms for graphics processing units. Journal of Experimental Algorithmics (JEA), 17:4–2, 2012.
+
+Dan Alistarh, Demjan Grubic, Jerry Liu, Ryota Tomioka, and Milan Vojnovic. Communicationefficient stochastic gradient descent, with applications to neural networks. 2017.
+
+Ammar Ahmad Awan, Khaled Hamidouche, Jahanzeb Maqbool Hashmi, and Dhabaleswar K Panda. S-caffe: Co-designing mpi runtimes and caffe for scalable deep learning on modern gpu clusters. In Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, pp. 193–205. ACM, 2017.
+
+Chia-Yu Chen, Jungwook Choi, Daniel Brand, Ankur Agrawal, Wei Zhang, and Kailash Gopalakrishnan. Adacomp: Adaptive residual gradient compression for data-parallel distributed training. arXiv preprint arXiv:1712.02679, 2017.
+
+Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In Advances in neural information processing systems, pp. 1223–1231, 2012.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.
+
+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.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Yujun Lin, Song Han, Huizi Mao, Yu Wang, and William J Dally. Deep gradient compression: Reducing the communication bandwidth for distributed training. arXiv preprint arXiv:1712.01887, 2017.
+
+Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016.
+
+Ofir Press and Lior Wolf. Using the output embedding to improve language models. arXiv preprint arXiv:1608.05859, 2016.
+
+Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in neural information processing systems, pp. 693–701, 2011.
+
+Felix Sattler, Simon Wiedemann, Klaus-Robert Muller, and Wojciech Samek. Sparse binary ¨ compression: Towards distributed deep learning with minimal communication. arXiv preprint arXiv:1805.08768, 2018.
+
+Frank Seide, Hao Fu, Jasha Droppo, Gang Li, and Dong Yu. 1-bit stochastic gradient descent and its application to data-parallel distributed training of speech dnns. In Fifteenth Annual Conference of the International Speech Communication Association, 2014.
+
+Shubhabrata Sengupta, Aaron E Lefohn, and John D Owens. A work-efficient step-efficient prefix sum algorithm. In Workshop on edge computing using new commodity architectures, pp. 26–27, 2006.
+
+Shubhabrata Sengupta, Mark Harris, Yao Zhang, and John D Owens. Scan primitives for gpu computing. In Graphics hardware, volume 2007, pp. 97–106, 2007.
+
+Nikko Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.
+
+Rajeev Thakur, Rolf Rabenseifner, and William Gropp. Optimization of collective communication operations in mpich. The International Journal of High Performance Computing Applications, 19 (1):49–66, 2005.
+
+Wei Wen, Cong Xu, Feng Yan, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Terngrad: Ternary gradients to reduce communication in distributed deep learning. In Advances in Neural Information Processing Systems, pp. 1508–1518, 2017.
+
+Yang You, Zhao Zhang, C Hsieh, James Demmel, and Kurt Keutzer. Imagenet training in minutes. CoRR, abs/1709.05011, 2017.
+
+# A COST MODEL FOR SPARSE AND DENSE SYNCHRONIZATIONS
+
+The left part of Figure 7 illustrates how sparse allgather works by recursive doubling method. We assume the compression rate on all of the node is the same as $D$ . If we use threshold binary search for communication-set selection, $D$ here should be the average compression ratio of all nodes for a good approximation. In the first step, nodes that are a distance 1 apart exchange their compressed residuals, the size of which is $M \times D$ . In the second step, nodes that are a distance 2 apart exchange their own data as well as the data they received in the previous step, which is $2 M \times D$ in total. In the third step, nodes that are a distance 4 apart exchange their own data as well the data they received in the previous two steps. In this way, for a power-of-two number of processes, all processes get all the data in $\boldsymbol { \mathrm { l g } } \boldsymbol { p }$ steps. The amount of data exchanged by each node is $M \times D$ in the first step, $2 M \times D$ in the second step, and so forth, up to $2 ^ { l g ( \bar { p } ) - 1 } \dot { M } \times D$ in the last step. Therefore, The time for message transfer taken by this algorithm is $T _ { t r a n s f e r } = l g ( p ) \alpha + ( p - 1 ) M \times D \beta$ . After including decompressing overhead $\gamma$ for collected $p$ different compressed residuals and communication selection overhead $T _ { s e l e c t }$ , the time for all-gather based synchronization should be Ttransf er $= T _ { s e l e c t } + l g ( p ) \alpha + ( p - 1 ) M \times D \beta + p \gamma _ { 1 }$
+
+As shown in the right part of Figure 7, the Rabenseifners algorithm is adopted for allreduce operation on messages. It does a reduce-scatter followed by an allgather. Reduce-scatter is a variant of reduce in which the result, instead of being stored at the root, is scattered among all $p$ nodes. We use a recursive halving algorithm, which is analogous to the recursive doubling algorithm used for allgather but in reverse way. In the first step, each node exchanges data with a node that is a distance $p / 2$ away: Each process sends the data needed by all processes in the other half, which is of size $M / 2$ . They also receives the data needed by all processes in its own half, and performs the reduction operation on the received data. In the second step, each process exchanges data with a process that is a distance $p / 4$ away. This procedure continues recursively, halving the data communicated at each step, for a total of $\boldsymbol { \mathrm { l g } } \boldsymbol { p }$ steps. After reduce-scatter, allgather phase will have the the same bandwidth and latency requirements. The time taken by Rabenseifners algorithm is the sum of the times taken by reduce-scatter (recursive halving), allgather and reduction operations. The total time should be $\begin{array} { r } { \dot { T } _ { t r a n s f e r } = 2 l g ( p ) \alpha + 2 \frac { p - 1 } { p } M \beta + \frac { p - 1 } { p } \bar { M } \gamma _ { 2 } } \end{array}$ .
+
+# B OVERLAPPING COMMUNICATION AND COMPUTATION
+
+It is necessary to improve data parallel efficiency by overlapping communication with computation through pipelining communication and gradient calculation. Before updating aggregated gradients after scaling with learning rate to weights, gradient clipping is usually adopted to avoid gradient explosion. It rescales all of the gradients when the sum of their norms exceeds a threshold. For RGC methods, the local clipping technique (Lin et al. (2017)) is adopted to perform gradient clipping by a new threshold $N ^ { - 1 / 2 }$ of original) locally before adding the current gradients to previous residuals. The difference is that traditional data parallel does clipping after communication of all layers are completed, while the RGC algorithm needs to do clipping before communication. In this case, we need to wait for the completion of the entire back-propagation to get gradients of all layers. And then we do clipping on gradients and then perform compression for communication. Local clipping is equivalent to introducing synchronization between computing and communication and thus eliminating the possibility of Communication hiding.
+
+![](images/7fdb265138a5791b5c4d32c07775e841225320568170aca39ef82a070f52fb25.jpg)  
+Figure 7: Communication pattern of sparse synchronization with allgather and dense synchronization with allreduce.
+
+As shown in Figure 8, We have abandoned gradient clipping for CNNs, which seldom have gradient exploration problem for the deep networks in order to explore the potential overlapping. As for RNNs, gradients are achieved after backpropagation of all time steps using Back Propagation Through Time (BPTT). When backpropagation of the last layer is completed, we use the gradients of all layers to conduct local gradient clipping. In this case, the communication time can only overlap with the compression calculation. Because even with the original data parallel approach, the computation and communication overlap for each layer can only be made at the last time step, RGC dose not introduce too much overhead.
+
+![](images/7f2800522513d0bc5671d01ea9c77eedb8eb1631a87bcc2244ad723e32450100.jpg)  
+Figure 8: Two different schemes to overlap communication with computation for CNNs and RNNs.
+
+# C CORRECTNESS FOR MOMENTUM SGD AND WARM-UP TRAINING
+
+We integrate the momentum masking and momentum correction schemes as proposed in Lin et al. (2017) for momentum SGD and Nesterov momentum SGD optimizers in RedSync. The Momentum SGD version of RGC method adopted by RedSync is illustrated in Algorithm 4. A warm-up training, by exponentially decreasing the compression ratio of the residuals in communication-set in first few epochs, is generally adopted to accelerate convergence in the first few iterations. For example, it is recommended to decrease the compression ratio of residuals in the warm-up period as follows: $2 5 \%$ , $6 . 2 5 \%$ , $1 . 5 6 2 5 \%$ , $0 . 4 \%$ , $0 . 1 \%$ . However, we find it could be inefficient for large-scale. As analyzed in the previous section, even synchronization of compressed residual with a compression ratio as $1 . 5 6 2 5 \%$ requires $100 \%$ bandwidth of dense allreduce for quantized RedSync on 64 GPUs. Instead of adopting high-compression-ratio RGC method of warm-up training, we use original SGD optimizer synchronized by allreduce in first few epochs if necessary.
+
+# Algorithm 4 Residual Gradient Compression using MSGE
+
+Input: node id $k$ , the number of node $N$   
+Input: dataset $\chi$   
+Input: use momentum, momentum, use nesterov   
+Input: mini batch size $^ { b }$ per node   
+Input: initial model $w = w [ 0 ] , . . . , w [ \# l a y e r ]$   
+Input: compression ratio $D$ $\mathbf { \Delta } ^ { \mathbf { \triangleq } } V ^ { k } \gets 0$ $U ^ { k } \gets 0$ for $t = 0 , 1$ , ...max iter do sample $b$ elements as $\chi _ { k } ^ { t }$ $G ^ { k } \hat { \mathbf { \xi } }  \nabla f ( \chi _ { k } ^ { t } ; \mathbf { w } )$ by forward and backward propagation for $j = \# l a y e r$ , $\# l a y e r - 1 , . . . , 0$ do if use momentum then $U _ { j } ^ { k } = m o m e n t u m \cdot U _ { j } ^ { k } + G _ { j } ^ { k }$ V kj = V kj + U kj if use nesterov then $V _ { j } ^ { k } = V _ { j } ^ { k } + G _ { j } ^ { k }$ end if else $V _ { j } ^ { k } = V _ { j } ^ { k } + G _ { j } ^ { k }$ end if Masks selection $( V _ { j } ^ { k } , D )$ $G _ { j } ^ { k } \gets$ Allreduce(compress $\cdot V _ { j } ^ { k }$ · Masks)) $V _ { j } ^ { k }  V _ { j } ^ { k } \odot$ (1 - Masks) if use momentum then $U _ { j } ^ { k } \gets U _ { j } ^ { k } \odot$ (1 - Masks) end if end for w ← SGD(w, decompress $( G ^ { k } ) _ { \ l }$ ) end for

parse/train/rkxJus0cFX/rkxJus0cFX_content_list.json

@@ -0,0 +1,1154 @@
+[
+    {
+        "type": "text",
+        "text": "REDSYNC : REDUCING SYNCHRONIZATION TRAFFIC FOR DISTRIBUTED DEEP LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Data parallelism has become a dominant method to scale Deep Neural Network (DNN) training across multiple nodes. Since the synchronization of the local models or gradients can be a bottleneck for large-scale distributed training, compressing communication traffic has gained widespread attention recently. Among several recent proposed compression algorithms, Residual Gradient Compression (RGC) is one of the most successful approaches—it can significantly compress the transmitting message size $0 . 1 \\%$ of the gradient size) of each node and still preserve accuracy. However, the literature on compressing deep networks focuses almost exclusively on achieving good compression rate, while the efficiency of RGC in real implementation has been less investigated. In this paper, we develop an RGC method that achieves significant training time improvement in real-world multi-GPU systems. Our proposed RGC system design called RedSync, introduces a set of optimizations to reduce communication bandwidth while introducing limited overhead. We examine the performance of RedSync on two different multiple GPU platforms, including a supercomputer and a multi-card server. Our test cases include image classification on Cifar10 and ImageNet, and language modeling tasks on Penn Treebank and Wiki2 datasets. For DNNs featured with high communication to computation ratio, which has long been considered with poor scalability, RedSync shows significant performance improvement. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            336,
+            568
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For training large-scale deep neural networks (DNNs) on multiple computing nodes, data parallelism has emerged as the most popular choice due to its simplicity and effectiveness (Dean et al. (2012); Recht et al. (2011)). However, the communication bandwidth of network fabric has become the bottleneck limiting data parallel performance. On one hand, models of DNNs, which already contain tens to hundreds of layers and totaling 10-20 million parameters today, continue to grow bigger. Therefore, the requirement of communicating model parameter updates among all computing nodes poses a higher challenge to network bandwidth. On the other hand, the development of DNN training accelerators has shifted the bottleneck of training towards communication across models. As the evolution of the inter-connected network bandwidth is not as fast as computing hardware, synchronization overhead has become the bottleneck of data parallelism on distributed systems using new computing hardware. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many recent studies focused on reducing the communication cost between nodes by reducing the size of the gradients to be transmitted. One line of work (Seide et al. (2014); Alistarh et al. (2017); Wen et al. (2017)) propose to quantize the gradients to low-precision values. Considering compression ratio (ratio of compressed gradients size to their original size) achieved by quantization is limited, another line of research orthogonal to quantization is to sparsify communication gradients and restrict weight-updates to a small subset of parameters. Residual Gradient Compression (RGC) method (Strom (2015); Aji & Heafield (2017); Chen et al. (2017); Lin et al. (2017); Sattler et al. (2018)) is currently the most promising pruning method to achieve good compression ratio while ensuring no loss of training accuracy. It transmits only a small subset of gradients and maintains the remaining gradients locally as residuals to be added to gradients of the next iteration. The first RGC implementation is proposed by Strom (2015) and uses a threshold-based method to only send gradients larger than a predefined constant threshold for fully-connected layers. Considering a predefined threshold is hard to be chosen appropriately, Aji & Heafield (2017) improve the robustness of RGC by selecting top $1 \\%$ gradients to communicate according to their magnitude. Because these two implementations are tuned for some specific network structures, applying them to other DNNs will lead to accuracy loss as indicated in Chen et al. (2017). Based on their work, the latest RGC variants, such as (Sattler et al. (2018); Chen et al. (2017); Lin et al. (2017)), are able to achieve a $0 . 1 \\%$ compression ratio on local gradients while ensuring almost no loss of model accuracy on a variety of DNN structures after introducing some key modifications. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite of good model accuracy achieved with simulation experiments, no recent studies have discussed the potential performance gain after integrating the latest RCG methods to real distributed training system, especially to the multi-GPU systems equipped with high-quality network infrastructures. The challenges of applying RGC to distributed GPU systems come from two aspects. First, there is no efficient compression algorithm proposed for RGC method. According to our experimental results, selecting top- $0 . 1 \\%$ elements with the state-of-the-art GPU-based top- $\\mathbf { \\nabla \\cdot k }$ algorithm are so expensive that the overhead of compression is much higher than the benefits of network bandwidth reduction. Second, synchronization of sparse data structures is nontrivial to be supported with existing efficient communication libraries, such as Message Passing Interface (MPI), which are designed for dense data structures. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Targeting multi-GPU systems, a highly-efficient RGC implementation called RedSync is proposed. Our contributions are listed as follows: ",
+        "bbox": [
+            176,
+            339,
+            820,
+            368
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We combined pruning and quantization techniques together to compress transmitting gradients. A set of parallel-friendly top- $0 . 1 \\%$ selection methods are designed to support pruning operations inside GPU device memory, which are orders of magnitude faster than the stateof-the-art GPU-based top-k selection method. Considering the distribution characteristics of communication data, we apply allgather operation using MPI for a sparse synchronization scheme. A cost model is derived to analyze both communication cost and calculation overhead. Based on it, we pointed out potential performance gain and the bottleneck of our implementation. RedSync is able to ensure almost no accuracy loss to train a set of DNNs after integrating with the latest algorithm improvements. This is the first work, as far as we known, to evaluate the performance of RGC method on the scale of 128 GPUs. RedSync provides significant performance improvements for communication-intensive networks, like VGG, AlexNet and some LSTMs. ",
+        "bbox": [
+            215,
+            376,
+            825,
+            555
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 DESIGN AND IMPLEMENTATION OF REDSYNC ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            584,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first give an overview of a simple RGC workflow used in RedSync (see more details in Algorithm 1). We denote a DNN model as $f ( \\mathbf { w } )$ , where $\\mathbf { w }$ is the vector of parameters. We assume a system has $N$ workers. Each worker, say the $k$ -th worker, holds a local dataset $\\chi _ { k } ^ { t }$ at iteration $t$ with size $b$ and a local copy of the global weight w. Synchronous SGD method is adopted in RedSync. At each iteration, node $k$ computes the gradient $G ^ { k }$ using local data, where $G _ { j } ^ { k }$ indicates gradients of layer $j$ . Each node also maintains a residual $V ^ { k }$ , which is initialized as 0 and used to accumulate untransmitted gradient from previous iterations. After added with latest gradient, a subset of residuals is selected as the communication-set, and is compressed into sparse data structures. The select operation in Algorithm 1 chooses more important elements based on magnitude. Those selected elements (denoted ask Masks) are synchronized among all the nodes using allreduce operations, which is able to take advantage of the highly-optimized allreduce operation on HPC systems (Thakur et al. (2005)). Synchronous SGD ",
+        "bbox": [
+            174,
+            616,
+            516,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Residual Gradient Compression ",
+        "text_level": 1,
+        "bbox": [
+            532,
+            650,
+            807,
+            665
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Input: node id $k$ , the number of node $N$   \nInput: dataset $\\chi$   \nInput: mini batch size $^ { b }$ per node   \nInput: initial model $w \\stackrel { \\cdot } { = } w [ 0 ] , . . . , w [ \\# l a y e r ]$   \nInput: compression ratio $D$ $\\mathbf { \\hat { \\boldsymbol { V } } } ^ { k } \\gets 0$ for $t = 0 , 1 , . . . m a x . i t e r \\ \\mathbf { d o }$ sample $b$ elements as $\\chi _ { k } ^ { t }$ $G ^ { k } \\dot { \\mathbf { \\Omega } }  \\nabla \\ f ( \\chi _ { k } ^ { t } \\ ; \\ \\mathbf { w } )$ by forward and backward propagation for $j = \\# l a y e r$ , $\\# l a y e r - 1 , . . . , 0$ do ${ V } _ { j } ^ { k } { + } = G _ { j } ^ { k }$ Masks select $( V _ { j } ^ { k } , D )$ Gkj ← Allreduce(compress(V kj · Masks)) V kj ← V kj \f (1 - Masks) end for w ← SGD(w, decompress $( G ^ { k } ) _ { \\ l } ^ { \\ l }$ ) end for ",
+        "bbox": [
+            531,
+            669,
+            856,
+            905
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/d37f0f10ce77164fe591a6b4c00fec54fc1f9f2660bb92d8eb3cf87d0d7b8867.jpg",
+        "image_caption": [
+            "Figure 1: Performance of four communication-set selection methods under message sizes. Elements in the data list are generated randomly from a standard uniform distribution. Comm. illustrates the time taken to synchronize the message through a network with a peak bandwidth of 3.5GBps by allreduce operation. Performance is measured as total time cost for 100 times independent operations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            114,
+            535,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "implemented with allreduce has been widely adopted in state-of-the-art large-scale CNN training tasks (Goyal et al. (2017) and You et al. (2017)). Remaining elements outside the communicationset are assigned as new residuals of the next iteration. The workflow of this algorithm is the same as an RGC variant called Deep Gradient Compression Method mentioned Lin et al. (2017). In the following, we details our contribution in implementations of select, Allreduce and decompress to make this workflow efficient in practice. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            390
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 PARALLEL-FRIENDLY COMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            472,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The efficiency of communication-set selection method is critical for the RGC system’s overall performance. Since a predefined threshold is difficult to determine, recent work (Lin et al. (2017); Sattler et al. (2018)) suggest to select top $0 . 1 \\%$ elements from residuals of each layer as the communication-set. However, the top- $0 . 1 \\%$ selection is nontrivial to be implemented on GPU. One of the most efficient top- $k$ selection methods designed for GPU can be implemented based on radixSelect algorithm (Alabi et al. (2012)), which determines each bit of the $k$ -th largest element by scan and scatter. Serial scan (Sengupta et al. (2007)) and scatter operations are extremely timeconsuming. As shown in Figure 1, the computation time for top- $0 . 1 \\%$ with radixSelect on a Titan X GPU sometimes is even slightly higher than the time for synchronizing these parameters through a 3.5 GBps network. To avoid performing a top- $0 . 1 \\%$ operation on a large number of parameters, we propose two communication-set selection algorithms called trimmed top- $k$ selection and threshold binary search selection, which are more efficient on GPUs. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Trimmed top- $k$ selection. Observing that the distribution of residuals is usually similar to a normal distribution, we can use statistical features to remove most of the smaller elements and limit radixSelect operation on a relatively small subset. As shown in Algorithm 2, we first calculate the mean and maximum of residuals’ absolute values of this layer. A relative large threshold value is chosen according to mean and maximum value, for example, $0 . 8 \\times ( m a x - m e a n ) + m e a n$ . Operation count nonzero gets the number of elements whose absolute values are greater than the threshold. If the number is smaller than $k$ (the number of top- $0 . 1 \\%$ elements ), we dynamically decrease the threshold until we find the number of parameters whose absolute value above the threshold is larger than $k$ . Then we trim all elements that are less than the threshold and perform a top- $k$ selection operation using radixSelect on the remaining elements. Operation mean, max and count nonzero can all be efficiently implemented with a single reduction operation. nonzero indices is a typical stream compaction problem, which uses just one scan operation as its backbone (Sengupta et al. (2006)). ",
+        "bbox": [
+            173,
+            611,
+            825,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Threshold binary search selection. For some layers with very large numbers of parameter elements, even conducting radixSelect on a small subset of elements will still be a very time-consuming operation. In order to completely avoid using radixSelect operation on GPU, we propose a method to select approximate top- $0 . 1 \\%$ elements as communication-set. Instead of identifying the kth (top $0 . 1 \\%$ th) largest element, we search for a threshold to make it between the $k$ th to $2 k$ th largest element, and then select elements larger than the threshold as communication-set. In this case, at least $0 . 1 \\%$ largest elements are included in the communication-set. As shown in Algorithm 3, we use a binary search algorithm to find such a threshold. To avoid excessive searching, it will always be terminated when the difference of left bound and right bound is less than a small value $\\epsilon$ . ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/1b01c3fad7e7d4c1dd07d5527231368a1c9e14dfbc5db0bbc5490645d0634844.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm2 trimmed top-k Selection</td><td>Algorithm 3 Top-k selection with threshold bi-</td></tr><tr><td>Input: tensor to be compressed X</td><td>nary search selection</td></tr><tr><td>Input:number of elements remained k</td><td>Input: tensor to be compressed X</td></tr><tr><td>Output:&lt;indice,values &gt; 1:mean ← mean(abs(X))</td><td>Input: number of elements remained k</td></tr><tr><td>2:max ←max(abs(X))</td><td>Input:Termination condition parameter é</td></tr><tr><td>3:∈←0.2</td><td>Output:&lt;indice,values &gt;</td></tr><tr><td>4:ratio←(1-∈)</td><td>1:mean ← mean(abs(X)); max ← max(abs(X))</td></tr><tr><td>5:</td><td>l←0.0;r ←1.0; threshold=0.0</td></tr><tr><td>nnz=count_nonzero(abs(X)&gt;threshold) 6: while nnz &gt;k do</td><td>whiler-l&gt;εdo</td></tr><tr><td></td><td>ratio=l+(r-l)/2</td></tr><tr><td>7: threshold←mean+ratio× (max-mean)</td><td>threshold← mean+ratio × (max-mean)</td></tr><tr><td>8: nnz=count_nonzero(abs(X)&gt;threshold)</td><td>nnz=count_nonzero(abs(X)&gt; threshold)</td></tr><tr><td>9: ratio=ratio-e</td><td>if nnz &gt;k and 2k &gt;nnz then</td></tr><tr><td>10:end while</td><td>break</td></tr><tr><td>11:indice ←nonzero_indices(abs(X) &gt;threshold))</td><td>else if nnz&lt;k/2 then</td></tr><tr><td>12:values ← Xlindice]</td><td>r=threshold</td></tr><tr><td></td><td>else</td></tr><tr><td></td><td>l=threshold</td></tr><tr><td></td><td>12: end if</td></tr><tr><td></td><td>13: 14: end while</td></tr><tr><td></td><td>15: indice ← nonzero_indices(abs(X)&gt; threshold))</td></tr><tr><td></td><td>16:values← X[indice]</td></tr></table>",
+        "bbox": [
+            173,
+            128,
+            823,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For layers with large sizes, such as the first fully-connected layer in VGG16 and softmax layer in LSTM, the time for count nonzero operation is still not negligible. We further improve the efficiency of the selection algorithm by reducing the number of count nonzero operations. We recommend that, after a threshold binary search for this layer, the threshold element can be reused in the next few iterations. The interval of search is empirically set to 5, and the selection algorithm introduces only one nonzero count overhead on average. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Figure 1, we compared the time cost of different selection approaches on parameter lists of different sizes. Compared with directly performing radixSelect, both proposed methods significantly reduce the selection time for large sizes. For top- $0 . 1 \\%$ selection on 64MB elements, trimmed top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ and sampled threshold binary search selection are 38.13 and $1 6 . 1 7 \\ \\times$ faster than radixSelect. In practice, we dynamically choose compression strategies: For smaller parameter sets such as biases and batch norm layers, we do not compress residuals or directly use radixSelect to select top- $0 . 1 \\%$ significant elements. Trimmed top-k selection is suitable for parameters of middle size layers, like convolutional layers, because it can ensure the compression ratio to be exactly $0 . 1 \\%$ and introduce no extra communication bandwidth requirements. Threshold binary search based selection is suitable for large size layers, like hidden layers and softmax layers in LSTMs, for which the compression cost is more critical to be optimized than the communication cost. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1.1 QUANTIZATION OF COMPRESSED RESIDUALS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            544,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compressed residuals should include $k$ indices and $k$ values. We further investigate the possibility of quantizing these values. By setting the values of all elements of the same sign in the communicationset to their mean, we can almost eliminate the communication bandwidth requirement of value information transmitting by using only one floating-point number instead of $k$ . In order to facilitate quantization compression, we slightly modify our select method to ensure that elements in the communication-set are all of the same sign. It can be achieved by choosing the largest $k$ elements and the smallest $k$ elements as communication-set in turns. In other words, if we select the largest $k$ elements (all positive numbers) in this layer as the communication-set at current iteration, we will choose smallest $k$ elements (all negative numbers) as the communication-set for the next iteration. It is worth noting that sampled threshold binary search selection cannot be used with quantization. In addition, we do not quantify the output layer of the DNN, in order to distinguish the correct classification information. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 SPARSE SYNCHRONIZATION AND DECOMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            842,
+            563,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Synchronization of dense gradient structures in traditional distributed DNN systems can be simply implemented with an allreduce operation, which has been well-studied on multiple-GPU systems (Awan et al. (2017)). However, the design of a sparse allreduce in a distributed setting is not as simple because each worker may contribute different non-zero indices in its compressed residuals. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "According to our observation, there are very few overlapping indices of the communication-set distribution of different nodes. For example, training VGG16 on Cifar10 dataset using 16 GPUs with a compression ratio as $0 . 1 \\%$ for each node, the averaged compression ratio of synchronized residuals of all nodes is $1 . 5 5 \\%$ . We utilize the allgather operation, an operation in which the data contributed by each node is gathered at all nodes, to implement sparse allreduce. The message representing compressed residuals of each node should include the information of indices and values of elements in communication-set. When using threshold binary search selection, the length of each node’s message is different. As a result, the packaged message should also include an initial element, which indicates the length of the compressed elements. Instead of using two allgather operations for indices and values message separately, we package the indices and values into a single message to reduce latency. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After finishing the allgather operation, each node collects $N$ compressed residuals of this layer from all the other nodes. We add the compressed residuals to the corresponding weights in the local model after scaling with the learning rate. It can be seen as an operation that adds a sparse array to a dense array, which has been fully-optimized in Level 1 function axpyi() of cuSparse library on GPU. ",
+        "bbox": [
+            176,
+            263,
+            825,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 OTHER TECHNIQUES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            357,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "RedSync implements a set of algorithm improvement techniques proposed in Lin et al. (2017). We details momentum correction, momentum factor masking and our modification to warmup training in Appendix C, as well as local gradient clipping in Appendix B. ",
+        "bbox": [
+            176,
+            364,
+            825,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 PERFORMANCE MODEL FOR RGC COMMUNICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            424,
+            576,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To analyze the potential performance gain of sparse synchronization, we adopt a widely-used performance model to estimate the communication cost in terms of latency and bandwidth used. We assume that the time taken to send a message between any two nodes can be modeled as $\\alpha + n \\beta$ , where $\\alpha$ is the latency (or startup time) per message, independent of message size, $\\beta$ is the transfer time per byte, and $n$ is the number of bytes transferred. The node’s network interface is assumed to be single ported; i.e. at most one message can be sent and one message can be received simultaneously. $M$ is the number of elements in residuals of current layer. $D$ is the compression ratio. In the case of reduction operations, we assume that $\\gamma _ { 2 }$ is the computational cost for performing the reduction operation for a message of size $M$ , and $\\gamma _ { 1 }$ is the cost to decompress the collected sparse message of size $M$ . For the case where the compression ratio of each node is different, which is always true for the binary search method, $D$ represents the average compression ratio of all nodes. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Suppose that we use recursive doubling for allgather and Rabenseifners algorithm mentioned in Thakur et al. (2005) for allreduce communication. The cost of quantized sparse and dense synchronization is illustrated Equation 1 and 2, respectively. The derivations are left in Appendix A. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            654
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88309f11e6ac195551d5ded4921ba07e7310a145f7c2473964c5c3acd722f9ca.jpg",
+        "text": "$$\nT _ { s p a r s e } = T _ { s e l e c t } + \\log ( p ) \\alpha + ( p - 1 ) ( M D ) \\beta + p \\gamma _ { 1 } \\quad T _ { d e n s e } = 2 \\log ( p ) \\alpha + 2 \\frac { p - 1 } { p } M \\beta + \\frac { p - 1 } { p } \\gamma _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            669,
+            797,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As implicated by the performance model, the compression rate for the model is not equal to the compression rate for communication bandwidth. The bandwidth term of sparse synchronization is $( p - 1 ) D M \\beta$ , which is proportional to the number of nodes $p$ . Even if the sparseness $D$ is $0 . 1 \\%$ for all $p$ node, when $p$ is 128, the communication bandwidth for sparse synchronization will be $12 . 8 \\%$ of dense synchronization rather than $0 . 1 \\%$ of dense synchronization. Second, the overhead of reduction may be a new bottleneck when scaling RedSync to larger scale. The last term $p \\gamma _ { 1 }$ in Eq. 1 indicates that the overhead to do reduction also increases linearly with the number of nodes $p$ . However, in Eq. 2, reduction overhead almost does not increase with number of nodes. ",
+        "bbox": [
+            173,
+            703,
+            825,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            837,
+            418,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 SETUPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            269,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We tested the accuracy and performance of our proposed implementation on two different multiGPU systems, including a world’s top GPU supercomputer and a multi-GPU server. Muradin is a ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e6f25b2f1217e969175533d70fb9b7f7669cce2afe8225a43f1009345eea8b10.jpg",
+        "image_caption": [
+            "Figure 2: Left : top-1 validation accuracy vs number of epochs of training VGG16 on Cifar10 (4 GPUs, total batch size $=$ 256). Center : top-1 validation accuracy vs number of epochs of training ResNet50 on ImageNet (8 GPUs, total batch size $= 2 5 6$ ). Right : Perplexity vs number of epochs of training LSTM on PTB (4 GPUs, total batch size $= 2 0$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            118,
+            614,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/83218f554b17143a85b6868a1de6329f7edaab5f720f23234ff867bded72c79e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Size</td><td rowspan=1 colspan=1>Gflop</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>RGC</td><td rowspan=1 colspan=1>qRGC</td></tr><tr><td rowspan=2 colspan=1>Cifar10</td><td rowspan=1 colspan=1>ResNet44</td><td rowspan=1 colspan=1>2.65</td><td rowspan=1 colspan=1>0.20</td><td rowspan=1 colspan=1>7.48%</td><td rowspan=1 colspan=1>7.17%</td><td rowspan=1 colspan=1>7.87%</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>59</td><td rowspan=1 colspan=1>0.31</td><td rowspan=1 colspan=1>8.31%</td><td rowspan=1 colspan=1>8.45%</td><td rowspan=1 colspan=1>8.13%</td></tr><tr><td rowspan=3 colspan=1>ImageNet</td><td rowspan=1 colspan=1>AlexNet</td><td rowspan=1 colspan=1>233</td><td rowspan=1 colspan=1>0.72</td><td rowspan=1 colspan=1>44.73%</td><td rowspan=1 colspan=1>44.91%</td><td rowspan=1 colspan=1>44.80%</td></tr><tr><td rowspan=1 colspan=1>ResNet50</td><td rowspan=1 colspan=1>103</td><td rowspan=1 colspan=1>8.22</td><td rowspan=1 colspan=1>24.07%</td><td rowspan=1 colspan=1>23.98%</td><td rowspan=1 colspan=1>23.85%</td></tr><tr><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>528</td><td rowspan=1 colspan=1>15.5</td><td rowspan=1 colspan=1>29.5%</td><td rowspan=1 colspan=1>29.1%</td><td rowspan=1 colspan=1>29.3%</td></tr><tr><td rowspan=1 colspan=1>PTB</td><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>204</td><td rowspan=1 colspan=1>2.52</td><td rowspan=1 colspan=1>75.86</td><td rowspan=1 colspan=1>75.14</td><td rowspan=1 colspan=1>74.69</td></tr><tr><td rowspan=1 colspan=1>Wiki2</td><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>344</td><td rowspan=1 colspan=1>2.52</td><td rowspan=1 colspan=1>88.23</td><td rowspan=1 colspan=1>88.01</td><td rowspan=1 colspan=1>87.84</td></tr></table>",
+        "bbox": [
+            173,
+            280,
+            560,
+            368
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe811f1034527e217def75ba84f6e394cc3723fc47e75020d49f306a913ab3c1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=6>Batch Size   128  256   512   1024   2048</td></tr><tr><td rowspan=1 colspan=6>ResNet44</td></tr><tr><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>7.09</td><td rowspan=1 colspan=1>7.48</td><td rowspan=1 colspan=1>8.18</td><td rowspan=1 colspan=1>10.02</td><td rowspan=1 colspan=1>16.8</td></tr><tr><td rowspan=1 colspan=1>RGC</td><td rowspan=1 colspan=1>6.40</td><td rowspan=1 colspan=1>7.17</td><td rowspan=1 colspan=1>7.471</td><td rowspan=1 colspan=1>10.13</td><td rowspan=1 colspan=1>10.87</td></tr><tr><td rowspan=1 colspan=1>qRGC</td><td rowspan=1 colspan=1>7.06</td><td rowspan=1 colspan=1>7.87</td><td rowspan=1 colspan=1>7.62</td><td rowspan=1 colspan=1>11.86</td><td rowspan=1 colspan=1>10.83</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>VGG16</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>7.74</td><td rowspan=1 colspan=1>8.31</td><td rowspan=1 colspan=1>9.06</td><td rowspan=1 colspan=1>9.49</td><td rowspan=1 colspan=1>10.09</td></tr><tr><td rowspan=1 colspan=1>RGC</td><td rowspan=1 colspan=1>7.43</td><td rowspan=1 colspan=1>8.45</td><td rowspan=1 colspan=1>9.31</td><td rowspan=1 colspan=1>9.90</td><td rowspan=1 colspan=1>11.12</td></tr><tr><td rowspan=1 colspan=1>qRGC</td><td rowspan=1 colspan=1>8.17</td><td rowspan=1 colspan=1>8.13</td><td rowspan=1 colspan=1>9.09</td><td rowspan=1 colspan=1>9.97</td><td rowspan=1 colspan=1>9.81</td></tr></table>",
+        "bbox": [
+            565,
+            273,
+            854,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Results of RGC are achieved by non-quantized RGC method, and results of qRGC are achieved from quantized RGC method using RedSync. The left table : Accuracy results for various networks. Size indicates the model size in MB. GFlop shows Giga Floating-Point Operations required for a forward pass using a single input sample. Accuracy of CNNs was measured as top-1 validation errors, and accuracy of LSTMs is measured as perplexity on validating dataset. Results on Cifar10 were measured using 4 nodes with batch-size as 64 for each node. Results on ImageNet were measured using 6 nodes with batch-size as 32 for each node. Results of LSTM were measured using 4 nodes with batch-size as 5 for each node. The right table: Test errors of RCG and SGD methods under different batch sizes on Cifar10. ",
+        "bbox": [
+            173,
+            383,
+            825,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "server with eight GPUs in the same node. It is equipped with one Intel(R) Xeon(R) CPU E5-2640 v4 and 8 TITAN Vs, which is connected to the CPU through PCI-E 3.0. Piz Daint is a GPU supercomputer. Each node of it includes two Intel Xeon E5-2690v3 CPUs and one NVIDIA Tesla P100 GPUs. In total, there are 5320 nodes connected by Aries interconnect with Dragonfly topology. We used pytorch v4.0 to conduct basic DNN training operations. For communication library, horovod an MPI wrapper upon pytorch, is used to provide collective communication operations. Horovod was compiled with OpenMPI v3.1 with cuda-aware supported on both systems. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We tested our performance on two major types of mainstream deep learning applications. For Image Classification tasks, we studied ResNet-44 and VGG16 on Cifar10 (Krizhevsky & Hinton (2009)), AlexNet, VGG16 and ResNet-50 on ImageNet (Deng et al. (2009)). For all CNNs, we used Nesterov’s momentum SGD as optimizer. We used the same learning rate strategies as the SGD for the RGC methods. Warm-up technique was applied to the first 5 epochs of ResNet50 and VGG16 for both SGD and RGC. For Language Modeling tasks, we picked two datasets for evaluation. The Penn Treebank corpus (PTB) dataset consists of 923,000 training, 73,000 validation and 82,000 test words (Marcus et al. (1993)). The WikiText language modeling dataset is a collection of over 100 million tokens extracted from the set of verified Good and Featured articles on Wikipedia (Merity et al. (2016)). It consists 2,088,628 training, 217,646 and 245,569 test words. We adopted a 2-layer LSTM language model architecture with 1500 hidden units per layer (Press & Wolf (2016)) to evaluate both datasets. We tied the weights of encoder and decoder and use vanilla SGD with gradient clipping. Learning rate decays when no improvement has been made in validation loss. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            828
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 EVALUATION OF ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            853,
+            411,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We examined the convergence of RedSycn on the datasets mentioned before. For the Cifar10 dataset, we used two CNNs, i.e. ResNet44 and VGG16, as test cases. Both DNNs were tested on 4 GPUs, and the total mini-batch size is 256. On the ImageNet dataset, we tested AlexNet, ResNet50, and ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "VGG16. On the PTB and Wiki2 dataset, we examined the perplexity of the 2-layer LSTM mentioned before. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the validation error of RGC and quantized RGC provided by RedSync on three test cases compared with original SGD. More comprehensive results are shown in the left side of Table 1. We also tested the sensitivity of the RGC method to large training data batch size. As shown in the right side of Table 1 when increasing the batch size to 2048, RedSync got no loss of accuracy compared to the original SGD. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 EVALUATION OF SCALABILITY AND SPEED ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            228,
+            509,
+            242
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next we tested the performance and scalability of RedSync as number of GPUs grow. Fig. 5 illustrates scalability of RedSync on Piz Daint with four test cases. Fig. 3 and Fig. 4 show the performance of RedSync on Muradin with six test cases. We compared RedSync and its quantization version Quantized-RedSync with a baseline data parallel implementation provided by horovod. Data was collected by averaging training time in 1000 training iterations. We used trimmed top-k algorithm to compress layers in CNNs larger than 128KB and used threshold binary search algorithm for hidden layers and the softmax layer for LSTM. Fig. 6 illustrates the cost of different parts using RedSync when scaling it to 128 GPUs on Piz Daint. Our observations are summarized as follows. ",
+        "bbox": [
+            173,
+            255,
+            825,
+            366
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. Using our parallel-friendly selection methods for compression is critical for system overall performance. In Fig. 3 and Fig. 4, we added an RGC implementation called pure RGC, which uses radixSelect to select top $0 . 1 \\%$ elements as communication-set rather than our proposed methods. The performance of pure $R G C$ is even slower than the baseline version, because compression time is too long. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. RedSync is suitable for accelerating data parallel training on DNNs with high communication to computation ratio. For VGG16, AlexNet and LSTM, although performance of RedSync on a single GPU is not as good as baseline version due to compression and decompression overhead, RedSync can achieve significant speedup with more than 2 GPUs. However, we observed no performance gain for ResNet50 both on Piz Daint and Muradin. As implicated in Table 1, the ratio of computation to communication of ResNet50 is the highest in the DNNs we investigated. On large scale, most of time during ResNet50 training with RedSync is wasted on decompression phase, as shown in Fig. 6, which overdrafts the benefit of communication bandwidth reduction. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3. The scalability curve of RedSync on Piz Daint shows a concave shape. For example, as shown in Fig. 5, RedSync gets a better speedup to baseline version on 32 GPUs than 128 GPUs for AlexNet. It is because that communication bandwidth requirement and decompression overhead both grow linearly with the number of GPU in use. Such phenomenon verifies our analysis using communication performance model. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4. Quantized-RedSync always achieves better performance than RedSync for CNNs. However, for LSTM training on small scale, Quantized-RedSync achieves worse performance than RedSync. This is due to the balance of communication and computational overhead. CNN adopts trimmed top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ as the communication-set selection method and its quantized version has similar computation cost. As shown in Fig. 6, no significant difference of selection cost in CNN training. Therefore, the reducing of communication cost by quantization improves the system’s overall performance. As for LSTMs, they use sampled threshold binary search as selection for non-quantized RedSync, but use threshold binary search for quantized RedSync. Sampled selection is much more faster. Therefore, on small-scale, RedSync has better performance than Quantized-RedSync due to less selection overhead. When scaling to more than 16 GPUs, benefit from the reduction of communication compensates for the cost of the communication-set selection. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            318,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This paper proposes a distributed implementation called RedSync to accelerate data parallel DNN training by utilizing a type of gradient sparsification method named as Residual Gradient Compression (RGC). We solved two major obstacles to implement RGC on multi-GPU systems $:$ high overhead of compression using GPU and lack of support for collective communication implementation for sparse data structures. We tested the performance of RedSync on two GPU platforms, including a supercomputer system and a multi-GPU server. For AlexNet, VGG16, and LSTM, we observed significant speedup for large-scale DNN training. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ffecbe560b70a61fba10e3d4a1f6fdebf4d7351b8d7ae8f0a5e7cfaeb9d6e88.jpg",
+        "image_caption": [
+            "Figure 3: Scalability of RedSync for CNNs training on ImageNet using Muradin. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            98,
+            761,
+            234
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/54be3dc109e4f6eb4bc68e4df07aa139ded23fbb56eeab3b2fc3f1418f6fb3c6.jpg",
+        "image_caption": [
+            "Figure 4: Scalability of RedSync for LSTM on PTB and Wiki2 datasets. Scalability of RedSync for LSTM VGG16 on Muradin. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            272,
+            761,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4be5f9491c9224318eb7e46081f9ffaef2f8069e6b7db65a8c4cf80fa1eeecf.jpg",
+        "image_caption": [
+            "Figure 5: Scalability of RedSync for CNNs with ImageNet and LSTM with PTB on Piz Daint. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            460,
+            826,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5839fafb3f3a50fc6f486ea0c3e51bffc6489ed7e4f840300b64a9f425d522d.jpg",
+        "image_caption": [
+            "Figure 6: The time cost of different parts in RedSync on Piz Daint. Time is the average 10 iterations cost. For each two column group, the left column illustrates time decomposition for RedSync and right column illustrates time decomposition for quantized RedSync. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            635,
+            764,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. arXiv preprint arXiv:1704.05021, 2017. ",
+        "bbox": [
+            174,
+            126,
+            821,
+            154
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tolu Alabi, Jeffrey D Blanchard, Bradley Gordon, and Russel Steinbach. Fast k-selection algorithms for graphics processing units. Journal of Experimental Algorithmics (JEA), 17:4–2, 2012. ",
+        "bbox": [
+            174,
+            161,
+            820,
+            191
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Alistarh, Demjan Grubic, Jerry Liu, Ryota Tomioka, and Milan Vojnovic. Communicationefficient stochastic gradient descent, with applications to neural networks. 2017. ",
+        "bbox": [
+            171,
+            199,
+            821,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ammar Ahmad Awan, Khaled Hamidouche, Jahanzeb Maqbool Hashmi, and Dhabaleswar K Panda. S-caffe: Co-designing mpi runtimes and caffe for scalable deep learning on modern gpu clusters. In Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, pp. 193–205. ACM, 2017. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            294
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chia-Yu Chen, Jungwook Choi, Daniel Brand, Ankur Agrawal, Wei Zhang, and Kailash Gopalakrishnan. Adacomp: Adaptive residual gradient compression for data-parallel distributed training. arXiv preprint arXiv:1712.02679, 2017. ",
+        "bbox": [
+            173,
+            301,
+            821,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In Advances in neural information processing systems, pp. 1223–1231, 2012. ",
+        "bbox": [
+            173,
+            352,
+            825,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            446
+        ],
+        "page_idx": 8
+    },
+    {
+        "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": [
+            176,
+            454,
+            823,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            506,
+            823,
+            521
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yujun Lin, Song Han, Huizi Mao, Yu Wang, and William J Dally. Deep gradient compression: Reducing the communication bandwidth for distributed training. arXiv preprint arXiv:1712.01887, 2017. ",
+        "bbox": [
+            176,
+            529,
+            823,
+            571
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993. ",
+        "bbox": [
+            171,
+            579,
+            823,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016. ",
+        "bbox": [
+            173,
+            617,
+            823,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ofir Press and Lior Wolf. Using the output embedding to improve language models. arXiv preprint arXiv:1608.05859, 2016. ",
+        "bbox": [
+            171,
+            654,
+            823,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in neural information processing systems, pp. 693–701, 2011. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Felix Sattler, Simon Wiedemann, Klaus-Robert Muller, and Wojciech Samek. Sparse binary ¨ compression: Towards distributed deep learning with minimal communication. arXiv preprint arXiv:1805.08768, 2018. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Frank Seide, Hao Fu, Jasha Droppo, Gang Li, and Dong Yu. 1-bit stochastic gradient descent and its application to data-parallel distributed training of speech dnns. In Fifteenth Annual Conference of the International Speech Communication Association, 2014. ",
+        "bbox": [
+            173,
+            792,
+            825,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shubhabrata Sengupta, Aaron E Lefohn, and John D Owens. A work-efficient step-efficient prefix sum algorithm. In Workshop on edge computing using new commodity architectures, pp. 26–27, 2006. ",
+        "bbox": [
+            176,
+            844,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shubhabrata Sengupta, Mark Harris, Yao Zhang, and John D Owens. Scan primitives for gpu computing. In Graphics hardware, volume 2007, pp. 97–106, 2007. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nikko Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rajeev Thakur, Rolf Rabenseifner, and William Gropp. Optimization of collective communication operations in mpich. The International Journal of High Performance Computing Applications, 19 (1):49–66, 2005. ",
+        "bbox": [
+            174,
+            143,
+            825,
+            186
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Cong Xu, Feng Yan, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Terngrad: Ternary gradients to reduce communication in distributed deep learning. In Advances in Neural Information Processing Systems, pp. 1508–1518, 2017. ",
+        "bbox": [
+            174,
+            199,
+            825,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Zhao Zhang, C Hsieh, James Demmel, and Kurt Keutzer. Imagenet training in minutes. CoRR, abs/1709.05011, 2017. ",
+        "bbox": [
+            173,
+            253,
+            820,
+            281
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A COST MODEL FOR SPARSE AND DENSE SYNCHRONIZATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            310,
+            714,
+            328
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The left part of Figure 7 illustrates how sparse allgather works by recursive doubling method. We assume the compression rate on all of the node is the same as $D$ . If we use threshold binary search for communication-set selection, $D$ here should be the average compression ratio of all nodes for a good approximation. In the first step, nodes that are a distance 1 apart exchange their compressed residuals, the size of which is $M \\times D$ . In the second step, nodes that are a distance 2 apart exchange their own data as well as the data they received in the previous step, which is $2 M \\times D$ in total. In the third step, nodes that are a distance 4 apart exchange their own data as well the data they received in the previous two steps. In this way, for a power-of-two number of processes, all processes get all the data in $\\boldsymbol { \\mathrm { l g } } \\boldsymbol { p }$ steps. The amount of data exchanged by each node is $M \\times D$ in the first step, $2 M \\times D$ in the second step, and so forth, up to $2 ^ { l g ( \\bar { p } ) - 1 } \\dot { M } \\times D$ in the last step. Therefore, The time for message transfer taken by this algorithm is $T _ { t r a n s f e r } = l g ( p ) \\alpha + ( p - 1 ) M \\times D \\beta$ . After including decompressing overhead $\\gamma$ for collected $p$ different compressed residuals and communication selection overhead $T _ { s e l e c t }$ , the time for all-gather based synchronization should be Ttransf er $= T _ { s e l e c t } + l g ( p ) \\alpha + ( p - 1 ) M \\times D \\beta + p \\gamma _ { 1 }$ ",
+        "bbox": [
+            173,
+            343,
+            825,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As shown in the right part of Figure 7, the Rabenseifners algorithm is adopted for allreduce operation on messages. It does a reduce-scatter followed by an allgather. Reduce-scatter is a variant of reduce in which the result, instead of being stored at the root, is scattered among all $p$ nodes. We use a recursive halving algorithm, which is analogous to the recursive doubling algorithm used for allgather but in reverse way. In the first step, each node exchanges data with a node that is a distance $p / 2$ away: Each process sends the data needed by all processes in the other half, which is of size $M / 2$ . They also receives the data needed by all processes in its own half, and performs the reduction operation on the received data. In the second step, each process exchanges data with a process that is a distance $p / 4$ away. This procedure continues recursively, halving the data communicated at each step, for a total of $\\boldsymbol { \\mathrm { l g } } \\boldsymbol { p }$ steps. After reduce-scatter, allgather phase will have the the same bandwidth and latency requirements. The time taken by Rabenseifners algorithm is the sum of the times taken by reduce-scatter (recursive halving), allgather and reduction operations. The total time should be $\\begin{array} { r } { \\dot { T } _ { t r a n s f e r } = 2 l g ( p ) \\alpha + 2 \\frac { p - 1 } { p } M \\beta + \\frac { p - 1 } { p } \\bar { M } \\gamma _ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            546,
+            825,
+            732
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B OVERLAPPING COMMUNICATION AND COMPUTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            655,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "It is necessary to improve data parallel efficiency by overlapping communication with computation through pipelining communication and gradient calculation. Before updating aggregated gradients after scaling with learning rate to weights, gradient clipping is usually adopted to avoid gradient explosion. It rescales all of the gradients when the sum of their norms exceeds a threshold. For RGC methods, the local clipping technique (Lin et al. (2017)) is adopted to perform gradient clipping by a new threshold $N ^ { - 1 / 2 }$ of original) locally before adding the current gradients to previous residuals. The difference is that traditional data parallel does clipping after communication of all layers are completed, while the RGC algorithm needs to do clipping before communication. In this case, we need to wait for the completion of the entire back-propagation to get gradients of all layers. And then we do clipping on gradients and then perform compression for communication. Local clipping is equivalent to introducing synchronization between computing and communication and thus eliminating the possibility of Communication hiding. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/7fdb265138a5791b5c4d32c07775e841225320568170aca39ef82a070f52fb25.jpg",
+        "image_caption": [
+            "Figure 7: Communication pattern of sparse synchronization with allgather and dense synchronization with allreduce. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            99,
+            808,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            345,
+            821,
+            373
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 8, We have abandoned gradient clipping for CNNs, which seldom have gradient exploration problem for the deep networks in order to explore the potential overlapping. As for RNNs, gradients are achieved after backpropagation of all time steps using Back Propagation Through Time (BPTT). When backpropagation of the last layer is completed, we use the gradients of all layers to conduct local gradient clipping. In this case, the communication time can only overlap with the compression calculation. Because even with the original data parallel approach, the computation and communication overlap for each layer can only be made at the last time step, RGC dose not introduce too much overhead. ",
+        "bbox": [
+            173,
+            381,
+            825,
+            492
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/7f2800522513d0bc5671d01ea9c77eedb8eb1631a87bcc2244ad723e32450100.jpg",
+        "image_caption": [
+            "Figure 8: Two different schemes to overlap communication with computation for CNNs and RNNs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            512,
+            745,
+            661
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C CORRECTNESS FOR MOMENTUM SGD AND WARM-UP TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            736,
+            751,
+            753
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We integrate the momentum masking and momentum correction schemes as proposed in Lin et al. (2017) for momentum SGD and Nesterov momentum SGD optimizers in RedSync. The Momentum SGD version of RGC method adopted by RedSync is illustrated in Algorithm 4. A warm-up training, by exponentially decreasing the compression ratio of the residuals in communication-set in first few epochs, is generally adopted to accelerate convergence in the first few iterations. For example, it is recommended to decrease the compression ratio of residuals in the warm-up period as follows: $2 5 \\%$ , $6 . 2 5 \\%$ , $1 . 5 6 2 5 \\%$ , $0 . 4 \\%$ , $0 . 1 \\%$ . However, we find it could be inefficient for large-scale. As analyzed in the previous section, even synchronization of compressed residual with a compression ratio as $1 . 5 6 2 5 \\%$ requires $100 \\%$ bandwidth of dense allreduce for quantized RedSync on 64 GPUs. Instead of adopting high-compression-ratio RGC method of warm-up training, we use original SGD optimizer synchronized by allreduce in first few epochs if necessary. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4 Residual Gradient Compression using MSGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            529,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Input: node id $k$ , the number of node $N$   \nInput: dataset $\\chi$   \nInput: use momentum, momentum, use nesterov   \nInput: mini batch size $^ { b }$ per node   \nInput: initial model $w = w [ 0 ] , . . . , w [ \\# l a y e r ]$   \nInput: compression ratio $D$ $\\mathbf { \\Delta } ^ { \\mathbf { \\triangleq } } V ^ { k } \\gets 0$ $U ^ { k } \\gets 0$ for $t = 0 , 1$ , ...max iter do sample $b$ elements as $\\chi _ { k } ^ { t }$ $G ^ { k } \\hat { \\mathbf { \\xi } }  \\nabla f ( \\chi _ { k } ^ { t } ; \\mathbf { w } )$ by forward and backward propagation for $j = \\# l a y e r$ , $\\# l a y e r - 1 , . . . , 0$ do if use momentum then $U _ { j } ^ { k } = m o m e n t u m \\cdot U _ { j } ^ { k } + G _ { j } ^ { k }$ V kj = V kj + U kj if use nesterov then $V _ { j } ^ { k } = V _ { j } ^ { k } + G _ { j } ^ { k }$ end if else $V _ { j } ^ { k } = V _ { j } ^ { k } + G _ { j } ^ { k }$ end if Masks selection $( V _ { j } ^ { k } , D )$ $G _ { j } ^ { k } \\gets$ Allreduce(compress $\\cdot V _ { j } ^ { k }$ · Masks)) $V _ { j } ^ { k }  V _ { j } ^ { k } \\odot$ (1 - Masks) if use momentum then $U _ { j } ^ { k } \\gets U _ { j } ^ { k } \\odot$ (1 - Masks) end if end for w ← SGD(w, decompress $( G ^ { k } ) _ { \\ l }$ ) end for ",
+        "bbox": [
+            174,
+            122,
+            553,
+            507
+        ],
+        "page_idx": 11
+    }
+]