Add files using upload-large-folder tool

parse/train/Arn2E4IRjEB/Arn2E4IRjEB.md

@@ -0,0 +1,377 @@
+# Flow Network based Generative Models for Non-Iterative Diverse Candidate Generation
+
+Emmanuel Bengio1,2, Moksh Jain1,5, Maksym Korablyov1 Doina Precup1,2,4, Yoshua Bengio1,3 1Mila, 2McGill University, 3Université de Montréal, 4DeepMind, 5Microsof
+
+# Abstract
+
+This paper is about the problem of learning a stochastic policy for generating an object (like a molecular graph) from a sequence of actions, such that the probability of generating an object is proportional to a given positive reward for that object. Whereas standard return maximization tends to converge to a single return-maximizing sequence, there are cases where we would like to sample a diverse set of high-return solutions. These arise, for example, in black-box function optimization when few rounds are possible, each with large batches of queries, where the batches should be diverse, e.g., in the design of new molecules. One can also see this as a problem of approximately converting an energy function to a generative distribution. While MCMC methods can achieve that, they are expensive and generally only perform local exploration. Instead, training a generative policy amortizes the cost of search during training and yields to fast generation. Using insights from Temporal Difference learning, we propose GFlowNet, based on a view of the generative process as a flow network, making it possible to handle the tricky case where different trajectories can yield the same final state, e.g., there are many ways to sequentially add atoms to generate some molecular graph. We cast the set of trajectories as a flow and convert the flow consistency equations into a learning objective, akin to the casting of the Bellman equations into Temporal Difference methods. We prove that any global minimum of the proposed objectives yields a policy which samples from the desired distribution, and demonstrate the improved performance and diversity of GFlowNet on a simple domain where there are many modes to the reward function, and on a molecule synthesis task.
+
+# 1 Introduction
+
+The maximization of expected return $R$ in reinforcement learning (RL) is generally achieved by putting all the probability mass of the policy $\pi$ on the highest-return sequence of actions. In this paper, we study the scenario where our objective is not to generate the single highest-reward sequence of actions but rather to sample a distribution of trajectories whose probability is proportional to a given positive return or reward function. This can be useful in tasks where exploration is important, i.e., we want to sample from the leading modes of the return function. This is equivalent to the problem of turning an energy function into a corresponding generative model, where the object to be generated is obtained via a sequence of actions. By changing the temperature of the energy function (i.e., scaling it multiplicatively) or by taking the power of the return, one can control how selective the generator should be, i.e., only generate from around the highest modes at low temperature or explore more with a higher temperature.
+
+A motivating application for this setup is iterative black-box optimization where the learner has access to an oracle which can compute a reward for a large batch of candidates at each round, e.g., in drug-discovery applications. Diversity of the generated candidates is particularly important when the oracle is itself uncertain, e.g., it may consist of cellular assays which is a cheap proxy for clinical trials, or it may consist of the result of a docking simulation (estimating how well a candidate small molecule binds to a target protein) which is a proxy for more accurate but more expensive downstream evaluations (like cellular assays or in-vivo assays in mice).
+
+When calling the oracle is expensive (e.g. it involves a biological experiment), a standard way (Angermueller et al., 2020) to apply machine learning in such exploration settings is to take the data already collected from the oracle (say a set of $( x , y )$ pairs where $x$ is a candidate solution an $y$ is a scalar evaluation of $x$ from the oracle) and train a supervised proxy $f$ (viewed as a simulator) which predicts $y$ from $x$ . The function $f$ or a variant of $f$ which incorporates uncertainty about its value, like in Bayesian optimization (Srinivas et al., 2010; Negoescu et al., 2011), can then be used as a reward function $R$ to train a generative model or a policy that will produce a batch of candidates for the next experimental assays. Searching for $x$ which maximizes $R ( x )$ is not sufficient because we would like to sample for the batch of queries a representative set of $x$ ’s with high values of $R$ , i.e., around modes of $R ( x )$ . Note that alternative ways to obtain diversity exist, e.g., with batch Bayesian optimization (Kirsch et al., 2019). An advantage of the proposed approach is that the computational cost is linear in the size of the batch (by opposition with methods which compare pairs of candidates, which is at least quadratic). With the possibility of assays of a hundred thousand candidates using synthetic biology, linear scaling would be a great advantage.
+
+In this paper, we thus focus on the specific machine learning problem of turning a given positive reward or return function into a generative policy which samples with a probability proportional to the return. In applications like the one mentioned above, we only apply the reward function after having generated a candidate, i.e., the reward is zero except in a terminal state, and the return is the terminal reward. We are in the so-called episodic setting of RL.
+
+The proposed approach views the probability assigned to an action given a state as the flow associated with a network whose nodes are states, and outgoing edges from that node are deterministic transitions driven by an action (not to be confused with normalizing flows; Rezende and Mohamed (2016)). The total flow into the network is the sum of the rewards in the terminal states (i.e., a partition function) and can be shown to be the flow at the root node (or start state). The proposed algorithm is inspired by Bellman updates and converges when the incoming and outgoing flow into and out of each state match. A policy which chooses an action with probability proportional to the outgoing flow corresponding to that action is proven to achieve the desired result, i.e., the probability of sampling a terminal state is proportional to its reward. In addition, we show that the resulting setup is off-policy; it converges to the above solution even if the training trajectories come from a different policy, so long as it has large enough support on the state space.
+
+The main contributions of this paper are as follows:
+
+• We propose GFlowNet, a novel generative method for unnormalized probability distributions based on flow networks and local flow-matching conditions: the flow incoming to a state must match the outgoing flow.   
+• We prove crucial properties of GFlowNet, including the link between the flow-matching conditions (which many training objectives can provide) and the resulting match of the generated policy with the target reward function. We also prove its offline properties and asymptotic convergence (if the training objective can be minimized). We also demonstrate that previous related work (Buesing et al., 2019) which sees the generative process like a tree would fail when there are many action sequences which can lead to the same state.   
+We demonstrate on synthetic data the usefulness of departing from seeking one mode of the return, and instead seeking to model the entire distribution and all its modes.   
+• We successfully apply GFlowNet to a large scale molecule synthesis domain, with comparative experiments against PPO and MCMC methods.
+
+All implementations are available at https://github.com/bengioe/gflownet.
+
+# 2 Approximating Flow Network generative models with a TD-like objective
+
+Consider a discrete set $\mathcal { X }$ and policy $\pi ( a | s )$ to sequentially build $x \in \mathcal { X }$ with probability $\pi ( x )$ with
+
+$$
+\pi ( x ) \approx { \frac { R ( x ) } { Z } } = { \frac { R ( x ) } { \sum _ { x ^ { \prime } \in { \mathcal { X } } } R ( x ^ { \prime } ) } }
+$$
+
+where $R ( x ) > 0$ is a reward for a terminal state $x$ . This would be useful to sample novel drug-like molecules when given a reward function $R$ that scores molecules based on their chemical properties. Being able to sample from the high modes of $R ( x )$ would provide diversity in the batches of generated molecules sent to assays. This is in contrast with the typical RL objective of maximizing return which we have found to often end up focusing around one or very few good molecules. In our context, $R ( x )$ is a proxy for the actual values obtained from assays, which means it can be called often and cheaply. $R ( x )$ is retrained or fine-tuned each time we acquire new data from the assays.
+
+What method should one use to generate batches sampled from $\pi ( x ) \propto R ( x ) ?$ Let’s first think of the state space under which we would operate.
+
+Let $s$ denote the set of states and $\mathcal { X } \subset \mathcal { S }$ denote the set of terminal states. Let $\mathcal { A }$ be a finite set, the alphabet, ${ \mathcal { A } } ( s ) \subseteq A$ be the set of allowed actions at state $s$ , and let $\mathcal { A } ^ { \ast } ( s )$ be the set of all sequences of actions allowed after state $s$ . To every action sequence $\vec { a } = ( a _ { 1 } , a _ { 2 } , a _ { 3 } , . . . , a _ { h } )$ of $a _ { i } \in \mathcal { A } , h \le H$ corresponds a single $x$ , i.e. the environment is deterministic so we can define a function $C$ mapping a sequence of actions $\vec { a }$ to an $x$ . If such a sequence is ‘incomplete’ we define its reward to be 0. When the correspondence between action sequences and states is bijective, a state $s$ is uniquely described by some sequence $\vec { a }$ , and we can visualize the generative process as the traversal of a tree from a single root node to a leaf corresponding to the sequence of actions along the way.
+
+However, when this correspondence is non-injective, i.e. when multiple action sequences describe the same $x$ , things get trickier. Instead of a tree, we get a directed acyclic graph or DAG (assuming that the sequences must be of finite length, i.e., there are no deterministic cycles), as illustrated in Figure 1. For example, and of interest here, molecules can be seen as graphs, which can be described in multiple orders (canonical representations such as SMILES strings also have this problem: there may be multiple descriptions for the same actual molecule). The standard approach to such a sampling problem is to use iterative MCMC methods (Xie et al., 2021; Grathwohl et al., 2021). Another option is to relax the desire to have $p ( x ) \propto R ( x )$ and to use non-interative (sequential) RL methods (Gottipati et al., 2020), but these are at high risk of getting stuck in local maxima and of missing modes. Indeed, in our setting, the policy which maximizes the expected return (which is the expected final reward) generates the sequence with the highest return (i.e., a single molecule).
+
+# 2.1 Flow Networks
+
+In this section we propose the Generative Flow Network framework, or GFlowNet, which enables us to learn policies such that $p ( x ) \propto R ( x )$ when sampled. We first discuss why existing methods are inadequate, and then show how we can use the metaphor of flows, sinks and sources, to construct adequate policies. We then show that such policies can be learned via a flow-matching objective.
+
+With existing methods in the bijective case, one can think of the sequential generation of one $x$ as an episode in a tree-structured deterministic MDP, where all leaves $x$ are terminal states (with reward $R ( x ) )$ and the root is initial state $s _ { 0 }$ . Interestingly, in such a case one can express the pseudo-value of a state $\tilde { V } ( s )$ as the sum of all the rewards of the descendants of $s$ (Buesing et al., 2019).
+
+In the non-injective case, these methods are inadequate. Constructing $\pi ( \tau ) \approx R ( \tau ) / Z$ , e.g. as per Buesing et al. (2019), MaxEnt RL (Haarnoja et al., 2017), or via an autoregressive method (Nash and Durkan, 2019; Shi et al., 2021) has a particular problem as shown below: if multiple action sequences $\vec { a }$ (i.e. multiple trajectories $\tau$ ) lead to a final state $x$ , then a serious bias can be introduced in the generative probabilities. Let us denote ${ \vec { a } } + { \vec { b } }$ as the concatenation of the two sequences of actions $\vec { a }$ and $\vec { b }$ , and by extension $s + { \vec { b } }$ the state reached by applying the actions in $\vec { b }$ from state $s$ .
+
+Proposition 1. Let $C : { \mathcal { A } } ^ { * } \mapsto { \mathcal { S } }$ associate each allowed action sequence $\vec { a } \in \mathcal { A } ^ { \ast }$ to a state $s = C ( \vec { a } ) \in S$ . Let $\tilde { V } : { \cal S } \mapsto { { \bf R } ^ { + } }$ associate each state $s \in S$ to $\begin{array} { r } { \tilde { V } ( s ) = \sum _ { \vec { b } \in \mathcal { A } ^ { * } ( s ) } R ( s + \vec { b } ) > 0 , } \end{array}$ where $\mathcal { A } ^ { \ast } ( s )$ is the set of allowed continuations from s and $s + { \vec { b } }$ denotes the resulting state, i.e., $\tilde { V } ( s )$ is the sum of the rewards of all the states reachable from $s$ . Consider a policy $\pi$ which starts from the state corresponding to the empty string $s _ { 0 } = C ( \emptyset )$ and chooses from state $s \in S$ an allowable action a ∈ A(s) with probability π(a|s) = $\begin{array} { r } { \pi ( a | s ) = \frac { \tilde { V } ( s + a ) } { \sum _ { b \in { \cal A } ( s ) } \tilde { V } ( s + b ) } } \end{array}$ . Denote $\pi ( \vec { a } = ( a _ { 1 } , \ldots , a _ { N } ) ) =$ $\begin{array} { r } { \prod _ { i = 1 } ^ { N } \pi ( a _ { i } | C ( a _ { 1 } , \dots , a _ { i - 1 } ) ) } \end{array}$ and $\pi ( s )$ with $s \in S$ the probability of visiting a state s with this policy. The following then obtains:   
+(a) $\begin{array} { r } { \dot { \pi } ( s ) = \dot { \sum } _ { \vec { a } _ { i } : C ( \vec { a } _ { i } ) = s } \pi ( \vec { a } _ { i } ) } \end{array}$ .
+
+$( b )$ If $C$ is bijective, then $\begin{array} { r } { \pi ( s ) = \frac { \tilde { V } ( s ) } { \tilde { V } ( s _ { 0 } ) } } \end{array}$ and as a special case for terminal states $x$ , $\begin{array} { r } { \pi ( x ) = \frac { R ( x ) } { \sum _ { x \in \mathcal { X } } R ( x ) } } \end{array}$ . (c) If $C$ is non-injective and there are $n ( x )$ distinct action sequences $\vec { a } _ { i }$ s.t. $C ( \vec { a } _ { i } ) = \dot { x }$ , then $\begin{array} { r } { \pi ( x ) = \frac { n ( x ) R ( x ) } { \sum _ { x ^ { \prime } \in \mathcal { X } } n ( x ^ { \prime } ) R ( x ^ { \prime } ) } } \end{array}$ .
+
+See Appendix A.1 for the proof. In combinatorial spaces, such as for molecules, where $C$ is noninjective (there are many ways to construct a molecule graph), this can become exponentially bad as trajectory lengths increase. It means that larger molecules would be exponentially more likely to be sampled than smaller ones, just because of the many more paths leading to them. In this scenario, the pseudo-value $\tilde { V }$ is “misinterpreting” the MDP’s structure as a tree, leading to the wrong $\pi ( x )$ .
+
+An alternative is to see the MDP as a flow network, that is, leverage the DAG structure of the MDP, and learn a flow $F$ , rather than estimating the pseudo-value $\tilde { V }$ as a sum of descendant rewards, as elaborated below. We define the flow network as a having a single source, the root node (or initial state) $s _ { 0 }$ with in-flow $Z$ , and one sink for each leaf (or terminal state) $x$ with out-flow $R ( x ) > 0$ . We write $T ( s , a ) = s ^ { \prime }$ to denote that the state-action pair $( s , a )$ leads to state $s ^ { \prime }$ . Note that because $C$ is not a bijection, i.e., there are many paths (action sequences) leading to some node, a node can have multiple parents, i.e. $| \{ ( s , a ) \mid \bar { T ( s , a ) } = s ^ { \prime } \} | \geq 1$ , except for the root, which has no parent. We write $F ( s , a )$ for the flow between node $s$ and node $s ^ { \prime } = T ( s , a )$ , $F ( s )$ for the total flow going through $s ^ { \th }$ 1. This construction is illustrated in Fig. 1.
+
+![](images/390eb9d5c13ec96c0daad8748cbe2eda9e5b15367cc919510da6f556c5da8aaa.jpg)  
+Figure 1: A flow network MDP. Episodes start at source $s _ { 0 }$ with flow $Z$ . Like with SMILES strings, there are no cycles. Terminal states are sinks with out-flow $R ( s )$ . Exemplar state $s _ { 3 }$ has parents $\left\{ ( s , a ) | T ( s , a ) = s _ { 3 } \right\} = \left\{ ( s _ { 1 } , a _ { 2 } ) , ( s _ { 2 } , a _ { 5 } ) \right\}$ and allowed actions $\overset { \cdot } { \underset { \cdot } { A } } ( s _ { 3 } ) = \{ a _ { 4 } , a _ { 7 } \}$ . $s _ { 4 }$ is a terminal sink state with $R ( s _ { 4 } ) > 0$ and only one parent. The goal is to estimate $F ( s , a )$ such that the flow equations are satisfied for all states: for each node, incoming flow equals outgoing flow.
+
+To satisfy flow conditions, we require that for any node, the incoming flow equals the outgoing flow, which is the total flow $F ( s )$ of node $s$ . Boundary conditions are given by the flow into the terminal nodes $x$ , $R ( x )$ . Formally, for any node $s ^ { \prime }$ , we must have that the in-flow
+
+$$
+F ( s ^ { \prime } ) = \sum _ { s , a : T ( s , a ) = s ^ { \prime } } F ( s , a )
+$$
+
+equals the out-flow
+
+$$
+F ( s ^ { \prime } ) = \sum _ { a ^ { \prime } \in \mathcal { A } ( s ^ { \prime } ) } F ( s ^ { \prime } , a ^ { \prime } ) .
+$$
+
+More concisely, with $R ( s ) = 0$ for interior nodes, and $\mathcal { A } ( s ) = \emptyset$ for leaf (sink/terminal) nodes, we write the following flow consistency equations:
+
+$$
+\sum _ { s , a : T ( s , a ) = s ^ { \prime } } F ( s , a ) = R ( s ^ { \prime } ) + \sum _ { a ^ { \prime } \in A ( s ^ { \prime } ) } F ( s ^ { \prime } , a ^ { \prime } ) .
+$$
+
+with $F$ being a flow, $F ( s , a ) > 0 \forall s , a$ (for this we needed to constrain $R ( x )$ to be positive too). One could include in principle nodes and edges with zero flow but it would make it difficult to talk about the logarithm of the flow, as we do below, and such states can always be excluded by the allowed set of actions for their parent states. Let us now show that such a flow correctly produces $\pi ( x ) = R ( x ) / Z$ when the above flow equations are satisfied.
+
+Proposition 2. Let us define a policy $\pi$ that generates trajectories starting in state $s _ { 0 }$ by sampling actions $a \in { \mathcal { A } } ( s )$ according to
+
+$$
+\pi ( a | s ) = { \frac { F ( s , a ) } { F ( s ) } }
+$$
+
+where $F ( s , a ) > 0$ is the flow through allowed edge $( s , a )$ , $\begin{array} { r } { F ( s ) = R ( s ) + \sum _ { a \in \mathcal { A } ( s ) } F ( s , a ) } \end{array}$ where $R ( s ) = 0$ for non-terminal nodes s and $F ( x ) = R ( x ) > 0$ for terminal nodes $x$ , and the flow consistency equation $\begin{array} { r } { \sum _ { s , a : T ( s , a ) = s ^ { \prime } } F ( s , a ) = R ( s ^ { \prime } ) + \sum _ { a ^ { \prime } \in A ( s ^ { \prime } ) } F ( s ^ { \prime } , a ^ { \prime } ) } \end{array}$ is satisfied. Let $\pi ( s )$ denote the probability of visiting state $s$ when starting at $s _ { 0 }$ and following $\pi ( \cdot | \cdot )$ . Then
+
+(a) $\begin{array} { r } { \pi ( s ) = \frac { F ( s ) } { F ( s _ { 0 } ) } } \end{array}$ (b) $\begin{array} { r } { F ( s _ { 0 } ) = \sum _ { x \in \mathcal { X } } R ( x ) } \end{array}$ (c) π(x) = P R(x)x0∈X R(x0) .
+
+Proof. We have $\pi ( s _ { 0 } ) = 1$ since we always start in root node $s _ { 0 }$ . Note that $\begin{array} { r } { \sum _ { x \in \mathcal { X } } \pi ( x ) = 1 } \end{array}$ because terminal states are mutually exclusive, but in the case of non-bijective $C$ , we cannot say that $\textstyle \sum _ { s \in S } \pi ( s )$ equals 1 because the different states are not mutually exclusive in general. This notation is different from the one typically used in RL where $\pi ( s )$ refers to the asymptotic distribution of the Markov chain. Then
+
+$$
+\pi ( s ^ { \prime } ) = \sum _ { ( a , s ) : T ( s , a ) = s ^ { \prime } } \pi ( a | s ) \pi ( s )
+$$
+
+i.e., using Eq. 5,
+
+$$
+\pi ( s ^ { \prime } ) = \sum _ { ( a , s ) : T ( s , a ) = s ^ { \prime } } { \frac { F ( s , a ) } { F ( s ) } } \pi ( s ) .
+$$
+
+We can now conjecture that the statement
+
+$$
+\pi ( s ) = { \frac { F ( s ) } { F ( s _ { 0 } ) } }
+$$
+
+is true and prove it by induction. This is trivially true for the root, which is our base statement, since $\pi ( s _ { 0 } ) = 1$ . By induction, we then have that if the statement is true for parents $s$ of $s ^ { \prime }$ , then
+
+$$
+\pi ( s ^ { \prime } ) = \sum _ { s , a : T ( s , a ) = s ^ { \prime } } { \frac { F ( s , a ) } { F ( s ) } } { \frac { F ( s ) } { F ( s _ { 0 } ) } } = { \frac { \sum _ { s , a : T ( s , a ) = s ^ { \prime } } F ( s , a ) } { F ( s _ { 0 } ) } } = { \frac { F ( s ^ { \prime } ) } { F ( s _ { 0 } ) } }
+$$
+
+which proves the statement, i.e., the first conclusion (a) of the theorem. We can then apply it to the case of terminal states $x$ , whose flow is fixed to $F ( x ) = R ( x )$ and obtain
+
+$$
+\pi ( x ) = { \frac { R ( x ) } { F ( s _ { 0 } ) } } .
+$$
+
+Noting that $\begin{array} { r } { \sum _ { x \in X } \pi ( x ) = 1 } \end{array}$ and summing both sides of Eq. 10 over $x$ we thus obtain (b), i.e., F (s0) = Px∈X R(x). Plugging this back into Eq. 10, we obtain (c), i.e., π(x) = P R(x)x0∈X R(x0) . □
+
+Thus our choice of $\pi ( a | s )$ satisfies our desiderata: it maps a reward function $R$ to a generative model which generates $x$ with probability $\pi ( x ) \propto R ( x )$ , whether $C$ is bijective or non-injective (the former being a special case of the latter, and we just provided a proof for the general non-injective case).
+
+# 2.2 Objective Functions for GFlowNet
+
+We can now leverage our RL intuitions to create a learning algorithm out of the above theoretical results. In particular, we propose to approximate the flows $F$ such that the flow consistency equations are respected at convergence with enough capacity in our estimator of $F$ , just like the Bellman equations for temporal-difference (TD) algorithms (Sutton and Barto, 2018). This could yield the following objective for a trajectory $\tau$ :
+
+$$
+\tilde { \mathcal { L } } _ { \theta } ( \tau ) = \sum _ { s ^ { \prime } \in \tau \neq s _ { 0 } } \left( \sum _ { s , a : T ( s , a ) = s ^ { \prime } } F _ { \theta } ( s , a ) - R ( s ^ { \prime } ) - \sum _ { a ^ { \prime } \in A ( s ^ { \prime } ) } F _ { \theta } ( s ^ { \prime } , a ^ { \prime } ) \right) ^ { 2 } .
+$$
+
+One issue from a learning point of view is that the flow will be very large for nodes near the root (early in the trajectory) and tiny for nodes near the leaves (late in the trajectory). In high-dimensional spaces where the cardinality of $\mathcal { X }$ is exponential (e.g., in the typical number of actions to form an $x$ ), the $F ( s , a )$ and $F ( s )$ for early states will be exponentially larger than for later states. Since we want $F ( s , a )$ to be the output of a neural network, this would lead to serious numerical issues.
+
+To avoid this problem, we define the flow matching objective on a log-scale, where we match not the incoming and outgoing flows but their logarithms, and we train our predictor to estimate $F _ { \theta } ^ { \log } ( s , a ) = \log F ( s , a )$ , and exponentiate-sum-log the  of logs: $F _ { \theta } ^ { \mathrm { l o g } }$ predictions to compute the loss, yielding
+
+$$
+\mathcal { L } _ { \theta , \epsilon } ( \tau ) = \sum _ { s ^ { \prime } \in \tau \neq s _ { 0 } } \left( \log \left[ \epsilon + \sum _ { s , a : T ( s , a ) = s ^ { \prime } } F _ { \theta } ^ { \log } ( s , a ) \right] - \log \left[ \epsilon + R ( s ^ { \prime } ) + \sum _ { a ^ { \prime } \in A ( s ^ { \prime } ) } \exp F _ { \theta } ^ { \log } ( s ^ { \prime } , a ^ { \prime } ) \right] \right) ^ { 2 }
+$$
+
+which gives equal gradient weighing to large and small magnitude predictions. Note that matching the logs of the flows is equivalent to making the ratio of the incoming and outgoing flow closer to 1. To give more weight to errors on large flows and avoid taking the logarithm of a tiny number, we compare log( $\epsilon +$ incoming flow) with log( $\epsilon +$ outgoing flow). It does not change the global minimum, which is still when the flow equations are satisfied, but it avoids numerical issues with taking the log of a tiny flow. The hyper-parameter $\epsilon$ also trades-off how much pressure we put on matching large versus small flows, and in our experiments is set to be close to the smallest value $R$ can take. Since we want to discover the top modes of $R$ , it makes sense to care more for the larger flows. Many other objectives are possible for which flow matching is also a global minimum.
+
+An interesting advantage of such objective functions is that they yield off-policy offline methods. The predicted flows $F$ do not depend on the policy used to sample trajectories (apart from the fact that the samples should sufficiently cover the space of trajectories in order to obtain generalization). This is formalized below, which shows that we can use any broad-support policy to sample training trajectories and still obtain the correct flows and generative model, i.e., training can be off-policy.
+
+Proposition 3. Let trajectories $\tau$ used to train $F _ { \theta }$ be sampled from an exploratory policy $P$ with the same support as the optimal $\pi$ defined in Eq. 5 for a consistent flow $F ^ { * } \in { \mathcal { F } } ^ { * }$ . A flow is consistent if Eq. 4 is respected. Also assume that $\exists \theta : F _ { \theta } = F ^ { * }$ , i.e., we choose a sufficiently rich family of predictors. Let $\theta ^ { * } \in \mathrm { a r g m i n } _ { \theta } E _ { P ( \tau ) } [ L _ { \theta } ( \tau ) ]$ a minimizer of the expected training loss. Let $L _ { \theta } ( \tau )$ have the property that when flows are matched it achieves its lowest possible value. First, it can $b e$ shown that this property is satisfied for the loss in Eq. 12. Then
+
+$$
+{ \cal F } _ { \theta ^ { * } } = { \cal F } ^ { * } , \mathrm { a n d } { \cal L } _ { \theta ^ { * } } ( \tau ) = 0 \forall \tau \sim { \cal P } ( \theta ) ,
+$$
+
+i.e., a global optimum of the expected loss provides the correct flows. If πθ∗ (a|s) = P Fθ∗ (s,a)a0∈A(s) Fθ∗ (s,a0) then we also have
+
+$$
+\pi _ { \theta ^ { \ast } } ( x ) = \frac { R ( x ) } { Z } .
+$$
+
+The proof is in Appendix A.1. Note that, in RL terms, this method is akin to asynchronous dynamic programming (Sutton and Barto, 2018, $\ S 4 . 5$ ), which is an off-policy off-line method which converges provided every state is visited infinitely many times asymptotically.
+
+# 3 Related Work
+
+The objective of training a policy generating states with a probability proportional to rewards was presented by Buesing et al. (2019) but the proposed method only makes sense when there is a bijection between action sequences and states. In contrast, GFlowNet is applicable in the more general setting where many paths can lead to the same state. The objective to sample with probability proportional to a given unnormalized positive function is achieved by many MCMC methods (Grathwohl et al., 2021; Dai et al., 2020). However, when mixing between modes is challenging (e.g., in high-dimensional spaces with well-separated modes occupying a fraction of the total volume) convergence to the target distribution can be extremely slow. In contrast, GFlowNet is not iterative and amortizes the challenge of sampling from such modes through a training procedure which must be sufficiently exploratory.
+
+This sampling problem comes up in molecule generation and has been studied in this context with numerous generative models (Shi et al., 2020; Jin et al., 2020; Luo et al., 2021), MCMC methods (Seff et al., 2019; Xie et al., 2021), RL (Segler et al., 2017; Cao and Kipf, 2018; Popova et al., 2019; Gottipati et al., 2020; Angermueller et al., 2020) and evolutionary methods (Brown et al., 2004; Jensen, 2019; Swersky et al., 2020). Some of these methods rely on a given set of "positive examples" (high-reward) to train a generative model, thus not taking advantage of the "negative examples" and the continuous nature of the measurements (some examples should be generated more often than others). Others rely on the traditional return maximization objectives of RL, which tends to focus on one or a few dominant modes, as we find in our experiments. Beyond molecules, there are previous works generating data non-greedily through RL (Bachman and Precup, 2015) or energy-based GANs (Dai et al., 2017).
+
+The objective that we formulate in (12) may remind the reader of the objective of control-asinference’s Soft Q-Learning (Haarnoja et al., 2017), with the difference that we include all the parents of a state in the in-flow, whereas Soft Q-Learning only uses the parent contained in the trajectory. Soft Q-Learning induces a different policy, as shown by Proposition 1, one where $P ( \tau ) \propto R ( \tau )$ rather than $P ( x ) \propto \bar { R } ( x )$ . More generally, we only consider deterministic generative settings whereas RL is a more general framework for stochastic environments.
+
+Literature at the intersection of network flow and deep learning is sparse, and is mostly concerned with solving maximum flow problems (Nazemi and Omidi, 2012; Chen and Zhang, 2020) or classification within existing flow networks (Rahul et al., 2017; Pekta¸s and Acarman, 2019). Finally, the idea of accounting for the search space being a DAG rather than a tree in MCTS, known as transpositions (Childs et al., 2008), also has some links with the proposed method.
+
+# 4 Empirical Results
+
+We first verify that GFlowNet works as advertised on an artificial domain small enough to compute the partition function exactly, and compare its abilities to recover modes compared to standard MCMC and RL methods, with its sampling distribution better matching the normalized reward. We find that GFlowNet (A) converges to $\pi ( x ) \propto R ( x )$ , (B) requires less samples to achieve some level of performance than MCMC and PPO methods and (C) recovers all the modes and does so faster than MCMC and PPO, both in terms of wall-time and number of states visited and queried. We then test GFlowNet on a large scale domain, which consists in generating small drug molecule graphs, with a reward that estimates their binding affinity to a target protein (see Appendix A.3). We find that GFlowNet finds higher reward and more diverse molecules faster than baselines.
+
+# 4.1 A (hyper-)grid domain
+
+Consider an MDP where states are the cells of a $n$ -dimensional hypercubic grid of side length $H$ . The agent starts at coordinate $x = ( 0 , 0 , \ldots )$ and is only allowed to increase coordinate $i$ with action $a _ { i }$ (up to $H$ , upon which the episode terminates). A stop action indicates to terminate the trajectory. There are many action sequences that lead to the same coordinate, making this MDP a DAG.The reward for ending the trajectory in $x$ is some $R ( x ) > 0$ . For MCMC methods, in order to have an ergodic chain, we allow the iteration to decrease coordinates as well, and there is no stop action.
+
+We ran experiments with this reward function:
+
+$$
+\begin{array} { r } { R ( x ) = R _ { 0 } + R _ { 1 } \prod _ { i } \mathbb { I } ( 0 . 2 5 < | x _ { i } / H - 0 . 5 | ) + R _ { 2 } \prod _ { i } \mathbb { I } ( 0 . 3 < | x _ { i } / H - 0 . 5 | < 0 . 4 ) } \end{array}
+$$
+
+with $0 < R _ { 0 } \ll R _ { 1 } < R _ { 2 }$ , pictured when $n = 2$ on the right. For this choice of $R$ , there are only interesting rewards near the corners of the grid, and there are exactly $2 ^ { n }$ modes. We set $R _ { 1 } \stackrel { \cdot } { = } 1 / 2$ , $R _ { 2 } = 2$ . By varying $R _ { 0 }$ and setting it closer to 0, we make this problem artificially harder, creating a region of the state space which it is undesirable to explore. To measure the performance of a method, we measure the empirical L1 error $\mathbb { E } [ | p ( x ) - \pi ( { \bar { x } } ) | ]$ . $p ( x ) = R ( x ) / Z$ is known in this domain, and $\pi$ is estimated by repeated sampling and counting frequencies for each possible $x$ . We also measure the number of modes with at least 1 visit as a function of the number of states visited.
+
+We run the above experiment for $R _ { 0 } \in \{ 1 0 ^ { - 1 } , 1 0 ^ { - 2 } , 1 0 ^ { - 3 } \}$ with $n = 4$ , $H = 8$ . In Fig. 2 we see that GFlowNet is robust to $R _ { 0 }$ and obtains a low L1 error, while a Metropolis-Hastings-MCMC based method requires exponentially more samples than GFlowNet to achieve some level of L1 error. This is apparent in Fig. 2 (with a log-scale horizontal axis) by comparing the slope of progress of GFlowNet (beyond the initial stage) and that of the MCMC sampler. We also see that MCMC takes much longer to visit each mode once as $R _ { 0 }$ decreases, while GFlowNet is only slightly affected, with GFlowNet converging to some level of L1 error faster, as per hypothesis (B). This suggests that
+
+GFlowNet is robust to the separation between modes (represented by $R _ { 0 }$ being smaller) and thus recovers all the modes much faster than MCMC (again, noting the log-scale of the horizontal axis).
+
+To compare to RL, we run PPO (Schulman et al., 2017). To discover all the modes in a reasonable time, we need to set the entropy maximization term much higher (0.5) than usual $( \ll 1 )$ ). We verify that PPO is not overly regularized by comparing it to a random agent. PPO finds all the modes faster than uniform sampling, but much more slowly than GFlowNet, and is also robust to the choice of $R _ { 0 }$ . This and the previous result validates hypothesis (C). We also run SAC (Haarnoja et al., 2018), finding similar or worse results. We provide additional results and discussion in Appendix A.6.
+
+![](images/f78e0a7efa3a201cb3d3a0ed1cb2db9072c6757469cb48b28d92d7518573dc09.jpg)  
+Figure 2: Hypergrid domain. Changing the task difficulty $R _ { 0 }$ to illustrate the advantage of GFlowNet over others. We see that as $R _ { 0 }$ gets smaller, MCMC struggles to fit the distribution because it struggles to visit all the modes. PPO also struggles to find all the modes, and requires very large entropy regularization, but is robust to the choice of $R _ { 0 }$ . We plot means over 10 runs for each setting.
+
+# 4.2 Generating small molecules
+
+Here our goal is to generate a diverse set of small molecules that have a high reward. We define a large-scale environment which allows an agent to sequentially generate molecules. This environment is challenging, with up to $1 0 ^ { 1 6 }$ states and between 100 and 2000 actions depending on the state.
+
+We follow the framework of Jin et al. (2020) and generate molecules by parts using a predefined vocabulary of building blocks that can be joined together forming a junction tree (detailed in A.3). This is also known as fragment-based drug design (Kumar et al., 2012; Xie et al., 2021). Generating such a graph can be described as a sequence of additive edits: given a molecule and constraints of chemical validity, we choose an atom to attach a block to. The action space is thus the product of choosing where to attach a block and choosing which block to attach. There is an extra action to stop the editing sequence. This sequence of edits yields a DAG MDP, as there are multiple action sequences that lead to the same molecule graph, and no edge removal actions, which prevents cycles.
+
+The reward is computed with a pretrained proxy model that predicts the binding energy of a molecule to a particular protein target (soluble epoxide hydrolase, sEH, see A.3). Although computing binding energy is computationally expensive, we can call this proxy cheaply. Note that for realistic drug design, we would need to consider many more quantities such as drug-likeness (Bickerton et al., 2012), toxicity, or synthesizability. Our goal here is not solve this problem, and our work situates itself within such a larger project. Instead, we want to show that given a proxy $R$ in the space of molecules, we can quickly match its induced distribution $\pi ( x ) \propto R ( x )$ and find many of its modes.
+
+We parameterize the proxy with an MPNN (Gilmer et al., 2017) over the atom graph. Our flow predictor $F _ { \theta }$ is parameterized similarly to MARS (Xie et al., 2021), with an MPNN, but over the junction tree graph (the graph of blocks), which had better performance. For fairness, this architecture is used for both GFlowNet and the baselines. Complete details can be found in Appendix A.4.
+
+We pretrain the proxy with a semi-curated semi-random dataset of $3 0 0 \mathrm { k }$ molecules (see A.4) down to a test MSE of 0.6; molecules are scored according to the docking score (Trott and Olson, 2010), renormalized so that most scores fall between 0 and 10 (to have $\bar { R ( } x { ) } > 0 { ) }$ . We plot the dataset’s reward distribution in Fig. 3. We train all generative models with up to $1 0 ^ { 6 }$ molecules. During training, sampling follows exploratory policy $P ( \boldsymbol { a } | \boldsymbol { s } )$ which is a mixture between $\pi ( a | s )$ (Eq. 5), used with probability 0.95, and a uniform distribution over allowed actions with probability 0.05.
+
+Experimental results In Fig. 3 we show the empirical distribution of rewards in two settings; first when we train our model with $R ( x )$ , then with ${ \bar { R } } ( x ) ^ { \beta }$ . If GFlowNet learns a reasonable policy $\pi$ this should shift the distribution to the right. This is indeed what we observe. We compare GFlowNet to MARS (Xie et al., 2021), known to work well in the molecule domain, and observe the same shift. Note that GFlowNet finds more high reward molecules than MARS with these $\beta$ values; this is consistent with the hypothesis that it finds high-reward modes faster (since MARS is an MCMC method, it would eventually converge to the same distribution, but takes more time).
+
+![](images/56144c31df71789119b3f527b0faeaa77f9787cb0bbabacc12616ad4ac31580d.jpg)  
+Figure 3: Empirical density of rewards. We verify that GFlowNet is consistent by training it with $R ^ { \beta }$ , $\beta = 4$ , which has the hypothesized effect of shifting the density to the right.
+
+![](images/ae057cac7ada7b6e331edd1d4fc3208b0beff1c559881aabc17c7e680348ab95.jpg)  
+Figure 4: The average reward of the top- $k$ as a function of learning (averaged over 3 runs). Only unique hits are counted. Note the log scale. Our method finds more unique good molecules faster.
+
+In Fig. 4, we show the average reward of the top- $k$ molecules found so far, without allowing for duplicates (based on SMILES). We compare GFlowNet with MARS, PPO, and JT-VAE (Jin et al., 2020) with Bayesian Optimization. As expected, PPO plateaus after a while; RL tends to be satisfied with good enough trajectories unless it is strongly regularized with exploration mechanisms. For GFlowNet and for MARS, the more molecules are visited, the better they become, with a slow convergence towards the proxy’s max reward. Given the same compute time, $\scriptstyle \mathbf { J } \mathbf { T } - \mathbf { V } \mathbf { A } \mathbf { E } + \mathbf { B } \mathbf { O }$ generates only about $1 0 ^ { 3 }$ molecules (due to its expensive Gaussian Process) and so does not perform well.
+
+The maximum reward in the proxy’s dataset is 10, with only 233 examples above 8. In our best run, we find 2339 unique molecules during training with a score above 8, only 39 of which are in the dataset. We compute the average pairwise Tanimoto similarity for the top 1000 samples: GFlowNet has a mean of $0 . 4 4 \pm 0 . 0 1$ , PPO, $0 . 6 2 \pm 0 . 0 3$ , and MARS, $0 . 5 9 \pm 0 . 0 2$ (mean and std over 3 runs). As expected, our MCMC baseline (MARS) and RL baseline (PPO) find less diverse candidates. We also find that GFlowNet discovers many more modes $( > 1 5 0 0$ with $R > 8$ vs $< 1 0 0$ for MARS). This is shown in Fig. 5 where we consider a mode to be a Bemis-Murcko scaffold (Bemis and Murcko, 1996), counted for molecules above a certain reward threshold. We provide additional insights into how GFlowNet matches the rewards in Appendix A.7.
+
+![](images/4f6c3d3fd8d0bad63785195c8151dd88346a1ad41ea3cef93552e73c8e733869.jpg)  
+Figure 5: Number of diverse Bemis-Murcko scaffolds found above reward threshold $T$ as a function of the number of molecules seen. Left, $T = 7 . 5$ . Right, $T = 8$ .
+
+# 4.3 Multi-Round Experiments
+
+To demonstrate the importance of diverse candidate generation in an active learning setting, we consider a sequential acquisition task. We simulate the setting where there is a limited budget for calls to the true oracle $O$ . We use a proxy $M$ initialized by training on a limited dataset of $( x , R ( x ) )$
+
+pairs $D _ { 0 }$ , where $R ( x )$ is the true reward from the oracle. The generative model $\left( \pi _ { \boldsymbol { \theta } } \right)$ is trained to fit to the unnormalized probability function learned by the proxy $M$ . We then sample a batch $B = \{ x _ { 1 } , x _ { 2 } , . . . x _ { k } \}$ where $x _ { i } \sim \pi _ { \theta }$ , which is evaluated with the oracle $O$ . The proxy $M$ is updated with this newly acquired and labeled batch, and the process is repeated for $N$ iterations. We discuss the experimental setting in more detail in Appendix A.5.
+
+![](images/57f77d159cae3745834d0ddf9b599ff5f9e8a19b8e5dd554012b7e815a7b0fe3.jpg)  
+Figure 6: The top- $\mathbf { \nabla } \cdot \mathbf { k }$ return (mean over 3 runs) in the 4-D Hyper-grid task with active learning. GFlowNet gets the highest return faster.
+
+![](images/6b4940bf58465c3496eea9644bbc71a972ddbd721a83526315b3b6676df6500d.jpg)  
+Figure 7: The top- $\mathbf { \nabla } \cdot \mathbf { k }$ docking reward (mean over 3 runs) in the molecule task with active learning. GFlowNet consistently generates better samples.
+
+Hyper-grid domain We present results for the multi-round task in the 4-D hyper-grid domain in Figure 6. We use a Gaussian Process (Williams and Rasmussen, 1995) as the proxy. We compare the Top- $k$ Return for all the methods, which is defined as mean(t $\mathrm { \gamma } \mathrm { p } { - } k ( D _ { i } ) ) { - } \mathrm { m e a n } \big ( \mathrm { t o p } { - } k ( D _ { i - 1 } ) \big )$ , where $D _ { i }$ is the dataset of points acquired until step $i$ , and $k = 1 0$ for this experiment. The initial dataset $D _ { 0 }$ $\left. \left| D _ { 0 } \right| \right. = \left. 5 1 2 \right.$ is the same for all the methods compared. We observe that GFlowNet consistently outperforms the baselines in terms of return over the initial set. We also observe that the mean pairwise L2-distance between the top - $k$ points at the end of the final round is $0 . 8 3 \pm 0 . 0 3$ , $0 . 6 1 \pm 0 . 0 1$ and $0 . 5 1 \pm 0 . 0 2$ for GFlowNet, MCMC and PPO respectively. This demonstrates the ability of GFlowNet to capture the modes, even in the absence of the true oracle, as well as the importance of capturing this diversity in multi-round settings.
+
+Small Molecules For the molecule discovery task, we initialize an MPNN proxy to predict docking scores from AutoDock (Trott and Olson, 2010), with $| D _ { 0 } | = 2 0 0 0$ molecules. At the end of each round we generate 200 molecules which are evaluated with AutoDock and used to update the proxy. Figure 7 shows GFlowNet discovers molecules with significantly higher energies than the initial set $D _ { 0 }$ . It also consistently outperforms MARS as well as Random Acquisition. PPO training was unstable and diverged consistently so the numbers are not reported. The mean pairwise Tanimoto similarity in the initial set is 0.60. At the end of the final round, it is $0 . 5 4 \pm 0 . 0 4$ for GFlowNet and $0 . 6 4 \pm 0 . 0 3$ for MARS. This further demonstrates the ability of GFlowNet to generate diverse candidates, which ultimately helps improve the final performance on the task. Similar to the single step setting, we observe that JT-VAE $+ \mathrm { B O }$ is only able to generate $1 0 ^ { 3 }$ molecules with similar compute time, and thus performs poorly.
+
+# 5 Discussion & Limitations
+
+In this paper we have introduced a novel TD-like objective for learning a flow for each state and (state, action) pair such that policies sampling actions proportional to these flows draw terminal states in proportion to their reward. This can be seen as an alternative approach to turn an energy function into a fast generative model, without the need for an iterative method like that needed with MCMC methods, and with the advantage that when training succeeds, the policy generates a great diversity of samples near the main modes of the target distribution without being slowed by issues of mixing between modes.
+
+Limitations. One downside of the proposed method is that, as for TD-based methods, the use of bootstrapping may cause optimization challenges (Kumar et al., 2020; Bengio et al., 2020) and limit its performance. In applications like drug discovery, sampling from the regions surrounding each mode is already an important advantage, but future work should investigate how to combine such a generative approach to local optimization in order to refine the generated samples and approach the local maxima of reward while keeping the batches of candidates diverse.
+
+Negative Social Impact. The authors do not foresee negative social impacts of this work specifically.
+
+# Acknowledgments and Disclosure of Funding
+
+This research was enabled in part by computational resources provided by Calcul Québec (www. calculquebec.ca) and Compute Canada (www.computecanada.ca). All authors are funded by their primary academic institution. We also acknowledge funding from Samsung Electronics Co., Ldt., CIFAR and IBM.
+
+The authors are grateful to Andrei Nica for generating the molecule dataset, to Maria Kadukova for advice on molecular docking, to Harsh Satija for feedback on the paper, as well as to all the members of the Mila Molecule Discovery team for the many research discussions on the challenges we faced.
+
+# Author Contributions
+
+EB and YB contributed to the original idea, and wrote most sections of the paper. YB wrote the proofs of Propositions 1-3, EB the proof of Proposition 4. EB wrote the code and ran experiments for sections 4.1 (hypergrid) and 4.2 (small molecules). MJ wrote the code and ran experiments for section 4.3 (multi-round) and wrote the corresponding results section of the paper. MK wrote the biochemical framework upon which the molecule experiments are built, assisted in debugging and running experiments for section 4.3, implemented mode-counting routines used in 4.2, and wrote the biochemical details of the paper.
+
+MK, DP and YB provided supervision for the project. All authors contributed to proofreading and editing the paper.
+
+# References
+
+Christof Angermueller, David Dohan, David Belanger, Ramya Deshpande, Kevin Murphy, and Lucy Colwell. Model-based reinforcement learning for biological sequence design. In International Conference on Learning Representations, 2020.   
+Philip Bachman and Doina Precup. Data generation as sequential decision making. Advances in Neural Information Processing Systems, 28:3249–3257, 2015.   
+Guy W Bemis and Mark A Murcko. The properties of known drugs. 1. molecular frameworks. Journal of medicinal chemistry, 39(15):2887–2893, 1996.   
+Emmanuel Bengio, Joelle Pineau, and Doina Precup. Interference and generalization in temporal difference learning. In International Conference on Machine Learning, pages 767–777. PMLR, 2020.   
+G Richard Bickerton, Gaia V Paolini, Jérémy Besnard, Sorel Muresan, and Andrew L Hopkins. Quantifying the chemical beauty of drugs. Nature chemistry, 4(2):90–98, 2012.   
+Nathan Brown, Ben McKay, François Gilardoni, and Johann Gasteiger. A graph-based genetic algorithm and its application to the multiobjective evolution of median molecules. Journal of chemical information and computer sciences, 44(3):1079–1087, 2004.   
+Lars Buesing, Nicolas Heess, and Theophane Weber. Approximate inference in discrete distributions with monte carlo tree search and value functions, 2019.   
+Nicola De Cao and Thomas Kipf. Molgan: An implicit generative model for small molecular graphs, 2018.   
+Yize Chen and Baosen Zhang. Learning to solve network flow problems via neural decoding. arXiv preprint arXiv:2002.04091, 2020.   
+Benjamin E Childs, James H Brodeur, and Levente Kocsis. Transpositions and move groups in monte carlo tree search. In 2008 IEEE Symposium On Computational Intelligence and Games, pages 389–395. IEEE, 2008.   
+Hanjun Dai, Rishabh Singh, Bo Dai, Charles Sutton, and Dale Schuurmans. Learning discrete energy-based models via auxiliary-variable local exploration. In Neural Information Processing Systems (NeurIPS), 2020.
+
+Zihang Dai, Amjad Almahairi, Philip Bachman, Eduard Hovy, and Aaron Courville. Calibrating energy-based generative adversarial networks. arXiv preprint arXiv:1702.01691, 2017.
+
+Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry, 2017.
+
+Sai Krishna Gottipati, Boris Sattarov, Sufeng Niu, Yashaswi Pathak, Haoran Wei, Shengchao Liu, Karam M. J. Thomas, Simon Blackburn, Connor W. Coley, Jian Tang, Sarath Chandar, and Yoshua Bengio. Learning to navigate the synthetically accessible chemical space using reinforcement learning, 2020.
+
+Will Grathwohl, Kevin Swersky, Milad Hashemi, David Duvenaud, and Chris J. Maddison. Oops i took a gradient: Scalable sampling for discrete distributions, 2021.
+
+Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement learning with deep energy-based policies. In International Conference on Machine Learning, pages 1352–1361. PMLR, 2017.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor, 2018.
+
+Jan H Jensen. A graph-based genetic algorithm and generative model/monte carlo tree search for the exploration of chemical space. Chemical science, 10(12):3567–3572, 2019.
+
+Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Chapter 11. junction tree variational autoencoder for molecular graph generation. Drug Discovery, page 228–249, 2020. ISSN 2041-3211. doi: 10. 1039/9781788016841-00228. URL http://dx.doi.org/10.1039/9781788016841-00228.
+
+Andreas Kirsch, Joost van Amersfoort, and Yarin Gal. Batchbald: Efficient and diverse batch acquisition for deep bayesian active learning, 2019.
+
+Ashutosh Kumar, A Voet, and KYJ Zhang. Fragment based drug design: from experimental to computational approaches. Current medicinal chemistry, 19(30):5128–5147, 2012.
+
+Aviral Kumar, Rishabh Agarwal, Dibya Ghosh, and Sergey Levine. Implicit under-parameterization inhibits data-efficient deep reinforcement learning, 2020.
+
+Greg Landrum. Rdkit: Open-source cheminformatics. URL http://www.rdkit.org.
+
+Youzhi Luo, Keqiang Yan, and Shuiwang Ji. Graphdf: A discrete flow model for molecular graph generation, 2021.
+
+Charlie Nash and Conor Durkan. Autoregressive energy machines, 2019.
+
+Alireza Nazemi and Farahnaz Omidi. A capable neural network model for solving the maximum flow problem. Journal of Computational and Applied Mathematics, 236(14):3498–3513, 2012.
+
+Diana M. Negoescu, Peter I. Frazier, and Warren B. Powell. The knowledge-gradient algorithm for sequencing experiments in drug discovery. 23(3):346–363, 2011. ISSN 1526-5528. doi: 10.1287/ijoc.1100.0417. URL https://doi.org/10.1287/ijoc.1100.0417.
+
+Andrew Y Ng, Stuart J Russell, et al. Algorithms for inverse reinforcement learning. In Icml, volume 1, page 2, 2000.
+
+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'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library. pdf.
+
+Abdurrahman Pekta¸s and Tankut Acarman. Deep learning to detect botnet via network flow summaries. Neural Computing and Applications, 31(11):8021–8033, 2019.
+
+Mariya Popova, Mykhailo Shvets, Junier Oliva, and Olexandr Isayev. Molecularrnn: Generating realistic molecular graphs with optimized properties, 2019.
+
+RK Rahul, T Anjali, Vijay Krishna Menon, and KP Soman. Deep learning for network flow analysis and malware classification. In International Symposium on Security in Computing and Communication, pages 226–235. Springer, 2017.
+
+Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows, 2016.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms, 2017.
+
+Ari Seff, Wenda Zhou, Farhan Damani, Abigail Doyle, and Ryan P Adams. Discrete object generation with reversible inductive construction. arXiv preprint arXiv:1907.08268, 2019.
+
+Marwin H. S. Segler, Thierry Kogej, Christian Tyrchan, and Mark P. Waller. Generating focussed molecule libraries for drug discovery with recurrent neural networks, 2017.
+
+Chence Shi, Minkai Xu, Zhaocheng Zhu, Weinan Zhang, Ming Zhang, and Jian Tang. Graphaf: a flow-based autoregressive model for molecular graph generation, 2020.
+
+Yunsheng Shi, Zhengjie Huang, Shikun Feng, Hui Zhong, Wenjin Wang, and Yu Sun. Masked label prediction: Unified message passing model for semi-supervised classification, 2021.
+
+Niranjan Srinivas, Andreas Krause, S. Kakade, and M. Seeger. Gaussian process optimization in the bandit setting: No regret and experimental design. In ICML, 2010.
+
+Teague Sterling and John J Irwin. Zinc 15–ligand discovery for everyone. Journal of chemical information and modeling, 55(11):2324–2337, 2015.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Kevin Swersky, Yulia Rubanova, David Dohan, and Kevin Murphy. Amortized bayesian optimization over discrete spaces. In Conference on Uncertainty in Artificial Intelligence, pages 769–778. PMLR, 2020.
+
+Oleg Trott and Arthur J Olson. Autodock vina: improving the speed and accuracy of docking with a new scoring function, efficient optimization, and multithreading. Journal of computational chemistry, 31(2):455–461, 2010.
+
+C. K. Williams and C. Rasmussen. Gaussian processes for regression. In Neural Information Processing Systems (NeurIPS), 1995.
+
+Yutong Xie, Chence Shi, Hao Zhou, Yuwei Yang, Weinan Zhang, Yong Yu, and Lei Li. {MARS}: Markov molecular sampling for multi-objective drug discovery. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=kHSu4ebxFXY.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] We provide proofs (see Section 2 and Appendix) for our theoretical claims and fair empirical results with our proposed methods and baselines (see Section 4).   
+(b) Did you describe the limitations of your work? [Yes] GFlowNet is limited by its use of bootstrapping, which is known to be challenging in Deep RL (see Section 5).   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] Our theoretical work is fairly agnostic to applications, and aims to compete with existing MCMC-based methods (see Sections 1, 4, and 5). Our empirical work situates itself in the context of automated drug-discovery.
+
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] All complete proofs are available in the Appendix.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Hyperparameters and architectural choices are reported in the Appendix, and verifiable in the provided code.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We omit error bars for clarity, but we report standard deviations in the Appendix to verify the significance of our results.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See A.3.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/Arn2E4IRjEB/Arn2E4IRjEB_content_list.json

@@ -0,0 +1,1847 @@
+[
+    {
+        "type": "text",
+        "text": "Flow Network based Generative Models for Non-Iterative Diverse Candidate Generation ",
+        "text_level": 1,
+        "bbox": [
+            232,
+            122,
+            766,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Emmanuel Bengio1,2, Moksh Jain1,5, Maksym Korablyov1 Doina Precup1,2,4, Yoshua Bengio1,3 1Mila, 2McGill University, 3Université de Montréal, 4DeepMind, 5Microsof ",
+        "bbox": [
+            245,
+            219,
+            743,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            300,
+            535,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper is about the problem of learning a stochastic policy for generating an object (like a molecular graph) from a sequence of actions, such that the probability of generating an object is proportional to a given positive reward for that object. Whereas standard return maximization tends to converge to a single return-maximizing sequence, there are cases where we would like to sample a diverse set of high-return solutions. These arise, for example, in black-box function optimization when few rounds are possible, each with large batches of queries, where the batches should be diverse, e.g., in the design of new molecules. One can also see this as a problem of approximately converting an energy function to a generative distribution. While MCMC methods can achieve that, they are expensive and generally only perform local exploration. Instead, training a generative policy amortizes the cost of search during training and yields to fast generation. Using insights from Temporal Difference learning, we propose GFlowNet, based on a view of the generative process as a flow network, making it possible to handle the tricky case where different trajectories can yield the same final state, e.g., there are many ways to sequentially add atoms to generate some molecular graph. We cast the set of trajectories as a flow and convert the flow consistency equations into a learning objective, akin to the casting of the Bellman equations into Temporal Difference methods. We prove that any global minimum of the proposed objectives yields a policy which samples from the desired distribution, and demonstrate the improved performance and diversity of GFlowNet on a simple domain where there are many modes to the reward function, and on a molecule synthesis task. ",
+        "bbox": [
+            232,
+            330,
+            766,
+            633
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            657,
+            310,
+            675
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The maximization of expected return $R$ in reinforcement learning (RL) is generally achieved by putting all the probability mass of the policy $\\pi$ on the highest-return sequence of actions. In this paper, we study the scenario where our objective is not to generate the single highest-reward sequence of actions but rather to sample a distribution of trajectories whose probability is proportional to a given positive return or reward function. This can be useful in tasks where exploration is important, i.e., we want to sample from the leading modes of the return function. This is equivalent to the problem of turning an energy function into a corresponding generative model, where the object to be generated is obtained via a sequence of actions. By changing the temperature of the energy function (i.e., scaling it multiplicatively) or by taking the power of the return, one can control how selective the generator should be, i.e., only generate from around the highest modes at low temperature or explore more with a higher temperature. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            840
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A motivating application for this setup is iterative black-box optimization where the learner has access to an oracle which can compute a reward for a large batch of candidates at each round, e.g., in drug-discovery applications. Diversity of the generated candidates is particularly important when the oracle is itself uncertain, e.g., it may consist of cellular assays which is a cheap proxy for clinical trials, or it may consist of the result of a docking simulation (estimating how well a candidate small molecule binds to a target protein) which is a proxy for more accurate but more expensive downstream evaluations (like cellular assays or in-vivo assays in mice). ",
+        "bbox": [
+            174,
+            847,
+            823,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When calling the oracle is expensive (e.g. it involves a biological experiment), a standard way (Angermueller et al., 2020) to apply machine learning in such exploration settings is to take the data already collected from the oracle (say a set of $( x , y )$ pairs where $x$ is a candidate solution an $y$ is a scalar evaluation of $x$ from the oracle) and train a supervised proxy $f$ (viewed as a simulator) which predicts $y$ from $x$ . The function $f$ or a variant of $f$ which incorporates uncertainty about its value, like in Bayesian optimization (Srinivas et al., 2010; Negoescu et al., 2011), can then be used as a reward function $R$ to train a generative model or a policy that will produce a batch of candidates for the next experimental assays. Searching for $x$ which maximizes $R ( x )$ is not sufficient because we would like to sample for the batch of queries a representative set of $x$ ’s with high values of $R$ , i.e., around modes of $R ( x )$ . Note that alternative ways to obtain diversity exist, e.g., with batch Bayesian optimization (Kirsch et al., 2019). An advantage of the proposed approach is that the computational cost is linear in the size of the batch (by opposition with methods which compare pairs of candidates, which is at least quadratic). With the possibility of assays of a hundred thousand candidates using synthetic biology, linear scaling would be a great advantage. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we thus focus on the specific machine learning problem of turning a given positive reward or return function into a generative policy which samples with a probability proportional to the return. In applications like the one mentioned above, we only apply the reward function after having generated a candidate, i.e., the reward is zero except in a terminal state, and the return is the terminal reward. We are in the so-called episodic setting of RL. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The proposed approach views the probability assigned to an action given a state as the flow associated with a network whose nodes are states, and outgoing edges from that node are deterministic transitions driven by an action (not to be confused with normalizing flows; Rezende and Mohamed (2016)). The total flow into the network is the sum of the rewards in the terminal states (i.e., a partition function) and can be shown to be the flow at the root node (or start state). The proposed algorithm is inspired by Bellman updates and converges when the incoming and outgoing flow into and out of each state match. A policy which chooses an action with probability proportional to the outgoing flow corresponding to that action is proven to achieve the desired result, i.e., the probability of sampling a terminal state is proportional to its reward. In addition, we show that the resulting setup is off-policy; it converges to the above solution even if the training trajectories come from a different policy, so long as it has large enough support on the state space. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            568
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of this paper are as follows: ",
+        "bbox": [
+            174,
+            574,
+            511,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose GFlowNet, a novel generative method for unnormalized probability distributions based on flow networks and local flow-matching conditions: the flow incoming to a state must match the outgoing flow.   \n• We prove crucial properties of GFlowNet, including the link between the flow-matching conditions (which many training objectives can provide) and the resulting match of the generated policy with the target reward function. We also prove its offline properties and asymptotic convergence (if the training objective can be minimized). We also demonstrate that previous related work (Buesing et al., 2019) which sees the generative process like a tree would fail when there are many action sequences which can lead to the same state.   \nWe demonstrate on synthetic data the usefulness of departing from seeking one mode of the return, and instead seeking to model the entire distribution and all its modes.   \n• We successfully apply GFlowNet to a large scale molecule synthesis domain, with comparative experiments against PPO and MCMC methods. ",
+        "bbox": [
+            205,
+            594,
+            825,
+            789
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "All implementations are available at https://github.com/bengioe/gflownet. ",
+        "bbox": [
+            174,
+            795,
+            717,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Approximating Flow Network generative models with a TD-like objective ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            816,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider a discrete set $\\mathcal { X }$ and policy $\\pi ( a | s )$ to sequentially build $x \\in \\mathcal { X }$ with probability $\\pi ( x )$ with ",
+        "bbox": [
+            174,
+            859,
+            818,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0723c164a902cd15483925d2c374ec5dedc95f3e7b6edbcf81b5f95f3d9d1019.jpg",
+        "text": "$$\n\\pi ( x ) \\approx { \\frac { R ( x ) } { Z } } = { \\frac { R ( x ) } { \\sum _ { x ^ { \\prime } \\in { \\mathcal { X } } } R ( x ^ { \\prime } ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            880,
+            606,
+            916
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $R ( x ) > 0$ is a reward for a terminal state $x$ . This would be useful to sample novel drug-like molecules when given a reward function $R$ that scores molecules based on their chemical properties. Being able to sample from the high modes of $R ( x )$ would provide diversity in the batches of generated molecules sent to assays. This is in contrast with the typical RL objective of maximizing return which we have found to often end up focusing around one or very few good molecules. In our context, $R ( x )$ is a proxy for the actual values obtained from assays, which means it can be called often and cheaply. $R ( x )$ is retrained or fine-tuned each time we acquire new data from the assays. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "What method should one use to generate batches sampled from $\\pi ( x ) \\propto R ( x ) ?$ Let’s first think of the state space under which we would operate. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $s$ denote the set of states and $\\mathcal { X } \\subset \\mathcal { S }$ denote the set of terminal states. Let $\\mathcal { A }$ be a finite set, the alphabet, ${ \\mathcal { A } } ( s ) \\subseteq A$ be the set of allowed actions at state $s$ , and let $\\mathcal { A } ^ { \\ast } ( s )$ be the set of all sequences of actions allowed after state $s$ . To every action sequence $\\vec { a } = ( a _ { 1 } , a _ { 2 } , a _ { 3 } , . . . , a _ { h } )$ of $a _ { i } \\in \\mathcal { A } , h \\le H$ corresponds a single $x$ , i.e. the environment is deterministic so we can define a function $C$ mapping a sequence of actions $\\vec { a }$ to an $x$ . If such a sequence is ‘incomplete’ we define its reward to be 0. When the correspondence between action sequences and states is bijective, a state $s$ is uniquely described by some sequence $\\vec { a }$ , and we can visualize the generative process as the traversal of a tree from a single root node to a leaf corresponding to the sequence of actions along the way. ",
+        "bbox": [
+            173,
+            228,
+            825,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, when this correspondence is non-injective, i.e. when multiple action sequences describe the same $x$ , things get trickier. Instead of a tree, we get a directed acyclic graph or DAG (assuming that the sequences must be of finite length, i.e., there are no deterministic cycles), as illustrated in Figure 1. For example, and of interest here, molecules can be seen as graphs, which can be described in multiple orders (canonical representations such as SMILES strings also have this problem: there may be multiple descriptions for the same actual molecule). The standard approach to such a sampling problem is to use iterative MCMC methods (Xie et al., 2021; Grathwohl et al., 2021). Another option is to relax the desire to have $p ( x ) \\propto R ( x )$ and to use non-interative (sequential) RL methods (Gottipati et al., 2020), but these are at high risk of getting stuck in local maxima and of missing modes. Indeed, in our setting, the policy which maximizes the expected return (which is the expected final reward) generates the sequence with the highest return (i.e., a single molecule). ",
+        "bbox": [
+            173,
+            345,
+            825,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Flow Networks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            515,
+            318,
+            530
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we propose the Generative Flow Network framework, or GFlowNet, which enables us to learn policies such that $p ( x ) \\propto R ( x )$ when sampled. We first discuss why existing methods are inadequate, and then show how we can use the metaphor of flows, sinks and sources, to construct adequate policies. We then show that such policies can be learned via a flow-matching objective. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With existing methods in the bijective case, one can think of the sequential generation of one $x$ as an episode in a tree-structured deterministic MDP, where all leaves $x$ are terminal states (with reward $R ( x ) )$ and the root is initial state $s _ { 0 }$ . Interestingly, in such a case one can express the pseudo-value of a state $\\tilde { V } ( s )$ as the sum of all the rewards of the descendants of $s$ (Buesing et al., 2019). ",
+        "bbox": [
+            174,
+            602,
+            823,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the non-injective case, these methods are inadequate. Constructing $\\pi ( \\tau ) \\approx R ( \\tau ) / Z$ , e.g. as per Buesing et al. (2019), MaxEnt RL (Haarnoja et al., 2017), or via an autoregressive method (Nash and Durkan, 2019; Shi et al., 2021) has a particular problem as shown below: if multiple action sequences $\\vec { a }$ (i.e. multiple trajectories $\\tau$ ) lead to a final state $x$ , then a serious bias can be introduced in the generative probabilities. Let us denote ${ \\vec { a } } + { \\vec { b } }$ as the concatenation of the two sequences of actions $\\vec { a }$ and $\\vec { b }$ , and by extension $s + { \\vec { b } }$ the state reached by applying the actions in $\\vec { b }$ from state $s$ . ",
+        "bbox": [
+            173,
+            666,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. Let $C : { \\mathcal { A } } ^ { * } \\mapsto { \\mathcal { S } }$ associate each allowed action sequence $\\vec { a } \\in \\mathcal { A } ^ { \\ast }$ to a state $s = C ( \\vec { a } ) \\in S$ . Let $\\tilde { V } : { \\cal S } \\mapsto { { \\bf R } ^ { + } }$ associate each state $s \\in S$ to $\\begin{array} { r } { \\tilde { V } ( s ) = \\sum _ { \\vec { b } \\in \\mathcal { A } ^ { * } ( s ) } R ( s + \\vec { b } ) > 0 , } \\end{array}$ where $\\mathcal { A } ^ { \\ast } ( s )$ is the set of allowed continuations from s and $s + { \\vec { b } }$ denotes the resulting state, i.e., $\\tilde { V } ( s )$ is the sum of the rewards of all the states reachable from $s$ . Consider a policy $\\pi$ which starts from the state corresponding to the empty string $s _ { 0 } = C ( \\emptyset )$ and chooses from state $s \\in S$ an allowable action a ∈ A(s) with probability π(a|s) = $\\begin{array} { r } { \\pi ( a | s ) = \\frac { \\tilde { V } ( s + a ) } { \\sum _ { b \\in { \\cal A } ( s ) } \\tilde { V } ( s + b ) } } \\end{array}$ . Denote $\\pi ( \\vec { a } = ( a _ { 1 } , \\ldots , a _ { N } ) ) =$ $\\begin{array} { r } { \\prod _ { i = 1 } ^ { N } \\pi ( a _ { i } | C ( a _ { 1 } , \\dots , a _ { i - 1 } ) ) } \\end{array}$ and $\\pi ( s )$ with $s \\in S$ the probability of visiting a state s with this policy. The following then obtains:   \n(a) $\\begin{array} { r } { \\dot { \\pi } ( s ) = \\dot { \\sum } _ { \\vec { a } _ { i } : C ( \\vec { a } _ { i } ) = s } \\pi ( \\vec { a } _ { i } ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            762,
+            826,
+            915
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$( b )$ If $C$ is bijective, then $\\begin{array} { r } { \\pi ( s ) = \\frac { \\tilde { V } ( s ) } { \\tilde { V } ( s _ { 0 } ) } } \\end{array}$ and as a special case for terminal states $x$ , $\\begin{array} { r } { \\pi ( x ) = \\frac { R ( x ) } { \\sum _ { x \\in \\mathcal { X } } R ( x ) } } \\end{array}$ . (c) If $C$ is non-injective and there are $n ( x )$ distinct action sequences $\\vec { a } _ { i }$ s.t. $C ( \\vec { a } _ { i } ) = \\dot { x }$ , then $\\begin{array} { r } { \\pi ( x ) = \\frac { n ( x ) R ( x ) } { \\sum _ { x ^ { \\prime } \\in \\mathcal { X } } n ( x ^ { \\prime } ) R ( x ^ { \\prime } ) } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            88,
+            825,
+            148
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "See Appendix A.1 for the proof. In combinatorial spaces, such as for molecules, where $C$ is noninjective (there are many ways to construct a molecule graph), this can become exponentially bad as trajectory lengths increase. It means that larger molecules would be exponentially more likely to be sampled than smaller ones, just because of the many more paths leading to them. In this scenario, the pseudo-value $\\tilde { V }$ is “misinterpreting” the MDP’s structure as a tree, leading to the wrong $\\pi ( x )$ . ",
+        "bbox": [
+            173,
+            156,
+            825,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An alternative is to see the MDP as a flow network, that is, leverage the DAG structure of the MDP, and learn a flow $F$ , rather than estimating the pseudo-value $\\tilde { V }$ as a sum of descendant rewards, as elaborated below. We define the flow network as a having a single source, the root node (or initial state) $s _ { 0 }$ with in-flow $Z$ , and one sink for each leaf (or terminal state) $x$ with out-flow $R ( x ) > 0$ . We write $T ( s , a ) = s ^ { \\prime }$ to denote that the state-action pair $( s , a )$ leads to state $s ^ { \\prime }$ . Note that because $C$ is not a bijection, i.e., there are many paths (action sequences) leading to some node, a node can have multiple parents, i.e. $| \\{ ( s , a ) \\mid \\bar { T ( s , a ) } = s ^ { \\prime } \\} | \\geq 1$ , except for the root, which has no parent. We write $F ( s , a )$ for the flow between node $s$ and node $s ^ { \\prime } = T ( s , a )$ , $F ( s )$ for the total flow going through $s ^ { \\th }$ 1. This construction is illustrated in Fig. 1. ",
+        "bbox": [
+            173,
+            234,
+            826,
+            362
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/390eb9d5c13ec96c0daad8748cbe2eda9e5b15367cc919510da6f556c5da8aaa.jpg",
+        "image_caption": [
+            "Figure 1: A flow network MDP. Episodes start at source $s _ { 0 }$ with flow $Z$ . Like with SMILES strings, there are no cycles. Terminal states are sinks with out-flow $R ( s )$ . Exemplar state $s _ { 3 }$ has parents $\\left\\{ ( s , a ) | T ( s , a ) = s _ { 3 } \\right\\} = \\left\\{ ( s _ { 1 } , a _ { 2 } ) , ( s _ { 2 } , a _ { 5 } ) \\right\\}$ and allowed actions $\\overset { \\cdot } { \\underset { \\cdot } { A } } ( s _ { 3 } ) = \\{ a _ { 4 } , a _ { 7 } \\}$ . $s _ { 4 }$ is a terminal sink state with $R ( s _ { 4 } ) > 0$ and only one parent. The goal is to estimate $F ( s , a )$ such that the flow equations are satisfied for all states: for each node, incoming flow equals outgoing flow. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            375,
+            746,
+            487
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To satisfy flow conditions, we require that for any node, the incoming flow equals the outgoing flow, which is the total flow $F ( s )$ of node $s$ . Boundary conditions are given by the flow into the terminal nodes $x$ , $R ( x )$ . Formally, for any node $s ^ { \\prime }$ , we must have that the in-flow ",
+        "bbox": [
+            173,
+            577,
+            826,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a8df3398bbf6f4f12444dc3e54dfc616ddd58b189bad2764e0c30e185e41571.jpg",
+        "text": "$$\nF ( s ^ { \\prime } ) = \\sum _ { s , a : T ( s , a ) = s ^ { \\prime } } F ( s , a )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            622,
+            596,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "equals the out-flow ",
+        "bbox": [
+            174,
+            662,
+            300,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e6ea01bc624453c34f7510a387923550cbe44d86c5482673fe056c8a626b8de.jpg",
+        "text": "$$\nF ( s ^ { \\prime } ) = \\sum _ { a ^ { \\prime } \\in \\mathcal { A } ( s ^ { \\prime } ) } F ( s ^ { \\prime } , a ^ { \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            675,
+            589,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More concisely, with $R ( s ) = 0$ for interior nodes, and $\\mathcal { A } ( s ) = \\emptyset$ for leaf (sink/terminal) nodes, we write the following flow consistency equations: ",
+        "bbox": [
+            174,
+            713,
+            823,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/59aaf587e0145d5c3810e4ce7c4cff6de11c7d560d140b640c5cdfd5a48cef77.jpg",
+        "text": "$$\n\\sum _ { s , a : T ( s , a ) = s ^ { \\prime } } F ( s , a ) = R ( s ^ { \\prime } ) + \\sum _ { a ^ { \\prime } \\in A ( s ^ { \\prime } ) } F ( s ^ { \\prime } , a ^ { \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            746,
+            665,
+            782
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with $F$ being a flow, $F ( s , a ) > 0 \\forall s , a$ (for this we needed to constrain $R ( x )$ to be positive too). One could include in principle nodes and edges with zero flow but it would make it difficult to talk about the logarithm of the flow, as we do below, and such states can always be excluded by the allowed set of actions for their parent states. Let us now show that such a flow correctly produces $\\pi ( x ) = R ( x ) / Z$ when the above flow equations are satisfied. ",
+        "bbox": [
+            173,
+            792,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2. Let us define a policy $\\pi$ that generates trajectories starting in state $s _ { 0 }$ by sampling actions $a \\in { \\mathcal { A } } ( s )$ according to ",
+        "bbox": [
+            168,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef05dc8e9f8dec6cff30946f2053cb0c42703f7db0971e2d3cbfafe6d0ad5c89.jpg",
+        "text": "$$\n\\pi ( a | s ) = { \\frac { F ( s , a ) } { F ( s ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            123,
+            560,
+            157
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $F ( s , a ) > 0$ is the flow through allowed edge $( s , a )$ , $\\begin{array} { r } { F ( s ) = R ( s ) + \\sum _ { a \\in \\mathcal { A } ( s ) } F ( s , a ) } \\end{array}$ where $R ( s ) = 0$ for non-terminal nodes s and $F ( x ) = R ( x ) > 0$ for terminal nodes $x$ , and the flow consistency equation $\\begin{array} { r } { \\sum _ { s , a : T ( s , a ) = s ^ { \\prime } } F ( s , a ) = R ( s ^ { \\prime } ) + \\sum _ { a ^ { \\prime } \\in A ( s ^ { \\prime } ) } F ( s ^ { \\prime } , a ^ { \\prime } ) } \\end{array}$ is satisfied. Let $\\pi ( s )$ denote the probability of visiting state $s$ when starting at $s _ { 0 }$ and following $\\pi ( \\cdot | \\cdot )$ . Then ",
+        "bbox": [
+            173,
+            160,
+            826,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(a) $\\begin{array} { r } { \\pi ( s ) = \\frac { F ( s ) } { F ( s _ { 0 } ) } } \\end{array}$ (b) $\\begin{array} { r } { F ( s _ { 0 } ) = \\sum _ { x \\in \\mathcal { X } } R ( x ) } \\end{array}$ (c) π(x) = P R(x)x0∈X R(x0) . ",
+        "bbox": [
+            171,
+            223,
+            343,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof. We have $\\pi ( s _ { 0 } ) = 1$ since we always start in root node $s _ { 0 }$ . Note that $\\begin{array} { r } { \\sum _ { x \\in \\mathcal { X } } \\pi ( x ) = 1 } \\end{array}$ because terminal states are mutually exclusive, but in the case of non-bijective $C$ , we cannot say that $\\textstyle \\sum _ { s \\in S } \\pi ( s )$ equals 1 because the different states are not mutually exclusive in general. This notation is different from the one typically used in RL where $\\pi ( s )$ refers to the asymptotic distribution of the Markov chain. Then ",
+        "bbox": [
+            173,
+            292,
+            825,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72fd7d73a3aa16ee3dc379e973b7362a6f63ad99d80bdc454ab1c85350cf093b.jpg",
+        "text": "$$\n\\pi ( s ^ { \\prime } ) = \\sum _ { ( a , s ) : T ( s , a ) = s ^ { \\prime } } \\pi ( a | s ) \\pi ( s )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            358,
+            612,
+            395
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "i.e., using Eq. 5, ",
+        "bbox": [
+            173,
+            396,
+            282,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8be396e0c5177c4197edd0d4de84302398435f4ce1b7c5391b7e77137a82d835.jpg",
+        "text": "$$\n\\pi ( s ^ { \\prime } ) = \\sum _ { ( a , s ) : T ( s , a ) = s ^ { \\prime } } { \\frac { F ( s , a ) } { F ( s ) } } \\pi ( s ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            407,
+            619,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can now conjecture that the statement ",
+        "bbox": [
+            174,
+            449,
+            446,
+            464
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5cf0cbe78c9ccd1ebdb014b26ac01a6a8bcd158767645a0024c320fa7d2c97a1.jpg",
+        "text": "$$\n\\pi ( s ) = { \\frac { F ( s ) } { F ( s _ { 0 } ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            467,
+            549,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "is true and prove it by induction. This is trivially true for the root, which is our base statement, since $\\pi ( s _ { 0 } ) = 1$ . By induction, we then have that if the statement is true for parents $s$ of $s ^ { \\prime }$ , then ",
+        "bbox": [
+            169,
+            503,
+            823,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a9c97a6cf2533a95838558914acfc8f67237b870fa753bd8b9ee137806b93032.jpg",
+        "text": "$$\n\\pi ( s ^ { \\prime } ) = \\sum _ { s , a : T ( s , a ) = s ^ { \\prime } } { \\frac { F ( s , a ) } { F ( s ) } } { \\frac { F ( s ) } { F ( s _ { 0 } ) } } = { \\frac { \\sum _ { s , a : T ( s , a ) = s ^ { \\prime } } F ( s , a ) } { F ( s _ { 0 } ) } } = { \\frac { F ( s ^ { \\prime } ) } { F ( s _ { 0 } ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            535,
+            738,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which proves the statement, i.e., the first conclusion (a) of the theorem. We can then apply it to the case of terminal states $x$ , whose flow is fixed to $F ( x ) = R ( x )$ and obtain ",
+        "bbox": [
+            173,
+            588,
+            825,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0439cdc68bff7812a51f845f20fe4a544fc8a659d248946603c60dbc01b104ab.jpg",
+        "text": "$$\n\\pi ( x ) = { \\frac { R ( x ) } { F ( s _ { 0 } ) } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            621,
+            552,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Noting that $\\begin{array} { r } { \\sum _ { x \\in X } \\pi ( x ) = 1 } \\end{array}$ and summing both sides of Eq. 10 over $x$ we thus obtain (b), i.e., F (s0) = Px∈X R(x). Plugging this back into Eq. 10, we obtain (c), i.e., π(x) = P R(x)x0∈X R(x0) . □ ",
+        "bbox": [
+            174,
+            657,
+            826,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus our choice of $\\pi ( a | s )$ satisfies our desiderata: it maps a reward function $R$ to a generative model which generates $x$ with probability $\\pi ( x ) \\propto R ( x )$ , whether $C$ is bijective or non-injective (the former being a special case of the latter, and we just provided a proof for the general non-injective case). ",
+        "bbox": [
+            173,
+            709,
+            826,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 Objective Functions for GFlowNet ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            760,
+            452,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can now leverage our RL intuitions to create a learning algorithm out of the above theoretical results. In particular, we propose to approximate the flows $F$ such that the flow consistency equations are respected at convergence with enough capacity in our estimator of $F$ , just like the Bellman equations for temporal-difference (TD) algorithms (Sutton and Barto, 2018). This could yield the following objective for a trajectory $\\tau$ : ",
+        "bbox": [
+            174,
+            781,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc2249bfcf70828fdaaf4a2a4b0a97344b91e44b51b91a16f6524ccf2e109103.jpg",
+        "text": "$$\n\\tilde { \\mathcal { L } } _ { \\theta } ( \\tau ) = \\sum _ { s ^ { \\prime } \\in \\tau \\neq s _ { 0 } } \\left( \\sum _ { s , a : T ( s , a ) = s ^ { \\prime } } F _ { \\theta } ( s , a ) - R ( s ^ { \\prime } ) - \\sum _ { a ^ { \\prime } \\in A ( s ^ { \\prime } ) } F _ { \\theta } ( s ^ { \\prime } , a ^ { \\prime } ) \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            858,
+            717,
+            910
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One issue from a learning point of view is that the flow will be very large for nodes near the root (early in the trajectory) and tiny for nodes near the leaves (late in the trajectory). In high-dimensional spaces where the cardinality of $\\mathcal { X }$ is exponential (e.g., in the typical number of actions to form an $x$ ), the $F ( s , a )$ and $F ( s )$ for early states will be exponentially larger than for later states. Since we want $F ( s , a )$ to be the output of a neural network, this would lead to serious numerical issues. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To avoid this problem, we define the flow matching objective on a log-scale, where we match not the incoming and outgoing flows but their logarithms, and we train our predictor to estimate $F _ { \\theta } ^ { \\log } ( s , a ) = \\log F ( s , a )$ , and exponentiate-sum-log the  of logs: $F _ { \\theta } ^ { \\mathrm { l o g } }$ predictions to compute the loss, yielding ",
+        "bbox": [
+            174,
+            166,
+            823,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/127271c49256a237d802a8df35f9cbecb8bb4cffca0f5a0fb96cd54f2be7ab7a.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\theta , \\epsilon } ( \\tau ) = \\sum _ { s ^ { \\prime } \\in \\tau \\neq s _ { 0 } } \\left( \\log \\left[ \\epsilon + \\sum _ { s , a : T ( s , a ) = s ^ { \\prime } } F _ { \\theta } ^ { \\log } ( s , a ) \\right] - \\log \\left[ \\epsilon + R ( s ^ { \\prime } ) + \\sum _ { a ^ { \\prime } \\in A ( s ^ { \\prime } ) } \\exp F _ { \\theta } ^ { \\log } ( s ^ { \\prime } , a ^ { \\prime } ) \\right] \\right) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            232,
+            785,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which gives equal gradient weighing to large and small magnitude predictions. Note that matching the logs of the flows is equivalent to making the ratio of the incoming and outgoing flow closer to 1. To give more weight to errors on large flows and avoid taking the logarithm of a tiny number, we compare log( $\\epsilon +$ incoming flow) with log( $\\epsilon +$ outgoing flow). It does not change the global minimum, which is still when the flow equations are satisfied, but it avoids numerical issues with taking the log of a tiny flow. The hyper-parameter $\\epsilon$ also trades-off how much pressure we put on matching large versus small flows, and in our experiments is set to be close to the smallest value $R$ can take. Since we want to discover the top modes of $R$ , it makes sense to care more for the larger flows. Many other objectives are possible for which flow matching is also a global minimum. ",
+        "bbox": [
+            173,
+            290,
+            826,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An interesting advantage of such objective functions is that they yield off-policy offline methods. The predicted flows $F$ do not depend on the policy used to sample trajectories (apart from the fact that the samples should sufficiently cover the space of trajectories in order to obtain generalization). This is formalized below, which shows that we can use any broad-support policy to sample training trajectories and still obtain the correct flows and generative model, i.e., training can be off-policy. ",
+        "bbox": [
+            173,
+            421,
+            826,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3. Let trajectories $\\tau$ used to train $F _ { \\theta }$ be sampled from an exploratory policy $P$ with the same support as the optimal $\\pi$ defined in Eq. 5 for a consistent flow $F ^ { * } \\in { \\mathcal { F } } ^ { * }$ . A flow is consistent if Eq. 4 is respected. Also assume that $\\exists \\theta : F _ { \\theta } = F ^ { * }$ , i.e., we choose a sufficiently rich family of predictors. Let $\\theta ^ { * } \\in \\mathrm { a r g m i n } _ { \\theta } E _ { P ( \\tau ) } [ L _ { \\theta } ( \\tau ) ]$ a minimizer of the expected training loss. Let $L _ { \\theta } ( \\tau )$ have the property that when flows are matched it achieves its lowest possible value. First, it can $b e$ shown that this property is satisfied for the loss in Eq. 12. Then ",
+        "bbox": [
+            173,
+            494,
+            826,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4ca2c999b9a0eb89f409cb0b6802a0608367e2f93fcfeafb0de4d84ea4c37e7.jpg",
+        "text": "$$\n{ \\cal F } _ { \\theta ^ { * } } = { \\cal F } ^ { * } , \\mathrm { a n d } { \\cal L } _ { \\theta ^ { * } } ( \\tau ) = 0 \\forall \\tau \\sim { \\cal P } ( \\theta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            582,
+            647,
+            599
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "i.e., a global optimum of the expected loss provides the correct flows. If πθ∗ (a|s) = P Fθ∗ (s,a)a0∈A(s) Fθ∗ (s,a0) then we also have ",
+        "bbox": [
+            171,
+            603,
+            820,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c19a29407339354b4e12ef1999e14d7d86d98da62e1edc6f7c11f922084c05cb.jpg",
+        "text": "$$\n\\pi _ { \\theta ^ { \\ast } } ( x ) = \\frac { R ( x ) } { Z } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            635,
+            557,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proof is in Appendix A.1. Note that, in RL terms, this method is akin to asynchronous dynamic programming (Sutton and Barto, 2018, $\\ S 4 . 5$ ), which is an off-policy off-line method which converges provided every state is visited infinitely many times asymptotically. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            726,
+            323,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The objective of training a policy generating states with a probability proportional to rewards was presented by Buesing et al. (2019) but the proposed method only makes sense when there is a bijection between action sequences and states. In contrast, GFlowNet is applicable in the more general setting where many paths can lead to the same state. The objective to sample with probability proportional to a given unnormalized positive function is achieved by many MCMC methods (Grathwohl et al., 2021; Dai et al., 2020). However, when mixing between modes is challenging (e.g., in high-dimensional spaces with well-separated modes occupying a fraction of the total volume) convergence to the target distribution can be extremely slow. In contrast, GFlowNet is not iterative and amortizes the challenge of sampling from such modes through a training procedure which must be sufficiently exploratory. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This sampling problem comes up in molecule generation and has been studied in this context with numerous generative models (Shi et al., 2020; Jin et al., 2020; Luo et al., 2021), MCMC methods (Seff et al., 2019; Xie et al., 2021), RL (Segler et al., 2017; Cao and Kipf, 2018; Popova et al., 2019; Gottipati et al., 2020; Angermueller et al., 2020) and evolutionary methods (Brown et al., 2004; Jensen, 2019; Swersky et al., 2020). Some of these methods rely on a given set of \"positive examples\" (high-reward) to train a generative model, thus not taking advantage of the \"negative examples\" and the continuous nature of the measurements (some examples should be generated more often than others). Others rely on the traditional return maximization objectives of RL, which tends to focus on one or a few dominant modes, as we find in our experiments. Beyond molecules, there are previous works generating data non-greedily through RL (Bachman and Precup, 2015) or energy-based GANs (Dai et al., 2017). ",
+        "bbox": [
+            173,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The objective that we formulate in (12) may remind the reader of the objective of control-asinference’s Soft Q-Learning (Haarnoja et al., 2017), with the difference that we include all the parents of a state in the in-flow, whereas Soft Q-Learning only uses the parent contained in the trajectory. Soft Q-Learning induces a different policy, as shown by Proposition 1, one where $P ( \\tau ) \\propto R ( \\tau )$ rather than $P ( x ) \\propto \\bar { R } ( x )$ . More generally, we only consider deterministic generative settings whereas RL is a more general framework for stochastic environments. ",
+        "bbox": [
+            173,
+            222,
+            826,
+            305
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Literature at the intersection of network flow and deep learning is sparse, and is mostly concerned with solving maximum flow problems (Nazemi and Omidi, 2012; Chen and Zhang, 2020) or classification within existing flow networks (Rahul et al., 2017; Pekta¸s and Acarman, 2019). Finally, the idea of accounting for the search space being a DAG rather than a tree in MCTS, known as transpositions (Childs et al., 2008), also has some links with the proposed method. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Empirical Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            388,
+            354,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first verify that GFlowNet works as advertised on an artificial domain small enough to compute the partition function exactly, and compare its abilities to recover modes compared to standard MCMC and RL methods, with its sampling distribution better matching the normalized reward. We find that GFlowNet (A) converges to $\\pi ( x ) \\propto R ( x )$ , (B) requires less samples to achieve some level of performance than MCMC and PPO methods and (C) recovers all the modes and does so faster than MCMC and PPO, both in terms of wall-time and number of states visited and queried. We then test GFlowNet on a large scale domain, which consists in generating small drug molecule graphs, with a reward that estimates their binding affinity to a target protein (see Appendix A.3). We find that GFlowNet finds higher reward and more diverse molecules faster than baselines. ",
+        "bbox": [
+            173,
+            415,
+            825,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 A (hyper-)grid domain ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            550,
+            370,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Consider an MDP where states are the cells of a $n$ -dimensional hypercubic grid of side length $H$ . The agent starts at coordinate $x = ( 0 , 0 , \\ldots )$ and is only allowed to increase coordinate $i$ with action $a _ { i }$ (up to $H$ , upon which the episode terminates). A stop action indicates to terminate the trajectory. There are many action sequences that lead to the same coordinate, making this MDP a DAG.The reward for ending the trajectory in $x$ is some $R ( x ) > 0$ . For MCMC methods, in order to have an ergodic chain, we allow the iteration to decrease coordinates as well, and there is no stop action. ",
+        "bbox": [
+            173,
+            571,
+            826,
+            655
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We ran experiments with this reward function: ",
+        "bbox": [
+            174,
+            661,
+            477,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/258a1185fb3947d8faf78bde2f3e7d39653dcd5d768c5a18995049eea6f48468.jpg",
+        "text": "$$\n\\begin{array} { r } { R ( x ) = R _ { 0 } + R _ { 1 } \\prod _ { i } \\mathbb { I } ( 0 . 2 5 < | x _ { i } / H - 0 . 5 | ) + R _ { 2 } \\prod _ { i } \\mathbb { I } ( 0 . 3 < | x _ { i } / H - 0 . 5 | < 0 . 4 ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            689,
+            723,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "with $0 < R _ { 0 } \\ll R _ { 1 } < R _ { 2 }$ , pictured when $n = 2$ on the right. For this choice of $R$ , there are only interesting rewards near the corners of the grid, and there are exactly $2 ^ { n }$ modes. We set $R _ { 1 } \\stackrel { \\cdot } { = } 1 / 2$ , $R _ { 2 } = 2$ . By varying $R _ { 0 }$ and setting it closer to 0, we make this problem artificially harder, creating a region of the state space which it is undesirable to explore. To measure the performance of a method, we measure the empirical L1 error $\\mathbb { E } [ | p ( x ) - \\pi ( { \\bar { x } } ) | ]$ . $p ( x ) = R ( x ) / Z$ is known in this domain, and $\\pi$ is estimated by repeated sampling and counting frequencies for each possible $x$ . We also measure the number of modes with at least 1 visit as a function of the number of states visited. ",
+        "bbox": [
+            174,
+            710,
+            826,
+            809
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We run the above experiment for $R _ { 0 } \\in \\{ 1 0 ^ { - 1 } , 1 0 ^ { - 2 } , 1 0 ^ { - 3 } \\}$ with $n = 4$ , $H = 8$ . In Fig. 2 we see that GFlowNet is robust to $R _ { 0 }$ and obtains a low L1 error, while a Metropolis-Hastings-MCMC based method requires exponentially more samples than GFlowNet to achieve some level of L1 error. This is apparent in Fig. 2 (with a log-scale horizontal axis) by comparing the slope of progress of GFlowNet (beyond the initial stage) and that of the MCMC sampler. We also see that MCMC takes much longer to visit each mode once as $R _ { 0 }$ decreases, while GFlowNet is only slightly affected, with GFlowNet converging to some level of L1 error faster, as per hypothesis (B). This suggests that ",
+        "bbox": [
+            174,
+            813,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "GFlowNet is robust to the separation between modes (represented by $R _ { 0 }$ being smaller) and thus recovers all the modes much faster than MCMC (again, noting the log-scale of the horizontal axis). ",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To compare to RL, we run PPO (Schulman et al., 2017). To discover all the modes in a reasonable time, we need to set the entropy maximization term much higher (0.5) than usual $( \\ll 1 )$ ). We verify that PPO is not overly regularized by comparing it to a random agent. PPO finds all the modes faster than uniform sampling, but much more slowly than GFlowNet, and is also robust to the choice of $R _ { 0 }$ . This and the previous result validates hypothesis (C). We also run SAC (Haarnoja et al., 2018), finding similar or worse results. We provide additional results and discussion in Appendix A.6. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            209
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f78e0a7efa3a201cb3d3a0ed1cb2db9072c6757469cb48b28d92d7518573dc09.jpg",
+        "image_caption": [
+            "Figure 2: Hypergrid domain. Changing the task difficulty $R _ { 0 }$ to illustrate the advantage of GFlowNet over others. We see that as $R _ { 0 }$ gets smaller, MCMC struggles to fit the distribution because it struggles to visit all the modes. PPO also struggles to find all the modes, and requires very large entropy regularization, but is robust to the choice of $R _ { 0 }$ . We plot means over 10 runs for each setting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            224,
+            790,
+            364
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Generating small molecules ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            405,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here our goal is to generate a diverse set of small molecules that have a high reward. We define a large-scale environment which allows an agent to sequentially generate molecules. This environment is challenging, with up to $1 0 ^ { 1 6 }$ states and between 100 and 2000 actions depending on the state. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We follow the framework of Jin et al. (2020) and generate molecules by parts using a predefined vocabulary of building blocks that can be joined together forming a junction tree (detailed in A.3). This is also known as fragment-based drug design (Kumar et al., 2012; Xie et al., 2021). Generating such a graph can be described as a sequence of additive edits: given a molecule and constraints of chemical validity, we choose an atom to attach a block to. The action space is thus the product of choosing where to attach a block and choosing which block to attach. There is an extra action to stop the editing sequence. This sequence of edits yields a DAG MDP, as there are multiple action sequences that lead to the same molecule graph, and no edge removal actions, which prevents cycles. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The reward is computed with a pretrained proxy model that predicts the binding energy of a molecule to a particular protein target (soluble epoxide hydrolase, sEH, see A.3). Although computing binding energy is computationally expensive, we can call this proxy cheaply. Note that for realistic drug design, we would need to consider many more quantities such as drug-likeness (Bickerton et al., 2012), toxicity, or synthesizability. Our goal here is not solve this problem, and our work situates itself within such a larger project. Instead, we want to show that given a proxy $R$ in the space of molecules, we can quickly match its induced distribution $\\pi ( x ) \\propto R ( x )$ and find many of its modes. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We parameterize the proxy with an MPNN (Gilmer et al., 2017) over the atom graph. Our flow predictor $F _ { \\theta }$ is parameterized similarly to MARS (Xie et al., 2021), with an MPNN, but over the junction tree graph (the graph of blocks), which had better performance. For fairness, this architecture is used for both GFlowNet and the baselines. Complete details can be found in Appendix A.4. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            787
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We pretrain the proxy with a semi-curated semi-random dataset of $3 0 0 \\mathrm { k }$ molecules (see A.4) down to a test MSE of 0.6; molecules are scored according to the docking score (Trott and Olson, 2010), renormalized so that most scores fall between 0 and 10 (to have $\\bar { R ( } x { ) } > 0 { ) }$ . We plot the dataset’s reward distribution in Fig. 3. We train all generative models with up to $1 0 ^ { 6 }$ molecules. During training, sampling follows exploratory policy $P ( \\boldsymbol { a } | \\boldsymbol { s } )$ which is a mixture between $\\pi ( a | s )$ (Eq. 5), used with probability 0.95, and a uniform distribution over allowed actions with probability 0.05. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental results In Fig. 3 we show the empirical distribution of rewards in two settings; first when we train our model with $R ( x )$ , then with ${ \\bar { R } } ( x ) ^ { \\beta }$ . If GFlowNet learns a reasonable policy $\\pi$ this should shift the distribution to the right. This is indeed what we observe. We compare GFlowNet to MARS (Xie et al., 2021), known to work well in the molecule domain, and observe the same shift. Note that GFlowNet finds more high reward molecules than MARS with these $\\beta$ values; this is consistent with the hypothesis that it finds high-reward modes faster (since MARS is an MCMC method, it would eventually converge to the same distribution, but takes more time). ",
+        "bbox": [
+            173,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/56144c31df71789119b3f527b0faeaa77f9787cb0bbabacc12616ad4ac31580d.jpg",
+        "image_caption": [
+            "Figure 3: Empirical density of rewards. We verify that GFlowNet is consistent by training it with $R ^ { \\beta }$ , $\\beta = 4$ , which has the hypothesized effect of shifting the density to the right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            84,
+            486,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae057cac7ada7b6e331edd1d4fc3208b0beff1c559881aabc17c7e680348ab95.jpg",
+        "image_caption": [
+            "Figure 4: The average reward of the top- $k$ as a function of learning (averaged over 3 runs). Only unique hits are counted. Note the log scale. Our method finds more unique good molecules faster. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            85,
+            818,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            314,
+            825,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 4, we show the average reward of the top- $k$ molecules found so far, without allowing for duplicates (based on SMILES). We compare GFlowNet with MARS, PPO, and JT-VAE (Jin et al., 2020) with Bayesian Optimization. As expected, PPO plateaus after a while; RL tends to be satisfied with good enough trajectories unless it is strongly regularized with exploration mechanisms. For GFlowNet and for MARS, the more molecules are visited, the better they become, with a slow convergence towards the proxy’s max reward. Given the same compute time, $\\scriptstyle \\mathbf { J } \\mathbf { T } - \\mathbf { V } \\mathbf { A } \\mathbf { E } + \\mathbf { B } \\mathbf { O }$ generates only about $1 0 ^ { 3 }$ molecules (due to its expensive Gaussian Process) and so does not perform well. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            486
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The maximum reward in the proxy’s dataset is 10, with only 233 examples above 8. In our best run, we find 2339 unique molecules during training with a score above 8, only 39 of which are in the dataset. We compute the average pairwise Tanimoto similarity for the top 1000 samples: GFlowNet has a mean of $0 . 4 4 \\pm 0 . 0 1$ , PPO, $0 . 6 2 \\pm 0 . 0 3$ , and MARS, $0 . 5 9 \\pm 0 . 0 2$ (mean and std over 3 runs). As expected, our MCMC baseline (MARS) and RL baseline (PPO) find less diverse candidates. We also find that GFlowNet discovers many more modes $( > 1 5 0 0$ with $R > 8$ vs $< 1 0 0$ for MARS). This is shown in Fig. 5 where we consider a mode to be a Bemis-Murcko scaffold (Bemis and Murcko, 1996), counted for molecules above a certain reward threshold. We provide additional insights into how GFlowNet matches the rewards in Appendix A.7. ",
+        "bbox": [
+            173,
+            492,
+            826,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f6c3d3fd8d0bad63785195c8151dd88346a1ad41ea3cef93552e73c8e733869.jpg",
+        "image_caption": [
+            "Figure 5: Number of diverse Bemis-Murcko scaffolds found above reward threshold $T$ as a function of the number of molecules seen. Left, $T = 7 . 5$ . Right, $T = 8$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            632,
+            810,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Multi-Round Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            397,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the importance of diverse candidate generation in an active learning setting, we consider a sequential acquisition task. We simulate the setting where there is a limited budget for calls to the true oracle $O$ . We use a proxy $M$ initialized by training on a limited dataset of $( x , R ( x ) )$ ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "pairs $D _ { 0 }$ , where $R ( x )$ is the true reward from the oracle. The generative model $\\left( \\pi _ { \\boldsymbol { \\theta } } \\right)$ is trained to fit to the unnormalized probability function learned by the proxy $M$ . We then sample a batch $B = \\{ x _ { 1 } , x _ { 2 } , . . . x _ { k } \\}$ where $x _ { i } \\sim \\pi _ { \\theta }$ , which is evaluated with the oracle $O$ . The proxy $M$ is updated with this newly acquired and labeled batch, and the process is repeated for $N$ iterations. We discuss the experimental setting in more detail in Appendix A.5. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/57f77d159cae3745834d0ddf9b599ff5f9e8a19b8e5dd554012b7e815a7b0fe3.jpg",
+        "image_caption": [
+            "Figure 6: The top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ return (mean over 3 runs) in the 4-D Hyper-grid task with active learning. GFlowNet gets the highest return faster. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            170,
+            480,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b4940bf58465c3496eea9644bbc71a972ddbd721a83526315b3b6676df6500d.jpg",
+        "image_caption": [
+            "Figure 7: The top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ docking reward (mean over 3 runs) in the molecule task with active learning. GFlowNet consistently generates better samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            519,
+            171,
+            812,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hyper-grid domain We present results for the multi-round task in the 4-D hyper-grid domain in Figure 6. We use a Gaussian Process (Williams and Rasmussen, 1995) as the proxy. We compare the Top- $k$ Return for all the methods, which is defined as mean(t $\\mathrm { \\gamma } \\mathrm { p } { - } k ( D _ { i } ) ) { - } \\mathrm { m e a n } \\big ( \\mathrm { t o p } { - } k ( D _ { i - 1 } ) \\big )$ , where $D _ { i }$ is the dataset of points acquired until step $i$ , and $k = 1 0$ for this experiment. The initial dataset $D _ { 0 }$ $\\left. \\left| D _ { 0 } \\right| \\right. = \\left. 5 1 2 \\right.$ is the same for all the methods compared. We observe that GFlowNet consistently outperforms the baselines in terms of return over the initial set. We also observe that the mean pairwise L2-distance between the top - $k$ points at the end of the final round is $0 . 8 3 \\pm 0 . 0 3$ , $0 . 6 1 \\pm 0 . 0 1$ and $0 . 5 1 \\pm 0 . 0 2$ for GFlowNet, MCMC and PPO respectively. This demonstrates the ability of GFlowNet to capture the modes, even in the absence of the true oracle, as well as the importance of capturing this diversity in multi-round settings. ",
+        "bbox": [
+            173,
+            367,
+            826,
+            507
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Small Molecules For the molecule discovery task, we initialize an MPNN proxy to predict docking scores from AutoDock (Trott and Olson, 2010), with $| D _ { 0 } | = 2 0 0 0$ molecules. At the end of each round we generate 200 molecules which are evaluated with AutoDock and used to update the proxy. Figure 7 shows GFlowNet discovers molecules with significantly higher energies than the initial set $D _ { 0 }$ . It also consistently outperforms MARS as well as Random Acquisition. PPO training was unstable and diverged consistently so the numbers are not reported. The mean pairwise Tanimoto similarity in the initial set is 0.60. At the end of the final round, it is $0 . 5 4 \\pm 0 . 0 4$ for GFlowNet and $0 . 6 4 \\pm 0 . 0 3$ for MARS. This further demonstrates the ability of GFlowNet to generate diverse candidates, which ultimately helps improve the final performance on the task. Similar to the single step setting, we observe that JT-VAE $+ \\mathrm { B O }$ is only able to generate $1 0 ^ { 3 }$ molecules with similar compute time, and thus performs poorly. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion & Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            676,
+            416,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we have introduced a novel TD-like objective for learning a flow for each state and (state, action) pair such that policies sampling actions proportional to these flows draw terminal states in proportion to their reward. This can be seen as an alternative approach to turn an energy function into a fast generative model, without the need for an iterative method like that needed with MCMC methods, and with the advantage that when training succeeds, the policy generates a great diversity of samples near the main modes of the target distribution without being slowed by issues of mixing between modes. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            800
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations. One downside of the proposed method is that, as for TD-based methods, the use of bootstrapping may cause optimization challenges (Kumar et al., 2020; Bengio et al., 2020) and limit its performance. In applications like drug discovery, sampling from the regions surrounding each mode is already an important advantage, but future work should investigate how to combine such a generative approach to local optimization in order to refine the generated samples and approach the local maxima of reward while keeping the batches of candidates diverse. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            890
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Negative Social Impact. The authors do not foresee negative social impacts of this work specifically. ",
+        "bbox": [
+            174,
+            897,
+            823,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This research was enabled in part by computational resources provided by Calcul Québec (www. calculquebec.ca) and Compute Canada (www.computecanada.ca). All authors are funded by their primary academic institution. We also acknowledge funding from Samsung Electronics Co., Ldt., CIFAR and IBM. ",
+        "bbox": [
+            174,
+            119,
+            826,
+            175
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The authors are grateful to Andrei Nica for generating the molecule dataset, to Maria Kadukova for advice on molecular docking, to Harsh Satija for feedback on the paper, as well as to all the members of the Mila Molecule Discovery team for the many research discussions on the challenges we faced. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Author Contributions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            242,
+            357,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "EB and YB contributed to the original idea, and wrote most sections of the paper. YB wrote the proofs of Propositions 1-3, EB the proof of Proposition 4. EB wrote the code and ran experiments for sections 4.1 (hypergrid) and 4.2 (small molecules). MJ wrote the code and ran experiments for section 4.3 (multi-round) and wrote the corresponding results section of the paper. MK wrote the biochemical framework upon which the molecule experiments are built, assisted in debugging and running experiments for section 4.3, implemented mode-counting routines used in 4.2, and wrote the biochemical details of the paper. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "MK, DP and YB provided supervision for the project. All authors contributed to proofreading and editing the paper. ",
+        "bbox": [
+            174,
+            376,
+            823,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            424,
+            266,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christof Angermueller, David Dohan, David Belanger, Ramya Deshpande, Kevin Murphy, and Lucy Colwell. Model-based reinforcement learning for biological sequence design. In International Conference on Learning Representations, 2020.   \nPhilip Bachman and Doina Precup. Data generation as sequential decision making. Advances in Neural Information Processing Systems, 28:3249–3257, 2015.   \nGuy W Bemis and Mark A Murcko. The properties of known drugs. 1. molecular frameworks. Journal of medicinal chemistry, 39(15):2887–2893, 1996.   \nEmmanuel Bengio, Joelle Pineau, and Doina Precup. Interference and generalization in temporal difference learning. In International Conference on Machine Learning, pages 767–777. PMLR, 2020.   \nG Richard Bickerton, Gaia V Paolini, Jérémy Besnard, Sorel Muresan, and Andrew L Hopkins. Quantifying the chemical beauty of drugs. Nature chemistry, 4(2):90–98, 2012.   \nNathan Brown, Ben McKay, François Gilardoni, and Johann Gasteiger. A graph-based genetic algorithm and its application to the multiobjective evolution of median molecules. Journal of chemical information and computer sciences, 44(3):1079–1087, 2004.   \nLars Buesing, Nicolas Heess, and Theophane Weber. Approximate inference in discrete distributions with monte carlo tree search and value functions, 2019.   \nNicola De Cao and Thomas Kipf. Molgan: An implicit generative model for small molecular graphs, 2018.   \nYize Chen and Baosen Zhang. Learning to solve network flow problems via neural decoding. arXiv preprint arXiv:2002.04091, 2020.   \nBenjamin E Childs, James H Brodeur, and Levente Kocsis. Transpositions and move groups in monte carlo tree search. In 2008 IEEE Symposium On Computational Intelligence and Games, pages 389–395. IEEE, 2008.   \nHanjun Dai, Rishabh Singh, Bo Dai, Charles Sutton, and Dale Schuurmans. Learning discrete energy-based models via auxiliary-variable local exploration. In Neural Information Processing Systems (NeurIPS), 2020. ",
+        "bbox": [
+            171,
+            444,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zihang Dai, Amjad Almahairi, Philip Bachman, Eduard Hovy, and Aaron Courville. Calibrating energy-based generative adversarial networks. arXiv preprint arXiv:1702.01691, 2017. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry, 2017. ",
+        "bbox": [
+            171,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sai Krishna Gottipati, Boris Sattarov, Sufeng Niu, Yashaswi Pathak, Haoran Wei, Shengchao Liu, Karam M. J. Thomas, Simon Blackburn, Connor W. Coley, Jian Tang, Sarath Chandar, and Yoshua Bengio. Learning to navigate the synthetically accessible chemical space using reinforcement learning, 2020. ",
+        "bbox": [
+            173,
+            167,
+            826,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Will Grathwohl, Kevin Swersky, Milad Hashemi, David Duvenaud, and Chris J. Maddison. Oops i took a gradient: Scalable sampling for discrete distributions, 2021. ",
+        "bbox": [
+            174,
+            233,
+            821,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement learning with deep energy-based policies. In International Conference on Machine Learning, pages 1352–1361. PMLR, 2017. ",
+        "bbox": [
+            174,
+            272,
+            826,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor, 2018. ",
+        "bbox": [
+            173,
+            324,
+            823,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jan H Jensen. A graph-based genetic algorithm and generative model/monte carlo tree search for the exploration of chemical space. Chemical science, 10(12):3567–3572, 2019. ",
+        "bbox": [
+            173,
+            363,
+            823,
+            392
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Chapter 11. junction tree variational autoencoder for molecular graph generation. Drug Discovery, page 228–249, 2020. ISSN 2041-3211. doi: 10. 1039/9781788016841-00228. URL http://dx.doi.org/10.1039/9781788016841-00228. ",
+        "bbox": [
+            176,
+            401,
+            821,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andreas Kirsch, Joost van Amersfoort, and Yarin Gal. Batchbald: Efficient and diverse batch acquisition for deep bayesian active learning, 2019. ",
+        "bbox": [
+            173,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashutosh Kumar, A Voet, and KYJ Zhang. Fragment based drug design: from experimental to computational approaches. Current medicinal chemistry, 19(30):5128–5147, 2012. ",
+        "bbox": [
+            173,
+            492,
+            823,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aviral Kumar, Rishabh Agarwal, Dibya Ghosh, and Sergey Levine. Implicit under-parameterization inhibits data-efficient deep reinforcement learning, 2020. ",
+        "bbox": [
+            173,
+            530,
+            823,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Greg Landrum. Rdkit: Open-source cheminformatics. URL http://www.rdkit.org. ",
+        "bbox": [
+            173,
+            569,
+            746,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Youzhi Luo, Keqiang Yan, and Shuiwang Ji. Graphdf: A discrete flow model for molecular graph generation, 2021. ",
+        "bbox": [
+            176,
+            593,
+            823,
+            622
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Charlie Nash and Conor Durkan. Autoregressive energy machines, 2019. ",
+        "bbox": [
+            174,
+            632,
+            655,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alireza Nazemi and Farahnaz Omidi. A capable neural network model for solving the maximum flow problem. Journal of Computational and Applied Mathematics, 236(14):3498–3513, 2012. ",
+        "bbox": [
+            173,
+            656,
+            818,
+            686
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diana M. Negoescu, Peter I. Frazier, and Warren B. Powell. The knowledge-gradient algorithm for sequencing experiments in drug discovery. 23(3):346–363, 2011. ISSN 1526-5528. doi: 10.1287/ijoc.1100.0417. URL https://doi.org/10.1287/ijoc.1100.0417. ",
+        "bbox": [
+            174,
+            695,
+            826,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y Ng, Stuart J Russell, et al. Algorithms for inverse reinforcement learning. In Icml, volume 1, page 2, 2000. ",
+        "bbox": [
+            174,
+            747,
+            823,
+            776
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library. pdf. ",
+        "bbox": [
+            176,
+            786,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Abdurrahman Pekta¸s and Tankut Acarman. Deep learning to detect botnet via network flow summaries. Neural Computing and Applications, 31(11):8021–8033, 2019. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mariya Popova, Mykhailo Shvets, Junier Oliva, and Olexandr Isayev. Molecularrnn: Generating realistic molecular graphs with optimized properties, 2019. ",
+        "bbox": [
+            173,
+            127,
+            823,
+            156
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "RK Rahul, T Anjali, Vijay Krishna Menon, and KP Soman. Deep learning for network flow analysis and malware classification. In International Symposium on Security in Computing and Communication, pages 226–235. Springer, 2017. ",
+        "bbox": [
+            176,
+            164,
+            823,
+            207
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows, 2016. ",
+        "bbox": [
+            171,
+            214,
+            826,
+            231
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms, 2017. ",
+        "bbox": [
+            173,
+            238,
+            825,
+            267
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ari Seff, Wenda Zhou, Farhan Damani, Abigail Doyle, and Ryan P Adams. Discrete object generation with reversible inductive construction. arXiv preprint arXiv:1907.08268, 2019. ",
+        "bbox": [
+            173,
+            275,
+            821,
+            304
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Marwin H. S. Segler, Thierry Kogej, Christian Tyrchan, and Mark P. Waller. Generating focussed molecule libraries for drug discovery with recurrent neural networks, 2017. ",
+        "bbox": [
+            173,
+            311,
+            821,
+            340
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chence Shi, Minkai Xu, Zhaocheng Zhu, Weinan Zhang, Ming Zhang, and Jian Tang. Graphaf: a flow-based autoregressive model for molecular graph generation, 2020. ",
+        "bbox": [
+            174,
+            348,
+            823,
+            377
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yunsheng Shi, Zhengjie Huang, Shikun Feng, Hui Zhong, Wenjin Wang, and Yu Sun. Masked label prediction: Unified message passing model for semi-supervised classification, 2021. ",
+        "bbox": [
+            176,
+            385,
+            825,
+            415
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Niranjan Srinivas, Andreas Krause, S. Kakade, and M. Seeger. Gaussian process optimization in the bandit setting: No regret and experimental design. In ICML, 2010. ",
+        "bbox": [
+            173,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Teague Sterling and John J Irwin. Zinc 15–ligand discovery for everyone. Journal of chemical information and modeling, 55(11):2324–2337, 2015. ",
+        "bbox": [
+            174,
+            459,
+            821,
+            488
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018. ",
+        "bbox": [
+            169,
+            496,
+            823,
+            511
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kevin Swersky, Yulia Rubanova, David Dohan, and Kevin Murphy. Amortized bayesian optimization over discrete spaces. In Conference on Uncertainty in Artificial Intelligence, pages 769–778. PMLR, 2020. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            561
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Oleg Trott and Arthur J Olson. Autodock vina: improving the speed and accuracy of docking with a new scoring function, efficient optimization, and multithreading. Journal of computational chemistry, 31(2):455–461, 2010. ",
+        "bbox": [
+            176,
+            569,
+            823,
+            612
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C. K. Williams and C. Rasmussen. Gaussian processes for regression. In Neural Information Processing Systems (NeurIPS), 1995. ",
+        "bbox": [
+            176,
+            621,
+            821,
+            648
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yutong Xie, Chence Shi, Hao Zhou, Yuwei Yang, Weinan Zhang, Yong Yu, and Lei Li. {MARS}: Markov molecular sampling for multi-objective drug discovery. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=kHSu4ebxFXY. ",
+        "bbox": [
+            176,
+            657,
+            825,
+            700
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            254,
+            741
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            751,
+            339,
+            765
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] We provide proofs (see Section 2 and Appendix) for our theoretical claims and fair empirical results with our proposed methods and baselines (see Section 4).   \n(b) Did you describe the limitations of your work? [Yes] GFlowNet is limited by its use of bootstrapping, which is known to be challenging in Deep RL (see Section 5).   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] Our theoretical work is fairly agnostic to applications, and aims to compete with existing MCMC-based methods (see Sections 1, 4, and 5). Our empirical work situates itself in the context of automated drug-discovery. ",
+        "bbox": [
+            232,
+            768,
+            825,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            236,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            123,
+            493,
+            138
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] All complete proofs are available in the Appendix. ",
+        "bbox": [
+            238,
+            142,
+            825,
+            188
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            191,
+            393,
+            207
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Hyperparameters and architectural choices are reported in the Appendix, and verifiable in the provided code.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We omit error bars for clarity, but we report standard deviations in the Appendix to verify the significance of our results.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See A.3. ",
+        "bbox": [
+            238,
+            210,
+            825,
+            357
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            210,
+            361,
+            823,
+            376
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            380,
+            825,
+            501
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            505,
+            705,
+            520
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            523,
+            825,
+            613
+        ],
+        "page_idx": 13
+    }
+]

parse/train/H4e7mBnC9f0/H4e7mBnC9f0.md

@@ -0,0 +1,310 @@
+# Differentiable Spike: Rethinking Gradient-Descent for Training Spiking Neural Networks
+
+Yuhang $\mathbf { L i } ^ { 1 : }$ ∗, Yufei $\mathbf { G u o ^ { 2 * } }$ , Shanghang Zhang3, Shikuang Deng1, Yongqing $\mathbf { H a i } ^ { 2 }$ , Shi $\mathbf { G u } ^ { \mathrm { 1 } \boxtimes }$
+
+1University of Electronic Science and Technology of China, 2Peking University, 3University of California Berkeley liyuhang699@gmail.com, yfguo@pku.edu.cn, gus@uestc.edu.cn
+
+# Abstract
+
+Spiking neural networks (SNNs) have emerged as a biology-inspired method mimicking the spiking nature of brain neurons. This biomimicry derives SNNs’ energy efficiency of inference on neuromorphic hardware. However, it also causes an intrinsic disadvantage in training high-performing SNNs from scratch since the discrete spike prohibits the gradient calculation. To overcome this issue, the surrogate gradient (SG) approach has been proposed as a continuous relaxation. Yet the heuristic choice of SG leaves it vacant how the SG benefits the SNN training. In this work, we first theoretically study the gradient descent problem in SNN training and introduce finite difference gradient to quantitatively analyze the training behavior of SNN. Based on the introduced finite difference gradient, we propose a new family of Differentiable Spike (Dspike) functions that can adaptively evolve during training to find the optimal shape and smoothness for gradient estimation. Extensive experiments over several popular network structures show that training SNN with Dspike consistently outperforms the state-of-the-art training methods. For example, on the CIFAR10-DVS classification task, we can train a spiking ResNet-18 and achieve $7 5 . 4 \%$ top-1 accuracy with 10 time steps.
+
+# 1 Introduction
+
+Recently, spiking neural networks (SNNs) have received increasing attention due to their biologyinspired neural behavior and efficient computation. SNNs deal with binary spike information and therefore enjoy the advantage of multiplication-free inference. Neuromorphic hardware such as TrueNorth [1] and Loihi [2] demonstrates that SNNs can save energy by orders of magnitude. Hybrid architecture like Tianjic [3] suggests its potential power for general intelligence when integrated with traditional artificial infrastructure. However, the bio-mimicry also causes an intrinsic disadvantage in training high-performing SNNs from scratch due to the discrete spike. As a result, obtaining a high-performing SNN has long been a critical problem limiting SNN’s deployment in practice.
+
+To be more specific, the appealing advantage of the multiplication-free computation in SNN is not recognized in its training [4]. Modern ML frameworks such as Pytorch [5], JAX [6], and Tensorflow [7] do not provide efficient and general instructions or high-level functions to accelerate the convolution with 0/1 spike activation. Moreover, the binary activation in SNN produces allor-nothing gradients [8] that are incompatible with typical gradient-based optimization methods for efficient neural network training. To circumvent this problem, many works adopt surrogate gradients [8] (typically the derivative of a soft-relaxed function) to replace the spike non-linear gradient. Although the heuristic choice of SG is beneficial to enable the gradient descent in SNN training, the theoretical soundness of SG has not been justified so far. What’s more, the gradient descent in SNN training may follow different updating rules from ANN. In fact, since the true gradient value of spike activation does not exist, the adoption of SG raises a new question of how to replace the $\infty$ -gradient adaptively through the training process for a good updating strategy of parameters.
+
+![](images/012f9c41f16a3f7d725581105934c4ac57dfecbb0474bbc6673af5b5ff35c998.jpg)  
+Figure 1: Overall workflow of the proposed algorithm. We use a general, flexible Dspike function and control its shape with finite difference method to facilitate the surrogate gradient descent in training SNN.
+
+In this work, we study this specialized problem of adaptive gradient estimation in SNN training. We first revisit the gradient descent algorithm with the finite difference method to accurately depict the loss landscape of adopting a surrogate gradient for the non-differentiable spike firing function. Then we further propose the Differentiable Spike (Dspike) function, which can adaptively change its shape and capture the direction of finite difference gradients. With such adaptive surrogate gradients, we establish an efficient algorithm of training SNN with large-scale models. The overall workflow of our algorithm is visualized in Fig. 1.
+
+Our contributions can be summarized as follows:
+
+• We identify the problem of adaptively estimating gradient in SNN training and propose a novel analysis framework for SNN’s surrogate gradient, through which we are able to not only explain why it works well but also indicate how we can improve its adaptivity to data through training. • We also introduce the novel Dspike function built from the hyperbolic tangent function. The Dspike function can learn its shape accordingly by matching it with the finite difference gradient. • Extensive experiments on both static and dynamic datasets show that our method is highly effective and efficient. For example, our model can achieve $7 5 . 4 \%$ top-1 accuracy on the CIFAR-DVS. Our SNN also only consumes $7 . 8 \%$ energy of the corresponding ANN on CIFAR-10.
+
+# 2 Related Work
+
+ANN-SNN Conversion. Generally, the algorithms to obtain a high-performance can be divided into two routes: (1) ANN-SNN conversion and (2) direct training SNN from scratch. Conversion-based methods [9, 10] utilize the knowledge from ANN and convert the ReLU activation to spike activation mechanism. This type of method can produce an SNN in a short time. For example, Rueckauer et al. [11] propose to traverse the training dataset to find the maximum activation. Then, the SNN can be converted by directly replacing several modules. In [12], maximum activation is abandoned since it may out-lie the central range of activation. The authors choose to find the percentile numbers for threshold voltage to improve the robustness. TSC [13] adopts the soft-reset (also known as reset by subtraction) mechanism and no leakage for conversion, which proves to be effective in conversion. Deng & Gu [14] decompose the conversion error to each layer, then propose to reduce the error by shifting the bias term. [15] first propose the calibration to reduce the conversion accuracy. ANN-SNN conversion is fast and accurate. However, achieving near lossless conversion requires a considerable amount of time steps $( > 2 0 0 )$ to accumulate the spikes, which may significantly add up the latency.
+
+Direct Training SNN. In contrast to the conversion method, direct training of SNNs can lower the time step and may further reduce energy consumption. Direct training leverages gradient-descent algorithms. And many works have been developed to tackle the non-differentiability of spike activation. This non-differentiable activation function is similar to the quantization or binarization neural network [16, 17, 18] or adder neural network [19]. [20] achieve high performance on CIFAR10 and other neuromorphic datasets. Some works use probabilistic models to approximate the gradient [21], which is also developed in binary stochastic model [22]. Another common approach is to use rate-encoding networks for gradients calculation [23, 24]. They quantize the spike rate as the magnitude of information transmitted. (Wu et al. 2019 [25] improves the leaky integrate-and-fire (LIF) model to an iterative LIF model and develops STBP learning algorithm. Zheng et al. [26] further propose the tdBN algorithm to balance the gradient norm and smooth the loss function in SNN training, enabling large-scale model optimization.
+
+# 3 Preliminary
+
+# 3.1 Leaky Integrate-and-Fire Model
+
+We use bold italic letters for vector representations. For example, $_ { \textbf { \em x } }$ and $\textbf {  { y } }$ denote the input and target output variables. Bold capital letters like W denote the matrices (or tensors as clear from the text). Constants are denoted by small upright letters, e.g., $a$ . With bracketed superscript and subscript, we can denote the time dimension and the element indices, respectively. For example, $\mathbf { \boldsymbol { \mathsf { u } } } _ { i } ^ { ( t ) }$ means the $i$ -th membrane potential at time step $t$ . We adopt the well-known Leaky Integrate-and-Fire (LIF) neuron model for a spiking neural network (SNN). Given a membrane potential $\mathbf { \boldsymbol { u } } ^ { ( t ) }$ , the pre-synaptic potential is updated as
+
+$$
+\begin{array} { r } { \pmb { u } ^ { ( t + 1 ) , \mathrm { p r e } } = \tau \pmb { u } ^ { ( t ) } + \pmb { c } ^ { ( t + 1 ) } , \mathrm { w h e r e } \ \pmb { c } ^ { ( t + 1 ) } = \mathbf { W } \pmb { x } ^ { ( t + 1 ) } . } \end{array}
+$$
+
+Here, $\tau$ is a constant leaky factor within $( 0 , 1 )$ and $c ^ { ( t + 1 ) }$ is the pre-synaptic input at time step $t + 1$ . The input can be calculated from the dot-product between the weights and the spike from the previous layer. Let $V _ { t h }$ be the firing threshold, the membrane potential will fire a spike when it exceeds the threshold, and then hard-reset to 0, given by
+
+$$
+\pmb { y } ^ { ( t + 1 ) } = \{ \begin{array} { l l } { 1 } & { \mathrm { i f ~ } \pmb { u } ^ { ( t + 1 ) , \mathrm { p r e } } > V _ { t h } } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} , \pmb { u } ^ { ( t + 1 ) } = \pmb { u } ^ { ( t + 1 ) , \mathrm { p r e } } \cdot ( 1 - \pmb { y } ^ { ( t + 1 ) } )
+$$
+
+After firing, the spike output $\pmb { y } ^ { ( t + 1 ) }$ will propagate to the next layer and become the input $\boldsymbol { x } ^ { ( t + 1 ) }$ of the next layer, (note that we omit the layer index for simplicity). $V _ { t h }$ is set to 0.5 in this work.
+
+Softmax in SNN. In the general classification model, the final network output will be leveraged to compute the softmax and then to find the winner class. However, the network output is highly variant per input sample, and unlike ReLU activation, the output could be positive or negative. For this reason, we choose to only integrate the network output, and do not fire them across time, as did in recent practices [26, 27].
+
+$$
+{ \pmb y } _ { \mathrm { n e t } } = \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { \pmb c } _ { \mathrm { n e t } } ^ { ( t ) } = \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { \bf W } { \pmb x } ^ { ( t ) } ,
+$$
+
+Then, we can compute the cross-entropy loss based on the ture label and Softmax $( y _ { \mathrm { n e t } } )$
+
+# 3.2 Time-dependent Batch Normalization
+
+Batch Normalization (BN) [28] is used to reduce internal covariate shift and smooth the loss landscape [29] during the optimization of an ANN. It enables the stable training of ANN even with more than 100 layers on the large-scale dataset, e.g. ResNet-152 [30]. However, BN layers are not designed to normalize spatial-temporal data at first. And simply transplanting BN in SNN training will lead to undesired results. To solve this problem, Zheng et al. [26] propose time-dependent Batch Normalization (tdBN), which normalizes the data in both spatial and temporal paradigm. tdBN will gather the pre-synaptic input along the time dimension, denoted by $\mathbf { C } = [ \pmb { c } ^ { ( 1 ) } , \pmb { c } ^ { ( 2 ) } , \pmb { , . . . } , \pmb { c } ^ { ( T ) } ]$ , and then normalize it by
+
+$$
+\begin{array} { r l r } & { \bar { \bf C } = \frac { \alpha V _ { t h } \left( { \bf C } - \mathbb { E } \left[ { \bf C } \right] \right) } { \sqrt { \mathbb { V } \mathbb { A } \mathbb { R } \left( { \bf C } \right) + \epsilon } } \qquad } & { \# \mathrm { n o r m a l i z e } } \\ & { \hat { \bf C } = \gamma \bar { \bf C } + \beta , \qquad } & { \# \mathrm { a f f i n e ~ t r a n s f o r m a t i o n } } \end{array}
+$$
+
+where $\mathbb { E }$ and $\mathbb { V } \mathbb { A } \mathbb { R }$ compute the mean and variance in channel dimension. $\gamma$ and $\beta$ are learnable parameters. Note that in tdBN the normalized tensor will multiply $\alpha V _ { t h }$ , which can prevent over-fire and under-fire by choosing $\alpha$ wisely. After tdBN, the pre-synaptic input in each time step will be fed into Eq. (1). tdBN stabilizes the training of SNN and achieves good results. We also adopt this training technique in our framework. See [26] for more details of tdBN.
+
+# 4 Methodology
+
+# 4.1 Non-Differentiable Spike
+
+One of the most notorious problems in SNN training is the non-differentiability of the firing function Eq. (2). The firing function could be viewed as a variant of sign function, whose derivative is identified as the Dirac delta function. This derivative is 0 almost everywhere except for the threshold that grows to infinity. Seemingly, directly using the Dirac delta function is not an ideal choice for gradient descent-based learning. To demonstrate this problem, let $L$ denote the task loss objective, we can compute the gradient of weights parameters using the spatial-temporal backpropagation (STBP):
+
+$$
+\frac { \partial L } { \partial \mathbf { W } } = \sum _ { t } \frac { \partial L } { \partial \pmb { y } ^ { ( t ) } } \frac { \partial \pmb { y } ^ { ( t ) } } { \partial \pmb { u } ^ { ( t ) , \mathrm { p r e } } } \frac { \partial \pmb { u } ^ { ( t ) , \mathrm { p r e } } } { \partial \pmb { c } ^ { ( t ) } } \frac { \partial \pmb { c } ^ { ( t ) } } { \partial \mathbf { W } } .
+$$
+
+In above equation, $\frac { \partial \pmb { y } ^ { ( t ) } } { \partial \pmb { u } ^ { ( t ) , \mathrm { p r e } } }$ is the gradient of firing function and is 0 almost everywhere, as aforementioned. As a consequence, the gradient descent $\begin{array} { r } { ( \mathbf { W }  \mathbf { W } - \eta \frac { \partial L } { \partial \mathbf { W } } ) } \end{array}$ either freezes weights or updates the weights to infinity.
+
+To mitigate this problem, prior work seeks an alternative gradient (also known as surrogate gradient) to circumvent this problem. A popular surrogate gradient may refer to the rectangular function proposed in [4], given by
+
+$$
+\frac { \partial \pmb { y } ^ { ( t ) } } { \partial \pmb { u } ^ { ( t ) , \mathrm { p r e } } } = \frac { 1 } { a } \mathrm { s i g n } \left( \left| \pmb { u } ^ { ( t ) , \mathrm { p r e } } - V _ { t h } \right| < \frac { a } { 2 } \right) ,
+$$
+
+where $a$ is a hyper-parameter and usually set to 1. When $V _ { t h } = 0 . 5 , a = 1$ , the gradient is simplified to 1 if $0 \leq u ^ { ( t ) , \mathrm { p r e } } \leq 1$ otherwise 0. This is known as the Straight-Through Estimator in Bengio et al. [22] and is broadly applied in binary networks [31]. Another family of surrogate gradient may refer to triangular gradients [32], given by
+
+$$
+\frac { \partial \pmb { y } ^ { ( t ) } } { \partial \pmb { u } ^ { ( t ) , \mathrm { p r e } } } = \gamma \operatorname* { m a x } \left( 0 , 1 - \left| \frac { \pmb { u } ^ { ( t ) , \mathrm { p r e } } } { V _ { t h } } - 1 \right| \right) .
+$$
+
+This surrogate gradient is computed based on the distance between the potential and threshold. Despite various surrogate gradients achieve acceptable accuracy, there lacks a theoretical justification for its reason and effectiveness.
+
+# 4.2 Rethinking Gradient-Descent in Spiking Neural Networks
+
+Gradient-descent (GD) algorithm is a first-order iterative optimization method. Theoretically, for each iteration, GD aims to find the steepest direction for the descent that minimizes the task loss:
+
+$$
+\operatorname* { m i n } _ { | | \Delta \mathbf { W } | | \leq \varepsilon } L ( \mathbf { W } + \Delta \mathbf { W } ) \approx \operatorname* { m i n } _ { | | \Delta \mathbf { W } | | \leq \varepsilon } L ( \mathbf { W } ) + \Delta \mathbf { W } \frac { \partial L } { \partial \mathbf { W } }
+$$
+
+Note that the right-hand side of the minimization is approximated by the first-order Taylor expansion. Given that $L ( \mathbf { W } )$ is constant at the current iteration, therefore we only have to find the right $\Delta \mathbf { W }$ that minimizes the second term. Since the 2nd term is a linear in $\Delta \mathbf { W }$ , it can be made as negative as we like by taking $\Delta { \bf W }$ large. Therefore the minimum is $\begin{array} { r } { \Delta \mathbf { W } = - \varepsilon \frac { \nabla \mathbf { w } L } { | | \nabla \mathbf { w } L | | } } \end{array}$ , (where $\begin{array} { r } { \nabla { \bf w } L = \frac { \partial L } { \partial \bf W } . } \end{array}$ ∂ L∂ W ).
+
+Note that the above condition is only sufficient for $\varepsilon  0$ to correctly approximate the loss with Taylor expansion. However, $\varepsilon  0$ means $\begin{array} { r } { \Delta \mathbf { W } = - \varepsilon \frac { \nabla \mathbf { w } L } { | | \nabla \mathbf { w } L | | }  0 } \end{array}$ , but in practice GD updates the weights by a small step (determined by learning rate), which, indicates a mismatch between the practical implementation and the theoretical assumption. In other words, gradient only inspects the change rate of loss around an infinitely small neighborhood, however, we are interested in the change rate around a tiny (but not infinitely small) area. In the case of SNN, the gradient will always be $0 ^ { \mathit { \Phi } }$ , yet for a tiny neighborhood the loss function will change, leading to non-zero gradients. To penetrate the non-differentiability of the firing function, we adopt a technique called finite difference. It estimates the gradient by evaluating the loss objective near the coordinate:
+
+![](images/45783978b928cbb997105b7291a1e3566ef066a2a4fbc4c021e17b11b23e1ac2.jpg)  
+Figure $\mathbf { 2 \alpha \& }$ Table 1: Left: The cosine similarity between the gradients used for update and the FDG. In (a) we show ANN gradients and in (b) we show SNN rectangular surrogate gradients. Right: Training SNN with finite difference gradient, given different $\varepsilon$ .
+
+$$
+\hat { \nabla } _ { \varepsilon , w } L = \left( \frac { L ( w _ { 1 } + \varepsilon e _ { 1 } ) - L ( w _ { 1 } - \varepsilon e _ { 1 } ) } { 2 \varepsilon } , \ldots , \frac { L ( w _ { k } + \varepsilon e _ { k } ) - L ( w _ { k } - \varepsilon e _ { k } ) } { 2 \varepsilon } \right) ,
+$$
+
+where $\textbf { \em w }$ is the flattened vector of $\mathbf { W }$ and $e _ { i }$ refers to standard basis vector with 1 at $i$ -th index. $\varepsilon$ is some small constant, e.g. 0.001. We call $\hat { \nabla } _ { \varepsilon , w } L$ as finite difference gradient (FDG). By the definition of gradient, we know FDG becomes the true gradient when $\varepsilon  0$ . FDG can be a useful tool in GD-based learning, however, evaluating finite difference for each element in the weight vector is tedious, which greatly slows down the training process. Nevertheless, FDG still offers us a choice to evaluate the gradient mismatch problem quantitatively.
+
+In order to illustrate this, we construct a toy problem: a simple 2-layer CNN on the MNIST dataset. The first layer is a $3 \mathrm { x } 3$ convolutional layer (output channel number is 6) with ReLU activation (or LIF spike activation) and average pooling for down-sampling. Then, we directly add a fully connected layer to predict the classification results. We train the toy model on MNIST for 5 epochs, with batch size 128 and learning rate 0.01 decayed to 0. In an effort to compute the FDG of the first layer, we have to perform $2 \times 1 \times 6 \times 3 \times 3 = 1 0 8$ times forward pass 3. In contrast, one has to perform 22 million times forward passes on a ResNet-18 [30] to compute the FDG of all parameters.
+
+Experiment I: FDG in ANN. We first train an ANN on MNIST and compare the disparity between real gradients and FDG. We use cosine similarity (i.e. $\begin{array} { r } { \cos _ { - } \sin ( { \pmb x } _ { 1 } , { \pmb x } _ { 2 } ) = \frac { { \pmb x } _ { 1 } { \pmb x } _ { 2 } } { | | { \pmb x } _ { 1 } | | _ { 2 } | | { \pmb x } _ { 2 } | | _ { 2 } } ) } \end{array}$ x1x2||x1||2||x2||2 ) to determine the angle between these two gradient vectors. For each epoch, we compute the mean cosine similarity in the first 100 training iterations. The results are demonstrated in Fig. 2(a). The FDG and real gradients consistently have an extremely similar direction $( > 0 . 9 9 \mathrm { c o s \_ s i m } )$ with $\varepsilon$ varying from 0.1 to 0.001. In conclusion, we show that (1) FDG is a valid signal and (2) the real gradients can effectively find the change rate within a small neighborhood in ANN optimization.
+
+Experiment II: FDG in SNN. Then, we compare the cosine similarity between the surrogate gradients in SNN and the FDG. In Fig. 2(b), we can tell that surrogate gradients share similar gradient direction with FDG when $\varepsilon = 0 . 1$ (i.e. more than 0.8 cosine similarity). However, decreasing $\varepsilon$ will lead to lower cosine similarity. In the case of $\varepsilon = 0 . 0 0 1$ , the angle between FDG and the surrogate gradients is nearly 90 degrees, (for comparison, in high-dimensional space, two arbitrary random Gaussian vectors are very likely to be orthogonal). This observation concludes that surrogate gradient can predict the change rate of loss in a relatively larger neighborhood, which justifies the soundness of surrogate gradients. However, SG fails to predict the FDG in small step size $\varepsilon$ . To this end, we need to figure out whether a large step size is better or a small step size is better.
+
+Experiment III: Training SNN with FDG. In SNN optimization, a natural question arises: What ε is optimal for gradient descent? First, the $\varepsilon$ has to be small enough to compute the non-linearity of the loss surface, meanwhile, it has to be large enough to ignore the noise from the rough step function. For this reason, we explore the optimal $\varepsilon$ by applying FDG in SNN optimization. The results are demonstrated in the Table 1. Note that all methods are trained on MNIST for only 10 epochs here. We show that the rectangular surrogate gradient with $a = 1$ reaches $9 4 . 9 \%$ accuracy. For FDG optimization, we evaluate $\varepsilon$ ranging from 0.001 to 0.5, and we find 0.1 is the best choice for optimizing SNN. The results confirm our assumption that $\varepsilon$ has to be neither too big nor too small. It also tells us using the instant change rate (very small $\varepsilon$ ) will lead to undesired performance degradation.
+
+# 4.3 Differentiable Spike
+
+In this section, we introduce the Dspike function, a novel surrogate gradient estimator, which can cover a large range of choices for SG. We choose the hyperbolic tangent function $\begin{array} { r } { \operatorname { t a n h } ( x ) = \frac { e ^ { x } - e ^ { - x } } { e ^ { x } + e ^ { - x } } } \end{array}$ as our basic building function for gradient estimation:
+
+$$
+\operatorname { D s p i k e } ( x ) = { \left\{ \begin{array} { l l } { 1 } & { { \mathrm { i f ~ } } x > 1 } \\ { a \cdot \operatorname { t a n h } ( b ( x - c ) ) + d } & { { \mathrm { i f ~ } } 0 \leq x \leq 1 } \\ { 0 } & { { \mathrm { i f ~ } } x < 0 } \end{array} \right. }
+$$
+
+When $x < 0$ or $x > 1$ , we choose to clip $x$ as did in other practice. The vanilla tanh function maps $( - \infty , + \infty )$ to $( - 1 , 1 )$ , thus we have four parameters to control its shape to alter the function mapping: from $[ - 1 , 1 ]$ to [1, 1]. We first use $c = V _ { t h } = 0 . 5$ to set the symmetry center to (0.5, 0.5). Parameter $b ( b > 0 )$ is called the temperature factor, it controls the shape of the Dspike function. Parameter $a$ and $d$ can then be determined by setting $\mathrm { D s p i k e ( 0 ) } = 0 , \mathrm { D s p i k e ( 1 ) } = 1$ . As a result, we can rewrite the function as:
+
+$$
+\mathrm { D s p i k e } ( x , b ) = \frac { \operatorname { t a n h } ( b ( x - 0 . 5 ) ) + \operatorname { t a n h } ( b / 2 ) } { 2 ( \operatorname { t a n h } ( b / 2 ) ) } , \mathrm { i f ~ } 0 \leq x \leq 1 .
+$$
+
+Dspike function has the capability to adjust the shape of the function, leading to different surrogate gradient estimations. To demonstrate that, we have the following lemma:
+
+Lemma 4.1. By changing the temperature $b$ , the shape of Dspike function can be altered. Specifically, we have $\dim _ { b \to 0 _ { + } } { \mathrm { D s p i k e } } ( x ) \to x$ and $\scriptstyle \operatorname* { l i m } _ { b \to + \infty }$ $\mathrm { D s p i k e } ( x ) \to \mathrm { s i g n } ( x - 0 . 5 )$ .
+
+Proof. We first prove the case $b \to 0 _ { + }$ . In this case, applying Taylor expansion to the tanh we have:
+
+$$
+\operatorname { t a n h } ( b x ) \approx b x - { \frac { b ^ { 3 } x ^ { 3 } } { 3 } } + \cdots + { \frac { 2 ^ { ( 2 n ) } ( 2 ^ { ( 2 n ) } - 1 ) B _ { 2 n } ( b x ) ^ { 2 n - 1 } } { ( 2 n ) ! } } ,
+$$
+
+where $B _ { n }$ is the $n$ -th Bernoulli number. When $b \to 0$ , we can safely ignore higher-order terms and only keep $b x$ . Thus, we can rewrite Eq. (12) to ${ \mathrm { D s p i k e } } ( x , b ) = { \sqrt [ { b } ] { b } } { \stackrel { - } { = } } x$ . Then, we prove the case $b \to + \infty$ . Since $\scriptstyle \operatorname* { l i m } _ { x \to + \infty } \operatorname { t a n h } ( x ) \to 1$ , we have:
+
+$$
+\operatorname* { l i m } _ { b \to + \infty } \operatorname { D s p i k e } ( x , b )  \{ \{ \begin{array} { l l } { \frac { 2 * \operatorname { t a n h } ( + \infty ) } { 2 * \operatorname { t a n h } ( + \infty ) } = 1 } & { \mathrm { i f ~ } x > 0 . 5 } \\ { \frac { \operatorname { t a n h } ( + \infty ) } { 2 * \operatorname { t a n h } ( + \infty ) } = 0 . 5 } & { \mathrm { i f ~ } x = 0 . 5 } \\ { \frac { 0 } { 2 * \operatorname { t a n h } ( + \infty ) } = 0 } & { \mathrm { i f ~ } x < 0 . 5 } \end{array} 
+$$
+
+With this temperature factor, our algorithm can simulate a wide range of surrogate gradients with different smoothness. We visualize the transition in Fig. 3 from both forward perspective and backward perspective. As aforementioned, surrogate gradient can mimic the FDG in a relatively large neighborhood. Our intuition is that the optimal surrogate gradient can be found by choosing temperature wisely. Thus our task becomes to optimize temperature and network parameters simultaneously during training. As did in former toy experiments (Sec. 4.2), we verify the cosine similarity between our Dspike gradients and the FDG at the beginning of each training epoch and update the temperature to better match the FDG. This algorithm is detailed in Algo. 1.
+
+As abovementioned, evaluating FDG could be time-consuming, due to the two times evaluation of the final loss for each weight element. Therefore, we choose to only compute the FDG in the first layer for two reasons. First, the first layer has much fewer weights. In ResNet-18 (for CIFAR10 dataset), the first layer only has $3 \times 3 \times 3 \times 6 4 = 5 7 6$ elements. Second, the gradient propagation may accumulate the error in the former layers, which effectively measures the gradient mismatch.
+
+![](images/b058289d96cf2a3af515bea104b590c2e4c5ac976b0e01ce56486282f76a0509.jpg)  
+Figure 3: The forward plot (left) as well as the backward plot (right) of Dspike function. By changing temperature parameter we can manipulate the gradient estimation in SNN training.
+
+# Algorithm 1: Training SNN with Dspike gradient
+
+Input: SNN to be trained; Training dataset, total training epoch $E$ , total training iteration in one epoch $I$ , FDG step size $\varepsilon$ , temperature update step size $\Delta b$ , initialized temperature $b ^ { 0 }$ .   
+for all $e = 1 , 2 , \ldots , E$ -th epoch do Collect input data and labels, computing the FDG $( \hat { \nabla } _ { \varepsilon , w } L )$ of the first layer using $\varepsilon$ ; for all $b$ in $\{ b ^ { e - 1 } , b ^ { e - 1 } + \Delta b , b ^ { e - 1 } - \Delta b \}$ do Compute Dsipke surrogate gradient $\nabla _ { b , w } L$ and $\cos \underline { { \mathrm {  ~ \scriptstyle ~ \psi ~ } } } \mathrm { s i m } ( \hat { \nabla } _ { \varepsilon , w } L , \nabla _ { b , w } L )$ Find the optimal temperature with the highest cosine similarity and update it to $b ^ { e }$ ; for all $i = 1 , 2 , \dots , I$ -iteration do Get training data and labels, compute Dspike surrogate gradient using optimal $b$ ; Descend loss function and update weights;
+
+return trained SNN.
+
+# 4.4 Time Inheritance Training
+
+We also introduce a novel training pipeline that can effectively reduce the time for training multiple SNNs. Unlike ANN-SNN conversion, direct training SNN is performed with a fixed time step $T$ . As a result, we must learn a new SNN from scratch if we decide to use another different $T$ . We propose Time Inheritance Training (TIT) pipeline to ameliorate this problem. First, we train an SNN to converge with high $T$ , e.g. 20. Then, we use this well-trained model to initialize an SNN with lower $T$ , say $T = 1 0$ . Consequently, the initialized model has exactly the same output as the former model in the first 10 time steps, enabling better initialization and faster convergence. In other words, TIT progressively reduces the time step finetuning from a higher time step SNN first. This idea resembles the curriculum learning proposed in Bengio et al. [33], which suggests learning the easy task first. Armed with TIT, we can reduce the training time of subsequent models by $7 5 \%$ , while sharing the same task performances.
+
+# 5 Experiments
+
+In this section, we report experimental results for our Dspike algorithm on CIFAR [34] and ImageNet dataset [35]. For static image dataset, we encode the images to spike using the first layer in the SNN, as adopted in recent works [27]. For the neuromorphic image dataset, the images are already converted to 0/1 spike format. We also replace the max-pooling layer with the average-pooling layer in the network architecture. The detailed implementation is described in each subsection.
+
+# 5.1 Network Architecture Choice
+
+For CIFAR series experiments. We mainly adopt the ResNet-family architectures [30]. Unlike traditional ResNet structure [30], we use a modified version with 3 stem layers and avg-downsample block, as introduced in [36]. Our ResNet-18 architectures contains 4 stages with 2 basic residual block in each stage. Our initial channel is set to 64 and doubled in each stage. In comparison with [26], they use ResNet-19 with 3 stages, with 3 blocks in the first 2 stages and 2 blocks in the last stage. However, they choose 128 channel and they has larger receptive field than our model. In general, their ResNet-19 has ${ \sim } 1 0$ times more operations than our ResNet-18. For ImageNet, we use the same VGG-16 as used in [27] and the same ResNet-34 as used in [26].
+
+Table 2: Training Spiking Neural Networks on CIFAR10 and CIFAR100.   
+
+<table><tr><td>Dataset</td><td>Method</td><td>Type</td><td>Architecture</td><td>Time Step</td><td>Accuracy</td></tr><tr><td rowspan="10">CIFAR10</td><td>SpikeNorm [10]</td><td>ANN-SNN conversion</td><td>VGG-16</td><td>2500</td><td>91.55</td></tr><tr><td>Hybrid-Train [40]</td><td>Hybrid</td><td>VGG-16</td><td>200</td><td>92.02</td></tr><tr><td>Spike-based BP [41]</td><td>SNN training</td><td>ResNet-11</td><td>100</td><td>90.95</td></tr><tr><td>STBP [4]</td><td>SNN training</td><td>5Conv, 2FC</td><td>12</td><td>90.53</td></tr><tr><td>TSSL-BP [42]</td><td>SNN training</td><td>5Conv,2FC</td><td>5</td><td>91.41</td></tr><tr><td>Diet-SNN [27]</td><td>SNN training</td><td>VGG-16</td><td>5</td><td>92.70</td></tr><tr><td></td><td>SNN training</td><td></td><td>6</td><td>93.16</td></tr><tr><td rowspan="3">STBP-tdBN[26]</td><td rowspan="3"></td><td>ResNet-19</td><td>4</td><td>92.92</td></tr><tr><td></td><td>2</td><td>92.34</td></tr><tr><td></td><td>6</td><td>94.25±0.07</td></tr><tr><td rowspan="3"></td><td>Dspike</td><td>SNN training</td><td>ResNet-18</td><td>4</td><td>93.66±0.05</td></tr><tr><td></td><td></td><td></td><td>2</td><td>93.13±0.07</td></tr><tr><td>BinarySNN [43] Diet-SNN [27]</td><td>BNN-SNN conversion SNN training</td><td>VGG-15 VGG-16</td><td>62</td><td>63.20</td></tr><tr><td rowspan="3">CIFAR100</td><td></td><td></td><td></td><td>5</td><td>69.67</td></tr><tr><td>Dspike</td><td>SNN training</td><td>ResNet-18</td><td>6 4</td><td>74.24±0.10 73.35±0.14</td></tr><tr><td></td><td></td><td></td><td>2</td><td>71.68±0.12</td></tr><tr><td rowspan="3"></td><td>Rollout [44]</td><td>Streaming roll out ANN</td><td>DenseNet</td><td></td><td></td></tr><tr><td>CIFAR10-DVS STBP-tdBN [26]</td><td>SNN training</td><td>ResNet-19</td><td>10 10</td><td>66.8</td></tr><tr><td>Dspike</td><td>SNN training</td><td>ResNet-18</td><td>10</td><td>67.8 75.4±0.05</td></tr></table>
+
+# 5.2 CIFAR
+
+The CIFAR10 (100) dataset contains 50K training and 10K test images with $3 2 \times 3 2$ pixels. We use AutoAugment [37] and Cutout [38] for data augmentation. We use ResNet-18 architecture for running experiments. We train the corresponding ANN first and use it to initialize the first SNN with $( T = 6$ ), then we use Time Inheritance Training to gradually reduce the time step to 2. For FDG computation, we use the best practice $\varepsilon = 0 . 1$ in the toy experiments. The temperature is initialized to 1, and we set the update step size to $\Delta b = 0 . 2$ . We adopt SGD optimizer with 0.9 momentum. In the first round of TIT, we train the model for 300 epochs with a learning rate of 0.01 cosine decayed [39] to 0. In the rest rounds of TIT, we only train the model for 50 epochs with a learning rate of 0.004. Weight decay (L2 regularization) is set to 0.0001. We run the model with 4 GTX 1080Tis. For each run, we report the mean accuracy as well as the standard deviation with 3 trials.
+
+We summarize the overall results in Table 2. On CIFAR10, our work can outperform state-of-the-art by $1 . 0 9 \%$ accuracy when $T = 6$ . It is also worth noting that the ResNet-19 used in [26] has $2 \mathbf { x }$ channel numbers and a larger feature-map, translating to $1 0 \mathrm { x }$ computation cost. Nevertheless, our ResNet-18 with Dspike still achieves higher accuracy. Notably, our ResNet-18 $T = 2 , 4$ ) is trained with TIT for only 50 epochs, yet still reaches a new state-of-the-art. We also conduct an ablation study: training a 2 time step spiking ResNet-18 without TIT for 300 epochs. The accuracy is only $9 3 . 1 3 \%$ which is subpar with the TIT method. We also verify Dspike on CIFAR100, with the same training pipeline here and we find our model can achieve much better performances than Diet-SNN [27].
+
+To further demonstrate the effectiveness of our method, we apply the Dspike function on the eventstream dataset CIFAR10-DVS [45]. CIFAR10-DVS contains 10k $1 2 8 \times 1 2 8$ images converted from CIFAR10. We split the dataset into 9k training images and $1 \mathrm { k }$ test images following the prior practice [26]. For data pre-processing and augmentation, we first resize the training image frames to $4 8 \times 4 8$ , then apply random horizontal flip. Additionally, we apply random roll within 5 pixels. The test images are directly resized to $4 8 \times 4 8$ . Training hyper-parameters are kept the same with the CIFAR10 experiments. Our proposed method can achieve $7 5 . 4 \%$ averaged top-1 accuracy on CIFAR10-DVS, with $7 . 6 \%$ absolute accuracy improvement compared with the existing state of the art.
+
+![](images/62ca32b702e6f8b0fce46b1b5de2fee86e70e10e3991c02c4413ea2c9190f967.jpg)  
+Figure 4 & Table 3: Left: Activation sparsity for each LIF layer. The $\mathbf { X }$ -axis denotes the layer index while the $\mathbf { y }$ -axis denotes the activation sparsity. Right: The computation operations count and the energy consumption comparison between ANN and SNN for each run, we select SNN from existing literature.
+
+Table 4: Training Spiking Neural Networks on ImageNet.   
+
+<table><tr><td>Method</td><td>Type</td><td>Architecture</td><td>Time Step</td><td> Accuracy</td></tr><tr><td>SpikeNorm [10]</td><td>ANN-SNN conversion</td><td>ResNet-34</td><td>2500</td><td>65.47</td></tr><tr><td>Hybrid-Train [40]</td><td>Hybrid</td><td>ResNet-34</td><td>250</td><td>61.48</td></tr><tr><td>Hybrid-Train [41]</td><td>Hybrid</td><td>VGG-16</td><td>250</td><td>65.19</td></tr><tr><td>STBP-tdBN [4]</td><td>SNN training</td><td>ResNet-34</td><td>6</td><td>63.72</td></tr><tr><td>Diet-SNN [27]</td><td>SNN training</td><td>VGG-16</td><td>5</td><td>69.00</td></tr><tr><td>Dspike</td><td>SNN training</td><td>ResNet-34</td><td>6</td><td>68.19</td></tr><tr><td>Dspike</td><td>SNN training</td><td>VGG-16</td><td>5</td><td>71.24</td></tr></table>
+
+# 5.3 ImageNet
+
+In this section we verify our algorithm on the ImageNet dataset. ImageNet dataset has more than $1 2 5 0 \mathrm { k }$ training images and 50k test images. We use the standard pre-processing and augmentation for training data [30]. The test data is directly centered cropped to $2 2 4 \times 2 2 4$ . We train ResNet-34 and VGG-16 on ImageNet using the same architecture in the CIFAR experiments. Each network is trained for 100 epochs with SGD optimizer with 0.9 momentum. The learning rate is set to 0.04 and weight decay is set to 0.00004. We train each model on 32 GTX 1080Tis with batch size of 10 per GPU. Following [26], to avoid the biased statistics, we synchronize the batch mean and variance across each device. Results are demonstrated in Table 4, Dspike training obtain $4 . 5 \%$ improvement compared to STBP-tdBN [26] and $2 . 2 \%$ improvement compared to Diet-SNN [27].
+
+# 5.4 Sparsity, Efficiency, and Energy Cost
+
+In this section, we measure the sparsity and efficient computation as well as the energy consumption of SNN. For ANN, the dot-product performs multiply-accumulate (MAC) operation, which is composed of an addition and a multiplication. In the case of SNN, its event-based operation and binary activation enable multiplication-free (except for the first rate-encoding layer) inference. Only one addition is needed if a spike is activated. In Fig. 4 we visualize the mean sparsity of activation of our spiking ResNet-18 on the whole CIFAR10 test set. We can see that each LIF layer has no more than $32 \%$ sparsity rate, which greatly saves energy. We also measure the operation number in Table 3. The addition count is calculated by $s * T * A$ , where $s$ is the mean sparsity, $T$ is the time step and $A$ is the addition number in ANN. For multiplication in SNN, we set it to the FLOPs of the first layer and scale it by $T$ . Our spiking ResNet-18 with 2 time-step has the lowest operation need for the inference. Then, we measure the energy consumption. Following [27], the energy is measured in $4 5 \mathrm { { n m } }$ CMOS technology. The MAC operation in ANN costs $4 . 6 p J$ energy and the accumulation in SNN costs $0 . 9 p J$ energy. Based on this, we compute the energy cost and put it in the table. Our network only costs $8 0 . 3 m J$ for a single forward, and consumes $1 2 . 8 \times$ lower energy compared with ANN.
+
+# 5.5 Ablation Study
+
+Our experiments use the same $\varepsilon$ for dataset and network architectures. In this section, we use different
+
+value for $\varepsilon$ and compare their results. The results is included in Table 5. Generally, we find a low temperature will decrease the performance, as we explained in Sec. 4.2, the desired optimization algorithm should ensure each update will decrease the loss function. Thus, the instantaneous derivative in SNN cannot measure such curvature information since the instantaneous
+
+Table 5: Accuracy comparison given different $\varepsilon$   
+
+<table><tr><td>Dataset</td><td>ε=0.01</td><td>ε=0.05 ε=0.1 ε=0.2</td><td></td></tr><tr><td>CIFAR10</td><td>91.78</td><td>93.11</td><td>94.07</td></tr><tr><td>CIFAR100</td><td>70.97</td><td>72.19</td><td>93.84 74.31 74.57</td></tr></table>
+
+derivative is always 0. Therefore, we find a large epsilon can help improve the performance. Indeed, the optimal $\varepsilon$ requires tuning, but our empirical results show that 0.1 can have good results.
+
+# 5.6 Visualization
+
+In this section, we provide further experimental visualization. In Fig. 5, we plot the temperature curve for CIFAR10-DVS experiments. The spiking ResNet-18 was trained for 300 epochs with cosine learning rate decay. We initialize $b$ to 1.0 and use $\Delta b { = } 0 . 2$ to optimize both temperature for gradient calculation and the weights parameters for network learning. For the initial 25 epochs, the temperature remains less-than-1. We think this is primarily due to the complex loss landscape at the starting stage of the training. During the 20 to 80 epoch, the temperature continues to be increasing. In this stage of learning the FDG desires to learn a sharp, narrow gradient with low bias but high variance. We also find the accuracy curve becomes more unstable in this stage of the training, as a consequence of the sharp gradient. After 80 epochs, the temperature becomes decreasing. Although the decreasing process is not aggressive as the former increasing stage, the trend is still obvious. From 80-250, the temperature decreases from 4.0 to 1.6 with some fluctuations. Then, at the end of the training stage, the temperature again becomes increasing.
+
+The intuition behind this tuning mechanism may remain unexplainable right now, however, we think it is the intrinsic nature of the gradient estimation in SNN. Through FDG, we are able to optimize the gradient calculation along with the weights learning.
+
+![](images/cbb32f98c9e8e60b4ab37fe6eeffec456f9a770d5e75d61cb0dff82ce30137ae.jpg)  
+Figure 5: The evolutution of temperature $^ { b }$ during optimization.
+
+# 6 Discussion
+
+In this work, we inspect the training process of SNN when using the surrogate gradient. The proposed finite difference gradient and Dspike function can be assembled with other optimization methods as a fundamental module of gradient estimation for training SNN. This suggests that the performance of SNN can be further increased when more sophisticated training approaches are integrated with the currently proposed methods in the future. Although the improvement on model performance is very significant, be that as it may, our work is still an extension to the conventional SG. How to efficiently find the best FDG gradient to directly deal with the non-linearity of spiking function still remains a problem. In addition, we only consider the LIF neurons for the analyses here, the efficiency of the proposed approaches on other types of spiking neurons still needs examination in practice.
+
+References   
+[1] Filipp Akopyan, Jun Sawada, Andrew Cassidy, Rodrigo Alvarez-Icaza, John Arthur, Paul Merolla, Nabil Imam, Yutaka Nakamura, Pallab Datta, Gi-Joon Nam, et al. Truenorth: Design and tool flow of a 65 mw 1 million neuron programmable neurosynaptic chip. IEEE transactions on computer-aided design of integrated circuits and systems, 34(10):1537–1557, 2015.   
+[2] Mike Davies, Narayan Srinivasa, Tsung-Han Lin, Gautham Chinya, Yongqiang Cao, Sri Harsha Choday, Georgios Dimou, Prasad Joshi, Nabil Imam, Shweta Jain, et al. Loihi: A neuromorphic manycore processor with on-chip learning. IEEE Micro, 38(1):82–99, 2018.   
+[3] Jing Pei, Lei Deng, Sen Song, Mingguo Zhao, Youhui Zhang, Shuang Wu, Guanrui Wang, Zhe Zou, Zhenzhi Wu, Wei He, et al. Towards artificial general intelligence with hybrid tianjic chip architecture. Nature, 572(7767):106–111, 2019.   
+[4] Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, Yuan Xie, and Luping Shi. Direct training for spiking neural networks: Faster, larger, better. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 1311–1318, 2019.   
+[5] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. arXiv preprint arXiv:1912.01703, 2019.   
+[6] James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: composable transformations of Python+NumPy programs, 2018.   
+[7] Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for large-scale machine learning. In 12th {USENIX} symposium on operating systems design and implementation ({OSDI} 16), pages 265–283, 2016.   
+[8] Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks. IEEE Signal Processing Magazine, 36(6):51–63, 2019. [9] Bing Han, Gopalakrishnan Srinivasan, and Kaushik Roy. Rmp-snn: Residual membrane potential neuron for enabling deeper high-accuracy and low-latency spiking neural network. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13558–13567, 2020.   
+[10] Abhronil Sengupta, Yuting Ye, Robert Wang, Chiao Liu, and Kaushik Roy. Going deeper in spiking neural networks: Vgg and residual architectures. Frontiers in Neuroscience, 13:95, 2019.   
+[11] Bodo Rueckauer, Iulia-Alexandra Lungu, Yuhuang Hu, and Michael Pfeiffer. Theory and tools for the conversion of analog to spiking convolutional neural networks. arXiv preprint arXiv:1612.04052, 2016.   
+[12] Bodo Rueckauer, Iulia-Alexandra Lungu, Yuhuang Hu, Michael Pfeiffer, and Shih-Chii Liu. Conversion of continuous-valued deep networks to efficient event-driven networks for image classification. Frontiers in Neuroscience, 11:682, 2017.   
+[13] Bing Han and Kaushik Roy. Deep spiking neural network: Energy efficiency through time based coding. In Proc. IEEE Eur. Conf. Comput. Vis.(ECCV), pages 388–404, 2020.   
+[14] Shikuang Deng and Shi Gu. Optimal conversion of conventional artificial neural networks to spiking neural networks. arXiv preprint arXiv:2103.00476, 2021.   
+[15] Yuhang Li, Shikuang Deng, Xin Dong, Ruihao Gong, and Shi Gu. A free lunch from ann: Towards efficient, accurate spiking neural networks calibration. arXiv preprint arXiv:2106.06984, 2021.   
+[16] Yuhang Li, Xin Dong, and Wei Wang. Additive powers-of-two quantization: An efficient non-uniform discretization for neural networks. arXiv preprint arXiv:1909.13144, 2019.   
+[17] Yuhang Li, Ruihao Gong, Xu Tan, Yang Yang, Peng Hu, Qi Zhang, Fengwei Yu, Wei Wang, and Shi Gu. Brecq: Pushing the limit of post-training quantization by block reconstruction. arXiv preprint arXiv:2102.05426, 2021.   
+[18] Yuhang Li, Mingzhu Shen, Jian Ma, Yan Ren, Mingxin Zhao, Qi Zhang, Ruihao Gong, Fengwei Yu, and Junjie Yan. MQBench: Towards reproducible and deployable model quantization benchmark. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 1), 2021.   
+[19] Hanting Chen, Yunhe Wang, Chunjing Xu, Boxin Shi, Chao Xu, Qi Tian, and Chang Xu. Addernet: Do we really need multiplications in deep learning? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1468–1477, 2020.   
+[20] Arnon Amir, Brian Taba, David Berg, Timothy Melano, Jeffrey McKinstry, Carmelo Di Nolfo, Tapan Nayak, Alexander Andreopoulos, Guillaume Garreau, Marcela Mendoza, et al. A low power, fully event-based gesture recognition system. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7243–7252, 2017.   
+[21] Johanni Brea, Walter Senn, and Jean-Pascal Pfister. Matching recall and storage in sequence learning with spiking neural networks. Journal of neuroscience, 33(23):9565–9575, 2013.   
+[22] Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.   
+[23] Jun Haeng Lee, Tobi Delbruck, and Michael Pfeiffer. Training deep spiking neural networks using backpropagation. Frontiers in Neuroscience, 10:508, 2016.   
+[24] Emre O Neftci, Charles Augustine, Somnath Paul, and Georgios Detorakis. Event-driven random back-propagation: Enabling neuromorphic deep learning machines. Frontiers in Neuroscience, 11:324, 2017.   
+[25] Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, and Luping Shi. Spatio-temporal backpropagation for training high-performance spiking neural networks. Frontiers in Neuroscience, 12:331, 2018.   
+[26] Hanle Zheng, Yujie Wu, Lei Deng, Yifan Hu, and Guoqi Li. Going deeper with directly-trained larger spiking neural networks. arXiv preprint arXiv:2011.05280, 2020.   
+[27] Nitin Rathi and Kaushik Roy. Diet-snn: Direct input encoding with leakage and threshold optimization in deep spiking neural networks. arXiv preprint arXiv:2008.03658, 2020.   
+[28] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.   
+[29] Shibani Santurkar, Dimitris Tsipras, Andrew Ilyas, and Aleksander Madry. How does batch normalization help optimization? arXiv preprint arXiv:1805.11604, 2018.   
+[30] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+[31] Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In NeurIPS, 2015.   
+[32] Guillaume Bellec, Darjan Salaj, Anand Subramoney, Robert Legenstein, and Wolfgang Maass. Long short-term memory and learning-to-learn in networks of spiking neurons. arXiv preprint arXiv:1803.09574, 2018.   
+[33] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th annual international conference on machine learning, pages 41–48, 2009.   
+[34] Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research).   
+[35] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.   
+[36] Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, and Mu Li. Bag of tricks for image classification with convolutional neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 558–567, 2019.   
+[37] Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018.   
+[38] Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   
+[39] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   
+[40] Nitin Rathi, Gopalakrishnan Srinivasan, Priyadarshini Panda, and Kaushik Roy. Enabling deep spiking neural networks with hybrid conversion and spike timing dependent backpropagation. arXiv preprint arXiv:2005.01807, 2020.   
+[41] Chankyu Lee, Syed Shakib Sarwar, Priyadarshini Panda, Gopalakrishnan Srinivasan, and Kaushik Roy. Enabling spike-based backpropagation for training deep neural network architectures. Frontiers in Neuroscience, 14, 2020.   
+[42] Wenrui Zhang and Peng Li. Temporal spike sequence learning via backpropagation for deep spiking neural networks. arXiv preprint arXiv:2002.10085, 2020.   
+[43] Sen Lu and Abhronil Sengupta. Exploring the connection between binary and spiking neural networks. Frontiers in Neuroscience, 14:535, 2020.   
+[44] Alexander Kugele, Thomas Pfeil, Michael Pfeiffer, and Elisabetta Chicca. Efficient processing of spatio-temporal data streams with spiking neural networks. Frontiers in Neuroscience, 14:439, 2020.   
+[45] Hongmin Li, Hanchao Liu, Xiangyang Ji, Guoqi Li, and Luping Shi. Cifar10-dvs: an eventstream dataset for object classification. Frontiers in Neuroscience, 11:309, 2017.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] Please see our discussion in Sec. 6   
+(c) Did you discuss any potential negative societal impacts of your work? [No]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] The proof is available in Sec. 4.3.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Our code will be available in the supplemental.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] All implementations are described in the experiments section.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We report the mean as well as the standard deviation accuracy in CIFAR experiments. For time consideration, we did not run them for ImageNet experiments, the results may be updated in the future.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] The computation resources description is provided in the experiment section.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We use CIFAR10/100 [34], ImageNet [35], and CIFAR10-DVS [45].   
+(b) Did you mention the license of the assets? [No] We adopt public datasets.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]
+
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/H4e7mBnC9f0/H4e7mBnC9f0_content_list.json

@@ -0,0 +1,1372 @@
+[
+    {
+        "type": "text",
+        "text": "Differentiable Spike: Rethinking Gradient-Descent for Training Spiking Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            122,
+            808,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuhang $\\mathbf { L i } ^ { 1 : }$ ∗, Yufei $\\mathbf { G u o ^ { 2 * } }$ , Shanghang Zhang3, Shikuang Deng1, Yongqing $\\mathbf { H a i } ^ { 2 }$ , Shi $\\mathbf { G u } ^ { \\mathrm { 1 } \\boxtimes }$ ",
+        "bbox": [
+            184,
+            224,
+            813,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1University of Electronic Science and Technology of China, 2Peking University, 3University of California Berkeley liyuhang699@gmail.com, yfguo@pku.edu.cn, gus@uestc.edu.cn ",
+        "bbox": [
+            254,
+            241,
+            741,
+            284
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spiking neural networks (SNNs) have emerged as a biology-inspired method mimicking the spiking nature of brain neurons. This biomimicry derives SNNs’ energy efficiency of inference on neuromorphic hardware. However, it also causes an intrinsic disadvantage in training high-performing SNNs from scratch since the discrete spike prohibits the gradient calculation. To overcome this issue, the surrogate gradient (SG) approach has been proposed as a continuous relaxation. Yet the heuristic choice of SG leaves it vacant how the SG benefits the SNN training. In this work, we first theoretically study the gradient descent problem in SNN training and introduce finite difference gradient to quantitatively analyze the training behavior of SNN. Based on the introduced finite difference gradient, we propose a new family of Differentiable Spike (Dspike) functions that can adaptively evolve during training to find the optimal shape and smoothness for gradient estimation. Extensive experiments over several popular network structures show that training SNN with Dspike consistently outperforms the state-of-the-art training methods. For example, on the CIFAR10-DVS classification task, we can train a spiking ResNet-18 and achieve $7 5 . 4 \\%$ top-1 accuracy with 10 time steps. ",
+        "bbox": [
+            233,
+            349,
+            766,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            594,
+            310,
+            612
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, spiking neural networks (SNNs) have received increasing attention due to their biologyinspired neural behavior and efficient computation. SNNs deal with binary spike information and therefore enjoy the advantage of multiplication-free inference. Neuromorphic hardware such as TrueNorth [1] and Loihi [2] demonstrates that SNNs can save energy by orders of magnitude. Hybrid architecture like Tianjic [3] suggests its potential power for general intelligence when integrated with traditional artificial infrastructure. However, the bio-mimicry also causes an intrinsic disadvantage in training high-performing SNNs from scratch due to the discrete spike. As a result, obtaining a high-performing SNN has long been a critical problem limiting SNN’s deployment in practice. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            731
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To be more specific, the appealing advantage of the multiplication-free computation in SNN is not recognized in its training [4]. Modern ML frameworks such as Pytorch [5], JAX [6], and Tensorflow [7] do not provide efficient and general instructions or high-level functions to accelerate the convolution with 0/1 spike activation. Moreover, the binary activation in SNN produces allor-nothing gradients [8] that are incompatible with typical gradient-based optimization methods for efficient neural network training. To circumvent this problem, many works adopt surrogate gradients [8] (typically the derivative of a soft-relaxed function) to replace the spike non-linear gradient. Although the heuristic choice of SG is beneficial to enable the gradient descent in SNN training, the theoretical soundness of SG has not been justified so far. What’s more, the gradient descent in SNN training may follow different updating rules from ANN. In fact, since the true gradient value of spike activation does not exist, the adoption of SG raises a new question of how to replace the $\\infty$ -gradient adaptively through the training process for a good updating strategy of parameters. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/012f9c41f16a3f7d725581105934c4ac57dfecbb0474bbc6673af5b5ff35c998.jpg",
+        "image_caption": [
+            "Figure 1: Overall workflow of the proposed algorithm. We use a general, flexible Dspike function and control its shape with finite difference method to facilitate the surrogate gradient descent in training SNN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            825,
+            262
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            327,
+            823,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we study this specialized problem of adaptive gradient estimation in SNN training. We first revisit the gradient descent algorithm with the finite difference method to accurately depict the loss landscape of adopting a surrogate gradient for the non-differentiable spike firing function. Then we further propose the Differentiable Spike (Dspike) function, which can adaptively change its shape and capture the direction of finite difference gradients. With such adaptive surrogate gradients, we establish an efficient algorithm of training SNN with large-scale models. The overall workflow of our algorithm is visualized in Fig. 1. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions can be summarized as follows: ",
+        "bbox": [
+            174,
+            464,
+            495,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We identify the problem of adaptively estimating gradient in SNN training and propose a novel analysis framework for SNN’s surrogate gradient, through which we are able to not only explain why it works well but also indicate how we can improve its adaptivity to data through training. • We also introduce the novel Dspike function built from the hyperbolic tangent function. The Dspike function can learn its shape accordingly by matching it with the finite difference gradient. • Extensive experiments on both static and dynamic datasets show that our method is highly effective and efficient. For example, our model can achieve $7 5 . 4 \\%$ top-1 accuracy on the CIFAR-DVS. Our SNN also only consumes $7 . 8 \\%$ energy of the corresponding ANN on CIFAR-10. ",
+        "bbox": [
+            171,
+            489,
+            826,
+            606
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            628,
+            321,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ANN-SNN Conversion. Generally, the algorithms to obtain a high-performance can be divided into two routes: (1) ANN-SNN conversion and (2) direct training SNN from scratch. Conversion-based methods [9, 10] utilize the knowledge from ANN and convert the ReLU activation to spike activation mechanism. This type of method can produce an SNN in a short time. For example, Rueckauer et al. [11] propose to traverse the training dataset to find the maximum activation. Then, the SNN can be converted by directly replacing several modules. In [12], maximum activation is abandoned since it may out-lie the central range of activation. The authors choose to find the percentile numbers for threshold voltage to improve the robustness. TSC [13] adopts the soft-reset (also known as reset by subtraction) mechanism and no leakage for conversion, which proves to be effective in conversion. Deng & Gu [14] decompose the conversion error to each layer, then propose to reduce the error by shifting the bias term. [15] first propose the calibration to reduce the conversion accuracy. ANN-SNN conversion is fast and accurate. However, achieving near lossless conversion requires a considerable amount of time steps $( > 2 0 0 )$ to accumulate the spikes, which may significantly add up the latency. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Direct Training SNN. In contrast to the conversion method, direct training of SNNs can lower the time step and may further reduce energy consumption. Direct training leverages gradient-descent algorithms. And many works have been developed to tackle the non-differentiability of spike activation. This non-differentiable activation function is similar to the quantization or binarization neural network [16, 17, 18] or adder neural network [19]. [20] achieve high performance on CIFAR10 and other neuromorphic datasets. Some works use probabilistic models to approximate the gradient [21], which is also developed in binary stochastic model [22]. Another common approach is to use rate-encoding networks for gradients calculation [23, 24]. They quantize the spike rate as the magnitude of information transmitted. (Wu et al. 2019 [25] improves the leaky integrate-and-fire (LIF) model to an iterative LIF model and develops STBP learning algorithm. Zheng et al. [26] further propose the tdBN algorithm to balance the gradient norm and smooth the loss function in SNN training, enabling large-scale model optimization. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            203
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Preliminary ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            220,
+            305,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Leaky Integrate-and-Fire Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            253,
+            439,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use bold italic letters for vector representations. For example, $_ { \\textbf { \\em x } }$ and $\\textbf {  { y } }$ denote the input and target output variables. Bold capital letters like W denote the matrices (or tensors as clear from the text). Constants are denoted by small upright letters, e.g., $a$ . With bracketed superscript and subscript, we can denote the time dimension and the element indices, respectively. For example, $\\mathbf { \\boldsymbol { \\mathsf { u } } } _ { i } ^ { ( t ) }$ means the $i$ -th membrane potential at time step $t$ . We adopt the well-known Leaky Integrate-and-Fire (LIF) neuron model for a spiking neural network (SNN). Given a membrane potential $\\mathbf { \\boldsymbol { u } } ^ { ( t ) }$ , the pre-synaptic potential is updated as ",
+        "bbox": [
+            173,
+            279,
+            826,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1b0abba2d5975e50ded4dd169b4904bbda9f04327fc2e1e4562c4767489dd23.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { u } ^ { ( t + 1 ) , \\mathrm { p r e } } = \\tau \\pmb { u } ^ { ( t ) } + \\pmb { c } ^ { ( t + 1 ) } , \\mathrm { w h e r e } \\ \\pmb { c } ^ { ( t + 1 ) } = \\mathbf { W } \\pmb { x } ^ { ( t + 1 ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            387,
+            681,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\tau$ is a constant leaky factor within $( 0 , 1 )$ and $c ^ { ( t + 1 ) }$ is the pre-synaptic input at time step $t + 1$ . The input can be calculated from the dot-product between the weights and the spike from the previous layer. Let $V _ { t h }$ be the firing threshold, the membrane potential will fire a spike when it exceeds the threshold, and then hard-reset to 0, given by ",
+        "bbox": [
+            173,
+            411,
+            826,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ab4c9628707e472e92d6affedfa1802807c77e6f434647d5fe14d1c391b6028.jpg",
+        "text": "$$\n\\pmb { y } ^ { ( t + 1 ) } = \\{ \\begin{array} { l l } { 1 } & { \\mathrm { i f ~ } \\pmb { u } ^ { ( t + 1 ) , \\mathrm { p r e } } > V _ { t h } } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } } \\end{array} , \\pmb { u } ^ { ( t + 1 ) } = \\pmb { u } ^ { ( t + 1 ) , \\mathrm { p r e } } \\cdot ( 1 - \\pmb { y } ^ { ( t + 1 ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            474,
+            735,
+            510
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After firing, the spike output $\\pmb { y } ^ { ( t + 1 ) }$ will propagate to the next layer and become the input $\\boldsymbol { x } ^ { ( t + 1 ) }$ of the next layer, (note that we omit the layer index for simplicity). $V _ { t h }$ is set to 0.5 in this work. ",
+        "bbox": [
+            173,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Softmax in SNN. In the general classification model, the final network output will be leveraged to compute the softmax and then to find the winner class. However, the network output is highly variant per input sample, and unlike ReLU activation, the output could be positive or negative. For this reason, we choose to only integrate the network output, and do not fire them across time, as did in recent practices [26, 27]. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            623
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7626e384ef5f413990e19b75b8faab634e4c08dbd90a8353aa425bbeb07cae8.jpg",
+        "text": "$$\n{ \\pmb y } _ { \\mathrm { n e t } } = \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { \\pmb c } _ { \\mathrm { n e t } } ^ { ( t ) } = \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { \\bf W } { \\pmb x } ^ { ( t ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            628,
+            616,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Then, we can compute the cross-entropy loss based on the ture label and Softmax $( y _ { \\mathrm { n e t } } )$ ",
+        "bbox": [
+            171,
+            678,
+            750,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Time-dependent Batch Normalization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            477,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Batch Normalization (BN) [28] is used to reduce internal covariate shift and smooth the loss landscape [29] during the optimization of an ANN. It enables the stable training of ANN even with more than 100 layers on the large-scale dataset, e.g. ResNet-152 [30]. However, BN layers are not designed to normalize spatial-temporal data at first. And simply transplanting BN in SNN training will lead to undesired results. To solve this problem, Zheng et al. [26] propose time-dependent Batch Normalization (tdBN), which normalizes the data in both spatial and temporal paradigm. tdBN will gather the pre-synaptic input along the time dimension, denoted by $\\mathbf { C } = [ \\pmb { c } ^ { ( 1 ) } , \\pmb { c } ^ { ( 2 ) } , \\pmb { , . . . } , \\pmb { c } ^ { ( T ) } ]$ , and then normalize it by ",
+        "bbox": [
+            173,
+            733,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af5882e9266d0097e3f54590a96a71a47d00d150f3009b0b074e9b6ad582e6bd.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { \\bar { \\bf C } = \\frac { \\alpha V _ { t h } \\left( { \\bf C } - \\mathbb { E } \\left[ { \\bf C } \\right] \\right) } { \\sqrt { \\mathbb { V } \\mathbb { A } \\mathbb { R } \\left( { \\bf C } \\right) + \\epsilon } } \\qquad } & { \\# \\mathrm { n o r m a l i z e } } \\\\ & { \\hat { \\bf C } = \\gamma \\bar { \\bf C } + \\beta , \\qquad } & { \\# \\mathrm { a f f i n e ~ t r a n s f o r m a t i o n } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            852,
+            712,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { E }$ and $\\mathbb { V } \\mathbb { A } \\mathbb { R }$ compute the mean and variance in channel dimension. $\\gamma$ and $\\beta$ are learnable parameters. Note that in tdBN the normalized tensor will multiply $\\alpha V _ { t h }$ , which can prevent over-fire and under-fire by choosing $\\alpha$ wisely. After tdBN, the pre-synaptic input in each time step will be fed into Eq. (1). tdBN stabilizes the training of SNN and achieves good results. We also adopt this training technique in our framework. See [26] for more details of tdBN. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            180,
+            315,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Non-Differentiable Spike ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            213,
+            387,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One of the most notorious problems in SNN training is the non-differentiability of the firing function Eq. (2). The firing function could be viewed as a variant of sign function, whose derivative is identified as the Dirac delta function. This derivative is 0 almost everywhere except for the threshold that grows to infinity. Seemingly, directly using the Dirac delta function is not an ideal choice for gradient descent-based learning. To demonstrate this problem, let $L$ denote the task loss objective, we can compute the gradient of weights parameters using the spatial-temporal backpropagation (STBP): ",
+        "bbox": [
+            173,
+            238,
+            825,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7d2d57bface8d1c9a9e59cc543fd3e9a61af2f5ea3c9fec2fa28b70a127d99a.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial \\mathbf { W } } = \\sum _ { t } \\frac { \\partial L } { \\partial \\pmb { y } ^ { ( t ) } } \\frac { \\partial \\pmb { y } ^ { ( t ) } } { \\partial \\pmb { u } ^ { ( t ) , \\mathrm { p r e } } } \\frac { \\partial \\pmb { u } ^ { ( t ) , \\mathrm { p r e } } } { \\partial \\pmb { c } ^ { ( t ) } } \\frac { \\partial \\pmb { c } ^ { ( t ) } } { \\partial \\mathbf { W } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            329,
+            642,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In above equation, $\\frac { \\partial \\pmb { y } ^ { ( t ) } } { \\partial \\pmb { u } ^ { ( t ) , \\mathrm { p r e } } }$ is the gradient of firing function and is 0 almost everywhere, as aforementioned. As a consequence, the gradient descent $\\begin{array} { r } { ( \\mathbf { W }  \\mathbf { W } - \\eta \\frac { \\partial L } { \\partial \\mathbf { W } } ) } \\end{array}$ either freezes weights or updates the weights to infinity. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To mitigate this problem, prior work seeks an alternative gradient (also known as surrogate gradient) to circumvent this problem. A popular surrogate gradient may refer to the rectangular function proposed in [4], given by ",
+        "bbox": [
+            173,
+            433,
+            825,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6192c78e9a91e3a70b28323af6b93dfd7a94ced7ba38ae600394e39937ee6843.jpg",
+        "text": "$$\n\\frac { \\partial \\pmb { y } ^ { ( t ) } } { \\partial \\pmb { u } ^ { ( t ) , \\mathrm { p r e } } } = \\frac { 1 } { a } \\mathrm { s i g n } \\left( \\left| \\pmb { u } ^ { ( t ) , \\mathrm { p r e } } - V _ { t h } \\right| < \\frac { a } { 2 } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            481,
+            642,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $a$ is a hyper-parameter and usually set to 1. When $V _ { t h } = 0 . 5 , a = 1$ , the gradient is simplified to 1 if $0 \\leq u ^ { ( t ) , \\mathrm { p r e } } \\leq 1$ otherwise 0. This is known as the Straight-Through Estimator in Bengio et al. [22] and is broadly applied in binary networks [31]. Another family of surrogate gradient may refer to triangular gradients [32], given by ",
+        "bbox": [
+            173,
+            520,
+            825,
+            578
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2aae9322b8d60fccc67674c65ff8ea44d61fa53b6a2d2d437a67583716ab22b.jpg",
+        "text": "$$\n\\frac { \\partial \\pmb { y } ^ { ( t ) } } { \\partial \\pmb { u } ^ { ( t ) , \\mathrm { p r e } } } = \\gamma \\operatorname* { m a x } \\left( 0 , 1 - \\left| \\frac { \\pmb { u } ^ { ( t ) , \\mathrm { p r e } } } { V _ { t h } } - 1 \\right| \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            584,
+            645,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This surrogate gradient is computed based on the distance between the potential and threshold. Despite various surrogate gradients achieve acceptable accuracy, there lacks a theoretical justification for its reason and effectiveness. ",
+        "bbox": [
+            174,
+            626,
+            826,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 Rethinking Gradient-Descent in Spiking Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            684,
+            617,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Gradient-descent (GD) algorithm is a first-order iterative optimization method. Theoretically, for each iteration, GD aims to find the steepest direction for the descent that minimizes the task loss: ",
+        "bbox": [
+            174,
+            710,
+            826,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92eabb09597cb37c6f28a6f711cfae9fd5ae7fc36ef51591a884b6d1c5173c7a.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { | | \\Delta \\mathbf { W } | | \\leq \\varepsilon } L ( \\mathbf { W } + \\Delta \\mathbf { W } ) \\approx \\operatorname* { m i n } _ { | | \\Delta \\mathbf { W } | | \\leq \\varepsilon } L ( \\mathbf { W } ) + \\Delta \\mathbf { W } \\frac { \\partial L } { \\partial \\mathbf { W } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            746,
+            686,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the right-hand side of the minimization is approximated by the first-order Taylor expansion. Given that $L ( \\mathbf { W } )$ is constant at the current iteration, therefore we only have to find the right $\\Delta \\mathbf { W }$ that minimizes the second term. Since the 2nd term is a linear in $\\Delta \\mathbf { W }$ , it can be made as negative as we like by taking $\\Delta { \\bf W }$ large. Therefore the minimum is $\\begin{array} { r } { \\Delta \\mathbf { W } = - \\varepsilon \\frac { \\nabla \\mathbf { w } L } { | | \\nabla \\mathbf { w } L | | } } \\end{array}$ , (where $\\begin{array} { r } { \\nabla { \\bf w } L = \\frac { \\partial L } { \\partial \\bf W } . } \\end{array}$ ∂ L∂ W ). ",
+        "bbox": [
+            174,
+            785,
+            826,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the above condition is only sufficient for $\\varepsilon  0$ to correctly approximate the loss with Taylor expansion. However, $\\varepsilon  0$ means $\\begin{array} { r } { \\Delta \\mathbf { W } = - \\varepsilon \\frac { \\nabla \\mathbf { w } L } { | | \\nabla \\mathbf { w } L | | }  0 } \\end{array}$ , but in practice GD updates the weights by a small step (determined by learning rate), which, indicates a mismatch between the practical implementation and the theoretical assumption. In other words, gradient only inspects the change rate of loss around an infinitely small neighborhood, however, we are interested in the change rate around a tiny (but not infinitely small) area. In the case of SNN, the gradient will always be $0 ^ { \\mathit { \\Phi } }$ , yet for a tiny neighborhood the loss function will change, leading to non-zero gradients. To penetrate the non-differentiability of the firing function, we adopt a technique called finite difference. It estimates the gradient by evaluating the loss objective near the coordinate: ",
+        "bbox": [
+            174,
+            851,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/45783978b928cbb997105b7291a1e3566ef066a2a4fbc4c021e17b11b23e1ac2.jpg",
+        "image_caption": [
+            "Figure $\\mathbf { 2 \\alpha \\& }$ Table 1: Left: The cosine similarity between the gradients used for update and the FDG. In (a) we show ANN gradients and in (b) we show SNN rectangular surrogate gradients. Right: Training SNN with finite difference gradient, given different $\\varepsilon$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            820,
+            228
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            299,
+            826,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58d8cd0dadd6ec7daa301f8ca1ddbe12b45417e8d2aece7303f08dfdb941588c.jpg",
+        "text": "$$\n\\hat { \\nabla } _ { \\varepsilon , w } L = \\left( \\frac { L ( w _ { 1 } + \\varepsilon e _ { 1 } ) - L ( w _ { 1 } - \\varepsilon e _ { 1 } ) } { 2 \\varepsilon } , \\ldots , \\frac { L ( w _ { k } + \\varepsilon e _ { k } ) - L ( w _ { k } - \\varepsilon e _ { k } ) } { 2 \\varepsilon } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            375,
+            756,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\textbf { \\em w }$ is the flattened vector of $\\mathbf { W }$ and $e _ { i }$ refers to standard basis vector with 1 at $i$ -th index. $\\varepsilon$ is some small constant, e.g. 0.001. We call $\\hat { \\nabla } _ { \\varepsilon , w } L$ as finite difference gradient (FDG). By the definition of gradient, we know FDG becomes the true gradient when $\\varepsilon  0$ . FDG can be a useful tool in GD-based learning, however, evaluating finite difference for each element in the weight vector is tedious, which greatly slows down the training process. Nevertheless, FDG still offers us a choice to evaluate the gradient mismatch problem quantitatively. ",
+        "bbox": [
+            173,
+            414,
+            825,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to illustrate this, we construct a toy problem: a simple 2-layer CNN on the MNIST dataset. The first layer is a $3 \\mathrm { x } 3$ convolutional layer (output channel number is 6) with ReLU activation (or LIF spike activation) and average pooling for down-sampling. Then, we directly add a fully connected layer to predict the classification results. We train the toy model on MNIST for 5 epochs, with batch size 128 and learning rate 0.01 decayed to 0. In an effort to compute the FDG of the first layer, we have to perform $2 \\times 1 \\times 6 \\times 3 \\times 3 = 1 0 8$ times forward pass 3. In contrast, one has to perform 22 million times forward passes on a ResNet-18 [30] to compute the FDG of all parameters. ",
+        "bbox": [
+            173,
+            506,
+            825,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Experiment I: FDG in ANN. We first train an ANN on MNIST and compare the disparity between real gradients and FDG. We use cosine similarity (i.e. $\\begin{array} { r } { \\cos _ { - } \\sin ( { \\pmb x } _ { 1 } , { \\pmb x } _ { 2 } ) = \\frac { { \\pmb x } _ { 1 } { \\pmb x } _ { 2 } } { | | { \\pmb x } _ { 1 } | | _ { 2 } | | { \\pmb x } _ { 2 } | | _ { 2 } } ) } \\end{array}$ x1x2||x1||2||x2||2 ) to determine the angle between these two gradient vectors. For each epoch, we compute the mean cosine similarity in the first 100 training iterations. The results are demonstrated in Fig. 2(a). The FDG and real gradients consistently have an extremely similar direction $( > 0 . 9 9 \\mathrm { c o s \\_ s i m } )$ with $\\varepsilon$ varying from 0.1 to 0.001. In conclusion, we show that (1) FDG is a valid signal and (2) the real gradients can effectively find the change rate within a small neighborhood in ANN optimization. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Experiment II: FDG in SNN. Then, we compare the cosine similarity between the surrogate gradients in SNN and the FDG. In Fig. 2(b), we can tell that surrogate gradients share similar gradient direction with FDG when $\\varepsilon = 0 . 1$ (i.e. more than 0.8 cosine similarity). However, decreasing $\\varepsilon$ will lead to lower cosine similarity. In the case of $\\varepsilon = 0 . 0 0 1$ , the angle between FDG and the surrogate gradients is nearly 90 degrees, (for comparison, in high-dimensional space, two arbitrary random Gaussian vectors are very likely to be orthogonal). This observation concludes that surrogate gradient can predict the change rate of loss in a relatively larger neighborhood, which justifies the soundness of surrogate gradients. However, SG fails to predict the FDG in small step size $\\varepsilon$ . To this end, we need to figure out whether a large step size is better or a small step size is better. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Experiment III: Training SNN with FDG. In SNN optimization, a natural question arises: What ε is optimal for gradient descent? First, the $\\varepsilon$ has to be small enough to compute the non-linearity of the loss surface, meanwhile, it has to be large enough to ignore the noise from the rough step function. For this reason, we explore the optimal $\\varepsilon$ by applying FDG in SNN optimization. The results are demonstrated in the Table 1. Note that all methods are trained on MNIST for only 10 epochs here. We show that the rectangular surrogate gradient with $a = 1$ reaches $9 4 . 9 \\%$ accuracy. For FDG optimization, we evaluate $\\varepsilon$ ranging from 0.001 to 0.5, and we find 0.1 is the best choice for optimizing SNN. The results confirm our assumption that $\\varepsilon$ has to be neither too big nor too small. It also tells us using the instant change rate (very small $\\varepsilon$ ) will lead to undesired performance degradation. ",
+        "bbox": [
+            174,
+            845,
+            823,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            203
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Differentiable Spike ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            217,
+            352,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the Dspike function, a novel surrogate gradient estimator, which can cover a large range of choices for SG. We choose the hyperbolic tangent function $\\begin{array} { r } { \\operatorname { t a n h } ( x ) = \\frac { e ^ { x } - e ^ { - x } } { e ^ { x } + e ^ { - x } } } \\end{array}$ as our basic building function for gradient estimation: ",
+        "bbox": [
+            174,
+            242,
+            825,
+            290
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a93428e1bca6efe0c9ed5f97b5d2b2236dd810d491bdcb421042840c7acdce7.jpg",
+        "text": "$$\n\\operatorname { D s p i k e } ( x ) = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { i f ~ } } x > 1 } \\\\ { a \\cdot \\operatorname { t a n h } ( b ( x - c ) ) + d } & { { \\mathrm { i f ~ } } 0 \\leq x \\leq 1 } \\\\ { 0 } & { { \\mathrm { i f ~ } } x < 0 } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            292,
+            679,
+            343
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When $x < 0$ or $x > 1$ , we choose to clip $x$ as did in other practice. The vanilla tanh function maps $( - \\infty , + \\infty )$ to $( - 1 , 1 )$ , thus we have four parameters to control its shape to alter the function mapping: from $[ - 1 , 1 ]$ to [1, 1]. We first use $c = V _ { t h } = 0 . 5$ to set the symmetry center to (0.5, 0.5). Parameter $b ( b > 0 )$ is called the temperature factor, it controls the shape of the Dspike function. Parameter $a$ and $d$ can then be determined by setting $\\mathrm { D s p i k e ( 0 ) } = 0 , \\mathrm { D s p i k e ( 1 ) } = 1$ . As a result, we can rewrite the function as: ",
+        "bbox": [
+            173,
+            345,
+            826,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b59cfc2c20fbfb26639208290198b22855af34af127dc047b15900cb284bf78.jpg",
+        "text": "$$\n\\mathrm { D s p i k e } ( x , b ) = \\frac { \\operatorname { t a n h } ( b ( x - 0 . 5 ) ) + \\operatorname { t a n h } ( b / 2 ) } { 2 ( \\operatorname { t a n h } ( b / 2 ) ) } , \\mathrm { i f ~ } 0 \\leq x \\leq 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            428,
+            700,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dspike function has the capability to adjust the shape of the function, leading to different surrogate gradient estimations. To demonstrate that, we have the following lemma: ",
+        "bbox": [
+            174,
+            463,
+            821,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.1. By changing the temperature $b$ , the shape of Dspike function can be altered. Specifically, we have $\\dim _ { b \\to 0 _ { + } } { \\mathrm { D s p i k e } } ( x ) \\to x$ and $\\scriptstyle \\operatorname* { l i m } _ { b \\to + \\infty }$ $\\mathrm { D s p i k e } ( x ) \\to \\mathrm { s i g n } ( x - 0 . 5 )$ . ",
+        "bbox": [
+            173,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof. We first prove the case $b \\to 0 _ { + }$ . In this case, applying Taylor expansion to the tanh we have: ",
+        "bbox": [
+            169,
+            536,
+            823,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9b62ee7cbb22f56faff29bc4f801acf63e237e0ec33b86500934de942e2a0fd.jpg",
+        "text": "$$\n\\operatorname { t a n h } ( b x ) \\approx b x - { \\frac { b ^ { 3 } x ^ { 3 } } { 3 } } + \\cdots + { \\frac { 2 ^ { ( 2 n ) } ( 2 ^ { ( 2 n ) } - 1 ) B _ { 2 n } ( b x ) ^ { 2 n - 1 } } { ( 2 n ) ! } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            553,
+            710,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $B _ { n }$ is the $n$ -th Bernoulli number. When $b \\to 0$ , we can safely ignore higher-order terms and only keep $b x$ . Thus, we can rewrite Eq. (12) to ${ \\mathrm { D s p i k e } } ( x , b ) = { \\sqrt [ { b } ] { b } } { \\stackrel { - } { = } } x$ . Then, we prove the case $b \\to + \\infty$ . Since $\\scriptstyle \\operatorname* { l i m } _ { x \\to + \\infty } \\operatorname { t a n h } ( x ) \\to 1$ , we have: ",
+        "bbox": [
+            173,
+            590,
+            826,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c23e0b9f9daaa34722e3b151dfd45d07fab89251464961afd0f333bd1f9867b6.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { b \\to + \\infty } \\operatorname { D s p i k e } ( x , b )  \\{ \\{ \\begin{array} { l l } { \\frac { 2 * \\operatorname { t a n h } ( + \\infty ) } { 2 * \\operatorname { t a n h } ( + \\infty ) } = 1 } & { \\mathrm { i f ~ } x > 0 . 5 } \\\\ { \\frac { \\operatorname { t a n h } ( + \\infty ) } { 2 * \\operatorname { t a n h } ( + \\infty ) } = 0 . 5 } & { \\mathrm { i f ~ } x = 0 . 5 } \\\\ { \\frac { 0 } { 2 * \\operatorname { t a n h } ( + \\infty ) } = 0 } & { \\mathrm { i f ~ } x < 0 . 5 } \\end{array} \n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            633,
+            691,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With this temperature factor, our algorithm can simulate a wide range of surrogate gradients with different smoothness. We visualize the transition in Fig. 3 from both forward perspective and backward perspective. As aforementioned, surrogate gradient can mimic the FDG in a relatively large neighborhood. Our intuition is that the optimal surrogate gradient can be found by choosing temperature wisely. Thus our task becomes to optimize temperature and network parameters simultaneously during training. As did in former toy experiments (Sec. 4.2), we verify the cosine similarity between our Dspike gradients and the FDG at the beginning of each training epoch and update the temperature to better match the FDG. This algorithm is detailed in Algo. 1. ",
+        "bbox": [
+            173,
+            723,
+            826,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As abovementioned, evaluating FDG could be time-consuming, due to the two times evaluation of the final loss for each weight element. Therefore, we choose to only compute the FDG in the first layer for two reasons. First, the first layer has much fewer weights. In ResNet-18 (for CIFAR10 dataset), the first layer only has $3 \\times 3 \\times 3 \\times 6 4 = 5 7 6$ elements. Second, the gradient propagation may accumulate the error in the former layers, which effectively measures the gradient mismatch. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b058289d96cf2a3af515bea104b590c2e4c5ac976b0e01ce56486282f76a0509.jpg",
+        "image_caption": [
+            "Figure 3: The forward plot (left) as well as the backward plot (right) of Dspike function. By changing temperature parameter we can manipulate the gradient estimation in SNN training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            89,
+            758,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Training SNN with Dspike gradient ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            320,
+            503,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Input: SNN to be trained; Training dataset, total training epoch $E$ , total training iteration in one epoch $I$ , FDG step size $\\varepsilon$ , temperature update step size $\\Delta b$ , initialized temperature $b ^ { 0 }$ .   \nfor all $e = 1 , 2 , \\ldots , E$ -th epoch do Collect input data and labels, computing the FDG $( \\hat { \\nabla } _ { \\varepsilon , w } L )$ of the first layer using $\\varepsilon$ ; for all $b$ in $\\{ b ^ { e - 1 } , b ^ { e - 1 } + \\Delta b , b ^ { e - 1 } - \\Delta b \\}$ do Compute Dsipke surrogate gradient $\\nabla _ { b , w } L$ and $\\cos \\underline { { \\mathrm {  ~ \\scriptstyle ~ \\psi ~ } } } \\mathrm { s i m } ( \\hat { \\nabla } _ { \\varepsilon , w } L , \\nabla _ { b , w } L )$ Find the optimal temperature with the highest cosine similarity and update it to $b ^ { e }$ ; for all $i = 1 , 2 , \\dots , I$ -iteration do Get training data and labels, compute Dspike surrogate gradient using optimal $b$ ; Descend loss function and update weights; ",
+        "bbox": [
+            174,
+            338,
+            805,
+            492
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "return trained SNN. ",
+        "bbox": [
+            173,
+            497,
+            310,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Time Inheritance Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            398,
+            556
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also introduce a novel training pipeline that can effectively reduce the time for training multiple SNNs. Unlike ANN-SNN conversion, direct training SNN is performed with a fixed time step $T$ . As a result, we must learn a new SNN from scratch if we decide to use another different $T$ . We propose Time Inheritance Training (TIT) pipeline to ameliorate this problem. First, we train an SNN to converge with high $T$ , e.g. 20. Then, we use this well-trained model to initialize an SNN with lower $T$ , say $T = 1 0$ . Consequently, the initialized model has exactly the same output as the former model in the first 10 time steps, enabling better initialization and faster convergence. In other words, TIT progressively reduces the time step finetuning from a higher time step SNN first. This idea resembles the curriculum learning proposed in Bengio et al. [33], which suggests learning the easy task first. Armed with TIT, we can reduce the training time of subsequent models by $7 5 \\%$ , while sharing the same task performances. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            312,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we report experimental results for our Dspike algorithm on CIFAR [34] and ImageNet dataset [35]. For static image dataset, we encode the images to spike using the first layer in the SNN, as adopted in recent works [27]. For the neuromorphic image dataset, the images are already converted to 0/1 spike format. We also replace the max-pooling layer with the average-pooling layer in the network architecture. The detailed implementation is described in each subsection. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Network Architecture Choice ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            416,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For CIFAR series experiments. We mainly adopt the ResNet-family architectures [30]. Unlike traditional ResNet structure [30], we use a modified version with 3 stem layers and avg-downsample block, as introduced in [36]. Our ResNet-18 architectures contains 4 stages with 2 basic residual block in each stage. Our initial channel is set to 64 and doubled in each stage. In comparison with [26], they use ResNet-19 with 3 stages, with 3 blocks in the first 2 stages and 2 blocks in the last stage. However, they choose 128 channel and they has larger receptive field than our model. In general, their ResNet-19 has ${ \\sim } 1 0$ times more operations than our ResNet-18. For ImageNet, we use the same VGG-16 as used in [27] and the same ResNet-34 as used in [26]. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/36ccfb7a46364a67ac604c6c1da492e6d294f37259cecdfdc3ad91bc69ecdf16.jpg",
+        "table_caption": [
+            "Table 2: Training Spiking Neural Networks on CIFAR10 and CIFAR100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Method</td><td>Type</td><td>Architecture</td><td>Time Step</td><td>Accuracy</td></tr><tr><td rowspan=\"10\">CIFAR10</td><td>SpikeNorm [10]</td><td>ANN-SNN conversion</td><td>VGG-16</td><td>2500</td><td>91.55</td></tr><tr><td>Hybrid-Train [40]</td><td>Hybrid</td><td>VGG-16</td><td>200</td><td>92.02</td></tr><tr><td>Spike-based BP [41]</td><td>SNN training</td><td>ResNet-11</td><td>100</td><td>90.95</td></tr><tr><td>STBP [4]</td><td>SNN training</td><td>5Conv, 2FC</td><td>12</td><td>90.53</td></tr><tr><td>TSSL-BP [42]</td><td>SNN training</td><td>5Conv,2FC</td><td>5</td><td>91.41</td></tr><tr><td>Diet-SNN [27]</td><td>SNN training</td><td>VGG-16</td><td>5</td><td>92.70</td></tr><tr><td></td><td>SNN training</td><td></td><td>6</td><td>93.16</td></tr><tr><td rowspan=\"3\">STBP-tdBN[26]</td><td rowspan=\"3\"></td><td>ResNet-19</td><td>4</td><td>92.92</td></tr><tr><td></td><td>2</td><td>92.34</td></tr><tr><td></td><td>6</td><td>94.25±0.07</td></tr><tr><td rowspan=\"3\"></td><td>Dspike</td><td>SNN training</td><td>ResNet-18</td><td>4</td><td>93.66±0.05</td></tr><tr><td></td><td></td><td></td><td>2</td><td>93.13±0.07</td></tr><tr><td>BinarySNN [43] Diet-SNN [27]</td><td>BNN-SNN conversion SNN training</td><td>VGG-15 VGG-16</td><td>62</td><td>63.20</td></tr><tr><td rowspan=\"3\">CIFAR100</td><td></td><td></td><td></td><td>5</td><td>69.67</td></tr><tr><td>Dspike</td><td>SNN training</td><td>ResNet-18</td><td>6 4</td><td>74.24±0.10 73.35±0.14</td></tr><tr><td></td><td></td><td></td><td>2</td><td>71.68±0.12</td></tr><tr><td rowspan=\"3\"></td><td>Rollout [44]</td><td>Streaming roll out ANN</td><td>DenseNet</td><td></td><td></td></tr><tr><td>CIFAR10-DVS STBP-tdBN [26]</td><td>SNN training</td><td>ResNet-19</td><td>10 10</td><td>66.8</td></tr><tr><td>Dspike</td><td>SNN training</td><td>ResNet-18</td><td>10</td><td>67.8 75.4±0.05</td></tr></table>",
+        "bbox": [
+            178,
+            111,
+            816,
+            422
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            446,
+            826,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 CIFAR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            540,
+            263,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The CIFAR10 (100) dataset contains 50K training and 10K test images with $3 2 \\times 3 2$ pixels. We use AutoAugment [37] and Cutout [38] for data augmentation. We use ResNet-18 architecture for running experiments. We train the corresponding ANN first and use it to initialize the first SNN with $( T = 6$ ), then we use Time Inheritance Training to gradually reduce the time step to 2. For FDG computation, we use the best practice $\\varepsilon = 0 . 1$ in the toy experiments. The temperature is initialized to 1, and we set the update step size to $\\Delta b = 0 . 2$ . We adopt SGD optimizer with 0.9 momentum. In the first round of TIT, we train the model for 300 epochs with a learning rate of 0.01 cosine decayed [39] to 0. In the rest rounds of TIT, we only train the model for 50 epochs with a learning rate of 0.004. Weight decay (L2 regularization) is set to 0.0001. We run the model with 4 GTX 1080Tis. For each run, we report the mean accuracy as well as the standard deviation with 3 trials. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We summarize the overall results in Table 2. On CIFAR10, our work can outperform state-of-the-art by $1 . 0 9 \\%$ accuracy when $T = 6$ . It is also worth noting that the ResNet-19 used in [26] has $2 \\mathbf { x }$ channel numbers and a larger feature-map, translating to $1 0 \\mathrm { x }$ computation cost. Nevertheless, our ResNet-18 with Dspike still achieves higher accuracy. Notably, our ResNet-18 $T = 2 , 4$ ) is trained with TIT for only 50 epochs, yet still reaches a new state-of-the-art. We also conduct an ablation study: training a 2 time step spiking ResNet-18 without TIT for 300 epochs. The accuracy is only $9 3 . 1 3 \\%$ which is subpar with the TIT method. We also verify Dspike on CIFAR100, with the same training pipeline here and we find our model can achieve much better performances than Diet-SNN [27]. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further demonstrate the effectiveness of our method, we apply the Dspike function on the eventstream dataset CIFAR10-DVS [45]. CIFAR10-DVS contains 10k $1 2 8 \\times 1 2 8$ images converted from CIFAR10. We split the dataset into 9k training images and $1 \\mathrm { k }$ test images following the prior practice [26]. For data pre-processing and augmentation, we first resize the training image frames to $4 8 \\times 4 8$ , then apply random horizontal flip. Additionally, we apply random roll within 5 pixels. The test images are directly resized to $4 8 \\times 4 8$ . Training hyper-parameters are kept the same with the CIFAR10 experiments. Our proposed method can achieve $7 5 . 4 \\%$ averaged top-1 accuracy on CIFAR10-DVS, with $7 . 6 \\%$ absolute accuracy improvement compared with the existing state of the art. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/62ca32b702e6f8b0fce46b1b5de2fee86e70e10e3991c02c4413ea2c9190f967.jpg",
+        "image_caption": [
+            "Figure 4 & Table 3: Left: Activation sparsity for each LIF layer. The $\\mathbf { X }$ -axis denotes the layer index while the $\\mathbf { y }$ -axis denotes the activation sparsity. Right: The computation operations count and the energy consumption comparison between ANN and SNN for each run, we select SNN from existing literature. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            89,
+            823,
+            179
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a7c27d956cdeb3fa5e0845e6b0e3b69fe36b1a9011c3cc103eb295f844ed0dd.jpg",
+        "table_caption": [
+            "Table 4: Training Spiking Neural Networks on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Type</td><td>Architecture</td><td>Time Step</td><td> Accuracy</td></tr><tr><td>SpikeNorm [10]</td><td>ANN-SNN conversion</td><td>ResNet-34</td><td>2500</td><td>65.47</td></tr><tr><td>Hybrid-Train [40]</td><td>Hybrid</td><td>ResNet-34</td><td>250</td><td>61.48</td></tr><tr><td>Hybrid-Train [41]</td><td>Hybrid</td><td>VGG-16</td><td>250</td><td>65.19</td></tr><tr><td>STBP-tdBN [4]</td><td>SNN training</td><td>ResNet-34</td><td>6</td><td>63.72</td></tr><tr><td>Diet-SNN [27]</td><td>SNN training</td><td>VGG-16</td><td>5</td><td>69.00</td></tr><tr><td>Dspike</td><td>SNN training</td><td>ResNet-34</td><td>6</td><td>68.19</td></tr><tr><td>Dspike</td><td>SNN training</td><td>VGG-16</td><td>5</td><td>71.24</td></tr></table>",
+        "bbox": [
+            245,
+            282,
+            750,
+            406
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            439,
+            823,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 ImageNet ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            281,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section we verify our algorithm on the ImageNet dataset. ImageNet dataset has more than $1 2 5 0 \\mathrm { k }$ training images and 50k test images. We use the standard pre-processing and augmentation for training data [30]. The test data is directly centered cropped to $2 2 4 \\times 2 2 4$ . We train ResNet-34 and VGG-16 on ImageNet using the same architecture in the CIFAR experiments. Each network is trained for 100 epochs with SGD optimizer with 0.9 momentum. The learning rate is set to 0.04 and weight decay is set to 0.00004. We train each model on 32 GTX 1080Tis with batch size of 10 per GPU. Following [26], to avoid the biased statistics, we synchronize the batch mean and variance across each device. Results are demonstrated in Table 4, Dspike training obtain $4 . 5 \\%$ improvement compared to STBP-tdBN [26] and $2 . 2 \\%$ improvement compared to Diet-SNN [27]. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 Sparsity, Efficiency, and Energy Cost ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            688,
+            470,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we measure the sparsity and efficient computation as well as the energy consumption of SNN. For ANN, the dot-product performs multiply-accumulate (MAC) operation, which is composed of an addition and a multiplication. In the case of SNN, its event-based operation and binary activation enable multiplication-free (except for the first rate-encoding layer) inference. Only one addition is needed if a spike is activated. In Fig. 4 we visualize the mean sparsity of activation of our spiking ResNet-18 on the whole CIFAR10 test set. We can see that each LIF layer has no more than $32 \\%$ sparsity rate, which greatly saves energy. We also measure the operation number in Table 3. The addition count is calculated by $s * T * A$ , where $s$ is the mean sparsity, $T$ is the time step and $A$ is the addition number in ANN. For multiplication in SNN, we set it to the FLOPs of the first layer and scale it by $T$ . Our spiking ResNet-18 with 2 time-step has the lowest operation need for the inference. Then, we measure the energy consumption. Following [27], the energy is measured in $4 5 \\mathrm { { n m } }$ CMOS technology. The MAC operation in ANN costs $4 . 6 p J$ energy and the accumulation in SNN costs $0 . 9 p J$ energy. Based on this, we compute the energy cost and put it in the table. Our network only costs $8 0 . 3 m J$ for a single forward, and consumes $1 2 . 8 \\times$ lower energy compared with ANN. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 Ablation Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            318,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our experiments use the same $\\varepsilon$ for dataset and network architectures. In this section, we use different ",
+        "bbox": [
+            181,
+            116,
+            820,
+            131
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "value for $\\varepsilon$ and compare their results. The results is included in Table 5. Generally, we find a low temperature will decrease the performance, as we explained in Sec. 4.2, the desired optimization algorithm should ensure each update will decrease the loss function. Thus, the instantaneous derivative in SNN cannot measure such curvature information since the instantaneous ",
+        "bbox": [
+            174,
+            131,
+            485,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/31a6cbda4c470ffa5457223268b018f1c939d6b0c2a6c27fc476c3d2cb1e6fe2.jpg",
+        "table_caption": [
+            "Table 5: Accuracy comparison given different $\\varepsilon$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>ε=0.01</td><td>ε=0.05 ε=0.1 ε=0.2</td><td></td></tr><tr><td>CIFAR10</td><td>91.78</td><td>93.11</td><td>94.07</td></tr><tr><td>CIFAR100</td><td>70.97</td><td>72.19</td><td>93.84 74.31 74.57</td></tr></table>",
+        "bbox": [
+            496,
+            167,
+            823,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "derivative is always 0. Therefore, we find a large epsilon can help improve the performance. Indeed, the optimal $\\varepsilon$ requires tuning, but our empirical results show that 0.1 can have good results. ",
+        "bbox": [
+            176,
+            241,
+            825,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.6 Visualization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            284,
+            303,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide further experimental visualization. In Fig. 5, we plot the temperature curve for CIFAR10-DVS experiments. The spiking ResNet-18 was trained for 300 epochs with cosine learning rate decay. We initialize $b$ to 1.0 and use $\\Delta b { = } 0 . 2$ to optimize both temperature for gradient calculation and the weights parameters for network learning. For the initial 25 epochs, the temperature remains less-than-1. We think this is primarily due to the complex loss landscape at the starting stage of the training. During the 20 to 80 epoch, the temperature continues to be increasing. In this stage of learning the FDG desires to learn a sharp, narrow gradient with low bias but high variance. We also find the accuracy curve becomes more unstable in this stage of the training, as a consequence of the sharp gradient. After 80 epochs, the temperature becomes decreasing. Although the decreasing process is not aggressive as the former increasing stage, the trend is still obvious. From 80-250, the temperature decreases from 4.0 to 1.6 with some fluctuations. Then, at the end of the training stage, the temperature again becomes increasing. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The intuition behind this tuning mechanism may remain unexplainable right now, however, we think it is the intrinsic nature of the gradient estimation in SNN. Through FDG, we are able to optimize the gradient calculation along with the weights learning. ",
+        "bbox": [
+            176,
+            482,
+            825,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/cbb32f98c9e8e60b4ab37fe6eeffec456f9a770d5e75d61cb0dff82ce30137ae.jpg",
+        "image_caption": [
+            "Figure 5: The evolutution of temperature $^ { b }$ during optimization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            534,
+            745,
+            709
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            755,
+            294,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we inspect the training process of SNN when using the surrogate gradient. The proposed finite difference gradient and Dspike function can be assembled with other optimization methods as a fundamental module of gradient estimation for training SNN. This suggests that the performance of SNN can be further increased when more sophisticated training approaches are integrated with the currently proposed methods in the future. Although the improvement on model performance is very significant, be that as it may, our work is still an extension to the conventional SG. How to efficiently find the best FDG gradient to directly deal with the non-linearity of spiking function still remains a problem. In addition, we only consider the LIF neurons for the analyses here, the efficiency of the proposed approaches on other types of spiking neurons still needs examination in practice. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Filipp Akopyan, Jun Sawada, Andrew Cassidy, Rodrigo Alvarez-Icaza, John Arthur, Paul Merolla, Nabil Imam, Yutaka Nakamura, Pallab Datta, Gi-Joon Nam, et al. Truenorth: Design and tool flow of a 65 mw 1 million neuron programmable neurosynaptic chip. IEEE transactions on computer-aided design of integrated circuits and systems, 34(10):1537–1557, 2015.   \n[2] Mike Davies, Narayan Srinivasa, Tsung-Han Lin, Gautham Chinya, Yongqiang Cao, Sri Harsha Choday, Georgios Dimou, Prasad Joshi, Nabil Imam, Shweta Jain, et al. Loihi: A neuromorphic manycore processor with on-chip learning. IEEE Micro, 38(1):82–99, 2018.   \n[3] Jing Pei, Lei Deng, Sen Song, Mingguo Zhao, Youhui Zhang, Shuang Wu, Guanrui Wang, Zhe Zou, Zhenzhi Wu, Wei He, et al. Towards artificial general intelligence with hybrid tianjic chip architecture. Nature, 572(7767):106–111, 2019.   \n[4] Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, Yuan Xie, and Luping Shi. Direct training for spiking neural networks: Faster, larger, better. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 1311–1318, 2019.   \n[5] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. arXiv preprint arXiv:1912.01703, 2019.   \n[6] James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: composable transformations of Python+NumPy programs, 2018.   \n[7] Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for large-scale machine learning. In 12th {USENIX} symposium on operating systems design and implementation ({OSDI} 16), pages 265–283, 2016.   \n[8] Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks. IEEE Signal Processing Magazine, 36(6):51–63, 2019. [9] Bing Han, Gopalakrishnan Srinivasan, and Kaushik Roy. Rmp-snn: Residual membrane potential neuron for enabling deeper high-accuracy and low-latency spiking neural network. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13558–13567, 2020.   \n[10] Abhronil Sengupta, Yuting Ye, Robert Wang, Chiao Liu, and Kaushik Roy. Going deeper in spiking neural networks: Vgg and residual architectures. Frontiers in Neuroscience, 13:95, 2019.   \n[11] Bodo Rueckauer, Iulia-Alexandra Lungu, Yuhuang Hu, and Michael Pfeiffer. Theory and tools for the conversion of analog to spiking convolutional neural networks. arXiv preprint arXiv:1612.04052, 2016.   \n[12] Bodo Rueckauer, Iulia-Alexandra Lungu, Yuhuang Hu, Michael Pfeiffer, and Shih-Chii Liu. Conversion of continuous-valued deep networks to efficient event-driven networks for image classification. Frontiers in Neuroscience, 11:682, 2017.   \n[13] Bing Han and Kaushik Roy. Deep spiking neural network: Energy efficiency through time based coding. In Proc. IEEE Eur. Conf. Comput. Vis.(ECCV), pages 388–404, 2020.   \n[14] Shikuang Deng and Shi Gu. Optimal conversion of conventional artificial neural networks to spiking neural networks. arXiv preprint arXiv:2103.00476, 2021.   \n[15] Yuhang Li, Shikuang Deng, Xin Dong, Ruihao Gong, and Shi Gu. A free lunch from ann: Towards efficient, accurate spiking neural networks calibration. arXiv preprint arXiv:2106.06984, 2021.   \n[16] Yuhang Li, Xin Dong, and Wei Wang. Additive powers-of-two quantization: An efficient non-uniform discretization for neural networks. arXiv preprint arXiv:1909.13144, 2019.   \n[17] Yuhang Li, Ruihao Gong, Xu Tan, Yang Yang, Peng Hu, Qi Zhang, Fengwei Yu, Wei Wang, and Shi Gu. Brecq: Pushing the limit of post-training quantization by block reconstruction. arXiv preprint arXiv:2102.05426, 2021.   \n[18] Yuhang Li, Mingzhu Shen, Jian Ma, Yan Ren, Mingxin Zhao, Qi Zhang, Ruihao Gong, Fengwei Yu, and Junjie Yan. MQBench: Towards reproducible and deployable model quantization benchmark. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 1), 2021.   \n[19] Hanting Chen, Yunhe Wang, Chunjing Xu, Boxin Shi, Chao Xu, Qi Tian, and Chang Xu. Addernet: Do we really need multiplications in deep learning? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1468–1477, 2020.   \n[20] Arnon Amir, Brian Taba, David Berg, Timothy Melano, Jeffrey McKinstry, Carmelo Di Nolfo, Tapan Nayak, Alexander Andreopoulos, Guillaume Garreau, Marcela Mendoza, et al. A low power, fully event-based gesture recognition system. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7243–7252, 2017.   \n[21] Johanni Brea, Walter Senn, and Jean-Pascal Pfister. Matching recall and storage in sequence learning with spiking neural networks. Journal of neuroscience, 33(23):9565–9575, 2013.   \n[22] Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.   \n[23] Jun Haeng Lee, Tobi Delbruck, and Michael Pfeiffer. Training deep spiking neural networks using backpropagation. Frontiers in Neuroscience, 10:508, 2016.   \n[24] Emre O Neftci, Charles Augustine, Somnath Paul, and Georgios Detorakis. Event-driven random back-propagation: Enabling neuromorphic deep learning machines. Frontiers in Neuroscience, 11:324, 2017.   \n[25] Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, and Luping Shi. Spatio-temporal backpropagation for training high-performance spiking neural networks. Frontiers in Neuroscience, 12:331, 2018.   \n[26] Hanle Zheng, Yujie Wu, Lei Deng, Yifan Hu, and Guoqi Li. Going deeper with directly-trained larger spiking neural networks. arXiv preprint arXiv:2011.05280, 2020.   \n[27] Nitin Rathi and Kaushik Roy. Diet-snn: Direct input encoding with leakage and threshold optimization in deep spiking neural networks. arXiv preprint arXiv:2008.03658, 2020.   \n[28] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.   \n[29] Shibani Santurkar, Dimitris Tsipras, Andrew Ilyas, and Aleksander Madry. How does batch normalization help optimization? arXiv preprint arXiv:1805.11604, 2018.   \n[30] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \n[31] Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In NeurIPS, 2015.   \n[32] Guillaume Bellec, Darjan Salaj, Anand Subramoney, Robert Legenstein, and Wolfgang Maass. Long short-term memory and learning-to-learn in networks of spiking neurons. arXiv preprint arXiv:1803.09574, 2018.   \n[33] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th annual international conference on machine learning, pages 41–48, 2009.   \n[34] Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research).   \n[35] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.   \n[36] Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, and Mu Li. Bag of tricks for image classification with convolutional neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 558–567, 2019.   \n[37] Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018.   \n[38] Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   \n[39] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   \n[40] Nitin Rathi, Gopalakrishnan Srinivasan, Priyadarshini Panda, and Kaushik Roy. Enabling deep spiking neural networks with hybrid conversion and spike timing dependent backpropagation. arXiv preprint arXiv:2005.01807, 2020.   \n[41] Chankyu Lee, Syed Shakib Sarwar, Priyadarshini Panda, Gopalakrishnan Srinivasan, and Kaushik Roy. Enabling spike-based backpropagation for training deep neural network architectures. Frontiers in Neuroscience, 14, 2020.   \n[42] Wenrui Zhang and Peng Li. Temporal spike sequence learning via backpropagation for deep spiking neural networks. arXiv preprint arXiv:2002.10085, 2020.   \n[43] Sen Lu and Abhronil Sengupta. Exploring the connection between binary and spiking neural networks. Frontiers in Neuroscience, 14:535, 2020.   \n[44] Alexander Kugele, Thomas Pfeil, Michael Pfeiffer, and Elisabetta Chicca. Efficient processing of spatio-temporal data streams with spiking neural networks. Frontiers in Neuroscience, 14:439, 2020.   \n[45] Hongmin Li, Hanchao Liu, Xiangyang Ji, Guoqi Li, and Luping Shi. Cifar10-dvs: an eventstream dataset for object classification. Frontiers in Neuroscience, 11:309, 2017. ",
+        "bbox": [
+            171,
+            75,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            75,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            357
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            254,
+            392
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            409,
+            339,
+            422
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] Please see our discussion in Sec. 6   \n(c) Did you discuss any potential negative societal impacts of your work? [No]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            428,
+            825,
+            532
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            536,
+            493,
+            551
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] The proof is available in Sec. 4.3. ",
+        "bbox": [
+            238,
+            555,
+            825,
+            599
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            604,
+            393,
+            619
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Our code will be available in the supplemental.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] All implementations are described in the experiments section.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We report the mean as well as the standard deviation accuracy in CIFAR experiments. For time consideration, we did not run them for ImageNet experiments, the results may be updated in the future.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] The computation resources description is provided in the experiment section. ",
+        "bbox": [
+            238,
+            623,
+            825,
+            796
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            801,
+            823,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We use CIFAR10/100 [34], ImageNet [35], and CIFAR10-DVS [45].   \n(b) Did you mention the license of the assets? [No] We adopt public datasets.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] ",
+        "bbox": [
+            238,
+            820,
+            825,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] ",
+        "bbox": [
+            236,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            123,
+            707,
+            138
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            142,
+            826,
+            232
+        ],
+        "page_idx": 13
+    }
+]

parse/train/R-616EWWKF5/R-616EWWKF5.md

@@ -0,0 +1,235 @@
+# Do Vision Transformers See Like Convolutional Neural Networks?
+
+Maithra Raghu Google Research, Brain Team maithrar@gmail.com
+
+Thomas Unterthiner Google Research, Brain Team unterthiner@google.com
+
+Simon Kornblith Google Research, Brain Team kornblith@google.com
+
+Chiyuan Zhang Google Research, Brain Team chiyuan@google.com
+
+Alexey Dosovitskiy Google Research, Brain Team adosovitskiy@google.com
+
+# Abstract
+
+Convolutional neural networks (CNNs) have so far been the de-facto model for visual data. Recent work has shown that (Vision) Transformer models (ViT) can achieve comparable or even superior performance on image classification tasks. This raises a central question: how are Vision Transformers solving these tasks? Are they acting like convolutional networks, or learning entirely different visual representations? Analyzing the internal representation structure of ViTs and CNNs on image classification benchmarks, we find striking differences between the two architectures, such as ViT having more uniform representations across all layers. We explore how these differences arise, finding crucial roles played by self-attention, which enables early aggregation of global information, and ViT residual connections, which strongly propagate features from lower to higher layers. We study the ramifications for spatial localization, demonstrating ViTs successfully preserve input spatial information, with noticeable effects from different classification methods. Finally, we study the effect of (pretraining) dataset scale on intermediate features and transfer learning, and conclude with a discussion on connections to new architectures such as the MLP-Mixer.
+
+# 1 Introduction
+
+Over the past several years, the successes of deep learning on visual tasks has critically relied on convolutional neural networks [20, 16]. This is largely due to the powerful inductive bias of spatial equivariance encoded by convolutional layers, which have been key to learning general purpose visual representations for easy transfer and strong performance. Remarkably however, recent work has demonstrated that Transformer neural networks are capable of equal or superior performance on image classification tasks at large scale [14]. These Vision Transformers (ViT) operate almost identically to Transformers used in language [13], using self-attention, rather than convolution, to aggregate information across locations. This is in contrast with a large body of prior work, which has focused on more explicitly incorporating image-specific inductive biases [30, 9, 4]
+
+This breakthrough highlights a fundamental question: how are Vision Transformers solving these image based tasks? Do they act like convolutions, learning the same inductive biases from scratch? Or are they developing novel task representations? What is the role of scale in learning these representations? And are there ramifications for downstream tasks? In this paper, we study these questions, uncovering key representational differences between ViTs and CNNs, the ways in which these difference arise, and effects on classification and transfer learning. Specifically, our contributions are:
+
+35th Conference on Neural Information Processing Systems (NeurIPS 2021).
+
+• We investigate the internal representation structure of ViTs and CNNs, finding striking differences between the two models, such as ViT having more uniform representations, with greater similarity between lower and higher layers.   
+• Analyzing how local/global spatial information is utilised, we find ViT incorporates more global information than ResNet at lower layers, leading to quantitatively different features.   
+• Nevertheless, we find that incorporating local information at lower layers remains vital, with large-scale pre-training data helping early attention layers learn to do this   
+• We study the uniform internal structure of ViT, finding that skip connections in ViT are even more influential than in ResNets, having strong effects on performance and representation similarity.   
+• Motivated by potential future uses in object detection, we examine how well input spatial information is preserved, finding connections between spatial localization and methods of classification.   
+• We study the effects of dataset scale on transfer learning, with a linear probes study revealing its importance for high quality intermediate representations.
+
+# 2 Related Work
+
+Developing non-convolutional neural networks to tackle computer vision tasks, particularly Transformer neural networks [44] has been an active area of research. Prior works have looked at local multiheaded self-attention, drawing from the structure of convolutional receptive fields [30, 36], directly combining CNNs with self-attention [4, 2, 46] or applying Transformers to smaller-size images [6, 9]. In comparison to these, the Vision Transformer [14] performs even less modification to the Transformer architecture, making it especially interesting to compare to CNNs. Since its development, there has also been very recent work analyzing aspects of ViT, particularly robustness [3, 31, 28] and effects of self-supervision [5, 7]. Other recent related work has looked at designing hybrid ViT-CNN models [49, 11], drawing on structural differences between the models. Comparison between Transformers and CNNs are also recently studied in the text domain [41].
+
+Our work focuses on the representational structure of ViTs. To study ViT representations, we draw on techniques from neural network representation similarity, which allow the quantitative comparisons of representations within and across neural networks [17, 34, 26, 19]. These techniques have been very successful in providing insights on properties of different vision architectures [29, 22, 18], representation structure in language models [48, 25, 47, 21], dynamics of training methods [33, 24] and domain specific model behavior [27, 35, 38]. We also apply linear probes in our study, which has been shown to be useful to analyze the learned representations in both vision [1] and text [8, 32, 45] models.
+
+# 3 Background and Experimental Setup
+
+Our goal is to understand whether there are differences in the way ViTs represent and solve image tasks compared to CNNs. Based on the results of Dosovitskiy et al. [14], we take a representative set of CNN and ViT models — ResNet50x1, ResNet152x2, ViT-B/32, ViT-B/16, ViT-L/16 and ViT-H/14. Unless otherwise specified, models are trained on the JFT-300M dataset [40], although we also investigate models trained on the ImageNet ILSVRC 2012 dataset [12, 37] and standard transfer learning benchmarks [50, 14]. We use a variety of analysis methods to study the layer representations of these models, gaining many insights into how these models function. We provide further details of the experimental setting in Appendix A.
+
+Representation Similarity and CKA (Centered Kernel Alignment): Analyzing (hidden) layer representations of neural networks is challenging because their features are distributed across a large number of neurons. This distributed aspect also makes it difficult to meaningfully compare representations across neural networks. Centered kernel alignment (CKA) [17, 10] addresses these challenges, enabling quantitative comparisons of representations within and across networks. Specifically, CKA takes as input $\mathbf { X } \in \mathbb { R } ^ { m \times p _ { 1 } }$ and $\mathbf { Y } \in \mathbb { R } ^ { \bar { m } \times p _ { 2 } }$ which are representations (activation matrices), of two layers, with $p _ { 1 }$ and $p _ { 2 }$ neurons respectively, evaluated on the same $m$ examples. Letting $K = X X ^ { \top }$ and $\pmb { L } = \pmb { Y } \pmb { Y } ^ { \top }$ denote the Gram matrices for the two layers (which measures the similarity of a pair of datapoints according to layer representations) CKA computes:
+
+$$
+\operatorname { C K A } ( K , L ) = { \frac { \operatorname { H S I C } ( K , L ) } { \sqrt { \operatorname { H S I C } ( K , K ) \operatorname { H S I C } ( L , L ) } } } ,
+$$
+
+![](images/6c5a9b6bab30d7d98cdfbdbc8c227090753b2fe9a3879c54d415bd98c335c458.jpg)  
+Figure 1: Representation structure of ViTs and convolutional networks show significant differences, with ViTs having highly similar representations throughout the model, while the ResNet models show much lower similarity between lower and higher layers. We plot CKA similarities between all pairs of layers across different model architectures. The results are shown as a heatmap, with the x and y axes indexing the layers from input to output. We observe that ViTs have relatively uniform layer similarity structure, with a clear grid-like pattern and large similarity between lower and higher layers. By contrast, the ResNet models show clear stages in similarity structure, with smaller similarity scores between lower and higher layers.
+
+![](images/8a4393cdf55bae8dbc53a5b8d7bc4fe6b0b545fc47427224ecdfabf1f9bbf2ea.jpg)  
+Figure 2: Cross model CKA heatmap between ViT and ResNet illustrate that a larger number of lower layers in the ResNet are similar to a smaller set of the lowest ViT layers. We compute a CKA heatmap comparing all layers of ViT to all layers of ResNet, for two different ViT models. We observe that the lower half of ResNet layers are similar to around the lowest quarter of ViT layers. The remaining half of the ResNet is similar to approximately the next third of ViT layers, with the highest ViT layers dissimilar to lower and higher ResNet layers.
+
+where HSIC is the Hilbert-Schmidt independence criterion [15]. Given the centering matrix $\begin{array} { r } { \pmb { H } = \pmb { I } _ { n } - \frac { 1 } { n } \pmb { 1 } \pmb { 1 } ^ { \top } } \end{array}$ and the centered Gram matrices $K ^ { \prime } = H K H$ and $L ^ { \prime } = H L H$ , $\mathrm { H S I C } ( \bar { K } , L ) =$ $\mathrm { v e c } ( K ^ { \prime } ) \cdot \mathrm { v e c } ( L ^ { \prime } ) / ( m - 1 ) ^ { 2 }$ , the similarity between these centered Gram matrices. CKA is invariant to orthogonal transformation of representations (including permutation of neurons), and the normalization term ensures invariance to isotropic scaling. These properties enable meaningful comparison and analysis of neural network hidden representations. To work at scale with our models and tasks, we approximate the unbiased estimator of HSIC [39] using minibatches, as suggested in [29].
+
+# 4 Representation Structure of ViTs and Convolutional Networks
+
+We begin our investigation by using CKA to study the internal representation structure of each model. How are representations propagated within the two architectures, and are there signs of functional differences? To answer these questions, we take every pair of layers $X , Y$ within a model and compute their CKA similarity. Note that we take representations not only from outputs of ViT/ResNet blocks, but also from intermediate layers, such as normalization layers and the hidden activations inside a ViT MLP. Figure 1 shows the results as a heatmap, for multiple ViTs and ResNets. We observe clear differences between the internal representation structure between the two model architectures: (1) ViTs show a much more uniform similarity structure, with a clear grid like structure (2) lower and higher layers in ViT show much greater similarity than in the ResNet, where similarity is divided into different (lower/higher) stages.
+
+We also perform cross-model comparisons, where we take all layers $\boldsymbol { X }$ from ViT and compare to all layers $\mathbf { Y }$ from ResNet. We observe (Figure 2) that the lower half of 60 ResNet layers are similar to approximately the lowest quarter of ViT layers. In particular, many more lower layers in the ResNet are needed to compute similar representations to the lower layers of ViT. The top half of the ResNet is approximately similar to the next third of the ViT layers. The final third of ViT layers is less similar to all ResNet layers, likely because this set of layers mainly manipulates the CLS token representation, further studied in Section 6.
+
+![](images/386cf223d2ffbb35198c4009d6b4a85458145d4f75ffea87e1a006a2a358ffcf.jpg)  
+Figure 3: Plotting attention head mean distances shows lower ViT layers attend both locally and globally, while higher layers primarily incorporate global information. For each attention head, we compute the pixel distance it attends to, weighted by the attention weights, and then average over 5000 datapoints to get an average attention head distance. We plot the heads sorted by their average attention distance for the two lowest and two highest layers in the ViT, observing that the lower layers attend both locally and globally, while the higher layers attend entirely globally.
+
+Taken together, these results suggest that (i) ViT lower layers compute representations in a different way to lower layers in the ResNet, (ii) ViT also more strongly propagates representations between lower and higher layers (iii) the highest layers of ViT have quite different representations to ResNet.
+
+# 5 Local and Global Information in Layer Representations
+
+In the previous section, we observed much greater similarity between lower and higher layers in ViT, and we also saw that ResNet required more lower layers to compute similar representations to a smaller set of ViT lower layers. In this section, we explore one possible reason for this difference: the difference in the ability to incorporate global information between the two models. How much global information is aggregated by early self-attention layers in ViT? Are there noticeable resulting differences to the features of CNNs, which have fixed, local receptive fields in early layers? In studying these questions, we demonstrate the influence of global representations and a surprising connection between scale and self-attention distances.
+
+Analyzing Attention Distances: We start by analyzing ViT self-attention layers, which are the mechanism for ViT to aggregate information from other spatial locations, and structurally very different to the fixed receptive field sizes of CNNs. Each self-attention layer comprises multiple self-attention heads, and for each head we can compute the average distance between the query patch position and the locations it attends to. This reveals how much local vs global information each self-attention layer is aggregating for the representation. Specifically, we weight the pixel distances by the attention weights for each attention head and average over 5000 datapoints, with results shown in Figure 3. In agreement with Dosovitskiy et al. [14], we observe that even in the lowest layers of ViT, self-attention layers have a mix of local heads (small distances) and global heads (large distances). This is in contrast to CNNs, which are hardcoded to attend only locally in the lower layers. At higher layers, all self-attention heads are global.
+
+Interestingly, we see a clear effect of scale on attention. In Figure 4, we look at attention distances when training only on ImageNet (no large-scale pre-training), which leads to much lower performance in ViT-L/16 and ViT-H/14 [14]. Comparing to Figure 3, we see that with not enough data, ViT does not learn to attend locally in earlier layers. Together, this suggests that using local information early on for image tasks (which is hardcoded into CNN architectures) is important for strong performance.
+
+Does access to global information result in different features? The results of Figure 3 demonstrate that ViTs have access to more global information than CNNs in their lower layers. But does this result in different learned features? As an interventional test, we take subsets of the ViT attention heads from the first encoder block, ranging from the subset corresponding to the most local attention heads to a subset of the representation corresponding to the most global attention heads. We then compute CKA similarity between these subsets and the lower layer representations of ResNet.
+
+![](images/3e35bf39b04f38b85758bdc7dde0ef4f00adc22579434f00626ddb89b2b308a2.jpg)  
+Figure 4: With less training data, lower attention layers do not learn to attend locally. Comparing the results to Figure 3, we see that training only on ImageNet leads to the lower layers not learning to attend more locally. These models also perform much worse when only trained on ImageNet, suggesting that incorporating local features (which is hardcoded into CNNs) may be important for strong performance. (See also Figure C.5.)
+
+![](images/b50de76cabe93c93d104733399583c33ea0cff5a1f97fe5aaa2edc900e257f5b.jpg)  
+Figure 5: Lower layer representations of ResNet are most similar to representations corresponding to local attention heads of ViT. We take subsets of ViT attention heads in the first encoder block, ranging from the most locally attending heads (smallest mean distance) to the most global heads (largest mean distance). We then compute CKA similarity between these subsets and lower layer representations in the ResNet. We observe that lower ResNet layers are most similar to the features learned by local attention heads of ViT, and decrease monotonically in similarity as more global information is incorporated, demonstrating that the global heads learn quantitatively different features.
+
+The results, shown in Figure 5, which plot the mean distance for each subset against CKA similarity, clearly show a monotonic decrease in similarity as mean attention distance grows, demonstrating that access to more global information also leads to quantitatively different features than computed by the local receptive fields in the lower layers of the ResNet.
+
+Effective Receptive Fields: We conclude by computing effective receptive fields [23] for both ResNets and ViTs, with results in Figure 6 and Appendix C. We observe that lower layer effective receptive fields for ViT are indeed larger than in ResNets, and while ResNet effective receptive fields grow gradually, ViT receptive fields become much more global midway through the network. ViT receptive fields also show strong dependence on their center patch due to their strong residual connections, studied in the next section. As we show in Appendix C, in attention sublayers, receptive fields taken before the residual connection show far less dependence on this central patch.
+
+# 6 Representation Propagation through Skip Connections
+
+The results of the previous section demonstrate that ViTs learn different representations to ResNets in lower layers due to access to global information, which explains some of the differences in represen tation structure observed in Section 4. However, the highly uniform nature of ViT representations (Figure 1) also suggests lower representations are faithfully propagated to higher layers. But how does this happen? In this section, we explore the role of skip connections in representation propagation across ViTs and ResNets, discovering ViT skip connections are highly influential, with a clear phase transition from preserving the CLS (class) token representation (in lower layers) to spatial token representations (in higher layers).
+
+![](images/9a061c043fa6a16a6fb6148580ad5f97d001bbc7aadf155ecf3200d8d3560545.jpg)  
+  
+Figure 7: Most information in ViT passes through skip connections. Comparison of representation norms between the skip-connection (identity) and the long branch for ViT-B/16 trained on ImageNet and a ResNet. For ViT, we show the CLS token separately from the rest of the representation. (left) shows the ratios separated for the first few tokens (token 0 is CLS), (right) shows averages over all tokens.
+
+Like Transformers, ViTs contain skip (aka identity or shortcut) connections throughout, which are added on after the (i) self-attention layer, and (ii) MLP layer. To study their effect, we plot the norm ratio $\vert \vert z _ { i } \vert \vert / \vert \vert f ( z _ { i } ) \vert \vert$ where $z _ { i }$ is the hidden representation of the ith layer coming from the skip connection, and $f ( z _ { i } )$ is the transformation of $z _ { i }$ from the long branch (i.e. MLP or self-attention.)
+
+The results are in Figure 7 (with additional cosine similarity analysis in Figure E.2.) The heatmap on the left shows $\| z _ { i } \| / \| f ( z _ { i } ) \|$ for different token representations. We observe a striking phase transition: in the first half of the network, the CLS token (token 0) representation is primarily propagated by the skip connection branch (high norm ratio), while the spatial token representations have a large contribution coming from the long branch (lower norm ratio). Strikingly, in the second half of the network, this is reversed.
+
+The right pane, which has line plots of these norm ratios across ResNet50, the ViT CLS token and the ViT spatial tokens additionally demonstrates that skip connection is much more influential in ViT compared to ResNet: we observe much higher norm ratios for ViT throughout, along with the phase transition from CLS to spatial token propagation (shown for the MLP and self-attention layers.)
+
+ViT Representation Structure without Skip Connections: The norm ratio results strongly suggest that skip connections play a key role in the representational structure of ViT. To test this interventionally, we train ViT models with skip connections removed in block $i$ for varying $i$ , and plot the CKA representation heatmap. The results, in Figure 8, illustrate that removing the skip connections in a block partitions the layer representations on either side. (We note a performance drop of $4 \%$ when removing skip connections from middle blocks.) This demonstrates the importance of representations being propagated by skip connections for the uniform similarity structure of ViT in Figure 1.
+
+![](images/9b62311e77302ff7ef59a66afb9f1da37e84703cc6a2b2c790b1d5ecf845180d.jpg)  
+Figure 8: ViT models trained without any skip connections in block $_ { i }$ show very little representation similarity between layers before/after block $_ { i }$ . We train several ViT models without any skip connections at block $_ { i }$ for varying $_ { i }$ to interventionally test the effect on representation structure. For middle blocks without skip connections, we observe a performance drop of $4 \%$ . We also observe that removing a skip connection at block $i$ partitions similar representations to before/after block $_ { i }$ — this demonstrates the importance of skip connections in ViT’s standard uniform representation structure.
+
+![](images/662f361e4843c907fbb6de40fb853fe028d23912e05dc0d404aafad244aa59bb.jpg)  
+ViT-B/32 final block Token at Location(0, 0) Token at Location(2, 1) Token at Location(4, 2) Token at Location(4, 4)   
+Figure 9: Higher layers of ViT maintain spatial location information more faithfully than ResNets. Each heatmap plot shows the CKA similarity between a single token representation in final block of the model and the input images, which are divided into non-overlapping patches. We observe that ViT tokens have strongest similarity to their corresponding spatial location in the image, but tokens corresponding to spatial locations at the edge of the image (e.g. token 0) additionally show similarity to other edge positions. This demonstrates that spatial information from the input is preserved even at the final layer of ViT. By contrast, ResNet “tokens” (features at a specific spatial location) are much less spatially discriminative, showing comparable similarity across a broad set of input spatial locations. See Appendix for additional layers and results.
+
+# 7 Spatial Information and Localization
+
+The results so far, on the role of self-attention in aggregating spatial information in ViTs, and skipconnections faithfully propagating representations to higher layers, suggest an important followup question: how well can ViTs perform spatial localization? Specifically, is spatial information from the input preserved in the higher layers of ViT? And how does it compare in this aspect to ResNet? An affirmative answer to this is crucial for uses of ViT beyond classification, such as object detection.
+
+![](images/432c77b207c0b6573a8801829a2edb45dffeed4ebea0d9b3aebcd4620aeb6b23.jpg)  
+Figure 10: When trained with global average pooling (GAP) instead of a CLS token, ViTs show less clear localization (compare Figure 9). We plot the same CKA heatmap between a token and different input images patches as in Figure 9, but for a ViT model trained with global average pooling (like ResNet) instead of a CLS token. We observe significantly less localization.
+
+![](images/4242cbfab2085256e8701780af666b8dac30524eed706bbb422c4fa5623e85d3.jpg)  
+Figure 11: Spatial localization experiments with linear probes. We train linear classifiers on 10-shot ImageNet classification from the representations extracted from different layers of ViT-B/32 models. We then plot the accuracy of the probe versus the (normalized) layer number. Left: We train a classifier on each token separately and report the average accuracy over all tokens (excluding the CLS token for the ViT CLS model.) Right: Comparison of ViT models pre-trained with a classification token or with global average pooling (GAP) and then evaluated with different ways of aggregating the token representations.
+
+We begin by comparing token representations in the higher layers of ViT and ResNet to those of input patches. Recall that ViT tokens have a corresponding input patch, and thus a corresponding input spatial location. For ResNet, we define a token representation to be all the convolutional channels at a particular spatial location. This also gives it a corresponding input spatial location. We can then take a token representation and compute its CKA score with input image patches at different locations. The results are illustrated for different tokens (with their spatial locations labelled) in Figure 9.
+
+For ViT, we observe that tokens corresponding to locations at the edge of the image are similar to edge image patches, but tokens corresponding to interior locations are well localized, with their representations being most similar to the corresponding image patch. By contrast, for ResNet, we see significantly weaker localization (though Figure D.3 shows improvements for earlier layers.)
+
+One factor influencing this clear difference between architectures is that ResNet is trained to classify with a global average pooling step, while ViT has a separate classification (CLS) token. To examine this further, we test a ViT architecture trained with global average pooling (GAP) for localization (see Appendix A for training details). The results, shown in Figure 10, demonstrate that global average pooling does indeed reduce localization in the higher layers. More results in Appendix Section D.
+
+Localization and Linear Probe Classification: The previous results have looked at localization through direct comparison of each token with input patches. To complete the picture, we look at using each token separately to perform classification with linear probes. We do this across different layers of the model, training linear probes to classify image label with closed-form few-shot linear regression similar to Dosovitskiy et al. [14] (details in Appendix A). Results are in Figure 11, with further results in Appendix F. The left pane shows average accuracy of classifiers trained on individual tokens, where we see that ResNet50 and ViT with GAP model tokens perform well at higher layers, while in the standard ViT trained with a CLS token the spatial tokens do poorly – likely because their representations remain spatially localized at higher layers, which makes global classification challenging. Supporting this are results on the right pane, which shows that a single token from the
+
+![](images/37a3520a72f917ad75d6afc376cbe417d5caefc64c20aab034592ff4aee318cf.jpg)  
+Figure 12: Measuring similarity of representations learned with varying amounts of data shows the importance of large datasets for higher layers and larger model representations. We compute the similarity of representations at each block for ViT models that have been trained on smaller subsets of the data to a model that has been trained on the full data on ViT-L/16 (left) and ViT-B/32 (right). We observe that while lower layer representations have high similarity even with $1 0 \%$ of the data, higher layers and larger models require significantly more data to learn similar representations.
+
+![](images/c97923c1aa3f362a320d1633b6d95d1e61546552b5c9a331942efa2cc1c3dcde.jpg)  
+Figure 13: Experiments with linear probes. We train linear classifiers on 10-shot ImageNet classification from the aggregated representations of different layers of different models. We then plot the accuracy of the probe versus the (normalized) layer number. Left: Comparison of ViTs pre-trained on JFT-300M or ImageNet and evaluated with linear probes on Imagenet. Right: Comparison of ViT and ResNet models trained JFT- $3 0 0 \mathrm { m }$ evaluated with linear probes on ImageNet.
+
+ViT-GAP model achieves comparable accuracy in the highest layer to all tokens pooled together. With the results of Figure 9, this suggests all higher layer tokens in GAP models learn similar (global) representations.
+
+# 8 Effects of Scale on Transfer Learning
+
+Motivated by the results of Dosovitskiy et al. [14] that demonstrate the importance of dataset scale for high performing ViTs, and our earlier result (Figure 4) on needing scale for local attention, we perform a study of the effect of dataset scale on representations in transfer learning.
+
+We begin by studying the effect on representations as the JFT-300M pretraining dataset size is varied. Figure 12 illustrates the results on ViT-B/32 and ViT-L/16. Even with $3 \%$ of the entire dataset, lower layer representations are very similar to the model trained on the whole dataset, but higher layers require larger amounts of pretraining data to learn the same representations as at large data scale, especially with the large model size. In Section G, we study how much representations change in finetuning, finding heterogeneity over datasets.
+
+We next look at dataset size effect on the larger ViT-L/16 and ViT-H/14 models. Specifically, in the left pane of Figure 13, we train linear classifer probes on ImageNet classes for models pretrained on JFT-300M vs models only pretrained on ImageNet. We observe the JFT-300M pretained models achieve much higher accuracies even with middle layer representations, with a $3 0 \%$ gap in absolute accuracy to the models pretrained only on ImageNet. This suggests that for larger models, the larger dataset is especially helpful in learning high quality intermediate representations. This conclusion is further supported by the results of the right pane of Figure 13, which shows linear probes on different ResNet and ViT models, all pretrained on JFT-300M. We again see the larger ViT models learn much stronger intermediate representations than the ResNets. Additional linear probes experiments in Section F demonstrate this same conclusion for transfer to CIFAR-10 and CIFAR-100.
+
+# 9 Discussion
+
+Limitations: Our study uses CKA [17], which summarizes measurements into a single scalar, to provide quantitative insights on representation similarity. While we have complemented this with interventional tests and other analyses (e.g. linear probes), more fine-grained methods may reveal additional insights and variations in the representations.
+
+Conclusion: Given the central role of convolutional neural networks in computer vision breakthroughs, it is remarkable that Transformer architectures (almost identical to those used in language) are capable of similar performance. This raises fundamental questions on whether these architectures work in the same way as CNNs. Drawing on representational similarity techniques, we find surprisingly clear differences in the features and internal structures of ViTs and CNNs. An analysis of self-attention and the strength of skip connections demonstrates the role of earlier global features and strong representation propagation in ViTs for these differences, while also revealing that some CNN properties, e.g. local information aggregation at lower layers, are important to ViTs, being learned from scratch at scale. We examine the potential for ViTs to be used beyond classification through a study of spatial localization, discovering ViTs with CLS tokens show strong preservation of spatial information — promising for future uses in object detection. Finally, we investigate the effect of scale for transfer learning, finding larger ViT models develop significantly stronger intermediate representations through larger pretraining datasets. These results are also very pertinent to understanding MLP-based architectures for vision proposed by concurrent work [42, 43], further discussed in Section H, and together answer central questions on differences between ViTs and CNNs, and suggest new directions for future study. From the perspective of societal impact, these findings and future work may help identify potential failures as well as greater model interpretability.
+
+# References
+
+[1] G. Alain and Y. Bengio. Understanding intermediate layers using linear classifier probes. arXiv preprint arXiv:1610.01644, 2016.   
+[2] I. Bello, B. Zoph, A. Vaswani, J. Shlens, and Q. V. Le. Attention augmented convolutional networks. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 3286–3295, 2019.   
+[3] S. Bhojanapalli, A. Chakrabarti, D. Glasner, D. Li, T. Unterthiner, and A. Veit. Understanding robustness of transformers for image classification. arXiv preprint arXiv:2103.14586, 2021.   
+[4] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pages 213–229. Springer, 2020.   
+[5] M. Caron, H. Touvron, I. Misra, H. Jégou, J. Mairal, P. Bojanowski, and A. Joulin. Emerging properties in self-supervised vision transformers. arXiv preprint arXiv:2104.14294, 2021.   
+[6] M. Chen, A. Radford, R. Child, J. Wu, H. Jun, D. Luan, and I. Sutskever. Generative pretraining from pixels. In International Conference on Machine Learning, pages 1691–1703. PMLR, 2020.   
+[7] X. Chen, S. Xie, and K. He. An empirical study of training self-supervised vision transformers. arXiv preprint arXiv:2104.02057, 2021.   
+[8] A. Conneau, G. Kruszewski, G. Lample, L. Barrault, and M. Baroni. What you can cram into a single vector: Probing sentence embeddings for linguistic properties. In ACL, 2018.   
+[9] J.-B. Cordonnier, A. Loukas, and M. Jaggi. On the relationship between self-attention and convolutional layers. arXiv preprint arXiv:1911.03584, 2019.   
+[10] C. Cortes, M. Mohri, and A. Rostamizadeh. Algorithms for learning kernels based on centered alignment. The Journal of Machine Learning Research, 13(1):795–828, 2012.   
+[11] S. d’Ascoli, H. Touvron, M. Leavitt, A. Morcos, G. Biroli, and L. Sagun. Convit: Improving vision transformers with soft convolutional inductive biases. arXiv preprint arXiv:2103.10697, 2021.   
+[12] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248–255. Ieee, 2009.   
+[13] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   
+[14] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+[15] A. Gretton, K. Fukumizu, C. H. Teo, L. Song, B. Schölkopf, A. J. Smola, et al. A kernel statistical test of independence. In Nips, volume 20, pages 585–592. Citeseer, 2007.   
+[16] A. Kolesnikov, L. Beyer, X. Zhai, J. Puigcerver, J. Yung, S. Gelly, and N. Houlsby. Big transfer (bit): General visual representation learning. arXiv preprint arXiv:1912.11370, 6(2):8, 2019.   
+[17] S. Kornblith, M. Norouzi, H. Lee, and G. Hinton. Similarity of neural network representations revisited. In ICML, 2019.   
+[18] S. Kornblith, H. Lee, T. Chen, and M. Norouzi. What’s in a loss function for image classification? arXiv preprint arXiv:2010.16402, 2020.   
+[19] N. Kriegeskorte, M. Mur, and P. A. Bandettini. Representational similarity analysis-connecting the branches of systems neuroscience. Frontiers in systems neuroscience, 2:4, 2008.   
+[20] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25:1097–1105, 2012.   
+[21] S. R. Kudugunta, A. Bapna, I. Caswell, N. Arivazhagan, and O. Firat. Investigating multilingual nmt representations at scale. arXiv preprint arXiv:1909.02197, 2019.   
+[22] G. W. Lindsay. Convolutional neural networks as a model of the visual system: past, present, and future. Journal of cognitive neuroscience, pages 1–15, 2020.   
+[23] W. Luo, Y. Li, R. Urtasun, and R. Zemel. Understanding the effective receptive field in deep convolutional neural networks. arXiv preprint arXiv:1701.04128, 2017.   
+[24] N. Maheswaranathan, A. H. Williams, M. D. Golub, S. Ganguli, and D. Sussillo. Universality and individuality in neural dynamics across large populations of recurrent networks. Advances in neural information processing systems, 2019:15629, 2019.   
+[25] A. Merchant, E. Rahimtoroghi, E. Pavlick, and I. Tenney. What happens to bert embeddings during fine-tuning? arXiv preprint arXiv:2004.14448, 2020.   
+[26] A. S. Morcos, M. Raghu, and S. Bengio. Insights on representational similarity in neural networks with canonical correlation. arXiv preprint arXiv:1806.05759, 2018.   
+[27] B. Mustafa, A. Loh, J. Freyberg, P. MacWilliams, M. Wilson, S. M. McKinney, M. Sieniek, J. Winkens, Y. Liu, P. Bui, et al. Supervised transfer learning at scale for medical imaging. arXiv preprint arXiv:2101.05913, 2021.   
+[28] M. Naseer, K. Ranasinghe, S. Khan, M. Hayat, F. S. Khan, and M.-H. Yang. Intriguing properties of vision transformers, 2021.   
+[29] T. Nguyen, M. Raghu, and S. Kornblith. Do wide and deep networks learn the same things? uncovering how neural network representations vary with width and depth. arXiv preprint arXiv:2010.15327, 2020.   
+[30] N. Parmar, A. Vaswani, J. Uszkoreit, L. Kaiser, N. Shazeer, A. Ku, and D. Tran. Image transformer. In International Conference on Machine Learning, pages 4055–4064. PMLR, 2018.   
+[31] S. Paul and P.-Y. Chen. Vision transformers are robust learners. arXiv preprint arXiv:2105.07581, 2021.   
+[32] M. E. Peters, M. Neumann, L. Zettlemoyer, and W.-t. Yih. Dissecting contextual word embeddings: Architecture and representation. In EMNLP, 2018.   
+[33] A. Raghu, M. Raghu, S. Bengio, and O. Vinyals. Rapid learning or feature reuse? towards understanding the effectiveness of maml. arXiv preprint arXiv:1909.09157, 2019.   
+[34] M. Raghu, J. Gilmer, J. Yosinski, and J. Sohl-Dickstein. Svcca: Singular vector canonical correlation analysis for deep learning dynamics and interpretability. arXiv preprint arXiv:1706.05806, 2017.   
+[35] M. Raghu, C. Zhang, J. Kleinberg, and S. Bengio. Transfusion: Understanding transfer learning for medical imaging. arXiv preprint arXiv:1902.07208, 2019.   
+[36] P. Ramachandran, N. Parmar, A. Vaswani, I. Bello, A. Levskaya, and J. Shlens. Stand-alone self-attention in vision models. arXiv preprint arXiv:1906.05909, 2019.   
+[37] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.   
+[38] J. Shi, E. Shea-Brown, and M. Buice. Comparison against task driven artificial neural networks reveals functional properties in mouse visual cortex. Advances in Neural Information Processing Systems, 32:5764–5774, 2019.   
+[39] L. Song, A. Smola, A. Gretton, J. Bedo, and K. Borgwardt. Feature selection via dependence maximization. Journal of Machine Learning Research, 13(5), 2012.   
+[40] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In Proceedings of the IEEE international conference on computer vision, pages 843–852, 2017.   
+[41] Y. Tay, M. Dehghani, J. Gupta, D. Bahri, V. Aribandi, Z. Qin, and D. Metzler. Are pre-trained convolutions better than pre-trained transformers? arXiv preprint arXiv:2105.03322, 2021.   
+[42] I. Tolstikhin, N. Houlsby, A. Kolesnikov, L. Beyer, X. Zhai, T. Unterthiner, J. Yung, D. Keysers, J. Uszkoreit, M. Lucic, et al. Mlp-mixer: An all-mlp architecture for vision. arXiv preprint arXiv:2105.01601, 2021.   
+[43] H. Touvron, P. Bojanowski, M. Caron, M. Cord, A. El-Nouby, E. Grave, A. Joulin, G. Synnaeve, J. Verbeek, and H. Jégou. Resmlp: Feedforward networks for image classification with dataefficient training. arXiv preprint arXiv:2105.03404, 2021.   
+[44] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017.   
+[45] E. Voita, R. Sennrich, and I. Titov. The bottom-up evolution of representations in the transformer: A study with machine translation and language modeling objectives. In EMNLP, 2019.   
+[46] B. Wu, C. Xu, X. Dai, A. Wan, P. Zhang, Z. Yan, M. Tomizuka, J. Gonzalez, K. Keutzer, and P. Vajda. Visual transformers: Token-based image representation and processing for computer vision. arXiv preprint arXiv:2006.03677, 2020.   
+[47] J. M. Wu, Y. Belinkov, H. Sajjad, N. Durrani, F. Dalvi, and J. Glass. Similarity analysis of contextual word representation models. arXiv preprint arXiv:2005.01172, 2020.   
+[48] S. Wu, A. Conneau, H. Li, L. Zettlemoyer, and V. Stoyanov. Emerging cross-lingual structure in pretrained language models. arXiv preprint arXiv:1911.01464, 2019.   
+[49] L. Yuan, Y. Chen, T. Wang, W. Yu, Y. Shi, Z. Jiang, F. E. Tay, J. Feng, and S. Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. arXiv preprint arXiv:2101.11986, 2021.   
+[50] X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, et al. The visual task adaptation benchmark. 2019.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 9   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] Where possible, we show variation arising from different sampling aspects, be that dataset samples or model runs. Note that for some of the pretrained models, we only have access to one pretrained checkpoint, and so we show results across multiple model architectures to demonstrate the results hold more broadly.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/S1erHoR5t7/S1erHoR5t7.md

@@ -0,0 +1,592 @@
+# THE RELATIVISTIC DISCRIMINATOR: A KEY ELEMENT MISSING FROM STANDARD GAN
+
+Alexia Jolicoeur-Martineau   
+Lady Davis Institute   
+MILA, Université de Montréal   
+Montreal, Canada   
+alexia.jolicoeur-martineau@mail.mcgill.ca
+
+# ABSTRACT
+
+In standard generative adversarial network (SGAN), the discriminator $D$ estimates the probability that the input data is real. The generator $G$ is trained to increase the probability that fake data is real. We argue that it should also simultaneously decrease the probability that real data is real because 1) this would account for $a$ priori knowledge that half of the data in the mini-batch is fake, 2) this would be observed with divergence minimization, and 3) SGAN would be more similar to integral probability metric (IPM) GANs.
+
+We show that this property can be induced by using a “relativistic discriminator” which estimate the probability that the given real data is more realistic than a randomly sampled fake data. We also present a variant in which the discriminator estimate the probability that the given real data is more realistic than fake data, on average. We generalize both approaches to non-standard GAN loss functions and we refer to them respectively as Relativistic GANs (RGANs) and Relativistic average GANs (RaGANs). We show that IPM-based GANs are a subset of RGANs which use the identity function.
+
+Empirically, we observe that 1) RGANs and RaGANs are significantly more stable and generate higher quality data samples than their non-relativistic counterparts, 2) Standard RaGAN with gradient penalty generate data of better quality than WGAN-GP while only requiring a single discriminator update per generator update (reducing the time taken for reaching the state-of-the-art by $400 \%$ ), and 3) RaGANs are able to generate plausible high resolutions images (256x256) from a very small sample $\scriptstyle ( \mathrm { N } = 2 0 1 1$ ), while GAN and LSGAN cannot; these images are of significantly better quality than the ones generated by WGAN-GP and SGAN with spectral normalization.
+
+The code is freely available on https://github.com/AlexiaJM/RelativisticGAN.
+
+# 1 INTRODUCTION
+
+Generative adversarial networks (GANs) (Hong et al., 2017) form a broad class of generative models in which a game is played between two competing neural networks, the discriminator $D$ and the generator $G$ . $D$ is trained to discriminate real from fake data, while $G$ is trained to generate fake data that $D$ will mistakenly recognize as real. In the original GAN by Goodfellow et al. (2014), which we refer to as Standard GAN (SGAN), $D$ is a classifier, thus it is predicting the probability that the input data is real. When $D$ is optimal, the loss function of SGAN is approximately equal to the Jensen–Shannon divergence (JSD) (Goodfellow et al., 2014).
+
+SGAN has two variants for the generator loss functions: saturating and non-saturating. In practice, the former has been found to be very unstable, while the latter has been found to more stable (Goodfellow et al., 2014). Under certain conditions, Arjovsky & Bottou (2017) proved that, if real and fake data are perfectly classified, the saturating loss has zero gradient and the non-saturating loss has non-zero, but volatile gradient. In practice, this means that the discriminator in SGAN often cannot be trained to optimality or with a too high learning rate; otherwise, gradients may vanish and, if so, training will stop. This problem is generally more noticeable in high-dimensional setting (e.g., high resolution images and discriminator architectures with high expressive power) given that there are enough degrees of freedom available to perfectly classify the training set.
+
+To improve on SGAN, many GAN variants have been suggested using different loss functions and discriminators that are not classifiers (e.g., LSGAN (Mao et al., 2017), WGAN (Arjovsky et al., 2017)). Although these approaches have partially succeeded in improving stability and data quality, the large-scale study by Lucic et al. (2017) suggests that these approaches do not consistently improve on SGAN. Additionally, some of the most successful approaches, such as WGAN-GP (Gulrajani et al., 2017), are much more computationally demanding than SGAN.
+
+Many of the recent successful GANs variants have been based on Integral probability metrics (IPMs) (Müller, 1997) (e.g., WGAN , WGAN-GP, Fisher GAN (Mroueh & Sercu, 2017), Sobolev GAN (Mroueh et al., 2017)). In IPM-based GANs, the discriminator is real-valued and constrained to a specific class of function which regularize the discriminator. See Mroueh et al. (2017) for a review of the different IPMs.
+
+These IPM constraints have been shown to be beneficial even in non-IPM based GANs. Spectral normalization (Miyato et al., 2018) improves the stability of various GANs and it consists in making the discriminator Lipschitz-1, which is the constraint of WGAN. Similarly, the gradient penalty of WGAN-GP also provides improve the stability of SGAN (Fedus et al., 2017). Although this shows that certain IPM constraints improve the stability of GANs, it does not explain why IPM-based GANs generally provide increased stability over other metrics/divergences in GANs (e.g., JSD for SGAN, $f$ -divergences for $f$ -GANs (Nowozin et al., 2016)).
+
+Note that although powerful, IPM-based GANs tend to more computationally demanding than other GANs. Certain IPM-based GANs use a gradient penalty (e.g. WGAN-GP, Sobolev GAN) which is very computationally costly and most IPM-based GANs need more than one discriminator update per generator update (WGAN-GP requires at least 5 (Gulrajani et al., 2017)). Assuming equal training time for $D$ and $G$ , every additional discriminator update increase training time by a significant $50 \%$ .
+
+In this paper, we argue that non-IPM-based GANs are missing a key ingredient, a relativistic discriminator, which IPM-based GANs already possess. We show that a relativistic discriminator is necessary to make GANs analogous to divergence minimization and produce sensible predictions based on the a priori knowledge that half of the samples in the mini-batch are fake. We provide empirical evidence showing that GANs with a relativistic discriminator are more stable and produce data of higher quality.
+
+# 2 BACKGROUND
+
+# 2.1 GENERATIVE ADVERSARIAL NETWORKS
+
+GANs can be defined very generally in terms of the discriminator in the following way:
+
+$$
+{ \cal L } _ { D } = \mathbb { E } _ { \boldsymbol { x } _ { r } \sim \mathbb { P } } \left[ \tilde { f } _ { 1 } ( D ( \boldsymbol { x } _ { r } ) ) \right] + \mathbb { E } _ { \boldsymbol { z } \sim \mathbb { P } _ { z } } \left[ \tilde { f } _ { 2 } ( D ( G ( \boldsymbol { z } ) ) ) \right] ,
+$$
+
+and
+
+$$
+L _ { G } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \tilde { g } _ { 1 } ( D ( x _ { r } ) ) \right] + \mathbb { E } _ { z \sim \mathbb { P } _ { z } } \left[ \tilde { g } _ { 2 } ( D ( G ( z ) ) ) \right] ,
+$$
+
+where $\tilde { f } _ { 1 } , \tilde { f } _ { 2 } , \tilde { g } _ { 1 } , \tilde { g } _ { 2 }$ are scalar-to-scalar functions, $\mathbb { P }$ is the distribution of real data, $\mathbb { P } _ { z }$ is generally a multivariate normal distribution centered at 0 with variance 1, $D ( x )$ is the discriminator evaluated at $x$ , $G ( z )$ is the generator evaluated at $\mathbf { Z }$ ( $\mathbb { Q }$ is the distribution of fake data, thus of $G ( z ) _ { , }$ ). Note that, through the paper, we refer to real data as $x _ { r }$ and fake data as $x _ { f }$ . Without loss of generality, we assume that both $L _ { D }$ and $L _ { G }$ are loss functions to be minimized.
+
+Most GANs can be separated into two classes: non-saturating and saturating loss functions. GANs with the saturating loss are such that $\tilde { g } _ { 1 } = - \tilde { f } _ { 1 }$ and $\tilde { g } _ { 2 } { = } { - } \tilde { f } _ { 2 }$ , while GANs with the non-saturating loss are such that $\tilde { g } _ { 1 } { = } \tilde { \tilde { f } _ { 2 } }$ and $\tilde { g } _ { 2 } { = } \tilde { f } _ { 1 }$ . Saturating GANs are intuitive as they can be interpreted as alternating between maximizing and minimizing the same loss function. After training $D$ to optimality, the loss function is generally an approximation of a divergence (e.g., Jensen–Shannon divergence (JSD) for SGAN (Goodfellow et al., 2014), $f$ -divergences for F-GANs (Nowozin et al., 2016), and Wassertein distance for WGAN (Arjovsky et al., 2017)). Thus, training $G$ to minimize $L _ { G }$ can be roughly interpreted as minimizing the approximated divergence (although this is not technically true; see
+
+Jolicoeur-Martineau (2018)). On the other hand, non-saturating GANs can be thought as optimizing the same loss function, but swapping real data with fake data (and vice-versa). In this article, unless otherwise specified, we assume a non-saturating loss for all GANs.
+
+SGAN assumes a cross-entropy loss, i.e., $\tilde { f } _ { 1 } ( D ( x ) ) = - \log ( D ( x ) )$ and $\tilde { f } _ { 2 } ( D ( x ) ) = - \log ( 1 -$ $D ( x ) )$ , where $D ( x ) = { \mathrm { s i g m o i d } } ( C ( x ) )$ , and $C ( x )$ is the non-transformed discriminator output (which we call the critic as per Arjovsky et al. (2017)). In most GANs, $C ( x )$ can be interpreted as how realistic the input data is; a negative number means that the input data looks fake (e.g., in SGAN, $D ( x ) = { \mathrm { s i g m o i d } } ( - 5 ) = 0 )$ , while a positive number means that the input data looks real (e.g., in SGAN, $D ( x ) = { \mathrm { s i g m o i d } } ( 5 ) = 1 \qquad $ ).
+
+# 2.2 INTEGRAL PROBABILITY METRICS
+
+IPMs are statistical divergences represented mathematically as:
+
+$$
+I P M _ { F } ( \mathbb { P } | | \mathbb { Q } ) = \operatorname* { s u p } _ { C \in \mathcal { F } } \mathbb { E } _ { x \sim \mathbb { P } } [ C ( x ) ] - \mathbb { E } _ { x \sim \mathbb { Q } } [ C ( x ) ] ,
+$$
+
+where $\mathcal { F }$ is a class of real-valued functions.
+
+IPM-based GANs can be defined using equation 1 and 2 where $\tilde { f } _ { 1 } ( D ( x ) ) = \tilde { g } _ { 2 } ( D ( x ) ) = - D ( x )$ and $\tilde { f } _ { 2 } ( D ( x ) ) = \tilde { g } _ { 1 } ( D ( x ) ) = D ( x )$ , where $D ( x ) = C ( x )$ (i.e., no transformation is applied). It can be observed that both discriminator and generator loss functions are unbounded and would diverge to $- \infty$ if optimized directly. However, IPMs assume that the discriminator is of a certain class of function that does not grow too quickly which prevent the loss functions from diverging. Each IPM applies a different constraint to the discriminator (e.g., WGAN assumes a Lipschitz $D$ , WGAN-GP assumes that $D$ has a gradient norm equal to 1 around real and fake data).
+
+# 3 MISSING PROPERTY OF SGAN
+
+We argue that the key missing property of SGAN is that the probability of real data being real $( D ( x _ { r } ) )$ should decrease as the probability of fake data being real $( D ( x _ { f } ) )$ increase. We provide three arguments suggesting that SGAN should have this property.
+
+# 3.1 PRIOR KNOWLEDGE ARGUMENT
+
+Assuming a rational human was shown half real data and half fake data. If they perceived all samples shown as equally real $( C ( x _ { f } ) \approx C ( x _ { r } )$ for most $x _ { r }$ and $x _ { f }$ ), they would assume that each sample has probability .50 of being real. However, this is not the case for the discriminator in SGAN. If all samples looked real $( C ( x _ { f } ) \approx C ( x _ { r } ) \ge 3 )$ , $D$ would assume incorrectly that they are indeed all real $( \bar { D ( \boldsymbol { x } ) } \approx 1$ for all $x$ ). Of course, once trained with the labels, $D$ would decrease $D ( x _ { f } )$ and thus would obtain more reasonable estimates. However, if $D ( x _ { r } )$ decreased as $D ( x _ { f } )$ increased, we would have had that $D ( x ) \approx . 5 0$ for all $x$ before even retraining $D$ . A rational human would not require retraining. IPM-based GANs implicitly account for the fact that some of the samples must be fake because they compare how realistic real data is compared to fake data. This is the behavior that we would want.
+
+# 3.2 DIVERGENCE MINIMIZATION ARGUMENT
+
+In SGAN, when optimized, we have that the discriminator loss function is equal to the Jensen–Shannon divergence (JSD) (Goodfellow et al., 2014). The JSD is minimized $\begin{array} { r l } { ( J S { \bar { D } } ( \mathbb { P } | | \mathbb { Q } ) = } \end{array}$ 0) when $\begin{array} { r } { D ( x _ { r } ) = D ( \bar { x } _ { f } ) = \frac { 1 } { 2 } } \end{array}$ for all $x _ { r } \in \mathbb { P }$ and $x _ { f } \in \mathbb { Q }$ and maximized $( J S D ( \mathbb { P } | | \mathbb { Q } ) = \log ( 2 ) )$ when $D ( x _ { r } ) = 1$ , $D ( x _ { f } ) = 0 \quad$ for all $x _ { r } \in \mathbb { P }$ and $x _ { f } \in \mathbb { Q }$ . Thus, if we were directly minimizing the divergence from maximum to minimum, we would expect $D ( x _ { r } )$ to smoothly decrease from 1 to .50 for most $x _ { r }$ and $D ( x _ { f } )$ to smoothly increase from 0 to .50 for most $x _ { f }$ (Figure 1a). However, when minimizing the saturating loss in SGAN, we are only increasing $D ( x _ { f } )$ , we are not decreasing $D ( x _ { r } )$ (Figure 1b). Furthermore, we are bringing $D ( x _ { f } )$ closer to 1 rather than .50.
+
+This means that SGAN dynamics are very different from the minimization of the JSD. To bring SGAN closer to divergence minimization, training the generator should not only increase $D ( x _ { f } )$ but also decrease $D ( x _ { r } )$ (Figure 1c). Note that although specific to the JSD, similar dynamics are true for other divergences; when the divergence is maximal, $D ( x _ { r } )$ and $D ( x _ { f } )$ are very far from one another, but they converge to the same value as the divergence approach zero. Thus, this argument applies to other divergences.
+
+![](images/b84d5b5dac7cbba09e1f162763dc7cf99a89df94239e4e6081eac3fafae929d0.jpg)  
+Figure 1: Expected discriminator output of the real and fake data for the a) direct minimization of the Jensen–Shannon divergence, b) actual training of the generator to minimize its loss function, and c) ideal training of the generator to minimize its loss function (lines are dotted when they cross beyond the equilibrium to signify that this may or may not be necessary).
+
+# 3.3 GRADIENT ARGUMENT
+
+We compare the gradients of standard GAN and IPM-based GANs for further insight. It can be shown that the gradients of the discriminator and generator in non-saturating SGAN are respectively:
+
+$$
+\nabla _ { \boldsymbol { w } } L _ { D } ^ { G A N } = - \mathbb { E } _ { \boldsymbol { x } _ { r } \sim \mathbb { P } } \left[ ( 1 - D ( \boldsymbol { x } _ { r } ) ) \nabla _ { \boldsymbol { w } } C ( \boldsymbol { x } _ { r } ) \right] + \mathbb { E } _ { \boldsymbol { x } _ { f } \sim \mathbb { Q } _ { \boldsymbol { \theta } } } \left[ D ( \boldsymbol { x } _ { f } ) \nabla _ { \boldsymbol { w } } C ( \boldsymbol { x } _ { f } ) \right] ,
+$$
+
+$$
+\nabla _ { \boldsymbol { \theta } } L _ { G } ^ { G A N } = - \mathbb { E } _ { z \sim \mathbb { P } _ { z } } \left[ ( 1 - D ( G ( z ) ) ) \nabla _ { \boldsymbol { x } } C ( G ( z ) ) J _ { \boldsymbol { \theta } } G ( z ) \right] ,
+$$
+
+where $J$ is the Jacobian.
+
+It can be shown that the gradients of the discriminator and generator in IPM-based GANs are respectively:
+
+$$
+\nabla _ { w } L _ { D } ^ { I P M } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \nabla _ { w } C ( x _ { r } ) ] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } _ { \theta } } [ \nabla _ { w } C ( x _ { f } ) ] ,
+$$
+
+$$
+\nabla _ { \boldsymbol { \theta } } L _ { G } ^ { I P M } = - \mathbb { E } _ { z \sim \mathbb { P } _ { z } } [ \nabla _ { \boldsymbol { x } } C ( G ( z ) ) J _ { \boldsymbol { \theta } } G ( z ) ] ,
+$$
+
+where $C ( x ) \in \mathcal F$ (the class of functions assigned by the IPM).
+
+From these equations, it can be observed that SGAN leads to the same dynamics as IPM-based GANs when we have that:
+
+1. $D ( x _ { r } ) = 0$ , $D ( x _ { f } ) = 1$ in the discriminator step of SGAN   
+2. $D ( x _ { f } ) = 0$ in the generator step of SGAN.   
+3. $C ( x ) \in \mathcal F$
+
+Assuming that the discriminator and generator are trained to optimality in each step (which we sometimes do for $D$ , but never for $G$ ) and that it is possible to perfectly distinguish real from the fake data (strong assumption, but generally true early in training); we would have that $D ( x _ { r } ) = 1$ , $D ( x _ { f } ) = 0$ in the generator step and that $D ( x _ { r } ) = 1$ , $D ( x _ { f } ) = 1$ in the discriminator step for most $x _ { r }$ and $x _ { f }$ (Figure 1b). Thus, the only missing assumption would be that $D ( x _ { r } ) = 0$ in the discriminator step.
+
+Although the above scenario is not realistic (because we never train $G$ to optimality), if all the assumptions were respected and the generator could indirectly influence $D ( x _ { r } )$ , we would have that $D ( x _ { r } ) = 0$ , $D ( x _ { f } ) = 1$ . Thus, SGAN would have the same gradients as IPM-based GANs. We conjecture that making SGAN more similar to IPM-based GANs could potentially improve its stability (our results will show that it does in fact improves stability).
+
+# 4 METHOD
+
+# 4.1 RELATIVISTIC STANDARD GAN
+
+In standard GAN, the discriminator can be defined, in term of the non-transformed layer $C ( x )$ , as $D ( x ) = { \mathrm { s i g m o i d } } ( C ( x ) )$ . A simple way to make discriminator relativistic (i.e., having the output of $D$ depends on both real and fake data) is to sample from real/fake data pairs $\tilde { \boldsymbol { x } } = \left( \boldsymbol { x } _ { r } , \boldsymbol { x } _ { f } \right)$ and define it as $\bar { D } ( \tilde { x } ) = \mathrm { s i g m o i d } ( C ( x _ { r } ) - C ( x _ { f } ) )$ .
+
+We can interpret this modification in the following way: the discriminator estimates the probability that the given real data is more realistic than a randomly sampled fake data. Similarly, we can define $\bar { D _ { r e v } } ( \tilde { x } ) = \mathrm { s i g m o i d } ( C ( x _ { f } ) - C ( x _ { r } ) )$ as the probability that the given fake data is more realistic than a randomly sampled real data. An interesting property of this discriminator is that we do not need to include $D _ { r e v }$ in the loss function through $\log ( 1 - D _ { r e v } ( \tilde { x } ) )$ because we have that $1 - D _ { r e v } ( \tilde { x } ) = 1 - \mathrm { s i g m o i d } ( C ( x _ { f } ) - C ( x _ { r } ) ) = \mathrm { s i g m o i d } ( C ( x _ { r } ) - C ( x _ { f } ) ) = D ( \tilde { x } ) ;$ thus, $\log ( D ( \tilde { x } ) )$ $= \log ( 1 - D _ { r e v } ( \tilde { x } ) )$ .
+
+The discriminator and generator (non-saturating) loss functions of the Relativistic Standard GAN (RSGAN) can be written as:
+
+$$
+\begin{array} { r l } & { L _ { D } ^ { R S G A N } = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ \log ( \mathrm { s i g m o i d } ( C ( x _ { r } ) - C ( x _ { f } ) ) ) \right] . } \\ & { } \\ & { L _ { G } ^ { R S G A N } = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ \log ( \mathrm { s i g m o i d } ( C ( x _ { f } ) - C ( x _ { r } ) ) ) \right] . } \end{array}
+$$
+
+# 4.2 RELATIVISTIC GANS
+
+More generally, we consider any discriminator defined as $a ( C ( x _ { r } ) - C ( x _ { f } ) )$ , where $a$ is the activation function, to be relativistic. This means that almost any GAN can have a relativistic discriminator. This forms a new class of models which we call Relativistic GANs (RGANs).
+
+Most GANs can be parametrized very generally in terms of the critic:
+
+$$
+L _ { D } ^ { G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ f _ { 1 } ( C ( x _ { r } ) ) \right] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ f _ { 2 } ( C ( x _ { f } ) ) \right]
+$$
+
+and
+
+$$
+L _ { G } ^ { G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ g _ { 1 } ( C ( x _ { r } ) ) \right] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ g _ { 2 } ( C ( x _ { f } ) ) \right] ,
+$$
+
+where $f _ { 1 } , f _ { 2 } , g _ { 1 } , g _ { 2 }$ are scalar-to-scalar functions. If we use a relativistic discriminator, these GANs now have the following form:
+
+$$
+L _ { D } ^ { R G A N } = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 2 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right]
+$$
+
+and
+
+$$
+L _ { G } ^ { R G A N } = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ g _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ g _ { 2 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] .
+$$
+
+If one use the identity function (i.e., $f _ { 1 } ( y ) = g _ { 2 } ( y ) = - y$ , $f _ { 2 } ( y ) = g _ { 1 } ( y ) = y )$ , this results in a degenerate case since there is no supremum/maximum. However, if one adds a constraint so that $C ( x _ { r } ) - C ( x _ { f } )$ is bounded, then there is a supremum and one arrives at IPM-based GANs. Thus, although different, IPM-based GANs share a very similar loss function focused on the difference in critics.
+
+Importantly, $g _ { 1 }$ is normally ignored in GANs because its gradient is zero since the generator does not influence it. However, in RGANs, $g _ { 1 }$ is influenced by fake data, thus by the generator.
+
+# 4.3 RELATIVISTIC AVERAGE GANS
+
+The discriminator has a very different interpretation in SGAN compared to RSGAN. In SGAN, $D ( x )$ estimates the probability that $x$ is real, while in RGANs, $D ( x _ { r } , x _ { f } )$ estimates the probability that $x _ { r }$ is more realistic than $x _ { f }$ . As a middle ground, we developed an alternative to the Relativistic Discriminator, which retains approximately the same interpretation as the discriminator in SGAN while still being relativistic.
+
+We propose the Relativistic average Discriminator (RaD) which compares the critic of the input data to the average critic of samples of the opposite type. The discriminator loss function for this approach can be formulated as:
+
+$$
+{ \cal L } _ { D } ^ { R a S G A N } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \log \left( \bar { D } ( x _ { r } ) \right) \right] - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \log \left( 1 - \bar { D } ( x _ { f } ) \right) \right] ,
+$$
+
+where
+
+$$
+\bar { D } ( x ) = \left\{ \begin{array} { l l } { \mathrm { s i g m o i d } ( C ( x ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) ) } & { \mathrm { i f ~ } x \mathrm { ~ i s ~ r e a l ~ } } \\ { \mathrm { s i g m o i d } ( C ( x ) - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } C ( x _ { r } ) ) } & { \mathrm { i f ~ } x \mathrm { ~ i s ~ f a k e . } } \end{array} \right.
+$$
+
+RaD has a more similar interpretation to the standard discriminator than the relativistic discriminator. With RaD, the discriminator estimates the probability that the given real data is more realistic than fake data, on average.
+
+As before, we can generalize this approach to work with any GAN loss function using the following formulation:
+
+$$
+{ \cal L } _ { D } ^ { R a G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ f _ { 1 } ( C ( x _ { r } ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) ) ) ] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } [ f _ { 2 } ( C ( x _ { f } ) - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } C ( x _ { r } ) ) ] .
+$$
+
+$L _ { G } ^ { R a G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ g _ { 1 } ( C ( x _ { r } ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) ) ) ] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } [ g _ { 2 } ( C ( x _ { f } ) - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } C ( x _ { r } ) ) ] .$ We call this general approach Relativistic average GAN (RaGAN).
+
+# 5 EXPERIMENTS
+
+Experiments were conducted on the CIFAR-10 dataset (Krizhevsky, 2009) and the CAT dataset (Zhang et al., 2008). Code was written in Pytorch (Paszke et al., 2017) and models were trained using the Adam optimizer (Kingma & Ba, 2014) for 100K generator iterations with seed 1 (which shows that we did not fish for the best seed, instead, we selected the seed a priori). We report the Fréchet Inception Distance (FID) (Heusel et al., 2017), a measure that is generally better correlated with data quality than the Inception Distance (Salimans et al., 2016) (Borji, 2018); lower FID means that the generated images are of better quality.
+
+For the models architectures, we used the standard CNN described by Miyato et al. (2018) on CIFAR10 and a relatively standard DCGAN architecture (Radford et al., 2015) on CAT (see Appendix). We also provide the source code required to replicate all analyses presented in this paper (See our repository: [Anonymous until peer review is finished]).
+
+# 5.1 CIFAR-10
+
+In these analyses, we compared standard GAN (SGAN), least-squares GAN (LSGAN), Wassertein GAN improved (WGAN-GP), Hinge-loss GAN (HingeGAN) (Miyato et al., 2018), Relativistic SGAN (RSGAN), Relativistic average SGAN (RaSGAN), Relativistic average LSGAN (RaLSGAN), and Relativistic average HingeGAN (RaHingeGAN) using the standard CNN architecture on stable setups (See Appendix for details on the loss functions used). Additionally, we tested RSGAN and RaSGAN with the same gradient-penalty as WGAN-GP (named RSGAN-GP and RaSGAN-GP respectively).
+
+We used the following two known stable setups: (DCGAN setup) $l r = . 0 0 0 2$ , $n _ { D } = 1$ , $\beta _ { 1 } = . 5 0$ and $\beta _ { 2 } = . 9 9 9$ (Radford et al., 2015), and (WGAN-GP setup) $l r = . 0 0 0 1$ , $n _ { D } = 5$ , $\beta _ { 1 } = . 5 0$ and $\beta _ { 2 } = . 9$ (Gulrajani et al., 2017), where $l r$ is the learning rate, $n _ { D }$ is the number of discriminator updates per generator update, and $\beta _ { 1 }$ , $\beta _ { 2 }$ are the ADAM momentum parameters. For optimal stability, we used batch norm (Ioffe & Szegedy, 2015) in $G$ and spectral norm (Miyato et al., 2018) in $D$ .
+
+Results are presented in Table 1. We observe that RSGAN and RaSGAN generally performed better than SGAN. Similarly, RaHingeGAN performed better than HingeGAN. RaLSGAN performed on par with LSGAN, albeit sightly worse. WGAN-GP performed poorly in the DCGAN setup, but very well in the WGAN-GP setup. RasGAN-GP performed poorly; however, RSGAN-GP performed better than all other loss functions using only one discriminator update per generator update. Importantly, the resulting FID of 25.60 is on par with the lowest FID obtained for this architecture using spectral normalization, as reported by Miyato et al. (2018) (25.5). Overall, these results show that using a relativistic discriminator generally improve data generation quality and that RSGAN works very well in conjunction with gradient penalty to obtain state-of-the-art results.
+
+Table 1: Fréchet Inception Distance (FID) at exactly $1 0 0 \mathrm { k }$ generator iterations on the CIFAR-10 dataset using stable setups with different GAN loss functions. We used spectral norm in $D$ and batch norm in $G$ . All models were trained using the same a priori selected seed (seed $^ { = 1 }$ ).   
+
+<table><tr><td>Loss</td><td>lr = .0002 lr = .0001 β = (.50,.999) β = (.50,.9) nD=1 nD=5</td></tr><tr><td>SGAN 40.64</td><td>41.32</td></tr><tr><td>RSGAN 36.61</td><td>55.29</td></tr><tr><td>RaSGAN</td><td>31.98 37.92</td></tr><tr><td>LSGAN</td><td>29.53 187.01</td></tr><tr><td>RaLSGAN 30.92</td><td>219.39</td></tr><tr><td>HingeGAN</td><td>49.53 80.85</td></tr><tr><td>RaHingeGAN</td><td>39.12 37.72</td></tr><tr><td>WGAN-GP</td><td>83.89 27.81</td></tr><tr><td>RSGAN-GP</td><td>25.60 28.13</td></tr><tr><td>RaSGAN-GP</td><td>331.86</td></tr></table>
+
+# 5.2 CAT
+
+CAT is a dataset containing around $1 0 \mathrm { k }$ pictures of cats with annotations. We cropped the pictures to the faces of the cats using those annotations. After removing outliers (hidden faces, blurriness, etc.), the CAT dataset contained 9304 images $\geq 6 4 \mathrm { x } 6 4$ , 6645 images $\geq 1 2 8 \mathrm { x } 1 2 8$ , and 2011 images $\geq$ 256x256. The CAT dataset is particularly challenging due to its small sample size and high-resolution images; this makes it perfect for testing the stability of different GAN loss functions.
+
+We trained different GAN loss functions on $6 4 \mathrm { x } 6 4$ , $1 2 8 \mathrm { x } 1 2 8$ , $2 5 6 \mathrm { x } 2 5 6$ images. For $2 5 6 \times 2 5 6$ images, we compared RaGANs to known stable approaches: SpectralSGAN (SGAN with spectral normalization in $D$ ) and WGAN-GP. Although some approaches were able to train on $2 5 6 \times 2 5 6$ images, they did so with significant mode collapse. To alleviate this problem, for $2 5 6 \mathrm { x } 2 5 6$ images, we packed the discriminator (Lin et al., 2017) (i.e., $D$ took a concatenated pair of images instead of a single image). We looked at the minimum, maximum, mean and standard deviation (SD) of the FID at 20k, 30k, ..., 100k generator iterations; results are presented in Table 2.
+
+Overall, we observe lower minimum FID, maximum FID, mean and standard deviation (sd) for RGANs and RaGANs than their non-relativistic counterparts (SGAN, LSGAN, RaLSGAN).
+
+In 64x64 resolution, both SGAN and LSGAN generated images with low FID, but they did so in a very unstable matter. For example, SGAN went from a FID of 17.50 at 30k iterations, to 310.56 at 40k iterations, and back to 27.72 at $5 0 \mathrm { k }$ iterations. Similarly, LSGAN went from a FID of 20.27 at $2 0 \mathrm { k }$ iterations, to 224.97 at 30k iterations, and back to 51.98 at 40k iterations. On the other hand, RaGANs were much more stable (lower max and SD) while also resulting in lower minimum FID. Using gradient-penalty did not improve data quality; however, it reduced the SD lower than without gradient penalty, thus increasing stability further.
+
+SGAN was unable to converge on $1 2 8 \mathrm { x } 1 2 8$ or bigger images and LSGAN was unable to converge on $2 5 6 \times 2 5 6$ images. Meanwhile, RaGANs were able to generate plausible images with low FID in all resolutions. Although SpectralSGAN and WGAN-GP were able to generate 256x256 images of cats, the samples they generated were of poor quality (high FID). Thus, in this very difficult setting, relativism provided a greater improvement in quality than gradient penalty or spectral normalization.
+
+# 6 CONCLUSION AND FUTURE WORK
+
+In this paper, we proposed the relativistic discriminator as a way to fix and improve on standard GAN. We further generalized this approach to any GAN loss and introduced a generally more stable variant called RaD. Our results suggest that relativism significantly improve data quality and stability of
+
+Table 2: Minimum (min), maximum (max), mean, and standard deviation (SD) of the Fréchet Inception Distance (FID) calculated at 20k, 30k . . . , 100k generator iterations on the CAT dataset with different GAN loss functions. The hyper-parameters used were $l r = . 0 0 0 2$ , $\beta = ( . 5 0 , . 9 9 9 )$ , $n _ { D } = 1$ , and batch norm (BN) in $D$ and $G$ . All models were trained using the same a priori selected seed (seed $^ { = 1 }$ ). Note: A missing number imply that the model did not converge and became stuck in the first few iterations.   
+
+<table><tr><td>Loss</td><td>Min</td><td>Max</td><td>Mean</td><td>SD</td></tr><tr><td colspan="5">64x64 images (N=9304)</td></tr><tr><td>SGAN</td><td>16.56</td><td>310.56</td><td>52.54</td><td>96.81</td></tr><tr><td>RSGAN</td><td>19.03</td><td>42.05</td><td>32.16</td><td>7.01</td></tr><tr><td>RaSGAN</td><td>15.38</td><td>33.11</td><td>20.53</td><td>5.68</td></tr><tr><td>LSGAN RaLSGAN</td><td>20.27 11.97</td><td>224.97 19.29</td><td>73.62 15.61</td><td>61.02 2.55</td></tr><tr><td>HingeGAN</td><td>17.60</td><td>50.94</td><td>32.23</td><td>14.44 3.96</td></tr><tr><td>RaHingeGAN RSGAN-GP</td><td>14.62</td><td>27.31</td><td>20.29</td><td>1.82</td></tr><tr><td>RaSGAN-GP</td><td>16.41 17.32</td><td>22.34 22</td><td>18.20 19.58</td><td>1.81</td></tr><tr><td>SGAN</td><td>128x128 images (N=6645) -</td><td>=</td><td></td><td></td></tr><tr><td>RaSGAN</td><td>21.05</td><td>39.65</td><td>28.53</td><td>6.52</td></tr><tr><td>LSGAN RaLSGAN</td><td>19.03 15.85</td><td>51.36 40.26</td><td>30.28 22.36</td><td>10.16 7.53</td></tr><tr><td>SGAN1</td><td>256x256 images (N=2011)</td><td></td><td></td><td></td></tr><tr><td>RaSGAN</td><td>= 32.11</td><td>= 102.76</td><td>= 56.64</td><td>21.03</td></tr><tr><td>SpectralSGAN</td><td>54.08 =</td><td>90.43</td><td>64.92</td><td>12.00</td></tr><tr><td>LSGAN1</td><td></td><td>1</td><td>1</td><td>=</td></tr><tr><td>RaLSGAN WGAN-GP</td><td>35.21 155.46</td><td>299.52 437.48</td><td>70.44 341.91</td><td>86.01 101.11</td></tr></table>
+
+GANs at no computational cost. Furthermore, using a relativistic discriminator with other tools of the trade (spectral norm, gradient penalty, etc.) may lead to better state-of-the-art.
+
+Future research is needed to fully understand the mathematical implications of adding relativism to GANs. Furthermore, our experiments were limited to certain loss functions using only one seed, due to computational constraints. More experiments are required to determine which relativistic GAN loss function is best over a wide-range of datasets and hyper-parameters. We greatly encourage researchers and machine learning enthusiasts with greater computing power to experiment further with our approach.
+
+# REFERENCES
+
+Martin Arjovsky and Léon Bottou. Towards principled methods for training generative adversarial networks. arXiv preprint arXiv:1701.04862, 2017.
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein generative adversarial networks. In International Conference on Machine Learning, pp. 214–223, 2017.
+
+Ali Borji. Pros and cons of gan evaluation measures. arXiv preprint arXiv:1802.03446, 2018.
+
+William Fedus, Mihaela Rosca, Balaji Lakshminarayanan, Andrew M Dai, Shakir Mohamed, and Ian Goodfellow. Many paths to equilibrium: Gans do not need to decrease adivergence at every step. arXiv preprint arXiv:1710.08446, 2017.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2672–2680. Curran Associates, Inc., 2014. URL http://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 5767–5777. Curran Associates, Inc., 2017. URL http://papers.nips.cc/ paper/7159-improved-training-of-wasserstein-gans.pdf.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Günter Klambauer, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a nash equilibrium. arXiv preprint arXiv:1706.08500, 2017.
+
+Yongjun Hong, Uiwon Hwang, Jaeyoon Yoo, and Sungroh Yoon. How generative adversarial nets and its variants work: An overview of gan. arXiv preprint arXiv:1711.05914, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Alexia Jolicoeur-Martineau. Gans beyond divergence minimization. arXiv preprint arXiv:1809.02145, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Zinan Lin, Ashish Khetan, Giulia Fanti, and Sewoong Oh. Pacgan: The power of two samples in generative adversarial networks. arXiv preprint arXiv:1712.04086, 2017.
+
+Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are gans created equal? a large-scale study. arXiv preprint arXiv:1711.10337, 2017.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In 2017 IEEE International Conference on Computer Vision (ICCV), pp. 2813–2821. IEEE, 2017.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957, 2018.
+
+Youssef Mroueh and Tom Sercu. Fisher gan. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 2513–2523. Curran Associates, Inc., 2017. URL http://papers.nips.cc/ paper/6845-fisher-gan.pdf.
+
+Youssef Mroueh, Chun-Liang Li, Tom Sercu, Anant Raj, and Yu Cheng. Sobolev gan. arXiv preprint arXiv:1711.04894, 2017.
+
+Alfred Müller. Integral probability metrics and their generating classes of functions. Advances in Applied Probability, 29(2):429–443, 1997.
+
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 271–279. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/6066-f-gan-training-generativeneural-samplers-using-variational-divergence-minimization.pdf.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, Xi Chen, and Xi Chen. Improved techniques for training gans. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 2234–2242. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/6125- improved-techniques-for-training-gans.pdf.
+
+Weiwei Zhang, Jian Sun, and Xiaoou Tang. Cat head detection-how to effectively exploit shape and texture features. In European Conference on Computer Vision, pp. 802–816. Springer, 2008.
+
+# APPENDICES
+
+A INTUITIVE AND MEMEFUL VISUAL REPRESENTATION OF RAGANS
+
+Table 3: An illustrative example of the discriminator’s output in standard GAN as traditionally defined $( P ( x _ { r } { \mathrm { ~ i s ~ r e a l } } ) = { \mathrm { ~ s i g m o i d } } ( C ( x _ { r } ) ) )$ versus the Relativistic average Discriminator (RaD) $( P ( x _ { r } \mathrm { i s } \mathrm { r e a l } | \overline { { C ( x _ { f } ) } } ) = \mathrm { s i g m o i d } ( C ( x _ { r } ) - \overline { { C ( x _ { f } ) } } ) )$ . Breads represent real images, while dogs   
+
+<table><tr><td colspan="2">resentfakeimages.</td><td colspan="2">Relative probability (Relativistic average Standard GAN)</td></tr><tr><td>Scenario</td><td>Absolute probability (Standard GAN)</td><td colspan="2"></td></tr><tr><td rowspan="2">Real image looks real and fake images look fake</td><td></td><td></td><td></td></tr><tr><td>C(xr)=8 P(xr is bread) = 1</td><td>C(xf)=-5 P(xr is bread|C(xf)) = 1</td><td></td></tr><tr><td rowspan="2">Real image looks real but fake images look similarly real on average</td><td></td><td></td><td></td></tr><tr><td>C(xr)=8 P(xr is bread) = 1</td><td>C(xf）=7</td><td>P(xr is bread|C(xf)) = .73</td></tr><tr><td rowspan="2">Real image looks fake but fake images look more fake on average P(xr is bread) = .05</td><td>福</td><td></td><td></td></tr><tr><td>C(xr)= -3</td><td>C（xf）</td><td>=-5 P(xr is bread|C(xf)) = .88</td></tr></table>
+
+# B INTUITION BEHIND RAGANS
+
+Although the relative discriminator provide the missing property that we want in GANs (i.e., $G$ influencing $D ( x _ { r } ) )$ , its interpretation is different from the standard discriminator. Rather than measuring “the probability that the input data is real”, it is now measuring “the probability that the input data is more realistic than a randomly sampled data of the opposing type (fake if the input is real or real if the input is fake)”. To make the relativistic discriminator act more globally, as in its original definition, our initial idea was the following: average the relativistic discriminator over random samples of data of the opposing type. This can be conceptualized in the following way:
+
+$$
+\begin{array} { r l } & { P ( x _ { r } \mathrm { ~ i s ~ r e a l } ) : = \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } [ P ( x _ { r } \mathrm { ~ i s ~ m o r e ~ r e a l ~ t h a n ~ } x _ { f } ) ] } \\ & { \quad \quad \quad = \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } [ \mathrm { s i g m o i d } ( C ( x _ { r } ) - C ( x _ { f } ) ) ] } \\ & { \quad \quad \quad = \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } [ D ( x _ { r } , x _ { f } ) ] , } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { P ( x _ { f } \mathrm { ~ i s ~ r e a l } ) : = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ P ( x _ { f } \mathrm { ~ i s ~ m o r e ~ r e a l ~ t h a n ~ } x _ { r } ) ] } \\ & { \phantom { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \mathrm { s i g m o i d } ( C ( x _ { f } ) - C ( x _ { r } ) ) ] } \\ & { \phantom { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ D ( x _ { f } , x _ { r } ) ] , } \end{array}
+$$
+
+where $D ( x _ { r } , x _ { f } ) = \mathrm { s i g m o i d } ( C ( x _ { r } ) - C ( x _ { f } ) )$ .
+
+Then, the following loss function for $D$ could be applied:
+
+$$
+L _ { D } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \log ( \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } [ D ( x _ { r } , x _ { f } ) ] ) ) ] - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } [ \log ( 1 - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ D ( x _ { f } , x _ { r } ) ] ) ] .
+$$
+
+The main problem with this idea is that it would require looking at all possible combinations of real and fake data in the mini-batch. This would transform the problem from $\mathcal { O } ( m )$ to $\mathcal { O } ( m ^ { 2 } )$ complexity, where $m$ is the batch size. This is problematic; therefore, we do not use this approach.
+
+Instead, we propose to use the Relativistic average Discriminator (RaD) which compares the critic of the input data to the average critic of samples of the opposite type (See section 4.3). This approach has $\mathcal { O } ( m )$ complexity.
+
+# C GRADIENTS
+
+# C.1 SGAN
+
+$$
+\begin{array} { r l } & { \nabla _ { w } L _ { D } ^ { G A N } = - \nabla _ { w } \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \log D ( x _ { r } ) ] - \nabla _ { w } \mathbb { E } _ { x _ { f } \sim \mathbb { Q } _ { \theta } } [ \log ( 1 - D ( x _ { f } ) ) ] } \\ & { \hphantom { \frac { \prod } { \prod } } = - \nabla _ { w } \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \log ( \frac { e ^ { C ( x _ { r } ) } } { e ^ { C ( x _ { r } ) } + 1 } ) ] - \nabla _ { w } \mathbb { E } _ { x _ { f } \sim \mathbb { Q } _ { \theta } } [ \log ( 1 - \frac { e ^ { C ( x _ { f } ) } } { e ^ { C ( x _ { f } ) } + 1 } ) ] } \\ & { \hphantom { \frac { \prod } { \prod } } = - \nabla _ { w } \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ C ( x _ { r } ) - \log ( e ^ { C ( x _ { r } ) } + 1 ) ] - \nabla _ { w } \mathbb { E } _ { x _ { f } \sim \mathbb { Q } _ { \theta } } [ \log ( 1 ) - \log ( e ^ { C ( x _ { f } ) } + 1 ) ] } \\ & { \hphantom { \frac { \prod } { \prod } } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \nabla _ { w } C ( x _ { r } ) ] + \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \frac { e ^ { C ( x _ { r } ) } } { e ^ { C ( x _ { r } ) } + 1 } \nabla _ { w } C ( x _ { r } ) ] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } _ { \theta } } [ \frac { e ^ { C ( x _ { f } ) } } { e ^ { C ( x _ { f } ) } + 1 } \nabla _ { w } C ( x _ { f } ) ] } \\ &  \hphantom { \frac { \prod } { \prod } } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ \nabla _ { w } C ( x _ { r } ) ] + \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ D ( x _ { r } ) \nabla _ { w } C ( x _ { r } ) ] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } _ { \theta } } [ D ( x _ { f } ) \nabla _ { w } C ( x _  f \end{array}
+$$
+
+$$
+\begin{array} { r l } { \nabla _ { \theta } L _ { G } ^ { G A N } = - \nabla _ { \theta } \mathbb { E } _ { z \sim \mathbb { P } _ { z } } \left[ \log D ( G ( z ) ) \right] } & { } \\ { = - \nabla _ { \theta } \mathbb { E } _ { z \sim \mathbb { P } _ { z } } \left[ \log \left( \frac { e ^ { C ( G ( z ) ) } } { e ^ { C ( G ( z ) ) } + 1 } \right) \right] } & { } \\ { = - \nabla _ { \theta } \mathbb { E } _ { z \sim \mathbb { P } _ { z } } \left[ C ( G ( z ) ) - \log \left( e ^ { C ( G ( z ) ) } + 1 \right) \right] } & { } \\ { = - \mathbb { E } _ { z \sim \mathbb { P } _ { z } } \left[ \nabla _ { x } C ( G ( z ) ) J _ { \theta } G ( z ) - \left( \frac { e ^ { C ( G ( z ) ) } } { e ^ { C ( G ( z ) ) } + 1 } \right) \nabla _ { x } C ( G ( z ) ) J _ { \theta } G ( z ) \right] } & { } \\ { = - \mathbb { E } _ { z \sim \mathbb { P } _ { z } } \left[ ( 1 - D ( G ( z ) ) ) \nabla _ { x } C ( G ( z ) ) J _ { \theta } G ( z ) \right] } & { } \end{array}
+$$
+
+# C.2 IPM-BASED GANS
+
+$$
+\begin{array} { r } { \nabla _ { \boldsymbol { w } } L _ { D } ^ { I P M } = - \nabla _ { \boldsymbol { w } } \mathbb { E } _ { \boldsymbol { x } _ { r } \sim \mathbb { P } } [ C ( \boldsymbol { x } _ { r } ) ] + \nabla _ { \boldsymbol { w } } \mathbb { E } _ { \boldsymbol { x } _ { f } \sim \mathbb { Q } _ { \boldsymbol { \theta } } } [ C ( \boldsymbol { x } _ { f } ) ] } \\ { = - \mathbb { E } _ { \boldsymbol { x } _ { r } \sim \mathbb { P } } [ \nabla _ { \boldsymbol { w } } C ( \boldsymbol { x } _ { r } ) ] + \mathbb { E } _ { \boldsymbol { x } _ { f } \sim \mathbb { Q } _ { \boldsymbol { \theta } } } [ \nabla _ { \boldsymbol { w } } C ( \boldsymbol { x } _ { f } ) ] } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \nabla _ { \theta } L _ { G } ^ { I P M } = - \nabla _ { \theta } \mathbb { E } _ { z \sim \mathbb { P } _ { z } } [ C ( G ( z ) ) ] } \\ & { \qquad = - \mathbb { E } _ { z \sim \mathbb { P } _ { z } } [ \nabla _ { x } C ( G ( z ) ) J _ { \theta } G ( z ) ] } \end{array}
+$$
+
+# D SIMPLIFIED FORM OF RELATIVISTIC SATURATING AND NON-SATURATING GANS
+
+The formulation of RGANs can be simplified when we have the following two properties: (1) $f _ { 2 } ( - y ) = f _ { 1 } ( y )$ and (2) the generator assumes a non-saturating loss $( g _ { 1 } ( y ) \overset { \cdot } { = } f _ { 2 } ( \overset { \cdot } { y } )$ and $g _ { 2 } ( y ) =$ $f _ { 1 } ( y ) )$ . These two properties are observed in standard GAN, LSGAN using symmetric labels (e.g., $^ { - 1 }$ and 1), IPM-based GANs, etc. With these two properties, RGANs with non-saturating loss can be formulated simply as:
+
+$$
+L _ { D } ^ { R G A N * } = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right]
+$$
+
+and
+
+$$
+L _ { G } ^ { R G A N * } = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] .
+$$
+
+Assuming $f _ { 2 } ( - y ) = f _ { 1 } ( y )$ , we have that
+
+$$
+\begin{array} { r l } & { L _ { D } ^ { R G A N } = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 2 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] } \\ & { \qquad = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] } \\ & { \qquad = 2 \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] . } \end{array}
+$$
+
+If $g _ { 1 } ( y ) = - f _ { 1 } ( y )$ and $g _ { 2 } ( y ) = - f _ { 2 } ( y )$ (saturating GAN), we have that
+
+$$
+\begin{array} { r l } & { L _ { G } ^ { R G A N - S } = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ g _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ g _ { 2 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] } \\ & { \quad \quad \quad \quad \quad = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 2 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] } \\ & { \quad \quad \quad = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] } \\ & { \quad \quad \quad = - 2 \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] . } \end{array}
+$$
+
+If $g _ { 1 } ( y ) = f _ { 2 } ( y )$ and $g _ { 2 } ( y ) = f _ { 1 } ( y )$ (non-saturating GAN), we have that
+
+$$
+\begin{array} { r l } & { L _ { G } ^ { R G A N - N S } = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ g _ { 1 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ g _ { 2 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] } \\ & { \quad \quad \quad \quad = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 2 } ( C ( x _ { r } ) - C ( x _ { f } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] } \\ & { \quad \quad \quad = \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] + \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] } \\ & { \quad \quad \quad = 2 \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ f _ { 1 } ( C ( x _ { f } ) - C ( x _ { r } ) ) \right] . } \end{array}
+$$
+
+# E TESTING THE GRADIENT ARGUMENT
+
+Previously, we argued that SGAN could be equivalent to IPM-GANs under very strict conditions and assumptions. We mentioned that although most assumptions are reasonable, the assumption that the generator is trained to optimality is unrealistic. In which case, SGAN would not be equivalent to IPM-based GANs since $D ( x _ { r } )$ would not reach 0.
+
+As an experiment, we calculated the mini-batch average of $D ( x _ { r } )$ in the first 100 iterations of the training for the CAT dataset in $2 5 6 \times 2 5 6$ . Note that SGAN becomes stuck at around 200 iterations and can never go beyond generating noise. Thus, a difference in the distribution of $D ( x _ { r } )$ could reveal something meaningful about why Relativistic GANs can converge while their non-relativistic counterparts cannot.
+
+In those 100 iterations, we have that the distance between $\mathbb { P }$ and $\mathbb { Q }$ is maximal since $G$ only generate noise. Thus, we can perfectly distinguish real from fake data, which is one of the assumptions. The remaining assumptions were that $D$ and $G$ would be trained to optimality. Although we did not train $D$ more than once, after the discriminator step, we generally had that $D ( x _ { r } ) \approx 1$ . What we wanted to verify is whether $D ( x _ { r } ) \approx 0$ after the generator step in Relativistic GANs, even though we did not train $G$ enough to reach optimality.
+
+![](images/f064e75600f2f13637acd2cebb1789f632bd9aebd04b8a689a6df29ebac6f20d.jpg)  
+Figure 2: Density plots of the mini-batch average of $D ( x _ { r } )$ during the first 100 iterations of training on CAT with $2 5 6 \mathrm { x } 2 5 6$ images using only one or two generator updates per discriminator updates. If $D ( x _ { r } ) = 0$ in all iterations, this would mean that the loss function would be the same as IPM-based GANs.
+
+Results are shown in Figure 2. We observe that with only one generator update per discriminator update $\because G = 1 \mathrm { \Omega }$ ), RSGAN and RaSGAN never reach an average $D ( x _ { r } )$ of 0 but the distribution is much less concentrated around 1 than with SGAN. With $n _ { G } = 2$ , RSGAN and RaSGAN sometimes reach an average $D ( x _ { r } )$ of 0 and they form an almost uniform distribution around $[ 0 , 1 ]$ . This suggests that with the missing property (i.e., using Relativistic GANs), SGAN can be made more similar to IPM-based GANs, but never equivalent. Thus, Relativistic Standard GANs can be seen as having a dynamic in-between SGAN and IPM-based GANs.
+
+# F CIFAR-10 HARD/UNSTABLE EXPERIMENTS
+
+In these analyses, we compared SGAN, LSGAN, WGAN-GP, RSGAN, RaSGAN, RaLSGAN, and RaHingeGAN with the standard CNN architecture on unstable setups in CIFAR-10. Unless otherwise specified, we used $l r = . 0 0 0 2$ , $\beta _ { 1 } = . 5$ , $\beta _ { 2 } = . 9 9 9$ , $n _ { D } = 1$ , and batch norm (Ioffe & Szegedy, 2015) in $G$ and $D$ . We tested the following four unstable setups: (1) $l r = . 0 0 1$ , (2) $\beta _ { 1 } = . 9$ , $\beta _ { 2 } = . 9$ , (3) no batch norm in $G$ or $D$ , and (4) all activation functions replaced with Tanh in both $G$ and $D$ (except for the output activation function of $D$ ).
+
+Results are presented in Table 4. We observe that RaLSGAN performed better than LSGAN in all setups. RaHingeGAN performed slightly worse than HingeGAN in most setups. RSGAN and RaSGAN performed better than SGAN in two out of four setups, although differences were small. WGAN-GP generally performed poorly which we suspect is due to the single discriminator update per generator update. Overall, this provide good support for the improved stability of using the relative discriminator with LSGAN, but not with HingeGAN and SGAN. Although results are worse for the relativistic discriminator in some settings, differences are minimal and probably reflect natural variations.
+
+It is surprising to observe low FID for SGAN without batch normalization considering its well-known difficulty with this setting (Arjovsky et al., 2017). Given these results, we suspected that CIFAR-10 may be too easy to fully observe the stabilizing effects of using the relative discriminator. Therefore, in the manuscript, we focused on the more difficult CAT dataset with high resolution pictures.
+
+# G LOSS FUNCTIONS USED IN EXPERIMENTS
+
+# G.1 SGAN (NON-SATURATING)
+
+$$
+\begin{array} { c } { { L _ { D } ^ { S G A N } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \log \left( \mathrm { s i g m o i d } ( C ( x _ { r } ) ) \right) \right] - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \log \left( 1 - \mathrm { s i g m o i d } ( C ( x _ { f } ) ) \right) \right] } } \\ { { L _ { G } ^ { S G A N } = - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \log \left( \mathrm { s i g m o i d } ( C ( x _ { f } ) ) \right) \right] } } \end{array}
+$$
+
+G.2 RSGAN
+
+$$
+{ \cal L } _ { D } ^ { R S G A N } = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ \log ( \operatorname { s i g m o i d } ( C ( x _ { r } ) - C ( x _ { f } ) ) ) \right]
+$$
+
+Table 4: Fréchet Inception Distance (FID) at exactly $1 0 0 \mathrm { k }$ generator iterations on the CIFAR-10 dataset using unstable setups with different GAN loss functions. Unless otherwise specified, we used $l r = . 0 0 0 2$ , $\beta = ( . 5 0 , . 9 9 9 )$ , $n _ { D } = 1$ , and batch norm (BN) in $D$ and $G$ . All models were trained using the same a priori selected seed (seed $^ { = 1 }$ ).   
+
+<table><tr><td>Loss</td><td>lr= .001</td><td>β=(.9,.9)</td><td>No BN</td><td>Tanh</td></tr><tr><td>SGAN</td><td>154.20</td><td>35.29</td><td>35.54</td><td>59.17</td></tr><tr><td>RSGAN</td><td>50.95</td><td>45.12</td><td>37.11</td><td>77.21</td></tr><tr><td>RaSGAN</td><td>55.55</td><td>43.46</td><td>41.96</td><td>54.42</td></tr><tr><td>LSGAN</td><td>52.27</td><td>225.94</td><td>38.54</td><td>147.87</td></tr><tr><td>RaLSGAN</td><td>33.33</td><td>48.92</td><td>34.66</td><td>53.07</td></tr><tr><td>HingeGAN</td><td>43.28</td><td>33.47</td><td>34.21</td><td>58.51</td></tr><tr><td>RaHingeGAN</td><td>51.05</td><td>42.78</td><td>43.75</td><td>50.69</td></tr><tr><td>WGAN-GP</td><td>61.97</td><td>104.95</td><td>85.27</td><td>59.94</td></tr></table>
+
+$$
+{ \cal L } _ { G } ^ { R S G A N } = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ \log ( \operatorname { s i g m o i d } ( C ( x _ { f } ) - C ( x _ { r } ) ) ) \right]
+$$
+
+# G.3 RASGAN
+
+$$
+\begin{array} { r l } & { \quad L _ { D } ^ { R a S G A N } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \log \left( \tilde { D } ( x _ { r } ) \right) \right] - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \log \left( 1 - \tilde { D } ( x _ { f } ) \right) \right] } \\ & { \quad L _ { G } ^ { R a S G A N } = - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \log \left( \tilde { D } ( x _ { f } ) \right) \right] - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \log \left( 1 - \tilde { D } ( x _ { r } ) \right) \right] } \\ & { \quad \tilde { D } ( x _ { r } ) = \mathrm { s i g m o i d } \left( C ( x _ { r } ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) \right) } \\ & { \quad \tilde { D } ( x _ { f } ) = \mathrm { s i g m o i d } \left( C ( x _ { f } ) - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } C ( x _ { r } ) \right) } \end{array}
+$$
+
+# G.4 LSGAN
+
+$$
+L _ { D } ^ { L S G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ ( C ( x _ { r } ) - 0 ) ^ { 2 } \right] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ ( C ( x _ { f } ) - 1 ) ^ { 2 } \right]
+$$
+
+$$
+L _ { G } ^ { L S G A N } = \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ ( C ( x _ { f } ) - 0 ) ^ { 2 } \right]
+$$
+
+# G.5 RALSGAN
+
+$$
+L _ { D } ^ { R a L S G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \left( C ( x _ { r } ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) - 1 \right) ^ { 2 } \right] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \left( C ( x _ { f } ) - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } C ( x _ { r } ) + 1 \right) ^ { 2 } \right]
+$$
+
+$$
+L _ { G } ^ { R a L S G A N } = \mathbb { E } _ { x _ { f } \sim \mathbb { P } } [ ( C ( x _ { f } ) - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } C ( x _ { r } ) - 1 ) ^ { 2 } ] + \mathbb { E } _ { x _ { r } \sim \mathbb { P } } [ ( C ( x _ { r } ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) + 1 ) ^ { 2 } ]
+$$
+
+# G.6 HINGEGAN
+
+$$
+L _ { D } ^ { H i n g e G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \operatorname* { m a x } ( 0 , 1 - C ( x _ { r } ) ) \right] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \operatorname* { m a x } ( 0 , 1 + C ( x _ { f } ) ) \right]
+$$
+
+$$
+L _ { G } ^ { H i n g e G A N } = - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ C ( x _ { f } ) \right]
+$$
+
+# G.7 RAHINGEGAN
+
+$$
+L _ { D } ^ { H i n g e G A N } = \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \operatorname* { m a x } ( 0 , 1 - \tilde { D } ( x _ { r } ) ) \right] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \operatorname* { m a x } ( 0 , 1 + \tilde { D } ( x _ { f } ) ) \right]
+$$
+
+$$
+\begin{array} { c } { { L _ { G } ^ { H i n g e G A N } = \mathbb { E } _ { x _ { f } \sim \mathbb { P } } \left[ \operatorname* { m a x } ( 0 , 1 - \tilde { D } ( x _ { f } ) ) \right] + \mathbb { E } _ { x _ { r } \sim \mathbb { Q } } \left[ \operatorname* { m a x } ( 0 , 1 + \tilde { D } ( x _ { r } ) ) \right] } } \\ { { \tilde { D } ( x _ { r } ) = C ( x _ { r } ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) } } \end{array}
+$$
+
+# G.8 WGAN-GP
+
+$$
+{ \cal L } _ { D } ^ { W G A N - G P } = - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ C ( x _ { r } ) \right] + \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ C ( x _ { f } ) \right] + \lambda \mathbb { E } _ { \hat { x } \sim \mathbb { P } _ { \hat { x } } } \left[ \left( | | \nabla _ { \hat { x } } C ( \hat { x } ) | | _ { 2 } - 1 \right) ^ { 2 } \right]
+$$
+
+$$
+L _ { G } ^ { W G A N - G P } = - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ C ( x _ { f } ) \right]
+$$
+
+$\mathbb { P } _ { \hat { x } }$ is the distribution of $\hat { x } = \epsilon x _ { r } + ( 1 - \epsilon ) x _ { f }$ , where $x _ { r } \sim \mathbb { P } , x _ { f } \sim \mathbb { Q } , \epsilon \sim U [ 0 , 1 ]$ .
+
+# G.9 RSGAN-GP
+
+$$
+{ \cal L } _ { D } ^ { R S G A N } = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ \log ( { \mathrm { s i g m o i d } ( C ( x _ { r } ) - C ( x _ { f } ) ) } ) \right] + \lambda \mathbb { E } _ { \hat { x } \sim \mathbb { P } _ { \hat { x } } } \left[ \left( | | \nabla _ { \hat { x } } C ( \hat { x } ) | | _ { 2 } - 1 \right) ^ { 2 } \right]
+$$
+
+$$
+{ \cal L } _ { G } ^ { R S G A N } = - \mathbb { E } _ { ( x _ { r } , x _ { f } ) \sim ( \mathbb { P } , \mathbb { Q } ) } \left[ \log ( \operatorname { s i g m o i d } ( C ( x _ { f } ) - C ( x _ { r } ) ) ) \right]
+$$
+
+$\mathbb { P } _ { \hat { x } }$ is the distribution of $\hat { x } = \epsilon x _ { r } + ( 1 - \epsilon ) x _ { f }$ , where $x _ { r } \sim \mathbb { P } , x _ { f } \sim \mathbb { Q } , \epsilon \sim U [ 0 , 1 ]$ .
+
+# G.10 RASGAN-GP
+
+$$
+\cdot \mathtt { R a S G A N } = - \mathbb { E } _ { x \sim \mathbb { P } } \left[ \log \left( \tilde { D } ( x _ { r } ) \right) \right] - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \log \left( 1 - \tilde { D } ( x _ { f } ) \right) \right] + \lambda \mathbb { E } _ { \hat { x } \sim \mathbb { P } _ { \hat { z } } } \left[ \left( | | \nabla _ { \tilde { x } } C ( \hat { x } ) | | _ { 2 } - \underline { { 1 } } \right) ^ { 2 } \right]
+$$
+
+$$
+L _ { G } ^ { R a S G A N } = - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } \left[ \log \left( \tilde { D } ( x _ { f } ) \right) \right] - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } \left[ \log \left( 1 - \tilde { D } ( x _ { r } ) \right) \right]
+$$
+
+$\tilde { D } ( x _ { r } ) =$ sigmoid $\left( C ( x _ { r } ) - \mathbb { E } _ { x _ { f } \sim \mathbb { Q } } C ( x _ { f } ) \right)$   
+$\tilde { D } ( x _ { f } ) =$ sigmoid $( C ( x _ { f } ) - \mathbb { E } _ { x _ { r } \sim \mathbb { P } } C ( x _ { r } ) )$   
+$\mathbb { P } _ { \hat { x } }$ is the distribution of $\hat { x } = \epsilon x _ { r } + ( 1 - \epsilon ) x _ { f }$ , where $x _ { r } \sim \mathbb { P } , x _ { f } \sim \mathbb { Q } , \epsilon \sim U [ 0 , 1 ]$ .
+
+# H ALGORITHMS
+
+# Algorithm 1 Training algorithm for non-saturating RGANs with symmetric loss functions
+
+Require: The number of $D$ iterations $n _ { D }$ ( $n _ { D } = 1$ unless one seeks to train $D$ to optimality), batch size $m$ , and functions $f$ which determine the objective function of the discriminator ( $f$ is $f _ { 1 }$ from equation 10 assuming that $f _ { 2 } ( - y ) = f _ { 1 } ( y )$ , which is true for many GANs).
+
+hile $\theta$ has not converged do for $t = 1 , \dots , n _ { D }$ do Sample $\{ \boldsymbol { x } ^ { ( i ) } \} _ { i = 1 } ^ { m } \sim \mathbb { P }$ Sample $\{ z ^ { ( i ) } \} _ { i = 1 } ^ { m } \sim { \mathbb { P } _ { z } }$ Update $w$ using SGD by ascending with $\begin{array} { r } { \nabla _ { w } \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \left[ f ( C _ { w } ( x ^ { ( i ) } ) - C _ { w } ( G _ { \theta } ( z ^ { ( i ) } ) ) ) \right] } \end{array}$ end for   
+Sample $\{ \boldsymbol { x } ^ { ( i ) } \} _ { i = 1 } ^ { m } \sim \mathbb { P }$   
+Sample $\{ z ^ { ( i ) } \} _ { i = 1 } ^ { m } \sim { \mathbb { P } } _ { z }$   
+Update $\theta$ using SGD by ascending with $\begin{array} { r } { \nabla _ { \theta } \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \left[ f ( C _ { w } ( G _ { \theta } ( z ^ { ( i ) } ) ) - C _ { w } ( x ^ { ( i ) } ) ) \right] } \end{array}$
+
+end while
+
+# Algorithm 2 Training algorithm for non-saturating RaGANs
+
+Require: The number of $D$ iterations $n _ { D }$ $n _ { D } = 1$ unless one seek to train $D$ to optimality), batch size $m$ , and functions $f _ { 1 }$ and $f _ { 2 }$ which determine the objective function of the discriminator (see equation 10).
+
+while $\theta$ has not converged do for $t = 1 , \dots , n _ { D }$ do Sample $\{ \boldsymbol { x } ^ { ( i ) } \} _ { i = 1 } ^ { m } \sim \mathbb { P }$ Sample Let Let $\begin{array} { r } { \overline { { C _ { w } ( x _ { r } ) } } = { \frac { 1 } { m } } \sum _ { i = 1 } ^ { m } C _ { w } ( x ^ { ( i ) } ) } \end{array}$ $\{ z ^ { ( i ) } \} _ { i = 1 } ^ { m } \sim { \mathbb { P } } _ { z }$ $\begin{array} { r } { \overline { { C _ { w } ( x _ { f } ) } } = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } C _ { w } ( G _ { \theta } ( z ^ { ( i ) } ) ) } \end{array}$
+
+Update $w$ using SGD by ascending with
+
+$$
+\begin{array} { r } { \nabla _ { w } \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \biggl [ f _ { 1 } ( C _ { w } ( x ^ { ( i ) } ) - \overline { { C _ { w } ( x _ { f } ) } } ) + f _ { 2 } ( C _ { w } ( G _ { \theta } ( z ^ { ( i ) } ) ) - \overline { { C _ { w } ( x _ { r } ) } } ) \biggr ] } \end{array}
+$$
+
+# end for
+
+Update $\theta$ using SGD by ascending with
+
+$$
+\begin{array} { r } { \nabla _ { \theta } \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \Bigl [ f _ { 1 } \bigl ( C _ { w } \bigl ( G _ { \theta } \bigl ( z ^ { ( i ) } \bigr ) \bigr ) - \overline { { C _ { w } \bigl ( x _ { r } \bigr ) } } \bigr ) + f _ { 2 } \bigl ( C _ { w } \bigl ( x ^ { ( i ) } \bigr ) - \overline { { C _ { w } \bigl ( x _ { f } \bigr ) } } \bigr ) \Bigr ] } \end{array}
+$$
+
+end while
+
+Generator   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R128 ~ N(0,I)</td></tr><tr><td rowspan=1 colspan=1>linear, 128 -&gt; 512*4*4</td></tr><tr><td rowspan=1 colspan=1>Reshape, 512*4*4 -&gt; 512 x 4 x 4</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, 512-&gt;256</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, 256-&gt;128</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, 128-&gt;64</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 3x3, stride 1, pad 1, 64-&gt;3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr></table>
+
+Discriminator   
+
+<table><tr><td rowspan=1 colspan=1>CER3x32x32</td></tr><tr><td rowspan=1 colspan=1>Conv2d 3x3,stride 1, pad 1,3-&gt;64</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.1</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, 64-&gt;64</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.1</td></tr><tr><td rowspan=1 colspan=1>Conv2d 3x3, stride 1, pad 1, 64-&gt;128</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.1</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4,stride 2, pad 1, 128-&gt;128</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.1</td></tr><tr><td rowspan=1 colspan=1>Conv2d 3x3, stride 1, pad 1, 128-&gt;256</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.1</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, 256-&gt;256</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.1</td></tr><tr><td rowspan=1 colspan=1>Conv2d 3x3, stride 1, pad 1, 256-&gt;512</td></tr><tr><td rowspan=1 colspan=1>Reshape,512 x 4 x 4 -&gt; 512*4*4</td></tr><tr><td rowspan=1 colspan=1>linear, 512*4*4 -&gt; 1</td></tr></table>
+
+# I.2 DCGAN 64X64
+
+Generator   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R128 ~ N(0,I)</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 1, pad 0, no bias,128-&gt;512</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 2, pad 1, no bias,512-&gt;256</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 2, pad 1, no bias,256-&gt;128</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias,128-&gt;64</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 2, pad 1, no bias, 64-&gt;3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr></table>
+
+Discriminator   
+
+<table><tr><td rowspan=1 colspan=1>x∈ R3x64x64</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias, 3-&gt;64</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2,pad 1, no bias, 64-&gt;128</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,128-&gt;256</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4,stride 2, pad 1, no bias,256-&gt;512</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,512-&gt;1</td></tr></table>
+
+Generator   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R128 ~ N(0,I)</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 1, pad 0, no bias,128-&gt;1024</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 2,pad 1, no bias,1024-&gt;512</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias, 512-&gt;256</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias,256-&gt;128</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias,128-&gt;64</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias, 64-&gt;3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr></table>
+
+Discriminator   
+
+<table><tr><td rowspan=1 colspan=1>C∈R3x128x128</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,3-&gt;64</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,64-&gt;128</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2,pad 1, no bias,128-&gt;256</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias, 256-&gt;512</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias, 512-&gt;1024</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,1024-&gt;1</td></tr></table>
+
+Generator   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R128 ~ N(0,I)</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 1, pad 0, no bias,128-&gt;1024</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias,1024-&gt;512</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2,pad 1, no bias, 512-&gt;256</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 2, pad 1, no bias,256-&gt;128</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias,128-&gt;64</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4,stride 2, pad 1, no bias, 64-&gt;32</td></tr><tr><td rowspan=1 colspan=1>BN and ReLU</td></tr><tr><td rowspan=1 colspan=1>ConvTranspose2d 4x4, stride 2, pad 1, no bias, 64-&gt;3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>x1 ∈R3x256x56,x2 ∈R3x56x256</td></tr><tr><td rowspan=1 colspan=1>Concatenate [x1, x2] ∈ R6x256x256</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,6-&gt;32</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2,pad 1, no bias,32-&gt;64</td></tr><tr><td rowspan=1 colspan=1>LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias, 64-&gt;128</td></tr><tr><td rowspan=1 colspan=1>BN andLeakyReLU0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,128-&gt;256</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2,pad 1, no bias,256-&gt;512</td></tr><tr><td rowspan=1 colspan=1>BN andLeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4,stride 2,pad 1, no bias, 512-&gt;1024</td></tr><tr><td rowspan=1 colspan=1>BN and LeakyReLU 0.2</td></tr><tr><td rowspan=1 colspan=1>Conv2d 4x4, stride 2, pad 1, no bias,1024-&gt;1</td></tr></table>
+
+This shows a selection of cats from certain models. Images shown are from the lowest FID registered at every 10k generator iterations. Given space constraint, with cats in high resolution, we show some of the nicer looking cats for each approach, there are evidently some worse looking cats (See https://github.com/AlexiaJM/RelativisticGAN/tree/ master/images/full_minibatch for all cats of the mini-batch).
+
+![](images/6c96b0c47d6a681d92402ec5819612a513b648d7333b75c6a99421b030e49a34.jpg)  
+Figure 3: 64x64 cats with RaLSGAN $( \mathrm { F I D } = 1 1 . 9 7 )$ )
+
+![](images/93a5e5e60d1f48b307024a2ea7bcf313fa53b7bbf270f2e2d92f734138f70064.jpg)  
+Figure 4: 128x128 cats with RaLSGAN $\mathrm { ( F I D = 1 } 5 . 8 5$ )
+
+![](images/af5d952d7811d39e05822e2300131f2558e09547e3e34785aa15c00c7a36b0f9.jpg)  
+Figure 5: $2 5 6 \times 2 5 6$ cats with GAN (5k iterations)
+
+![](images/9b4fd66ead28838503f85ab7e0f7982c1b042e018ce72ff87de624b49c99449b.jpg)  
+Figure 6: 256x256 cats with LSGAN (5k iterations)
+
+![](images/efafc9497a5ad1da5dff98ddf0d9b98904fb811bf44c1c18a165273455db1016.jpg)  
+Figure 7: 256x256 cats with RaSGAN (FID = 32.11)
+
+![](images/59bc6b8f154af9dd0a9abeaa90488a79336057e5e418eb2598ad7a8761318c87.jpg)  
+Figure 8: 256x256 cats with RaLSGAN $\mathrm { ( F I D } = 3 5 . 2 1 $ )
+
+![](images/17027e182d3ca70500c9843b6e2eb5ef057a03afa9d32e38432cafb95ee49051.jpg)  
+Figure 9: 256x256 cats with SpectralSGAN $\mathrm { ( F I D } = 5 4 . 7 3 $ )
+
+![](images/4b743c332f15e44aa1a77a85337371f1b44e2e93a7697fcb4da9d8003a0c5b56.jpg)  
+Figure 10: 256x256 cats with WGAN-GP $\mathrm { { F I D } > 1 0 0 } )$ )

parse/train/SkhQHMW0W/SkhQHMW0W.md

@@ -0,0 +1,355 @@
+# DEEP GRADIENT COMPRESSION: REDUCING THE COMMUNICATION BANDWIDTH FOR DISTRIBUTED TRAINING
+
+Yujun Lin ∗   
+Tsinghua University   
+Beijing National Research Center   
+for Information Science and Technology   
+linyy14@mails.tsinghua.edu.cn   
+Song Han †   
+Stanford University   
+Google Brain   
+songhan@stanford.edu
+
+Huizi Mao Stanford University huizi@stanford.edu
+
+# Yu Wang
+
+Tsinghua University Beijing National Research Center for Information Science and Technology yu-wang@mail.tsinghua.edu.cn
+
+William J. Dally Stanford University NVIDIA dally@stanford.edu
+
+# ABSTRACT
+
+Large-scale distributed training requires significant communication bandwidth for gradient exchange that limits the scalability of multi-node training, and requires expensive high-bandwidth network infrastructure. The situation gets even worse with distributed training on mobile devices (federated learning), which suffers from higher latency, lower throughput, and intermittent poor connections. In this paper, we find $9 9 . 9 \%$ of the gradient exchange in distributed SGD are redundant, and propose Deep Gradient Compression (DGC) to greatly reduce the communication bandwidth. To preserve accuracy during this compression, DGC employs four methods: momentum correction, local gradient clipping, momentum factor masking, and warm-up training. We have applied Deep Gradient Compression to image classification, speech recognition, and language modeling with multiple datasets including Cifar10, ImageNet, Penn Treebank, and Librispeech Corpus. On these scenarios, Deep Gradient Compression achieves a gradient compression ratio from $2 7 0 \times$ to $6 0 0 \times$ without losing accuracy, cutting the gradient size of ResNet-50 from 97MB to 0.35MB, and for DeepSpeech from 488MB to 0.74MB. Deep gradient compression enables large-scale distributed training on inexpensive commodity 1Gbps Ethernet and facilitates distributed training on mobile.
+
+# 1 INTRODUCTION
+
+Large-scale distributed training improves the productivity of training deeper and larger models (Chilimbi et al., 2014; Xing et al., 2015; Moritz et al., 2015; Zinkevich et al., 2010). Synchronous stochastic gradient descent (SGD) is widely used for distributed training. By increasing the number of training nodes and taking advantage of data parallelism, the total computation time of the forward-backward passes on the same size training data can be dramatically reduced. However, gradient exchange is costly and dwarfs the savings of computation time (Li et al., 2014; Wen et al.,
+
+![](images/4fc386e290a584c321a5ceece6dddea87170b012d181d7057dd735c2a74c1c93.jpg)  
+Figure 1: Deep Gradient Compression can reduce the communication time, improve the scalability, and speed up distributed training.
+
+2017), especially for recurrent neural networks (RNN) where the computation-to-communication ratio is low. Therefore, the network bandwidth becomes a significant bottleneck for scaling up distributed training. This bandwidth problem gets even worse when distributed training is performed on mobile devices, such as federated learning (McMahan et al., 2016; Konecnˇ y et al., 2016). Training \` on mobile devices is appealing due to better privacy and better personalization (Google, 2017), but a critical problem is that those mobile devices suffer from even lower network bandwidth, intermittent network connections, and expensive mobile data plan.
+
+Deep Gradient Compression (DGC) solves the communication bandwidth problem by compressing the gradients, as shown in Figure 1. To ensure no loss of accuracy, DGC employs momentum correction and local gradient clipping on top of the gradient sparsification to maintain model performance. DGC also uses momentum factor masking and warmup training to overcome the staleness problem caused by reduced communication.
+
+We empirically verified Deep Gradient Compression on a wide range of tasks, models, and datasets: CNN for image classification (with Cifar10 and ImageNet), RNN for language modeling (with Penn Treebank) and speech recognition (with Librispeech Corpus). These experiments demonstrate that gradients can be compressed up to $6 0 0 \times$ without loss of accuracy, which is an order of magnitude higher than previous work (Aji & Heafield, 2017).
+
+# 2 RELATED WORK
+
+Researchers have proposed many approaches to overcome the communication bottleneck in distributed training. For instance, asynchronous SGD accelerates the training by removing gradient synchronization and updating parameters immediately once a node has completed back-propagation (Dean et al., 2012; Recht et al., 2011; Li et al., 2014). Gradient quantization and sparsification to reduce communication data size are also extensively studied.
+
+Gradient Quantization Quantizing the gradients to low-precision values can reduce the communication bandwidth. Seide et al. (2014) proposed 1-bit SGD to reduce gradients transfer data size and achieved $1 0 \times$ speedup in traditional speech applications. Alistarh et al. (2016) proposed another approach called QSGD which balance the trade-off between accuracy and gradient precision. Similar to QSGD, Wen et al. (2017) developed TernGrad which uses 3-level gradients. Both of these works demonstrate the convergence of quantized training, although TernGrad only examined CNNs and QSGD only examined the training loss of RNNs. There are also attempts to quantize the entire model, including gradients. DoReFa-Net (Zhou et al., 2016) uses 1-bit weights with 2-bit gradients.
+
+Gradient Sparsification Strom (2015) proposed threshold quantization to only send gradients larger than a predefined constant threshold. However, the threshold is hard to choose in practice. Therefore, Dryden et al. (2016) chose a fixed proportion of positive and negative gradient updates separately, and Aji & Heafield (2017) proposed Gradient Dropping to sparsify the gradients by a single threshold based on the absolute value. To keep the convergence speed, Gradient Dropping
+
+# Algorithm 1 Gradient Sparsification on node $k$
+
+Input: dataset $\chi$   
+Input: minibatch size $^ { b }$ per node   
+Input: the number of nodes $N$   
+Input: optimization function $S G D$   
+Input: init parameters $w = \{ w [ 0 ] , w [ 1 ] , \cdot \cdot \cdot , w [ M ] \}$   
+1: $G ^ { k }  0$   
+2: for $t = 0 , 1 , \cdots$ do   
+3: $G _ { t } ^ { k } \gets \hat { G } _ { t - 1 } ^ { k }$   
+4: for $i = 1 , \cdots , b \bullet$ do   
+5: Sample data $x$ from $\chi$   
+6: $\begin{array} { r } { G _ { t } ^ { k } \stackrel { \cdot } {  } G _ { t } ^ { k } + \frac { 1 } { N b } \nabla f \tilde { ( } x ; w _ { t } ) } \end{array}$   
+7: end for   
+8: for $j = 0 , \cdots , M$ do   
+9: Select threshold: $t h r  s \%$ of $\left. G _ { t } ^ { k } [ j ] \right.$   
+10: $\begin{array} { r l } & { M a s k  | G _ { t } ^ { k } [ j ] | > t h r } \\ & { \widetilde { G } _ { t } ^ { k } [ j ]  G _ { t } ^ { k } [ j ] \odot M a s k } \\ & { G _ { t } ^ { k } [ j ]  G _ { t } ^ { k } [ j ] \odot \neg M a s k } \end{array}$   
+11:   
+12:   
+13: 14: $A l l$ d for-reduce $\begin{array} { r } { G _ { t } ^ { k } : G _ { t } \gets \sum _ { k = 1 } ^ { N } e n c o d e ( \widetilde { G } _ { t } ^ { k } ) } \end{array}$   
+15: $w _ { t + 1 } \gets S G D \left( w _ { t } , G _ { t } \right)$   
+16: end for
+
+![](images/124b78f7ccaaa13342437c8a70de1680a2c9c82ac80fc3a7636059550529fc06.jpg)  
+Figure 2: Momentum Correction
+
+requires adding the layer normalization(Lei Ba et al., 2016). Gradient Dropping saves $9 9 \%$ of gradient exchange while incurring $0 . 3 \%$ loss of BLEU score on a machine translation task. Concurrently, Chen et al. (2017) proposed to automatically tunes the compression rate depending on local gradient activity, and gained compression ratio around $2 0 0 \times$ for fully-connected layers and $4 0 \times$ for convolutional layers with negligible degradation of top-1 accuracy on ImageNet dataset.
+
+Compared to the previous work, DGC pushes the gradient compression ratio to up to $6 0 0 \times$ for the whole model (same compression ratio for all layers). DGC does not require extra layer normalization, and thus does not need to change the model structure. Most importantly, Deep Gradient Compression results in no loss of accuracy.
+
+# 3 DEEP GRADIENT COMPRESSION
+
+# 3.1 GRADIENT SPARSIFICATION
+
+We reduce the communication bandwidth by sending only the important gradients (sparse update). We use the gradient magnitude as a simple heuristics for importance: only gradients larger than a threshold are transmitted. To avoid losing information, we accumulate the rest of the gradients locally. Eventually, these gradients become large enough to be transmitted. Thus, we send the large gradients immediately but eventually send all of the gradients over time, as shown in Algorithm 1. The encode() function packs the 32-bit nonzero gradient values and 16-bit run lengths of zeros.
+
+The insight is that the local gradient accumulation is equivalent to increasing the batch size over time. Let $F ( w )$ be the loss function which we want to optimize. Synchronous Distributed SGD performs the following update with $N$ training nodes in total:
+
+$$
+F ( w ) = \frac { 1 } { | \chi | } \sum _ { x \in \chi } f ( x , w ) , \qquad w _ { t + 1 } = w _ { t } - \eta \frac { 1 } { N b } \sum _ { k = 1 } ^ { N } \sum _ { x \in \mathcal { B } _ { k , t } } \nabla f ( x , w _ { t } )
+$$
+
+where $\chi$ is the training dataset, $w$ are the weights of a network, $f ( x , w )$ is the loss computed from samples $x \in \chi , \eta$ is the learning rate, $N$ is the number of training nodes, and $B _ { k , t }$ for $1 \leq k < N$ is a sequence of $N$ minibatches sampled from $\chi$ at iteration $t$ , each of size $b$ .
+
+Consider the weight value $w ^ { ( i ) }$ of $i$ -th position in flattened weights $w$ . After $T$ iterations, we have
+
+$$
+w _ { t + T } ^ { ( i ) } = w _ { t } ^ { ( i ) } - \eta T \cdot \frac { 1 } { N b T } \sum _ { k = 1 } ^ { N } \left( \sum _ { \tau = 0 } ^ { T - 1 } \sum _ { x \in \mathcal { B } _ { k , t + \tau } } \nabla ^ { ( i ) } f ( x , w _ { t + \tau } ) \right)
+$$
+
+Equation 2 shows that local gradient accumulation can be considered as increasing the batch size from $N b$ to $N b T$ (the second summation over $\tau$ ), where $T$ is the length of the sparse update interval between two iterations at which the gradient of $w ^ { ( i ) }$ is sent. Learning rate scaling (Goyal et al., 2017) is a commonly used technique to deal with large minibatch. It is automatically satisfied in Equation 2 where the $T$ in the learning rate $\eta T$ and batch size $N b T$ are canceled out.
+
+# 3.2 IMPROVING THE LOCAL GRADIENT ACCUMULATION
+
+Without care, the sparse update will greatly harm convergence when sparsity is extremely high (Chen et al., 2017). For example, Algorithm 1 incurred more than $1 . 0 \%$ loss of accuracy on the Cifar10 dataset, as shown in Figure 3(a). We find momentum correction and local gradient clipping can mitigate this problem.
+
+Momentum Correction Momentum SGD is widely used in place of vanilla SGD. However, Algorithm 1 doesn’t directly apply to SGD with the momentum term, since it ignores the discounting factor between the sparse update intervals.
+
+Distributed training with vanilla momentum SGD on $N$ training nodes follows (Qian, 1999),
+
+$$
+u _ { t } = m u _ { t - 1 } + \sum _ { k = 1 } ^ { N } \left( \nabla _ { k , t } \right) , \quad w _ { t + 1 } = w _ { t } - \eta u _ { t }
+$$
+
+where $m$ is the momentum, $N$ is the number of training nodes, and $\begin{array} { r } { \nabla _ { k , t } = \frac { 1 } { N b } \sum _ { x \in { \mathcal { B } _ { k , t } } } \nabla f ( x , w _ { t } ) } \end{array}$
+
+Consider the weight value $w ^ { ( i ) }$ of $i$ -th position in flattened weights $w$ . After $T$ iterations, the change in weight value $w ^ { ( i ) }$ shows as follows,
+
+$$
+w _ { t + T } ^ { ( i ) } = w _ { t } ^ { ( i ) } - \eta \left[ \cdots + \left( \sum _ { \tau = 0 } ^ { T - 2 } m ^ { \tau } \right) \nabla _ { k , t + 1 } ^ { ( i ) } + \left( \sum _ { \tau = 0 } ^ { T - 1 } m ^ { \tau } \right) \nabla _ { k , t } ^ { ( i ) } \right]
+$$
+
+If SGD with the momentum is directly applied to the sparse gradient scenario (line 15 in Algorithm 1), the update rule is no longer equivalent to Equation 3, which becomes:
+
+$$
+v _ { k , t } = v _ { k , t - 1 } + \nabla _ { k , t } , \quad u _ { t } = m u _ { t - 1 } + \sum _ { k = 1 } ^ { N } s p a r s e \left( v _ { k , t } \right) , \quad w _ { t + 1 } = w _ { t } - \eta u _ { t }
+$$
+
+where the first term is the local gradient accumulation on the training node $k$ . Once the accumulation result $v _ { k , t }$ is larger than a threshold, it will pass hard thresholding in the sparse () function, and be encoded and get sent over the network in the second term. Similarly to the line 12 in Algorithm 1, the accumulation result $v _ { k , t }$ gets cleared by the mask in the sparse $( )$ function.
+
+The change in weight value $w ^ { ( i ) }$ after the sparse update interval $T$ becomes,
+
+$$
+w _ { t + T } ^ { ( i ) } = w _ { t } ^ { ( i ) } - \eta \left( \cdot \cdot \cdot + \nabla _ { k , t + 1 } ^ { ( i ) } + \nabla _ { k , t } ^ { ( i ) } \right)
+$$
+
+The disappearance of the accumulated discounting factor $\scriptstyle \sum _ { \tau = 0 } ^ { T - 1 } m ^ { \tau }$ in Equation 6 compared to Equation 4 leads to the loss of convergence performance. It is illustrated in Figure 2(a), where Equation 4 drives the optimization from point $A$ to point $B$ , but with local gradient accumulation, Equation 4 goes to point $C$ . When the gradient sparsity is high, the update interval $T$ dramatically increases, and thus the significant side effect will harm the model performance. To avoid this error, we need momentum correction on top of Equation 5 to make sure the sparse update is equivalent to the dense update as in Equation 3.
+
+If we regard the velocity $u _ { t }$ in Equation 3 as ”gradient”, the second term of Equation 3 can be considered as the vanilla SGD for the ”gradient” $u _ { t }$ . The local gradient accumulation is proved to be effective for the vanilla SGD in Section 3.1. Therefore, we can locally accumulate the velocity $u _ { t }$ instead of the real gradient $\nabla _ { k , t }$ to migrate Equation 5 to approach Equation 3:
+
+$$
+u _ { k , t } = m u _ { k , t - 1 } + \nabla _ { k , t } , \quad v _ { k , t } = v _ { k , t - 1 } + u _ { k , t } , \quad w _ { t + 1 } = w _ { t } - \eta \sum _ { k = 1 } ^ { N } s p a r s e \left( v _ { k , t } \right) ,
+$$
+
+where the first two terms are the corrected local gradient accumulation, and the accumulation result $v _ { k , t }$ is used for the subsequent sparsification and communication. Bumulation, we can deduce the accumulated discounting factor le change in the localin Equation 4 from $\scriptstyle \sum _ { \tau = 0 } ^ { T - 1 } m ^ { \tau }$ Equation 7, as shown in Figure 2(b).
+
+We refer to this migration as the momentum correction. It is a tweak to the update equation, it doesn’t incur any hyper parameter. Beyond the vanilla momentum SGD, we also look into Nesterov momentum SGD in Appendix B, which is similar to momentum SGD.
+
+Local Gradient Clipping Gradient clipping is widely adopted to avoid the exploding gradient problem (Bengio et al., 1994). The method proposed by Pascanu et al. (2013) rescales the gradients whenever the sum of their L2-norms exceeds a threshold. This step is conventionally executed after gradient aggregation from all nodes. Because we accumulate gradients over iterations on each node independently, we perform the gradient clipping locally before adding the current gradient $G _ { t }$ to previous accumulation $( G _ { t - 1 }$ in Algorithm 1). As explained in Appendix C, we scale the threshold by $N ^ { - 1 / 2 }$ , the current node’s fraction of the global threshold if all $N$ nodes had identical gradient distributions. In practice, we find that the local gradient clipping behaves very similarly to the vanilla gradient clipping in training, which suggests that our assumption might be valid in real-world data.
+
+As we will see in Section 4, momentum correction and local gradient clipping help improve the word error rate from $1 4 . 1 \%$ to $1 2 . 9 \%$ on the AN4 corpus, while training curves follow the momentum SGD more closely.
+
+# 3.3 OVERCOMING THE STALENESS EFFECT
+
+Because we delay the update of small gradients, when these updates do occur, they are outdated or stale. In our experiments, most of the parameters are updated every 600 to 1000 iterations when gradient sparsity is $9 9 . 9 \%$ , which is quite long compared to the number of iterations per epoch. Staleness can slow down convergence and degrade model performance. We mitigate staleness with momentum factor masking and warm-up training.
+
+Momentum Factor Masking Mitliagkas et al. (2016) discussed the staleness caused by asynchrony and attributed it to a term described as implicit momentum. Inspired by their work, we introduce momentum factor masking, to alleviate staleness. Instead of searching for a new momentum coefficient as suggested in Mitliagkas et al. (2016), we simply apply the same mask to both the accumulated gradients $v _ { k , t }$ and the momentum factor $u _ { k , t }$ in Equation 7:
+
+$$
+M a s k \gets | v _ { k , t } | > t h r , \quad v _ { k , t } \gets v _ { k , t } \odot \neg M a s k , \quad u _ { k , t } \gets u _ { k , t } \odot \neg M a s k
+$$
+
+This mask stops the momentum for delayed gradients, preventing the stale momentum from carrying the weights in the wrong direction.
+
+Warm-up Training In the early stages of training, the network is changing rapidly, and the gradients are more diverse and aggressive. Sparsifying gradients limits the range of variation of the model, and thus prolongs the period when the network changes dramatically. Meanwhile, the remaining aggressive gradients from the early stage are accumulated before being chosen for the next update, and therefore they may outweigh the latest gradients and misguide the optimization direction. The warm-up training method introduced in large minibatch training (Goyal et al., 2017) is helpful. During the warm-up period, we use a less aggressive learning rate to slow down the changing speed of the neural network at the start of training, and also less aggressive gradient sparsity, to reduce the number of extreme gradients being delayed. Instead of linearly ramping up the learning rate during the first several epochs, we exponentially increase the gradient sparsity from a relatively small value to the final value, in order to help the training adapt to the gradients of larger sparsity.
+
+Table 1: Techniques in Deep Gradient Compression   
+
+<table><tr><td rowspan=1 colspan=1>Techniques</td><td rowspan=1 colspan=1>Gradient        DeepDropping      Gradient(Aji &amp; Heafield,2017) Compression</td><td rowspan=1 colspan=1>Overcome StalenessReduce     Ensure                MaintainImproveBandwidthConvergenceAccuracyConvergenceIterations</td></tr><tr><td rowspan=1 colspan=1>GradientSparsification</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Local GradientAccumulation</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>MomentumCorrection</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Local GradientClipping</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>MomentumFactor Masking</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Warm-upTraining</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√           √</td></tr></table>
+
+As shown in Table 1, momentum correction and local gradient clipping improve the local gradient accumulation, while the momentum factor masking and warm-up training alleviate the staleness effect. On top of gradient sparsification and local gradient accumulation, these four techniques make up the Deep Gradient Compression (pseudo code in Appendix D), and help push the gradient compression ratio higher while maintaining the accuracy.
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENT SETTINGS
+
+We validate our approach on three types of machine learning tasks: image classification on Cifar10 and ImageNet, language modeling on Penn Treebank dataset, and speech recognition on AN4 and Librispeech corpus. The only hyper-parameter introduced by Deep Gradient Compression is the warm-up training strategy. In all experiments related to DGC, we rise the sparsity in the warm-up period as follows: $7 5 \%$ , $9 3 . 7 5 \%$ , $9 8 . 4 3 7 5 \%$ , $9 9 . 6 \%$ , $9 9 . 9 \%$ (exponentially increase till $9 9 . 9 \%$ ). We evaluate the reduction in the network bandwidth by the gradient compression ratio as follows,
+
+$$
+\mathrm { \ " { s r a d i e n t } ~ C o m p r e s s i o n ~ R a t i o } = s i z e \left[ e n c o d e \left( s p a r s e ( G ^ { k } ) \right) \right] / s i z e \left[ G ^ { k } \right]
+$$
+
+where $G ^ { k }$ is the gradients computed on the training node $k$ .
+
+Image Classification We studied ResNet-110 on Cifar10, AlexNet and ResNet-50 on ImageNet. Cifar10 consists of 50,000 training images and 10,000 validation images in 10 classes (Krizhevsky & Hinton, 2009), while ImageNet contains over 1 million training images and 50,000 validation images in 1000 classes (Deng et al., 2009). We train the models with momentum SGD following the training schedule in Gross & Wilber (2016). The warm-up period for DGC is 4 epochs out of164 epochs for Cifar10 and 4 epochs out of 90 epochs for ImageNet Dataset.
+
+Language Modeling The Penn Treebank corpus (PTB) dataset consists of 923,000 training, 73,000 validation and 82,000 test words (Marcus et al., 1993). The vocabulary we select is the same as the one in Mikolov et al. (2010). We adopt the 2-layer LSTM language model architecture with 1500 hidden units per layer (Press & Wolf, 2016), tying the weights of encoder and decoder as suggested in Inan et al. (2016) and using vanilla SGD with gradient clipping, while learning rate decays when no improvement has been made in validation loss. The warm-up period is 1 epoch out of 40 epochs.
+
+Table 2: ResNet-110 trained on Cifar10 Dataset   
+
+<table><tr><td># GPUs in total</td><td>Batchsize in total per iteration</td><td>Training Method</td><td>Top 1 Accuracy</td><td></td></tr><tr><td rowspan="3">4</td><td rowspan="3">128</td><td>Baseline</td><td>93.75%</td><td></td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield, 2017)</td><td>92.75%</td><td>-1.00%</td></tr><tr><td>Deep Gradient Compression</td><td>93.87%</td><td>+0.12%</td></tr><tr><td rowspan="3">8</td><td rowspan="3">256</td><td>Baseline</td><td>92.92%</td><td></td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield,2017)</td><td>93.02%</td><td>+0.10%</td></tr><tr><td>Deep Gradient Compression</td><td>93.28%</td><td>+0.37%</td></tr><tr><td rowspan="3">16</td><td rowspan="3">512</td><td>Baseline</td><td>93.14%</td><td>-0.21%</td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield, 2017)</td><td>92.93%</td><td></td></tr><tr><td>Deep Gradient Compression</td><td>93.20%</td><td>+0.06%</td></tr><tr><td rowspan="3">32</td><td rowspan="3">1024</td><td>Baseline</td><td>93.10%</td><td></td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield, 2017)</td><td>92.10%</td><td>-1.00%</td></tr><tr><td>Deep Gradient Compression</td><td>93.18%</td><td>+0.08%</td></tr></table>
+
+Table 3: Comparison of gradient compression ratio on ImageNet Dataset   
+
+<table><tr><td>Model</td><td>Training Method</td><td>Top-1 Accuracy</td><td>Top-5 Accuracy</td><td>Gradient Size</td><td>Compression Ratio</td></tr><tr><td rowspan="5">AlexNet</td><td>Baseline</td><td>58.17%</td><td>80.19%</td><td>232.56 MB</td><td>1x</td></tr><tr><td>TernGrad</td><td>57.28%</td><td>80.23%</td><td>1 29.18 MB</td><td>8×</td></tr><tr><td>(Wen et al., 2017) Deep Gradient</td><td>(-0.89%) 58.20%</td><td>(+0.04%) 80.20%</td><td>2</td><td></td></tr><tr><td>Compression</td><td>(+0.03%)</td><td>(+0.01%)</td><td>0.39 MB</td><td>597 ×</td></tr><tr><td>Baseline</td><td>75.96</td><td>92.91%</td><td>97.49 MB</td><td>1×</td></tr><tr><td>ResNet-50</td><td>Deep Gradient Compression</td><td>76.15 (+0.19%)</td><td>92.97% (+0.06%)</td><td>0.35 MB</td><td>277×</td></tr></table>
+
+Speech Recognition The AN4 dataset contains 948 training and 130 test utterances (Acero, 1990) while Librispeech corpus contains 960 hours of reading speech (Panayotov et al., 2015). We use DeepSpeech architecture without $\mathbf { n }$ -gram language model, which is a multi-layer RNN following a stack of convolution layers (Hannun et al., 2014). We train a 5-layer LSTM of 800 hidden units per layer for AN4, and a 7-layer GRU of 1200 hidden units per layer for LibriSpeech, with Nesterov momentum $S G D$ and gradient clipping, while learning rate anneals every epoch. The warm-up period for DGC is 1 epoch out of 80 epochs.
+
+# 4.2 RESULTS AND ANALYSIS
+
+We first examine Deep Gradient Compression on image classification task. Figure 3(a) and 3(b) are the Top-1 accuracy and training loss of ResNet-110 on Cifar10 with 4 nodes. The gradient sparsity is $9 9 . 9 \%$ (only $0 . 1 \%$ is non-zero). The learning curve of Gradient Dropping (Aji & Heafield, 2017) (red) is worse than the baseline due to gradient staleness. With momentum correction (yellow), the learning curve converges slightly faster, and the accuracy is much closer to the baseline. With momentum factor masking and warm-up training techniques (blue), gradient staleness is eliminated, and the learning curve closely follows the baseline. Table 2 shows the detailed accuracy. The accuracy of ResNet-110 is fully maintained while using Deep Gradient Compression.
+
+When scaling to the large-scale dataset, Figure 3(c) and 3(d) show the learning curve of ResNet-50 when the gradient sparsity is $9 9 . 9 \%$ . The accuracy fully matches the baseline. An interesting observation is that the top-1 error of training with sparse gradients decreases faster than the baseline with the same training loss. Table 3 shows the results of AlexNet and ResNet-50 training on ImageNet with 4 nodes. We compare the gradient compression ratio with Terngrad (Wen et al., 2017) on AlexNet (ResNet is not studied in Wen et al. (2017)). Deep Gradient Compression gives $7 5 \times$ better compression than Terngrad with no loss of accuracy. For ResNet-50, the compression ratio is slightly lower ( $2 7 7 \times$ vs. $5 9 7 \times$ ) with a slight increase in accuracy.
+
+![](images/e656c450092c001f7c593a39af68523f3d343082b527c6df59aca5c41a496228.jpg)  
+Figure 3: Learning curves of ResNet in image classification task (the gradient sparsity is $9 9 . 9 \%$ ).
+
+Table 4: Training results of language modeling and speech recognition with 4 nodes   
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=3>Language Modeling on PTB</td><td rowspan=1 colspan=3> Speech Recognition on LibriSpeech</td></tr><tr><td rowspan=2 colspan=1>TrainingMethod</td><td rowspan=2 colspan=1>Perplexity</td><td rowspan=2 colspan=1>GradientSize</td><td rowspan=2 colspan=1>CompressionRatio</td><td rowspan=1 colspan=1>Word Error Rate (WER)</td><td rowspan=2 colspan=1>GradientSize</td><td rowspan=2 colspan=1>CompressionRatio</td></tr><tr><td rowspan=1 colspan=1>test-clean  test-other</td></tr><tr><td rowspan=1 colspan=1>Baseline</td><td rowspan=1 colspan=1>72.30</td><td rowspan=1 colspan=1>194.68MB</td><td rowspan=1 colspan=1>1x</td><td rowspan=1 colspan=1>9.45%     27.07%</td><td rowspan=1 colspan=1>488.08 MB</td><td rowspan=1 colspan=1>1x</td></tr><tr><td rowspan=1 colspan=1>Deep GradientCompression</td><td rowspan=1 colspan=1>72.24(-0.06)</td><td rowspan=1 colspan=1>0.42 MB</td><td rowspan=1 colspan=1>462 ×</td><td rowspan=1 colspan=1>9.06%     27.04%(-0.39%)   (-0.03%)</td><td rowspan=1 colspan=1>0.74 MB</td><td rowspan=1 colspan=1>608×</td></tr></table>
+
+For language modeling, Figure 4 shows the perplexity and training loss of the language model trained with 4 nodes when the gradient sparsity is $9 9 . 9 \%$ . The training loss with Deep Gradient Compression closely match the baseline, so does the validation perplexity. From Table 4, Deep Gradient Compression compresses the gradient by $4 6 2 \times$ with a slight reduction in perplexity.
+
+For speech recognition, Figure 5 shows the word error rate (WER) and training loss curve of 5-layer LSTM on AN4 Dataset with 4 nodes when the gradient sparsity is $9 9 . 9 \%$ . The learning curves show the same improvement acquired from techniques in Deep Gradient Compression as for the image network. Table 4 shows word error rate (WER) performance on LibriSpeech test dataset, where test-clean contains clean speech and test-other noisy speech. The model trained with Deep Gradient Compression gains better recognition ability on both clean and noisy speech, even when gradients size is compressed by $6 0 8 \times$ .
+
+# 5 SYSTEM ANALYSIS AND PERFORMANCE
+
+Implementing DGC requires gradient top- $k$ selection. Given the target sparsity ratio of $9 9 . 9 \%$ , we need to pick the top $0 . 1 \%$ largest over millions of weights. Its complexity is $O ( n )$ , where $n$ is the number of the gradient elements (Cormen, 2009). We propose to use sampling to reduce top- $k$ selection time. We sample only $0 . 1 \%$ to $1 \%$ of the gradients and perform top- $k$ selection on the samples to estimate the threshold for the entire population. If the number of gradients exceeding the threshold is far more than expected, a precise threshold is calculated from the already-selected gradients. Hierarchically calculating the threshold significantly reduces top- $k$ selection time. In practice, total extra computation time is negligible compared to network communication time which is usually from hundreds of milliseconds to several seconds depending on the network bandwidth.
+
+![](images/da729b546b722eb99540362f021c38de97675aa8a17d5ae1cd3d1a74da50f94a.jpg)  
+Figure 4: Perplexity and training loss of LSTM language model on PTB dataset (the gradient sparsity is $9 9 . 9 \%$ ).
+
+![](images/bb4e3055bd7875c3516526a76cdc8c3060114f813f5a668f138b55bd3fbae26b.jpg)  
+Figure 5: WER and training loss of 5-layer LSTM on AN4 (the gradient sparsity is $9 9 . 9 \%$
+
+![](images/94ecc53592aacda14a957cf87a0316a83bf0163aa1dd7c6c51ff89d2d819db0b.jpg)
+
+![](images/01aa745236eba55636af83f7a478017e6ef9f97dacffb205e6d02938d815c04f.jpg)  
+Figure 6: Deep Gradient Compression improves the speedup and scalability of distributed training. Each training node has 4 NVIDIA Titan XP GPUs and one PCI switch.
+
+We use the performance model proposed in Wen et al. (2017) to perform the scalability analysis, combining the lightweight profiling on single training node with the analytical communication modeling. With the all-reduce communication model (Rabenseifner, 2004; Bruck et al., 1997), the density of sparse data doubles at every aggregation step in the worst case. However, even considering this effect, Deep Gradient Compression still significantly reduces the network communication time, as implied in Figure 6.
+
+Figure 6 shows the speedup of multi-node training compared with single-node training. Conventional training achieves much worse speedup with 1Gbps (Figure 6(a)) than 10Gbps Ethernet (Figure 6(b)). Nonetheless, Deep Gradient Compression enables the training with 1Gbps Ethernet to be competitive with conventional training with 10Gbps Ethernet. For instance, when training AlexNet with 64 nodes, conventional training only achieves about $3 0 \times$ speedup with 10Gbps Ethernet (Apache, 2016), while with DGC, more than $4 0 \times$ speedup is achieved with only 1Gbps Ethernet. From the comparison of Figure 6(a) and 6(b), Deep Gradient Compression benefits even more when the communication-to-computation ratio of the model is higher and the network bandwidth is lower.
+
+# 6 CONCLUSION
+
+Deep Gradient Compression (DGC) compresses the gradient by $2 7 0 { - } 6 0 0 \times$ for a wide range of CNNs and RNNs. To achieve this compression without slowing down the convergence, DGC employs momentum correction, local gradient clipping, momentum factor masking and warm-up training. We further propose hierarchical threshold selection to speed up the gradient sparsification process. Deep Gradient Compression reduces the required communication bandwidth and improves the scalability of distributed training with inexpensive, commodity networking infrastructure.
+
+# 7 ACKNOWLEDGEMENT
+
+This work was supported by National Natural Science Foundation of China (No.61622403), Tsinghua University Initiative Scientific Research Program and Beijing National Research Center for Information Science and Technology. We are also thankful to reviewers for their helpful suggestions.
+
+# REFERENCES
+
+Alejandro Acero. Acoustical and environmental robustness in automatic speech recognition. In Proc. of ICASSP, 1990.
+
+Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. In Empirical Methods in Natural Language Processing (EMNLP), 2017.
+
+Dan Alistarh, Jerry Li, Ryota Tomioka, and Milan Vojnovic. Qsgd: Randomized quantization for communication-optimal stochastic gradient descent. arXiv preprint arXiv:1610.02132, 2016.
+
+Apache. Image classification with mxnet. https://github.com/apache/incubator-mxnet/ tree/master/example/image-classification, 2016.
+
+Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE transactions on neural networks, 5(2):157–166, 1994.
+
+Jehoshua Bruck, Ching-Tien Ho, Shlomo Kipnis, Eli Upfal, and Derrick Weathersby. Efficient algorithms for all-to-all communications in multiport message-passing systems. IEEE Transactions on parallel and distributed systems, 8(11):1143–1156, 1997.
+
+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.
+
+Trishul M Chilimbi, Yutaka Suzue, Johnson Apacible, and Karthik Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In OSDI, volume 14, pp. 571–582, 2014.
+
+Thomas H Cormen. Introduction to algorithms. MIT press, 2009.
+
+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.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009.
+
+Nikoli Dryden, Sam Ade Jacobs, Tim Moon, and Brian Van Essen. Communication quantization for dataparallel training of deep neural networks. In Proceedings of the Workshop on Machine Learning in High Performance Computing Environments, pp. 1–8. IEEE Press, 2016.
+
+Google. Federated learning: Collaborative machine learning without centralized training data, 2017. URL https://research.googleblog.com/2017/04/ federated-learning-collaborative.html.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, ´ Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+S. Gross and M. Wilber. Training and investigating residual nets. https://github.com/facebook/ fb.resnet.torch, 2016.
+
+Awni Hannun, Carl Case, Jared Casper, Bryan Catanzaro, Greg Diamos, Erich Elsen, Ryan Prenger, Sanjeev Satheesh, Shubho Sengupta, Adam Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014.
+
+Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. arXiv preprint arXiv:1611.01462, 2016.
+
+Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richt \` arik, Ananda Theertha Suresh, and Dave Bacon. ´ Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.   
+J. Lei Ba, J. R. Kiros, and G. E. Hinton. Layer Normalization. ArXiv e-prints, July 2016.   
+Mu Li, David G Andersen, Alexander J Smola, and Kai Yu. Communication efficient distributed machine learning with the parameter server. In Advances in Neural Information Processing Systems, pp. 19–27, 2014.   
+Mitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a large annotated corpus of english: The penn treebank. COMPUTATIONAL LINGUISTICS, 19(2):313–330, 1993.   
+H Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, et al. Communication-efficient learning of deep networks from decentralized data. arXiv preprint arXiv:1602.05629, 2016.   
+Tomas Mikolov, Martin Karafiat, Lukas Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent neural \` network based language model. In Interspeech, volume 2, pp. 3, 2010.   
+Ioannis Mitliagkas, Ce Zhang, Stefan Hadjis, and Christopher Re. Asynchrony begets momentum, with an ´ application to deep learning. In Communication, Control, and Computing (Allerton), 2016 54th Annual Allerton Conference on, pp. 997–1004. IEEE, 2016.   
+Philipp Moritz, Robert Nishihara, Ion Stoica, and Michael I Jordan. Sparknet: Training deep networks in spark. arXiv preprint arXiv:1511.06051, 2015.   
+Yurii Nesterov. A method of solving a convex programming problem with convergence rate o (1/k2). In Soviet Mathematics Doklady, volume 27, pp. 372–376, 1983.   
+Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In Acoustics, Speech and Signal Processing (ICASSP), 2015 IEEE International Conference on, pp. 5206–5210. IEEE, 2015.   
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pp. 1310–1318, 2013.   
+Ofir Press and Lior Wolf. Using the output embedding to improve language models. arXiv preprint arXiv:1608.05859, 2016.   
+Ning Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12(1):145–151, 1999.   
+Rolf Rabenseifner. Optimization of collective reduction operations. In International Conference on Computational Science, pp. 1–9. Springer, 2004.   
+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.
+
+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.
+
+Nikko Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.
+
+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, 2017.
+
+Eric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhimanu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Transactions on Big Data, 1(2):49–67, 2015.
+
+Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016.
+
+Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pp. 2595–2603, 2010.
+
+# A SYNCHRONOUS DISTRIBUTED STOCHASTIC GRADIENT DESCENT
+
+In practice, each training node performs the forward-backward pass on different batches sampled from the training dataset with the same network model. The gradients from all nodes are summed up to optimize their models. By this synchronization step, models on different nodes are always the same during the training. The aggregation step can be achieved in two ways. One method is using the parameter servers as the intermediary which store the parameters among several servers (Dean et al., 2012). The nodes push the gradients to the servers while the servers are waiting for the gradients from all nodes. Once all gradients are sent, the servers update the parameters, and then all nodes pull the latest parameters from the servers. The other method is to perform the All-reduce operation on the gradients among all nodes and to update the parameters on each node independently (Goyal et al., 2017), as shown in Algorithm 2 and Figure 7. In this paper, we adopt the latter approach by default.
+
+![](images/6a08c0a3c8217ddfc8762679dfb0d2ce41f9f699504333c8d85bc675d5029e10.jpg)
+
+(a) Each node independently calculates gradients (b) All-reduce operation of gradient aggregation
+
+![](images/cab34d62dbb8bc5a0de99b3b2c221d8236282b11e6cf8dd54c5510e70657cec4.jpg)  
+Figure 7: Distributed Synchronous SGD
+
+<table><tr><td>Algorithm 2 Distributed Synchronous SGD on node k</td></tr><tr><td>Input: Dataset X Input: minibatch size b per node Input: the number of nodes N Input: Optimization Function SGD Input: Init parameters w = {w[0],·,w[M]} 1: for t =0,1,. do</td></tr></table>
+
+# B GRADIENT SPARSIFICATION WITH NESTROV MOMENTUM CORRECTION
+
+The conventional update rule for Nesterov momentum SGD (Nesterov, 1983) follows,
+
+$$
+u _ { t + 1 } = m u _ { t } + \sum _ { k = 1 } ^ { N } \left( \nabla _ { k , t } \right) , \quad w _ { t + 1 } = w _ { t } - \eta \left( m \cdot u _ { t + 1 } + \nabla _ { t } \right)
+$$
+
+where $m$ is the momentum, $N$ is the number of training nodes, and $\begin{array} { r } { \nabla _ { k , t } = \frac { 1 } { N b } \sum _ { x \in { \mathcal { B } _ { k , t } } } \nabla f ( x , w _ { t } ) } \end{array}$ . Before momentum correction, the sparse update follows,
+
+$$
+v _ { k , t + 1 } = v _ { k , t } + \nabla _ { k , t } , \quad u _ { t + 1 } = m u _ { t } + \sum _ { k = 1 } ^ { N } s p a r s e \left( v _ { k , t + 1 } \right) , \quad w _ { t + 1 } = w _ { t } - \eta u _ { t + 1 }
+$$
+
+After momentum correction sharing the same methodology with Equation 7, it becomes,
+
+$$
+\iota _ { k , t + 1 } = m u _ { k , t } + \nabla _ { k , t } , \quad v _ { k , t + 1 } = v _ { k , t } + \left( m \cdot u _ { k , t + 1 } + \nabla _ { k , t } \right) , \quad w _ { t + 1 } = w _ { t } - \eta \sum _ { k = 1 } ^ { N } s p a r s e \left( v _ { k , t + 1 } \right) .
+$$
+
+# C LOCAL GRADIENT CLIPPING
+
+When training the recurrent neural network with gradient clipping, we perform the gradient clipping locally before adding the current gradient $G _ { t } ^ { k }$ to previous accumulation $G _ { t - 1 } ^ { k }$ in Algorithm 1. Denote the origin threshold for the gradients L2-norm $| | G | | _ { 2 }$ as $t h r _ { G }$ , and the threshold for the local gradients L2-norm $| | G ^ { k } | | _ { 2 }$ as as $t h r _ { G ^ { k } }$ .
+
+Assuming all $N$ training nodes have independent identical gradient distributions with the variance $\sigma ^ { 2 }$ , the sum of gradients from all nodes have the variance $N \bar { \sigma } ^ { 2 }$ . Therefore,
+
+$$
+E \left[ | | G ^ { k } | | _ { 2 } \right] \approx \sigma , \quad E \left[ | | G | | _ { 2 } \right] \approx N ^ { 1 / 2 } \sigma
+$$
+
+Thus, We scale the threshold by $N ^ { - 1 / 2 }$ , the current node’s fraction of the global threshold,
+
+$$
+t h r _ { G ^ { k } } = N ^ { - 1 / 2 } \cdot t h r _ { G }
+$$
+
+# D DEEP GRADIENT COMPRESSION ALGORITHM
+
+<table><tr><td>vanilla momentum SGD on node k</td><td>Algorithm 3 Deep Gradient Compression for Algorithm 4 Deep Gradient Compression for Nesterc momentum SGD on node k</td></tr><tr><td>Input: dataset X</td><td>Input: dataset X</td></tr><tr><td>Input: minibatch size b per node</td><td>Input:minibatch size b per node</td></tr><tr><td>Input: momentum m</td><td>Input: momentum m</td></tr><tr><td></td><td></td></tr><tr><td>Input: the number of nodes N</td><td>Input: the number of nodes N</td></tr><tr><td>Input: optimization function SGD Input: initial parameters w= {w[O],··,w[M]}</td><td>Input: optimization function SGD Input: initial parameters w={w[O],··,w[M]}</td></tr><tr><td>1:Uk ←0,Vk ←0</td><td>1:Uk←0,Vk←0</td></tr><tr><td>2: for t=0,1,.·. do</td><td>2: for t = 0,1,.· do</td></tr><tr><td>3: G←</td><td>3: G←0</td></tr><tr><td>4: fori=1,.,bdo</td><td>4: fori=1,.,bdo</td></tr><tr><td>5: Sample data x from X</td><td>5: Sample data x from X</td></tr><tr><td>G←G+f（x;0t） 6:</td><td>G←G+f（x;0t） 6:</td></tr><tr><td>7: end for</td><td>7: end for</td></tr><tr><td>8: if Gradient Clipping then</td><td>8: if Gradient Clipping then</td></tr><tr><td>9: Gk ← Local-Gradient_Clipping(Gk)</td><td>9: Gl ← Local_Gradient_Clipping(Gt)</td></tr><tr><td>10: end if</td><td>10: end if</td></tr><tr><td>11: U←m.Uk-1+Gk</td><td>11: U←m·(U-1+G&#x27;）</td></tr><tr><td>12: V←V1+U</td><td>12: V←V1+U+G</td></tr><tr><td>13: forj=0,..,M do</td><td>13: for j=0,..,M do</td></tr><tr><td>14: thr ←s%of|V[j]l</td><td>14: thr ←s%of|Vk[j]l</td></tr><tr><td>15: Mask ← |V[j] &gt;thr</td><td>15: Mask ← |V[]| &gt;thr</td></tr><tr><td>G[] ←V Mask 16:</td><td>16: G]←V[j]Mask</td></tr><tr><td>17: V[j] ←Vj]-Mask</td><td>17: V] ←V-Mask</td></tr><tr><td>18: U]←Uj-Mask</td><td>18: U←U-Mask</td></tr><tr><td>19: end for</td><td>19: end for</td></tr><tr><td>20:</td><td>20: All-reduce: Gt ← ∑N 1 encode(G&#x27;)</td></tr><tr><td>21: 0t+1 ← SGD(0t,Gt)</td><td>21: 0t+1 ← SGD(0t,Gt) 22:</td></tr></table>

parse/train/SkhQHMW0W/SkhQHMW0W_content_list.json

@@ -0,0 +1,1660 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP GRADIENT COMPRESSION: REDUCING THE COMMUNICATION BANDWIDTH FOR DISTRIBUTED TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yujun Lin ∗   \nTsinghua University   \nBeijing National Research Center   \nfor Information Science and Technology   \nlinyy14@mails.tsinghua.edu.cn   \nSong Han †   \nStanford University   \nGoogle Brain   \nsonghan@stanford.edu ",
+        "bbox": [
+            184,
+            195,
+            468,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            540,
+            195,
+            738,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Huizi Mao Stanford University huizi@stanford.edu ",
+        "bbox": [
+            183,
+            286,
+            362,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yu Wang ",
+        "text_level": 1,
+        "bbox": [
+            539,
+            286,
+            604,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tsinghua University Beijing National Research Center for Information Science and Technology yu-wang@mail.tsinghua.edu.cn ",
+        "bbox": [
+            537,
+            301,
+            812,
+            356
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "William J. Dally Stanford University NVIDIA dally@stanford.edu ",
+        "bbox": [
+            183,
+            377,
+            362,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            469,
+            544,
+            484
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large-scale distributed training requires significant communication bandwidth for gradient exchange that limits the scalability of multi-node training, and requires expensive high-bandwidth network infrastructure. The situation gets even worse with distributed training on mobile devices (federated learning), which suffers from higher latency, lower throughput, and intermittent poor connections. In this paper, we find $9 9 . 9 \\%$ of the gradient exchange in distributed SGD are redundant, and propose Deep Gradient Compression (DGC) to greatly reduce the communication bandwidth. To preserve accuracy during this compression, DGC employs four methods: momentum correction, local gradient clipping, momentum factor masking, and warm-up training. We have applied Deep Gradient Compression to image classification, speech recognition, and language modeling with multiple datasets including Cifar10, ImageNet, Penn Treebank, and Librispeech Corpus. On these scenarios, Deep Gradient Compression achieves a gradient compression ratio from $2 7 0 \\times$ to $6 0 0 \\times$ without losing accuracy, cutting the gradient size of ResNet-50 from 97MB to 0.35MB, and for DeepSpeech from 488MB to 0.74MB. Deep gradient compression enables large-scale distributed training on inexpensive commodity 1Gbps Ethernet and facilitates distributed training on mobile. ",
+        "bbox": [
+            233,
+            503,
+            764,
+            738
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            767,
+            336,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large-scale distributed training improves the productivity of training deeper and larger models (Chilimbi et al., 2014; Xing et al., 2015; Moritz et al., 2015; Zinkevich et al., 2010). Synchronous stochastic gradient descent (SGD) is widely used for distributed training. By increasing the number of training nodes and taking advantage of data parallelism, the total computation time of the forward-backward passes on the same size training data can be dramatically reduced. However, gradient exchange is costly and dwarfs the savings of computation time (Li et al., 2014; Wen et al., ",
+        "bbox": [
+            174,
+            800,
+            825,
+            885
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/4fc386e290a584c321a5ceece6dddea87170b012d181d7057dd735c2a74c1c93.jpg",
+        "image_caption": [
+            "Figure 1: Deep Gradient Compression can reduce the communication time, improve the scalability, and speed up distributed training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            95,
+            825,
+            276
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2017), especially for recurrent neural networks (RNN) where the computation-to-communication ratio is low. Therefore, the network bandwidth becomes a significant bottleneck for scaling up distributed training. This bandwidth problem gets even worse when distributed training is performed on mobile devices, such as federated learning (McMahan et al., 2016; Konecnˇ y et al., 2016). Training \\` on mobile devices is appealing due to better privacy and better personalization (Google, 2017), but a critical problem is that those mobile devices suffer from even lower network bandwidth, intermittent network connections, and expensive mobile data plan. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            438
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep Gradient Compression (DGC) solves the communication bandwidth problem by compressing the gradients, as shown in Figure 1. To ensure no loss of accuracy, DGC employs momentum correction and local gradient clipping on top of the gradient sparsification to maintain model performance. DGC also uses momentum factor masking and warmup training to overcome the staleness problem caused by reduced communication. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We empirically verified Deep Gradient Compression on a wide range of tasks, models, and datasets: CNN for image classification (with Cifar10 and ImageNet), RNN for language modeling (with Penn Treebank) and speech recognition (with Librispeech Corpus). These experiments demonstrate that gradients can be compressed up to $6 0 0 \\times$ without loss of accuracy, which is an order of magnitude higher than previous work (Aji & Heafield, 2017). ",
+        "bbox": [
+            174,
+            521,
+            825,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            611,
+            344,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Researchers have proposed many approaches to overcome the communication bottleneck in distributed training. For instance, asynchronous SGD accelerates the training by removing gradient synchronization and updating parameters immediately once a node has completed back-propagation (Dean et al., 2012; Recht et al., 2011; Li et al., 2014). Gradient quantization and sparsification to reduce communication data size are also extensively studied. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Gradient Quantization Quantizing the gradients to low-precision values can reduce the communication bandwidth. Seide et al. (2014) proposed 1-bit SGD to reduce gradients transfer data size and achieved $1 0 \\times$ speedup in traditional speech applications. Alistarh et al. (2016) proposed another approach called QSGD which balance the trade-off between accuracy and gradient precision. Similar to QSGD, Wen et al. (2017) developed TernGrad which uses 3-level gradients. Both of these works demonstrate the convergence of quantized training, although TernGrad only examined CNNs and QSGD only examined the training loss of RNNs. There are also attempts to quantize the entire model, including gradients. DoReFa-Net (Zhou et al., 2016) uses 1-bit weights with 2-bit gradients. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            838
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Gradient Sparsification Strom (2015) proposed threshold quantization to only send gradients larger than a predefined constant threshold. However, the threshold is hard to choose in practice. Therefore, Dryden et al. (2016) chose a fixed proportion of positive and negative gradient updates separately, and Aji & Heafield (2017) proposed Gradient Dropping to sparsify the gradients by a single threshold based on the absolute value. To keep the convergence speed, Gradient Dropping ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Gradient Sparsification on node $k$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            128,
+            462,
+            142
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input: dataset $\\chi$   \nInput: minibatch size $^ { b }$ per node   \nInput: the number of nodes $N$   \nInput: optimization function $S G D$   \nInput: init parameters $w = \\{ w [ 0 ] , w [ 1 ] , \\cdot \\cdot \\cdot , w [ M ] \\}$   \n1: $G ^ { k }  0$   \n2: for $t = 0 , 1 , \\cdots$ do   \n3: $G _ { t } ^ { k } \\gets \\hat { G } _ { t - 1 } ^ { k }$   \n4: for $i = 1 , \\cdots , b \\bullet$ do   \n5: Sample data $x$ from $\\chi$   \n6: $\\begin{array} { r } { G _ { t } ^ { k } \\stackrel { \\cdot } {  } G _ { t } ^ { k } + \\frac { 1 } { N b } \\nabla f \\tilde { ( } x ; w _ { t } ) } \\end{array}$   \n7: end for   \n8: for $j = 0 , \\cdots , M$ do   \n9: Select threshold: $t h r  s \\%$ of $\\left. G _ { t } ^ { k } [ j ] \\right.$   \n10: $\\begin{array} { r l } & { M a s k  | G _ { t } ^ { k } [ j ] | > t h r } \\\\ & { \\widetilde { G } _ { t } ^ { k } [ j ]  G _ { t } ^ { k } [ j ] \\odot M a s k } \\\\ & { G _ { t } ^ { k } [ j ]  G _ { t } ^ { k } [ j ] \\odot \\neg M a s k } \\end{array}$   \n11:   \n12:   \n13: 14: $A l l$ d for-reduce $\\begin{array} { r } { G _ { t } ^ { k } : G _ { t } \\gets \\sum _ { k = 1 } ^ { N } e n c o d e ( \\widetilde { G } _ { t } ^ { k } ) } \\end{array}$   \n15: $w _ { t + 1 } \\gets S G D \\left( w _ { t } , G _ { t } \\right)$   \n16: end for ",
+        "bbox": [
+            174,
+            146,
+            493,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/124b78f7ccaaa13342437c8a70de1680a2c9c82ac80fc3a7636059550529fc06.jpg",
+        "image_caption": [
+            "Figure 2: Momentum Correction "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            529,
+            117,
+            790,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "requires adding the layer normalization(Lei Ba et al., 2016). Gradient Dropping saves $9 9 \\%$ of gradient exchange while incurring $0 . 3 \\%$ loss of BLEU score on a machine translation task. Concurrently, Chen et al. (2017) proposed to automatically tunes the compression rate depending on local gradient activity, and gained compression ratio around $2 0 0 \\times$ for fully-connected layers and $4 0 \\times$ for convolutional layers with negligible degradation of top-1 accuracy on ImageNet dataset. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Compared to the previous work, DGC pushes the gradient compression ratio to up to $6 0 0 \\times$ for the whole model (same compression ratio for all layers). DGC does not require extra layer normalization, and thus does not need to change the model structure. Most importantly, Deep Gradient Compression results in no loss of accuracy. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            595
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DEEP GRADIENT COMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            473,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 GRADIENT SPARSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            408,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We reduce the communication bandwidth by sending only the important gradients (sparse update). We use the gradient magnitude as a simple heuristics for importance: only gradients larger than a threshold are transmitted. To avoid losing information, we accumulate the rest of the gradients locally. Eventually, these gradients become large enough to be transmitted. Thus, we send the large gradients immediately but eventually send all of the gradients over time, as shown in Algorithm 1. The encode() function packs the 32-bit nonzero gradient values and 16-bit run lengths of zeros. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            766
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The insight is that the local gradient accumulation is equivalent to increasing the batch size over time. Let $F ( w )$ be the loss function which we want to optimize. Synchronous Distributed SGD performs the following update with $N$ training nodes in total: ",
+        "bbox": [
+            174,
+            772,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3c8238449f53ea823bf258c11239dc8d0c8cfae0e506ac17e531e488a001420.jpg",
+        "text": "$$\nF ( w ) = \\frac { 1 } { | \\chi | } \\sum _ { x \\in \\chi } f ( x , w ) , \\qquad w _ { t + 1 } = w _ { t } - \\eta \\frac { 1 } { N b } \\sum _ { k = 1 } ^ { N } \\sum _ { x \\in \\mathcal { B } _ { k , t } } \\nabla f ( x , w _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            824,
+            736,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\chi$ is the training dataset, $w$ are the weights of a network, $f ( x , w )$ is the loss computed from samples $x \\in \\chi , \\eta$ is the learning rate, $N$ is the number of training nodes, and $B _ { k , t }$ for $1 \\leq k < N$ is a sequence of $N$ minibatches sampled from $\\chi$ at iteration $t$ , each of size $b$ . ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider the weight value $w ^ { ( i ) }$ of $i$ -th position in flattened weights $w$ . After $T$ iterations, we have ",
+        "bbox": [
+            169,
+            102,
+            813,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c81644f2d37ca151b77aae6cd00ecd4a1bba0bd79a4ea56c2c4052265ce7b376.jpg",
+        "text": "$$\nw _ { t + T } ^ { ( i ) } = w _ { t } ^ { ( i ) } - \\eta T \\cdot \\frac { 1 } { N b T } \\sum _ { k = 1 } ^ { N } \\left( \\sum _ { \\tau = 0 } ^ { T - 1 } \\sum _ { x \\in \\mathcal { B } _ { k , t + \\tau } } \\nabla ^ { ( i ) } f ( x , w _ { t + \\tau } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            125,
+            710,
+            176
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Equation 2 shows that local gradient accumulation can be considered as increasing the batch size from $N b$ to $N b T$ (the second summation over $\\tau$ ), where $T$ is the length of the sparse update interval between two iterations at which the gradient of $w ^ { ( i ) }$ is sent. Learning rate scaling (Goyal et al., 2017) is a commonly used technique to deal with large minibatch. It is automatically satisfied in Equation 2 where the $T$ in the learning rate $\\eta T$ and batch size $N b T$ are canceled out. ",
+        "bbox": [
+            173,
+            181,
+            826,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 IMPROVING THE LOCAL GRADIENT ACCUMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            271,
+            581,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Without care, the sparse update will greatly harm convergence when sparsity is extremely high (Chen et al., 2017). For example, Algorithm 1 incurred more than $1 . 0 \\%$ loss of accuracy on the Cifar10 dataset, as shown in Figure 3(a). We find momentum correction and local gradient clipping can mitigate this problem. ",
+        "bbox": [
+            173,
+            296,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Momentum Correction Momentum SGD is widely used in place of vanilla SGD. However, Algorithm 1 doesn’t directly apply to SGD with the momentum term, since it ignores the discounting factor between the sparse update intervals. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Distributed training with vanilla momentum SGD on $N$ training nodes follows (Qian, 1999), ",
+        "bbox": [
+            174,
+            417,
+            779,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15bb8402e149dc3429a789ac4c70c7b9a7196933a7e8510a99631c737f11a9ce.jpg",
+        "text": "$$\nu _ { t } = m u _ { t - 1 } + \\sum _ { k = 1 } ^ { N } \\left( \\nabla _ { k , t } \\right) , \\quad w _ { t + 1 } = w _ { t } - \\eta u _ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            440,
+            656,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $m$ is the momentum, $N$ is the number of training nodes, and $\\begin{array} { r } { \\nabla _ { k , t } = \\frac { 1 } { N b } \\sum _ { x \\in { \\mathcal { B } _ { k , t } } } \\nabla f ( x , w _ { t } ) } \\end{array}$ ",
+        "bbox": [
+            171,
+            492,
+            821,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consider the weight value $w ^ { ( i ) }$ of $i$ -th position in flattened weights $w$ . After $T$ iterations, the change in weight value $w ^ { ( i ) }$ shows as follows, ",
+        "bbox": [
+            176,
+            518,
+            823,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ead087014a331c4c320e69d7e4a04f3441b82b650433a06ca276b51d8dc50eb2.jpg",
+        "text": "$$\nw _ { t + T } ^ { ( i ) } = w _ { t } ^ { ( i ) } - \\eta \\left[ \\cdots + \\left( \\sum _ { \\tau = 0 } ^ { T - 2 } m ^ { \\tau } \\right) \\nabla _ { k , t + 1 } ^ { ( i ) } + \\left( \\sum _ { \\tau = 0 } ^ { T - 1 } m ^ { \\tau } \\right) \\nabla _ { k , t } ^ { ( i ) } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            558,
+            715,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If SGD with the momentum is directly applied to the sparse gradient scenario (line 15 in Algorithm 1), the update rule is no longer equivalent to Equation 3, which becomes: ",
+        "bbox": [
+            169,
+            614,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60dfd25e7b27acd7a860e41d73d6ca539daa0c3fd4b39664f634ca8ef33c9a92.jpg",
+        "text": "$$\nv _ { k , t } = v _ { k , t - 1 } + \\nabla _ { k , t } , \\quad u _ { t } = m u _ { t - 1 } + \\sum _ { k = 1 } ^ { N } s p a r s e \\left( v _ { k , t } \\right) , \\quad w _ { t + 1 } = w _ { t } - \\eta u _ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            650,
+            761,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the first term is the local gradient accumulation on the training node $k$ . Once the accumulation result $v _ { k , t }$ is larger than a threshold, it will pass hard thresholding in the sparse () function, and be encoded and get sent over the network in the second term. Similarly to the line 12 in Algorithm 1, the accumulation result $v _ { k , t }$ gets cleared by the mask in the sparse $( )$ function. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The change in weight value $w ^ { ( i ) }$ after the sparse update interval $T$ becomes, ",
+        "bbox": [
+            173,
+            765,
+            674,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d12d7e8f5d507e60b76e175d7504cbf1895ce6372c1e11a127813e0774a4189.jpg",
+        "text": "$$\nw _ { t + T } ^ { ( i ) } = w _ { t } ^ { ( i ) } - \\eta \\left( \\cdot \\cdot \\cdot + \\nabla _ { k , t + 1 } ^ { ( i ) } + \\nabla _ { k , t } ^ { ( i ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            789,
+            635,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The disappearance of the accumulated discounting factor $\\scriptstyle \\sum _ { \\tau = 0 } ^ { T - 1 } m ^ { \\tau }$ in Equation 6 compared to Equation 4 leads to the loss of convergence performance. It is illustrated in Figure 2(a), where Equation 4 drives the optimization from point $A$ to point $B$ , but with local gradient accumulation, Equation 4 goes to point $C$ . When the gradient sparsity is high, the update interval $T$ dramatically increases, and thus the significant side effect will harm the model performance. To avoid this error, we need momentum correction on top of Equation 5 to make sure the sparse update is equivalent to the dense update as in Equation 3. ",
+        "bbox": [
+            173,
+            823,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If we regard the velocity $u _ { t }$ in Equation 3 as ”gradient”, the second term of Equation 3 can be considered as the vanilla SGD for the ”gradient” $u _ { t }$ . The local gradient accumulation is proved to be effective for the vanilla SGD in Section 3.1. Therefore, we can locally accumulate the velocity $u _ { t }$ instead of the real gradient $\\nabla _ { k , t }$ to migrate Equation 5 to approach Equation 3: ",
+        "bbox": [
+            176,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d502270da579dc5cf9a98e5b17e02caea5630a0ac018a8acd0eab6826aa8e745.jpg",
+        "text": "$$\nu _ { k , t } = m u _ { k , t - 1 } + \\nabla _ { k , t } , \\quad v _ { k , t } = v _ { k , t - 1 } + u _ { k , t } , \\quad w _ { t + 1 } = w _ { t } - \\eta \\sum _ { k = 1 } ^ { N } s p a r s e \\left( v _ { k , t } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            167,
+            779,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the first two terms are the corrected local gradient accumulation, and the accumulation result $v _ { k , t }$ is used for the subsequent sparsification and communication. Bumulation, we can deduce the accumulated discounting factor le change in the localin Equation 4 from $\\scriptstyle \\sum _ { \\tau = 0 } ^ { T - 1 } m ^ { \\tau }$ Equation 7, as shown in Figure 2(b). ",
+        "bbox": [
+            174,
+            219,
+            825,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We refer to this migration as the momentum correction. It is a tweak to the update equation, it doesn’t incur any hyper parameter. Beyond the vanilla momentum SGD, we also look into Nesterov momentum SGD in Appendix B, which is similar to momentum SGD. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Local Gradient Clipping Gradient clipping is widely adopted to avoid the exploding gradient problem (Bengio et al., 1994). The method proposed by Pascanu et al. (2013) rescales the gradients whenever the sum of their L2-norms exceeds a threshold. This step is conventionally executed after gradient aggregation from all nodes. Because we accumulate gradients over iterations on each node independently, we perform the gradient clipping locally before adding the current gradient $G _ { t }$ to previous accumulation $( G _ { t - 1 }$ in Algorithm 1). As explained in Appendix C, we scale the threshold by $N ^ { - 1 / 2 }$ , the current node’s fraction of the global threshold if all $N$ nodes had identical gradient distributions. In practice, we find that the local gradient clipping behaves very similarly to the vanilla gradient clipping in training, which suggests that our assumption might be valid in real-world data. ",
+        "bbox": [
+            173,
+            343,
+            825,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As we will see in Section 4, momentum correction and local gradient clipping help improve the word error rate from $1 4 . 1 \\%$ to $1 2 . 9 \\%$ on the AN4 corpus, while training curves follow the momentum SGD more closely. ",
+        "bbox": [
+            176,
+            477,
+            823,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 OVERCOMING THE STALENESS EFFECT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            486,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Because we delay the update of small gradients, when these updates do occur, they are outdated or stale. In our experiments, most of the parameters are updated every 600 to 1000 iterations when gradient sparsity is $9 9 . 9 \\%$ , which is quite long compared to the number of iterations per epoch. Staleness can slow down convergence and degrade model performance. We mitigate staleness with momentum factor masking and warm-up training. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Momentum Factor Masking Mitliagkas et al. (2016) discussed the staleness caused by asynchrony and attributed it to a term described as implicit momentum. Inspired by their work, we introduce momentum factor masking, to alleviate staleness. Instead of searching for a new momentum coefficient as suggested in Mitliagkas et al. (2016), we simply apply the same mask to both the accumulated gradients $v _ { k , t }$ and the momentum factor $u _ { k , t }$ in Equation 7: ",
+        "bbox": [
+            173,
+            650,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b49d852870b1037656d13680d30c725a009d8991e82d14b343075452a3d0e5e1.jpg",
+        "text": "$$\nM a s k \\gets | v _ { k , t } | > t h r , \\quad v _ { k , t } \\gets v _ { k , t } \\odot \\neg M a s k , \\quad u _ { k , t } \\gets u _ { k , t } \\odot \\neg M a s k\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            729,
+            748,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This mask stops the momentum for delayed gradients, preventing the stale momentum from carrying the weights in the wrong direction. ",
+        "bbox": [
+            173,
+            753,
+            823,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Warm-up Training In the early stages of training, the network is changing rapidly, and the gradients are more diverse and aggressive. Sparsifying gradients limits the range of variation of the model, and thus prolongs the period when the network changes dramatically. Meanwhile, the remaining aggressive gradients from the early stage are accumulated before being chosen for the next update, and therefore they may outweigh the latest gradients and misguide the optimization direction. The warm-up training method introduced in large minibatch training (Goyal et al., 2017) is helpful. During the warm-up period, we use a less aggressive learning rate to slow down the changing speed of the neural network at the start of training, and also less aggressive gradient sparsity, to reduce the number of extreme gradients being delayed. Instead of linearly ramping up the learning rate during the first several epochs, we exponentially increase the gradient sparsity from a relatively small value to the final value, in order to help the training adapt to the gradients of larger sparsity. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/8db09cb678177982b3f2a11ae2f254756b21c0d28d4e9b256e214b3667e6a75c.jpg",
+        "table_caption": [
+            "Table 1: Techniques in Deep Gradient Compression "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Techniques</td><td rowspan=1 colspan=1>Gradient        DeepDropping      Gradient(Aji &amp; Heafield,2017) Compression</td><td rowspan=1 colspan=1>Overcome StalenessReduce     Ensure                MaintainImproveBandwidthConvergenceAccuracyConvergenceIterations</td></tr><tr><td rowspan=1 colspan=1>GradientSparsification</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Local GradientAccumulation</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>MomentumCorrection</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Local GradientClipping</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>MomentumFactor Masking</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Warm-upTraining</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√           √</td></tr></table>",
+        "bbox": [
+            178,
+            127,
+            821,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            390,
+            821,
+            419
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, momentum correction and local gradient clipping improve the local gradient accumulation, while the momentum factor masking and warm-up training alleviate the staleness effect. On top of gradient sparsification and local gradient accumulation, these four techniques make up the Deep Gradient Compression (pseudo code in Appendix D), and help push the gradient compression ratio higher while maintaining the accuracy. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            326,
+            532
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            382,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We validate our approach on three types of machine learning tasks: image classification on Cifar10 and ImageNet, language modeling on Penn Treebank dataset, and speech recognition on AN4 and Librispeech corpus. The only hyper-parameter introduced by Deep Gradient Compression is the warm-up training strategy. In all experiments related to DGC, we rise the sparsity in the warm-up period as follows: $7 5 \\%$ , $9 3 . 7 5 \\%$ , $9 8 . 4 3 7 5 \\%$ , $9 9 . 6 \\%$ , $9 9 . 9 \\%$ (exponentially increase till $9 9 . 9 \\%$ ). We evaluate the reduction in the network bandwidth by the gradient compression ratio as follows, ",
+        "bbox": [
+            173,
+            574,
+            825,
+            659
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/589d3ed0ac9ac0e346b081b1f466295631ca19586d79642a24fcbf99a871e871.jpg",
+        "text": "$$\n\\mathrm { \\ \" { s r a d i e n t } ~ C o m p r e s s i o n ~ R a t i o } = s i z e \\left[ e n c o d e \\left( s p a r s e ( G ^ { k } ) \\right) \\right] / s i z e \\left[ G ^ { k } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            666,
+            740,
+            686
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $G ^ { k }$ is the gradients computed on the training node $k$ . ",
+        "bbox": [
+            174,
+            694,
+            563,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Image Classification We studied ResNet-110 on Cifar10, AlexNet and ResNet-50 on ImageNet. Cifar10 consists of 50,000 training images and 10,000 validation images in 10 classes (Krizhevsky & Hinton, 2009), while ImageNet contains over 1 million training images and 50,000 validation images in 1000 classes (Deng et al., 2009). We train the models with momentum SGD following the training schedule in Gross & Wilber (2016). The warm-up period for DGC is 4 epochs out of164 epochs for Cifar10 and 4 epochs out of 90 epochs for ImageNet Dataset. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Language Modeling The Penn Treebank corpus (PTB) dataset consists of 923,000 training, 73,000 validation and 82,000 test words (Marcus et al., 1993). The vocabulary we select is the same as the one in Mikolov et al. (2010). We adopt the 2-layer LSTM language model architecture with 1500 hidden units per layer (Press & Wolf, 2016), tying the weights of encoder and decoder as suggested in Inan et al. (2016) and using vanilla SGD with gradient clipping, while learning rate decays when no improvement has been made in validation loss. The warm-up period is 1 epoch out of 40 epochs. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0c3c1c38abc10127aec8e3478a82d92caa82f17cbcddb9cffc25b863b3ecb584.jpg",
+        "table_caption": [
+            "Table 2: ResNet-110 trained on Cifar10 Dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td># GPUs in total</td><td>Batchsize in total per iteration</td><td>Training Method</td><td>Top 1 Accuracy</td><td></td></tr><tr><td rowspan=\"3\">4</td><td rowspan=\"3\">128</td><td>Baseline</td><td>93.75%</td><td></td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield, 2017)</td><td>92.75%</td><td>-1.00%</td></tr><tr><td>Deep Gradient Compression</td><td>93.87%</td><td>+0.12%</td></tr><tr><td rowspan=\"3\">8</td><td rowspan=\"3\">256</td><td>Baseline</td><td>92.92%</td><td></td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield,2017)</td><td>93.02%</td><td>+0.10%</td></tr><tr><td>Deep Gradient Compression</td><td>93.28%</td><td>+0.37%</td></tr><tr><td rowspan=\"3\">16</td><td rowspan=\"3\">512</td><td>Baseline</td><td>93.14%</td><td>-0.21%</td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield, 2017)</td><td>92.93%</td><td></td></tr><tr><td>Deep Gradient Compression</td><td>93.20%</td><td>+0.06%</td></tr><tr><td rowspan=\"3\">32</td><td rowspan=\"3\">1024</td><td>Baseline</td><td>93.10%</td><td></td></tr><tr><td>Gradient Dropping (Aji &amp; Heafield, 2017)</td><td>92.10%</td><td>-1.00%</td></tr><tr><td>Deep Gradient Compression</td><td>93.18%</td><td>+0.08%</td></tr></table>",
+        "bbox": [
+            192,
+            121,
+            807,
+            320
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc5e80e3bcd4541266faae9f517572525beb45cd502ce29d96d8bf12f1c5e8dd.jpg",
+        "table_caption": [
+            "Table 3: Comparison of gradient compression ratio on ImageNet Dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Training Method</td><td>Top-1 Accuracy</td><td>Top-5 Accuracy</td><td>Gradient Size</td><td>Compression Ratio</td></tr><tr><td rowspan=\"5\">AlexNet</td><td>Baseline</td><td>58.17%</td><td>80.19%</td><td>232.56 MB</td><td>1x</td></tr><tr><td>TernGrad</td><td>57.28%</td><td>80.23%</td><td>1 29.18 MB</td><td>8×</td></tr><tr><td>(Wen et al., 2017) Deep Gradient</td><td>(-0.89%) 58.20%</td><td>(+0.04%) 80.20%</td><td>2</td><td></td></tr><tr><td>Compression</td><td>(+0.03%)</td><td>(+0.01%)</td><td>0.39 MB</td><td>597 ×</td></tr><tr><td>Baseline</td><td>75.96</td><td>92.91%</td><td>97.49 MB</td><td>1×</td></tr><tr><td>ResNet-50</td><td>Deep Gradient Compression</td><td>76.15 (+0.19%)</td><td>92.97% (+0.06%)</td><td>0.35 MB</td><td>277×</td></tr></table>",
+        "bbox": [
+            178,
+            362,
+            816,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Speech Recognition The AN4 dataset contains 948 training and 130 test utterances (Acero, 1990) while Librispeech corpus contains 960 hours of reading speech (Panayotov et al., 2015). We use DeepSpeech architecture without $\\mathbf { n }$ -gram language model, which is a multi-layer RNN following a stack of convolution layers (Hannun et al., 2014). We train a 5-layer LSTM of 800 hidden units per layer for AN4, and a 7-layer GRU of 1200 hidden units per layer for LibriSpeech, with Nesterov momentum $S G D$ and gradient clipping, while learning rate anneals every epoch. The warm-up period for DGC is 1 epoch out of 80 epochs. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            659,
+            388,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first examine Deep Gradient Compression on image classification task. Figure 3(a) and 3(b) are the Top-1 accuracy and training loss of ResNet-110 on Cifar10 with 4 nodes. The gradient sparsity is $9 9 . 9 \\%$ (only $0 . 1 \\%$ is non-zero). The learning curve of Gradient Dropping (Aji & Heafield, 2017) (red) is worse than the baseline due to gradient staleness. With momentum correction (yellow), the learning curve converges slightly faster, and the accuracy is much closer to the baseline. With momentum factor masking and warm-up training techniques (blue), gradient staleness is eliminated, and the learning curve closely follows the baseline. Table 2 shows the detailed accuracy. The accuracy of ResNet-110 is fully maintained while using Deep Gradient Compression. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When scaling to the large-scale dataset, Figure 3(c) and 3(d) show the learning curve of ResNet-50 when the gradient sparsity is $9 9 . 9 \\%$ . The accuracy fully matches the baseline. An interesting observation is that the top-1 error of training with sparse gradients decreases faster than the baseline with the same training loss. Table 3 shows the results of AlexNet and ResNet-50 training on ImageNet with 4 nodes. We compare the gradient compression ratio with Terngrad (Wen et al., 2017) on AlexNet (ResNet is not studied in Wen et al. (2017)). Deep Gradient Compression gives $7 5 \\times$ better compression than Terngrad with no loss of accuracy. For ResNet-50, the compression ratio is slightly lower ( $2 7 7 \\times$ vs. $5 9 7 \\times$ ) with a slight increase in accuracy. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e656c450092c001f7c593a39af68523f3d343082b527c6df59aca5c41a496228.jpg",
+        "image_caption": [
+            "Figure 3: Learning curves of ResNet in image classification task (the gradient sparsity is $9 9 . 9 \\%$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            109,
+            795,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2ca96e8553aa94a6140fa492cc38bc5e994e2241030507f065ba70571b17ae26.jpg",
+        "table_caption": [
+            "Table 4: Training results of language modeling and speech recognition with 4 nodes "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=3>Language Modeling on PTB</td><td rowspan=1 colspan=3> Speech Recognition on LibriSpeech</td></tr><tr><td rowspan=2 colspan=1>TrainingMethod</td><td rowspan=2 colspan=1>Perplexity</td><td rowspan=2 colspan=1>GradientSize</td><td rowspan=2 colspan=1>CompressionRatio</td><td rowspan=1 colspan=1>Word Error Rate (WER)</td><td rowspan=2 colspan=1>GradientSize</td><td rowspan=2 colspan=1>CompressionRatio</td></tr><tr><td rowspan=1 colspan=1>test-clean  test-other</td></tr><tr><td rowspan=1 colspan=1>Baseline</td><td rowspan=1 colspan=1>72.30</td><td rowspan=1 colspan=1>194.68MB</td><td rowspan=1 colspan=1>1x</td><td rowspan=1 colspan=1>9.45%     27.07%</td><td rowspan=1 colspan=1>488.08 MB</td><td rowspan=1 colspan=1>1x</td></tr><tr><td rowspan=1 colspan=1>Deep GradientCompression</td><td rowspan=1 colspan=1>72.24(-0.06)</td><td rowspan=1 colspan=1>0.42 MB</td><td rowspan=1 colspan=1>462 ×</td><td rowspan=1 colspan=1>9.06%     27.04%(-0.39%)   (-0.03%)</td><td rowspan=1 colspan=1>0.74 MB</td><td rowspan=1 colspan=1>608×</td></tr></table>",
+        "bbox": [
+            137,
+            523,
+            862,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            648,
+            825,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For language modeling, Figure 4 shows the perplexity and training loss of the language model trained with 4 nodes when the gradient sparsity is $9 9 . 9 \\%$ . The training loss with Deep Gradient Compression closely match the baseline, so does the validation perplexity. From Table 4, Deep Gradient Compression compresses the gradient by $4 6 2 \\times$ with a slight reduction in perplexity. ",
+        "bbox": [
+            173,
+            684,
+            825,
+            739
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For speech recognition, Figure 5 shows the word error rate (WER) and training loss curve of 5-layer LSTM on AN4 Dataset with 4 nodes when the gradient sparsity is $9 9 . 9 \\%$ . The learning curves show the same improvement acquired from techniques in Deep Gradient Compression as for the image network. Table 4 shows word error rate (WER) performance on LibriSpeech test dataset, where test-clean contains clean speech and test-other noisy speech. The model trained with Deep Gradient Compression gains better recognition ability on both clean and noisy speech, even when gradients size is compressed by $6 0 8 \\times$ . ",
+        "bbox": [
+            173,
+            746,
+            825,
+            844
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 SYSTEM ANALYSIS AND PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            540,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Implementing DGC requires gradient top- $k$ selection. Given the target sparsity ratio of $9 9 . 9 \\%$ , we need to pick the top $0 . 1 \\%$ largest over millions of weights. Its complexity is $O ( n )$ , where $n$ is the number of the gradient elements (Cormen, 2009). We propose to use sampling to reduce top- $k$ selection time. We sample only $0 . 1 \\%$ to $1 \\%$ of the gradients and perform top- $k$ selection on the samples to estimate the threshold for the entire population. If the number of gradients exceeding the threshold is far more than expected, a precise threshold is calculated from the already-selected gradients. Hierarchically calculating the threshold significantly reduces top- $k$ selection time. In practice, total extra computation time is negligible compared to network communication time which is usually from hundreds of milliseconds to several seconds depending on the network bandwidth. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/da729b546b722eb99540362f021c38de97675aa8a17d5ae1cd3d1a74da50f94a.jpg",
+        "image_caption": [
+            "Figure 4: Perplexity and training loss of LSTM language model on PTB dataset (the gradient sparsity is $9 9 . 9 \\%$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            102,
+            792,
+            265
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb4e3055bd7875c3516526a76cdc8c3060114f813f5a668f138b55bd3fbae26b.jpg",
+        "image_caption": [
+            "Figure 5: WER and training loss of 5-layer LSTM on AN4 (the gradient sparsity is $9 9 . 9 \\%$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            301,
+            472,
+            464
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/94ecc53592aacda14a957cf87a0316a83bf0163aa1dd7c6c51ff89d2d819db0b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            303,
+            790,
+            463
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/01aa745236eba55636af83f7a478017e6ef9f97dacffb205e6d02938d815c04f.jpg",
+        "image_caption": [
+            "Figure 6: Deep Gradient Compression improves the speedup and scalability of distributed training. Each training node has 4 NVIDIA Titan XP GPUs and one PCI switch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            497,
+            815,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We use the performance model proposed in Wen et al. (2017) to perform the scalability analysis, combining the lightweight profiling on single training node with the analytical communication modeling. With the all-reduce communication model (Rabenseifner, 2004; Bruck et al., 1997), the density of sparse data doubles at every aggregation step in the worst case. However, even considering this effect, Deep Gradient Compression still significantly reduces the network communication time, as implied in Figure 6. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows the speedup of multi-node training compared with single-node training. Conventional training achieves much worse speedup with 1Gbps (Figure 6(a)) than 10Gbps Ethernet (Figure 6(b)). Nonetheless, Deep Gradient Compression enables the training with 1Gbps Ethernet to be competitive with conventional training with 10Gbps Ethernet. For instance, when training AlexNet with 64 nodes, conventional training only achieves about $3 0 \\times$ speedup with 10Gbps Ethernet (Apache, 2016), while with DGC, more than $4 0 \\times$ speedup is achieved with only 1Gbps Ethernet. From the comparison of Figure 6(a) and 6(b), Deep Gradient Compression benefits even more when the communication-to-computation ratio of the model is higher and the network bandwidth is lower. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            318,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deep Gradient Compression (DGC) compresses the gradient by $2 7 0 { - } 6 0 0 \\times$ for a wide range of CNNs and RNNs. To achieve this compression without slowing down the convergence, DGC employs momentum correction, local gradient clipping, momentum factor masking and warm-up training. We further propose hierarchical threshold selection to speed up the gradient sparsification process. Deep Gradient Compression reduces the required communication bandwidth and improves the scalability of distributed training with inexpensive, commodity networking infrastructure. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            369,
+            387,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by National Natural Science Foundation of China (No.61622403), Tsinghua University Initiative Scientific Research Program and Beijing National Research Center for Information Science and Technology. We are also thankful to reviewers for their helpful suggestions. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            285,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alejandro Acero. Acoustical and environmental robustness in automatic speech recognition. In Proc. of ICASSP, 1990. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. In Empirical Methods in Natural Language Processing (EMNLP), 2017. ",
+        "bbox": [
+            173,
+            517,
+            823,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Alistarh, Jerry Li, Ryota Tomioka, and Milan Vojnovic. Qsgd: Randomized quantization for communication-optimal stochastic gradient descent. arXiv preprint arXiv:1610.02132, 2016. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Apache. Image classification with mxnet. https://github.com/apache/incubator-mxnet/ tree/master/example/image-classification, 2016. ",
+        "bbox": [
+            176,
+            587,
+            823,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE transactions on neural networks, 5(2):157–166, 1994. ",
+        "bbox": [
+            173,
+            619,
+            823,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jehoshua Bruck, Ching-Tien Ho, Shlomo Kipnis, Eli Upfal, and Derrick Weathersby. Efficient algorithms for all-to-all communications in multiport message-passing systems. IEEE Transactions on parallel and distributed systems, 8(11):1143–1156, 1997. ",
+        "bbox": [
+            174,
+            654,
+            823,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            174,
+            700,
+            823,
+            739
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Trishul M Chilimbi, Yutaka Suzue, Johnson Apacible, and Karthik Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In OSDI, volume 14, pp. 571–582, 2014. ",
+        "bbox": [
+            171,
+            747,
+            821,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas H Cormen. Introduction to algorithms. MIT press, 2009. ",
+        "bbox": [
+            173,
+            781,
+            563,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            176,
+            804,
+            825,
+            843
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009. ",
+        "bbox": [
+            174,
+            851,
+            823,
+            877
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nikoli Dryden, Sam Ade Jacobs, Tim Moon, and Brian Van Essen. Communication quantization for dataparallel training of deep neural networks. In Proceedings of the Workshop on Machine Learning in High Performance Computing Environments, pp. 1–8. IEEE Press, 2016. ",
+        "bbox": [
+            176,
+            885,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Google. Federated learning: Collaborative machine learning without centralized training data, 2017. URL https://research.googleblog.com/2017/04/ federated-learning-collaborative.html. ",
+        "bbox": [
+            171,
+            104,
+            823,
+            143
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, ´ Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            174,
+            154,
+            821,
+            191
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. Gross and M. Wilber. Training and investigating residual nets. https://github.com/facebook/ fb.resnet.torch, 2016. ",
+        "bbox": [
+            173,
+            200,
+            823,
+            228
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Awni Hannun, Carl Case, Jared Casper, Bryan Catanzaro, Greg Diamos, Erich Elsen, Ryan Prenger, Sanjeev Satheesh, Shubho Sengupta, Adam Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014. ",
+        "bbox": [
+            174,
+            236,
+            823,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. arXiv preprint arXiv:1611.01462, 2016. ",
+        "bbox": [
+            173,
+            285,
+            821,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richt \\` arik, Ananda Theertha Suresh, and Dave Bacon. ´ Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016. ",
+        "bbox": [
+            176,
+            320,
+            825,
+            361
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.   \nJ. Lei Ba, J. R. Kiros, and G. E. Hinton. Layer Normalization. ArXiv e-prints, July 2016.   \nMu Li, David G Andersen, Alexander J Smola, and Kai Yu. Communication efficient distributed machine learning with the parameter server. In Advances in Neural Information Processing Systems, pp. 19–27, 2014.   \nMitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a large annotated corpus of english: The penn treebank. COMPUTATIONAL LINGUISTICS, 19(2):313–330, 1993.   \nH Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, et al. Communication-efficient learning of deep networks from decentralized data. arXiv preprint arXiv:1602.05629, 2016.   \nTomas Mikolov, Martin Karafiat, Lukas Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent neural \\` network based language model. In Interspeech, volume 2, pp. 3, 2010.   \nIoannis Mitliagkas, Ce Zhang, Stefan Hadjis, and Christopher Re. Asynchrony begets momentum, with an ´ application to deep learning. In Communication, Control, and Computing (Allerton), 2016 54th Annual Allerton Conference on, pp. 997–1004. IEEE, 2016.   \nPhilipp Moritz, Robert Nishihara, Ion Stoica, and Michael I Jordan. Sparknet: Training deep networks in spark. arXiv preprint arXiv:1511.06051, 2015.   \nYurii Nesterov. A method of solving a convex programming problem with convergence rate o (1/k2). In Soviet Mathematics Doklady, volume 27, pp. 372–376, 1983.   \nVassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In Acoustics, Speech and Signal Processing (ICASSP), 2015 IEEE International Conference on, pp. 5206–5210. IEEE, 2015.   \nRazvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pp. 1310–1318, 2013.   \nOfir Press and Lior Wolf. Using the output embedding to improve language models. arXiv preprint arXiv:1608.05859, 2016.   \nNing Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12(1):145–151, 1999.   \nRolf Rabenseifner. Optimization of collective reduction operations. In International Conference on Computational Science, pp. 1–9. Springer, 2004.   \nBenjamin 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": [
+            169,
+            342,
+            826,
+            929
+        ],
+        "page_idx": 10
+    },
+    {
+        "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": [
+            174,
+            104,
+            823,
+            142
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            151,
+            823,
+            179
+        ],
+        "page_idx": 11
+    },
+    {
+        "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, 2017. ",
+        "bbox": [
+            174,
+            188,
+            821,
+            226
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhimanu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Transactions on Big Data, 1(2):49–67, 2015. ",
+        "bbox": [
+            174,
+            234,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016. ",
+        "bbox": [
+            173,
+            282,
+            823,
+            309
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pp. 2595–2603, 2010. ",
+        "bbox": [
+            171,
+            318,
+            823,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A SYNCHRONOUS DISTRIBUTED STOCHASTIC GRADIENT DESCENT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            754,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In practice, each training node performs the forward-backward pass on different batches sampled from the training dataset with the same network model. The gradients from all nodes are summed up to optimize their models. By this synchronization step, models on different nodes are always the same during the training. The aggregation step can be achieved in two ways. One method is using the parameter servers as the intermediary which store the parameters among several servers (Dean et al., 2012). The nodes push the gradients to the servers while the servers are waiting for the gradients from all nodes. Once all gradients are sent, the servers update the parameters, and then all nodes pull the latest parameters from the servers. The other method is to perform the All-reduce operation on the gradients among all nodes and to update the parameters on each node independently (Goyal et al., 2017), as shown in Algorithm 2 and Figure 7. In this paper, we adopt the latter approach by default. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a08c0a3c8217ddfc8762679dfb0d2ce41f9f699504333c8d85bc675d5029e10.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            299,
+            460,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Each node independently calculates gradients (b) All-reduce operation of gradient aggregation ",
+        "bbox": [
+            178,
+            396,
+            465,
+            410
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/cab34d62dbb8bc5a0de99b3b2c221d8236282b11e6cf8dd54c5510e70657cec4.jpg",
+        "image_caption": [
+            "Figure 7: Distributed Synchronous SGD "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            417,
+            460,
+            501
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            508,
+            464,
+            522
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/94356c511685fe4b71bbf005ee555b462c45e64c82e3c4f08fd2e57bac9229dd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 2 Distributed Synchronous SGD on node k</td></tr><tr><td>Input: Dataset X Input: minibatch size b per node Input: the number of nodes N Input: Optimization Function SGD Input: Init parameters w = {w[0],·,w[M]} 1: for t =0,1,. do</td></tr></table>",
+        "bbox": [
+            488,
+            306,
+            815,
+            534
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B GRADIENT SPARSIFICATION WITH NESTROV MOMENTUM CORRECTION ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            566,
+            797,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The conventional update rule for Nesterov momentum SGD (Nesterov, 1983) follows, ",
+        "bbox": [
+            173,
+            597,
+            738,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2fdcc77ca01b8a4fe2cd1219af489e6f6171c470b7d63c175efeb6ac49f6ac14.jpg",
+        "text": "$$\nu _ { t + 1 } = m u _ { t } + \\sum _ { k = 1 } ^ { N } \\left( \\nabla _ { k , t } \\right) , \\quad w _ { t + 1 } = w _ { t } - \\eta \\left( m \\cdot u _ { t + 1 } + \\nabla _ { t } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            614,
+            705,
+            659
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $m$ is the momentum, $N$ is the number of training nodes, and $\\begin{array} { r } { \\nabla _ { k , t } = \\frac { 1 } { N b } \\sum _ { x \\in { \\mathcal { B } _ { k , t } } } \\nabla f ( x , w _ { t } ) } \\end{array}$ . Before momentum correction, the sparse update follows, ",
+        "bbox": [
+            173,
+            660,
+            825,
+            699
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21b08082858a9ac146bab20cc37861b015e19d049aa00d7a40c9903ee3aae432.jpg",
+        "text": "$$\nv _ { k , t + 1 } = v _ { k , t } + \\nabla _ { k , t } , \\quad u _ { t + 1 } = m u _ { t } + \\sum _ { k = 1 } ^ { N } s p a r s e \\left( v _ { k , t + 1 } \\right) , \\quad w _ { t + 1 } = w _ { t } - \\eta u _ { t + 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            700,
+            777,
+            744
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "After momentum correction sharing the same methodology with Equation 7, it becomes, ",
+        "bbox": [
+            171,
+            746,
+            754,
+            761
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4598211f3c8e2edee9f4857eb77462634990192bca5d3bade00d761680fb2bd0.jpg",
+        "text": "$$\n\\iota _ { k , t + 1 } = m u _ { k , t } + \\nabla _ { k , t } , \\quad v _ { k , t + 1 } = v _ { k , t } + \\left( m \\cdot u _ { k , t + 1 } + \\nabla _ { k , t } \\right) , \\quad w _ { t + 1 } = w _ { t } - \\eta \\sum _ { k = 1 } ^ { N } s p a r s e \\left( v _ { k , t + 1 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            762,
+            831,
+            805
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C LOCAL GRADIENT CLIPPING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            449,
+            853
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "When training the recurrent neural network with gradient clipping, we perform the gradient clipping locally before adding the current gradient $G _ { t } ^ { k }$ to previous accumulation $G _ { t - 1 } ^ { k }$ in Algorithm 1. Denote the origin threshold for the gradients L2-norm $| | G | | _ { 2 }$ as $t h r _ { G }$ , and the threshold for the local gradients L2-norm $| | G ^ { k } | | _ { 2 }$ as as $t h r _ { G ^ { k } }$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            925
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Assuming all $N$ training nodes have independent identical gradient distributions with the variance $\\sigma ^ { 2 }$ , the sum of gradients from all nodes have the variance $N \\bar { \\sigma } ^ { 2 }$ . Therefore, ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22f25d4b8bfb3693b17b290510e4a7691337649fdc6c13fa3ec3b351222e4345.jpg",
+        "text": "$$\nE \\left[ | | G ^ { k } | | _ { 2 } \\right] \\approx \\sigma , \\quad E \\left[ | | G | | _ { 2 } \\right] \\approx N ^ { 1 / 2 } \\sigma\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            138,
+            632,
+            160
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Thus, We scale the threshold by $N ^ { - 1 / 2 }$ , the current node’s fraction of the global threshold, ",
+        "bbox": [
+            171,
+            166,
+            769,
+            183
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1cb6d5bf8689b380cdf48b088d2e7fafa5550b02e021eab455e0d7c32a6ab5e9.jpg",
+        "text": "$$\nt h r _ { G ^ { k } } = N ^ { - 1 / 2 } \\cdot t h r _ { G }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            189,
+            578,
+            208
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D DEEP GRADIENT COMPRESSION ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            227,
+            589,
+            243
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/4b36e6e2acf37812054b8f1fcde6c7e2da624af20f15dfed3b7f2ce093d3f6a8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>vanilla momentum SGD on node k</td><td>Algorithm 3 Deep Gradient Compression for Algorithm 4 Deep Gradient Compression for Nesterc momentum SGD on node k</td></tr><tr><td>Input: dataset X</td><td>Input: dataset X</td></tr><tr><td>Input: minibatch size b per node</td><td>Input:minibatch size b per node</td></tr><tr><td>Input: momentum m</td><td>Input: momentum m</td></tr><tr><td></td><td></td></tr><tr><td>Input: the number of nodes N</td><td>Input: the number of nodes N</td></tr><tr><td>Input: optimization function SGD Input: initial parameters w= {w[O],··,w[M]}</td><td>Input: optimization function SGD Input: initial parameters w={w[O],··,w[M]}</td></tr><tr><td>1:Uk ←0,Vk ←0</td><td>1:Uk←0,Vk←0</td></tr><tr><td>2: for t=0,1,.·. do</td><td>2: for t = 0,1,.· do</td></tr><tr><td>3: G←</td><td>3: G←0</td></tr><tr><td>4: fori=1,.,bdo</td><td>4: fori=1,.,bdo</td></tr><tr><td>5: Sample data x from X</td><td>5: Sample data x from X</td></tr><tr><td>G←G+f（x;0t） 6:</td><td>G←G+f（x;0t） 6:</td></tr><tr><td>7: end for</td><td>7: end for</td></tr><tr><td>8: if Gradient Clipping then</td><td>8: if Gradient Clipping then</td></tr><tr><td>9: Gk ← Local-Gradient_Clipping(Gk)</td><td>9: Gl ← Local_Gradient_Clipping(Gt)</td></tr><tr><td>10: end if</td><td>10: end if</td></tr><tr><td>11: U←m.Uk-1+Gk</td><td>11: U←m·(U-1+G&#x27;）</td></tr><tr><td>12: V←V1+U</td><td>12: V←V1+U+G</td></tr><tr><td>13: forj=0,..,M do</td><td>13: for j=0,..,M do</td></tr><tr><td>14: thr ←s%of|V[j]l</td><td>14: thr ←s%of|Vk[j]l</td></tr><tr><td>15: Mask ← |V[j] &gt;thr</td><td>15: Mask ← |V[]| &gt;thr</td></tr><tr><td>G[] ←V Mask 16:</td><td>16: G]←V[j]Mask</td></tr><tr><td>17: V[j] ←Vj]-Mask</td><td>17: V] ←V-Mask</td></tr><tr><td>18: U]←Uj-Mask</td><td>18: U←U-Mask</td></tr><tr><td>19: end for</td><td>19: end for</td></tr><tr><td>20:</td><td>20: All-reduce: Gt ← ∑N 1 encode(G&#x27;)</td></tr><tr><td>21: 0t+1 ← SGD(0t,Gt)</td><td>21: 0t+1 ← SGD(0t,Gt) 22:</td></tr></table>",
+        "bbox": [
+            173,
+            284,
+            816,
+            685
+        ],
+        "page_idx": 13
+    }
+]

parse/train/SybqeKgA-/SybqeKgA-.md

@@ -0,0 +1,294 @@
+# ON BATCH ADAPTIVE TRAINING FOR DEEP LEARNING: LOWER LOSS AND LARGER STEP SIZE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Mini-batch gradient descent and its variants are commonly used in deep learning. The principle of mini-batch gradient descent is to use noisy gradient calculated on a batch to estimate the real gradient, thus balancing the computation cost per iteration and the uncertainty of noisy gradient. However, its batch size is a fixed hyper parameter requiring manual setting before training the neural network. Yin et al. (2017) proposed a batch adaptive stochastic gradient descent (BA-SGD) that can dynamically choose a proper batch size as learning proceeds. We extend the BA-SGD to momentum algorithm, and evaluate both the BA-SGD and the batch adaptive momentum (BA-Momentum) on two deep learning tasks from natural language processing to image classification. Experiments confirm that batch adaptive methods can achieve a lower loss compared with mini-batch methods and methods that manually increase the batch size, after scanning the same epochs of data. Furthermore, our BA-Momentum is more robust against larger step sizes, in that it can dynamically enlarge the batch size to reduce the larger uncertainty brought by larger step sizes. We also identified an interesting phenomenon, batch size boom. The code implementing the batch adaptive framework is now open source, applicable to any gradient-based optimization problems.
+
+# 1 INTRODUCTION
+
+Efficiency of training large neural networks becomes increasingly important as deep neural networks tend to have more parameters and require more training data to achieve the state-of-the-art performance on a wide variety of tasks (Goodfellow et al., 2015). For training deep neural networks, stochastic gradient descent (SGD) (Robbins & Monro, 1951) and its variants, including momentum, which utilizes past updates with an exponential decay (Qian, 1999), and other methods that can adapt different learning rates for each dimension, such as ADAGRAD (Duchi et al., 2010), ADADELTA (Zeiler, 2012) and ADAM (Kingma & Ba, 2014), are commonly used.
+
+SGD approximates the gradient by only using a single data instance in each iteration, which may lead to uncertainty of approximation. This uncertainty can be reduced by adopting a batch of instances to do the approximation. In mini-batch SGD, the batch size is a fixed hyper parameter requiring manual setting before training the neural network. Setting the batch size typically involves a tuning procedure in which the best batch size is chosen by a series of attempts.
+
+Yin et al. (2017) has developed a batch adaptive stochastic gradient descent (BA-SGD) that can dynamically choose a proper batch size as learning proceeds. BA-SGD models the decrease of objective value as a Gaussian random walk game with rebound on the basis of Taylor extension and central limit theorem. Its core idea is to only update the parameters when the ratio between the expected decrease of objective value and the current batch size is large enough, otherwise enlarge the batch size to better approximate the gradient. It claimed that by smartly choosing the batch size, the BA-SGD not only conserves the fast convergence of SGD algorithm but also avoids too frequent model updates, and compared with mini-batch SGD, its objective value decreases more, after scanning the same amount of data.
+
+However, the experiment in Yin et al. (2017) was only conducted on some simple classification tasks using fully connected neural network with one input layer, one output layer and two hidden layers. What about the evaluation on some complex neural networks, such as convolutional neural network (CNN) and recurrent neural network (RNN)? How well would the batch adaptive algorithm perform on other complicated tasks related to natural language processing and computer vision? Furthermore, empirical studies reveal that SGD usually performs not so well in some deep and complex neural networks (Sutskever et al., 2013). Can this batch adaptive framework be extended to other gradient based optimization algorithms except SGD?
+
+Therefore, in this paper we extend the batch adaptive framework to momentum algorithm, and evaluate both the batch adaptive SGD (BA-SGD) and the batch adaptive momentum (BA-Momentum) on two deep learning tasks from natural language processing to image classification. These two tasks use RNN and CNN respectively, which cover most of the deep learning models.
+
+In our experiments, we have the following observations. First, for batch adaptive methods, their loss functions converge to lower values after scanning same epoches of data, compared with fixedbatch-size methods. Second, BA-Momentum is more robust against large step sizes by dynamically enlarging the batch size to counteract with the larger noise brought by larger step sizes. Third, we observed a batch size boom, a concentrated period where the batch size frequently increases to larger values, in the training of BA-Momentum. The batch size boom is of significance in that it always appears at the point where mini-batch method starts to reach its lowest possible loss and it helps BA-Momentum keep dropping to even lower loss. More details on these observations and their analysis can be found in Section 4. The code implementing the batch adaptive framework using Theano (AlR) is now open source 1, which is applicable to any gradient-based optimization problems.
+
+This paper is organized as follows. In Section 2, we briefly introduce the batch adaptive framework proposed by Yin et al. (2017). In Section 3, we extend the batch adaptive framework to momentum algorithm. In Section 4, we demonstrate the performance of BA-M and BA-SGD on Fashion-MNIST (Xiao et al., 2017) and relation extraction task, and then reveal the robustness of BA-Momentum against large step sizes. In Section 5, we discuss some efficiency issue concerned with implementing this batch adaptive framework, and also propose several promising applications based on this framework.
+
+# 2 PREREQUISITES
+
+In this section we briefly summarize the batch adaptive stochastic gradient descent proposed by Yin et al. (2017).
+
+# 2.1 NOTATIONS
+
+We use $\mathcal { X }$ and $\mathcal { V }$ to respectively denote the training data set and its random subset. The vector of model parameters is denoted by $\vec { \theta }$ and is subscripted by $t$ to denote an iteration. F is used to denote objective function, while $\mathbf { f } _ { \vec { \theta } }$ is the partial derivative of function F with model parameters $\vec { \theta }$ (i.e. the gradient, computed over the whole data set).
+
+# 2.2 BATCH ADAPTIVE FRAMEWORK
+
+Let $\vec { \xi _ { j } }$ denote the difference between the approximate gradient computed on an individual instance $\mathbf { g } _ { \vec { \theta } } ^ { j }$ and the real gradient $\mathbf { f } _ { \vec { \theta } }$ , thus, $\hat { \mathbf { f } } _ { \vec { \theta } }$ , the approximate gradient computed on a batch $\mathcal { V }$ can be written
+
+$$
+\hat { \mathbf { f } } _ { \vec { \theta } } = \frac { \sum _ { \mathbf { y } _ { j } \in \mathcal { V } } \mathbf { g } _ { \vec { \theta } } ^ { j } } { | \mathcal { V } | } = \mathbf { f } _ { \vec { \theta } } + \frac { \sum _ { \mathbf { y } _ { j } \in \mathcal { V } } \vec { \xi _ { j } } } { | \mathcal { V } | }
+$$
+
+The term $\frac { \sum _ { \mathbf { y } _ { j } \in \mathcal { y } } \vec { \xi _ { j } } } { | \mathcal { y } | }$ can be viewed as a random variable determined by the randomly sampled batch $\mathcal { V }$ . On the basis of Central Limit Theorem (CLT), it should satisfy a multi-dimension normal distribution $\begin{array} { r } { \mathcal { N } ( \mathbf { 0 } , \frac { \Sigma } { | \mathcal { V } | } ) } \end{array}$ , where $\pmb { \Sigma }$ is the covariance matrix of $\vec { \xi _ { j } }$ . $\mathbf { f } _ { \vec { \theta } }$ is the real gradient, computed on the whole data set and treated as a constant given the parameters $\vec { \theta }$ . Thus we have $\hat { \mathbf { f } } _ { \vec { \theta } } \sim \mathcal { N } ( \mathbf { f } _ { \vec { \theta } } , \frac { \Sigma } { | \mathcal { V } | } )$ .
+
+After modelling the estimation of gradient on a batch as a normally distributed random variable, Yin et al. (2017) uses first-order Taylor extension to approximate the objective function $\mathbb { F } ( \vec { \theta } )$ at any parameter configuration. The equation is shown below.
+
+$$
+\boldsymbol { \mathsf { F } } ( \overrightarrow { \theta } ) = \boldsymbol { \mathsf { F } } ( \overrightarrow { \theta _ { 0 } } ) + \mathbf { f } _ { \overrightarrow { \theta _ { 0 } } } ^ { T } \cdot ( \overrightarrow { \theta } - \overrightarrow { \theta _ { 0 } } ) + \mathtt { h } _ { \overrightarrow { \theta _ { 0 } } } ( \overrightarrow { \theta } )
+$$
+
+where the function $\mathtt { h } _ { \vec { \theta } _ { 0 } } ( \vec { \theta } )$ is the remainder term satisfying $\begin{array} { r } { \operatorname* { l i m } _ { \vec { \theta } \to \vec { \theta } _ { 0 } } \mathtt { h } _ { \vec { \theta } _ { 0 } } ( \vec { \theta } ) = 0 } \end{array}$
+
+If SGD optimization algorithm is adopted to update the parameters, with Equation (1) and Equation (2), the decrease of objective value can be expressed as:
+
+$$
+\Delta \mathbf { F } ( \vec { \theta } _ { 0 } ) = \mathbf { F } ( \vec { \theta } _ { 0 } - \eta \hat { \mathbf { f } } _ { \vec { \theta } _ { 0 } } ) - \mathbf { F } ( \vec { \theta } _ { 0 } ) \approx - \eta \mathbf { f } _ { \vec { \theta } _ { 0 } } ^ { T } \cdot \left( \mathbf { f } _ { \vec { \theta } _ { 0 } } + \frac { \sum _ { \mathbf { y } _ { j } \in \mathcal { N } } \vec { \xi } _ { j } } { | \mathcal { y } | } \right) = - \eta \cdot \mathbf { f } _ { \vec { \theta } _ { 0 } } ^ { T } \mathbf { f } _ { \vec { \theta } _ { 0 } } - \eta \cdot \mathbf { f } _ { \vec { \theta } _ { 0 } } ^ { T } \cdot \vec { \varepsilon } _ { \mathcal { V } }
+$$
+
+where $\eta$ is the learning rate, and the noise term satisfies $\vec { \varepsilon } _ { y } \sim \mathcal { N } ( \mathbf { 0 } , \frac { \Sigma } { | y | } )$ , then $\vec { \varepsilon } _ { y } ^ { T } \cdot \mathbf { f } _ { \vec { \theta } _ { 0 } }$ can be viewed as a weighted sum of each dimension of vector $\vec { \varepsilon } _ { y }$ , thus satisfying a one-dimension Gaussian distribution, i.e. $\begin{array} { r } { \vec { \varepsilon } _ { y } ^ { T } \cdot \mathbf { f } _ { \vec { \theta _ { 0 } } } \sim \mathcal { N } ( 0 , \frac { \mathbf { f } _ { \vec { \theta _ { 0 } } } ^ { T } \cdot \pmb { \Sigma } \cdot \mathbf { f } _ { \vec { \theta _ { 0 } } } } { | \mathcal { V } | } ) } \end{array}$ Tθ\~0 ·Σ·fθ\~0|Y| ). Then ∆F(\~θ0) also satisfies a Gaussian distribution, i.e. $\begin{array} { r } { \Delta \mathbb { F } ( \vec { \theta _ { 0 } } ) \sim \mathcal { N } ( - \eta \mathbf { f } _ { \vec { \theta _ { 0 } } } ^ { T } \mathbf { f } _ { \vec { \theta _ { 0 } } } , \eta ^ { 2 } \frac { \mathbf { f } _ { \vec { \theta _ { 0 } } } ^ { T } \cdot \Sigma \cdot \mathbf { f } _ { \vec { \theta _ { 0 } } } } { | \mathcal { V } | } ) } \end{array}$ . In practice, they use the approximate gradient $\hat { \mathbf { f } } _ { \vec { \theta _ { 0 } } }$ to calculate the mean and variance of $\Delta \mathbb { F } (  { \vec { \theta } } _ { 0 } )$ .
+
+For the covariance matrix of $\vec { \varepsilon } _ { \mathcal { Y } } , \pmb { \Sigma }$ , its unbiased estimation $\hat { \Sigma }$ is:
+
+$$
+\hat { \mathbf { \Sigma } } = \frac { \sum _ { \mathbf { y } _ { j } \in \mathcal { Y } } ( \mathbf { g } _ { \vec { \theta _ { 0 } } } ^ { j } - \hat { \mathbf { f } } _ { \vec { \theta _ { 0 } } } ) ( \mathbf { g } _ { \vec { \theta _ { 0 } } } ^ { j } - \hat { \mathbf { f } } _ { \vec { \theta _ { 0 } } } ) ^ { T } } { | \mathcal { Y } | - 1 }
+$$
+
+After modelling the decrease of objective value as a normally distributed random variable, Yin et al.   
+(2017) abstract the process of objective value change as a random walk game with a Gaussian dice.
+
+In the game, the objective value is regarded as a state. For the simplicity of notation, we define a state $s _ { t }$ as below.
+
+$$
+s _ { t } = - \frac { \Delta \mathsf { F } } { \eta }
+$$
+
+The decrease of objective value, namely the transfer from the current state to the next state is determined by a Gaussian dice, of which the mean solely depend on the current state and the variance is controlled by the state and the batch to be chosen. They define the domain of game state as a half closed set of real numbers $[ S ^ { * } , + \infty )$ , where $S ^ { * }$ is the minimum objective value that the learning can possibly achieve. The game starts with a random state and the goal is to move as close as possible to $S ^ { * }$ . There are two ways of state transfer: one directly decreasing from $S _ { i }$ to $S _ { j }$ , another first reaching minimum point $S ^ { * }$ and then rebounding to $S _ { j }$ .
+
+Formally, for state $s _ { t }$ , the moving step $\triangle { s _ { t } }$ is generated by a Gaussian dice $\begin{array} { r } { \mathcal { N } ( \mu _ { t } , \frac { \sigma _ { t } ^ { 2 } } { m } ) } \end{array}$ σ 2t ) , where $\boldsymbol { \mu } _ { t } = \hat { \mathbf { f } } _ { \vec { \theta _ { t } } } ^ { T } \hat { \mathbf { f } } _ { \vec { \theta _ { t } } }$ , $\sigma _ { t } ^ { 2 } = \hat { \mathbf { f } } _ { \vec { \theta } _ { t } } ^ { T } \hat { \Sigma } \hat { \mathbf { f } } _ { \vec { \theta } _ { t } }$ = fˆTθ\~t , $m = | \mathcal { V } |$ , denoting the batch size. The state transition equation is presented below.
+
+$$
+s _ { t + 1 } = | s _ { t } - S ^ { * } - \eta \triangle s _ { t } | + S ^ { * } = \left\{ { s _ { t } } - \eta \triangle s _ { t } , \quad \quad \mathrm { i f ~ } s _ { t } - \eta \triangle s _ { t } \geq S ^ { * } \right.
+$$
+
+Let $p _ { m } ^ { s _ { t } } ( \triangle s _ { t } )$ denote the probability density function for a random moving step $\begin{array} { r } { \triangle s _ { t } \sim \mathcal N \left( \mu _ { t } , \frac { \sigma _ { t } ^ { 2 } } { m } \right) } \end{array}$ .   
+The expected value of next state can be expressed as follows.
+
+$$
+\begin{array} { l } { \displaystyle { \bf E } _ { m } ^ { s _ { t } } ( s _ { t + 1 } ) = \int _ { - \infty } ^ { + \infty } p _ { m } ^ { s _ { t } } ( \triangle s _ { t } ) ( | s _ { t } - S ^ { * } - \eta \cdot \triangle s _ { t } | + S ^ { * } ) d \triangle s _ { t } } \\ { = ( s _ { t } - S ^ { * } - \eta \mu _ { t } ) \left\{ \Phi ( a ) - \Phi ( - a ) \right\} + \frac { \eta \sigma _ { t } } { \sqrt { m } } \sqrt { \frac { 2 } { \pi } } e ^ { - \frac { a ^ { 2 } } { 2 } } + S ^ { * } } \\ { \mathrm { w h e r e ~ } a = \frac { s _ { t } - S ^ { * } - \eta \mu _ { t } } { \eta \sigma _ { t } } \sqrt { m } } \end{array}
+$$
+
+To decide the best batch size, one should consider both the variance of estimated gradients and computation cost. Large batch can reduce the variance and therefore make more accurate updates, whereas it also requires more computations. Yin et al. (2017) then define a utility function to find a balance. Maximizing the utility means achieving the largest expected decrease of loss per data instance.
+
+$$
+\mathbf { u } ( m , s _ { t } ) = { \frac { s _ { t } - \mathbf { E } _ { m } ^ { s _ { t } } \left( s _ { t + 1 } \right) } { m } }
+$$
+
+$$
+m ^ { * } \gets \arg \operatorname* { m a x } _ { m } \mathtt { u } ( m , s _ { t } )
+$$
+
+where $m ^ { * }$ is the best batch size for the $( t + 1 )$ -th iteration.
+
+For more specifications on the BA-SGD algorithm, see Yin et al. (2017).
+
+# 3 BATCH ADAPTIVE MOMENTUM
+
+The main appeal of momentum is its ability to reduce oscillations and accelerate convergence (Goh, 2017). The idea behind momentum is that it accelerates learning along dimensions where gradient continues pointing to the same direction, and slows down those where sign of gradient constantly changes (Zeiler, 2012). Recent work on momentum, called YellowFin, an automatic tuner for both momentum and learning rate, helps momentum optimizer converge in even fewer iterations than ADAM on large ResNet and LSTM models (Zhang et al., 2017). Since it is both powerful and popular, we would like to also apply the batch adaptive framework to momentum optimizer.
+
+# 3.1 MOMENTUM
+
+Momentum utilizes past parameter updates with an exponential decay. Its way of update is given by
+
+$$
+ { \vec { \theta } } _ { t + 1 } =  { \vec { \theta } } _ { t } - \mathtt { m } _ { t }
+$$
+
+$$
+\boldsymbol { \mathfrak { m } } _ { t } = \rho \boldsymbol { \mathfrak { m } } _ { t - 1 } + \eta \hat { \boldsymbol { \mathfrak { f } } } _ { \vec { \theta _ { t } } }
+$$
+
+where ${ \mathfrak { m } } _ { t }$ denotes momentum at the $t$ -th iteration and $\rho$ is the rate controlling the decay of the previous parameter updates. Equation 11 can also be written in the following form.
+
+$$
+\mathtt { m } _ { t } = \eta \sum _ { \tau = 0 } ^ { t } \rho ^ { t - \tau } \hat { \mathbf { f } } _ { \vec { \theta } _ { \tau } }
+$$
+
+# 3.2 DERIVATION
+
+Referring to Equation 3, we can analogically estimate the decrease of objective value in the following expression.
+
+$$
+\begin{array} { r } { \Delta \mathtt { F } _ { t } = \mathtt { F } ( \vec { \theta } _ { t + 1 } ) - \mathtt { F } ( \vec { \theta _ { t } } ) = \mathtt { f } _ { \vec { \theta _ { t } } } ^ { T } ( \vec { \theta _ { t + 1 } } - \vec { \theta _ { t } } ) = - \mathtt { f } _ { \vec { \theta _ { t } } } ^ { T } \mathtt { m } _ { t } } \\ { = - \eta \mathtt { f } _ { \vec { \theta _ { t } } } ^ { T } \displaystyle \sum _ { \tau = 0 } ^ { t } \rho ^ { t - \tau } \hat { \mathtt { f } } _ { \vec { \theta _ { \tau } } } = - \eta \mathtt { f } _ { \vec { \theta _ { t } } } ^ { T } \displaystyle \sum _ { \tau = 0 } ^ { t } \rho ^ { t - \tau } ( \mathtt { f } _ { \vec { \theta _ { \tau } } } + \vec { \varepsilon } _ { \tau } ) } \end{array}
+$$
+
+where $\begin{array} { r } { \vec { \varepsilon } _ { \tau } = \frac { \sum _ { \mathbf { y } _ { j } \in \mathcal { y } _ { \tau } } \vec { \xi } _ { j } } { | \mathcal { y } _ { \tau } | } } \end{array}$ is the noise term which represents the difference between the real gradient and the estimated gradient calculated on a batch ${ \mathcal { D } } _ { \tau }$ chosen at the $\tau$ -th iteration. Though the estimated gradient from the previous iterations (i.e. $\tau = 0 . . . t - 1 )$ has noise, their batches which respectively determine their noise have already been selected, thus their noise is no longer a random variable but a constant. However, for the $t$ -th iteration, we have not decided which batch to be sampled, therefore $\vec { \varepsilon _ { t } }$ is indeed a random variable, and on the basis of CLT we know it is normally distributed, i.e. $\begin{array} { r } { \vec { \varepsilon _ { t } } \sim \mathcal { N } ( \mathbf { 0 } , \frac { \Sigma _ { t } } { | \mathcal { V } _ { t } | } ) } \end{array}$ . Based on this and the fact that real gradients, $\mathbf { f } _ { \vec { \theta } _ { \tau } }$ $( \tau = 0 . . . t )$ , are all constants for the $t$ -th iteration, we then have the decrease of objective value, $\Delta \mathsf { F } _ { t }$ , satisfying a one-dimensional Gaussian distribution, which is also experimentally verified in Appendix B.
+
+We need to calculate the mean and variance of $\Delta \mathsf { F } _ { t }$ , but we prefer not to record all the $\hat { \mathbf { f } } _ { \vec { \theta } _ { \tau } }$ from previous iterations. Therefore, we construct a recurrence formula to avoid the trouble.
+
+Let $\begin{array} { r } { \mathcal { P } _ { t } = \sum _ { \tau = 0 } ^ { t } \rho ^ { t - \tau } \big ( \mathbf { f } _ { \vec { \theta } _ { \tau } } + \vec { \varepsilon } _ { \tau } \big ) } \end{array}$ , then we have the following recurrence formula.
+
+$$
+\mathcal { P } _ { t } = ( \pounds _ { \vec { \theta _ { t } } } + \vec { \varepsilon _ { t } } ) + \rho \mathcal { P } _ { t - 1 }
+$$
+
+Thus the mean and variance of $\mathcal { P } _ { t }$ can be calculated in the following forms.
+
+$$
+\begin{array} { c } { \displaystyle \mu _ { \mathcal { P } _ { t } } = \rho \mu _ { \mathcal { P } _ { t - 1 } } + \hat { \mathbf { f } } _ { \vec { \theta _ { t } } } } \\ { \displaystyle \Sigma _ { \mathcal { P } _ { t } } = \frac { \hat { \mathrm { \Sigma } } _ { t } } { | \mathcal { V } _ { t } | } } \end{array}
+$$
+
+Now we have trated in Secti $\Delta \mathbf { F } _ { t } \sim \mathcal { N } ( - \eta \hat { \mathbf { f } } _ { \vec { \theta _ { t } } } ^ { T } \mu _ { \mathcal { P } _ { t } } , \eta ^ { 2 } \hat { \mathbf { f } } _ { \vec { \theta _ { t } } } ^ { T } \Sigma _ { \mathcal { P } _ { t } } \hat { \mathbf { f } } _ { \vec { \theta _ { t } } } )$ ith rebound illus-. $\begin{array} { r } { \triangle s _ { t } \sim \mathcal N ( \hat { \mathbf f } _ { \vec { \theta } _ { t } } ^ { T } \mu _ { \mathcal P _ { t } } , \hat { \mathbf f } _ { \vec { \theta _ { t } } } ^ { T } \Sigma _ { \mathcal P _ { t } } \hat { \mathbf f } _ { \vec { \theta _ { t } } } ) } \end{array}$
+
+For simplicity, we let $\sigma _ { t } ^ { 2 } = \hat { \mathbf { f } } _ { \vec { \theta _ { t } } } ^ { T } \hat { \Sigma } _ { t } \hat { \mathbf { f } } _ { \vec { \theta _ { t } } }$ , $\mu _ { t } = \hat { \mathbf { f } } _ { \vec { \theta _ { t } } } ^ { T } \mu _ { \mathcal { P } _ { t } }$ , $m = | \mathcal { D } _ { t } |$ , thus $\begin{array} { r } { \triangle s _ { t } \sim N ( \mu _ { t } , \frac { \sigma _ { t } ^ { 2 } } { m } ) } \end{array}$ . Then the expected value of the next state shares the same expression with Equation 7, though the mean of $\triangle { s _ { t } }$ is different.
+
+For batch adaptive momentum algorithm, we also adopt the utility function in Equation 8, and the best batch size is the one that maximizes the utility function, calculated through Equation 9.
+
+# 3.3 ALGORITHM
+
+At the end of this section, we would like to summarize how the batch adaptive momentum algorithm is implemented by presenting the pseudo code below. In the pseudo code, the $M$ stands for the total budget, i.e. the total number of instances used for training, the $m _ { 0 }$ means sampling step, the smallest batch increment. The rest symbols have been introduced before. In this pseudo code, we aim to calculate the optimal batch size for each update step. When an optimal size is determined and it is larger than the current batch size, we need to add more instances to enlarge the batch. However, $s _ { t } , \mu _ { t } , \sigma _ { t }$ will change every time we add more instances, leading to a different optimal size. Thus
+
+# Algorithm 1 Batch-Adaptive Momentum
+
+<table><tr><td colspan="3">1: procedure BA-MOMENTUM(X,0,n, ρ, M, mo)</td></tr><tr><td colspan="3">while M&gt;O do</td></tr><tr><td>2: 3:</td><td>Vt←</td><td></td></tr><tr><td>4:</td><td>repeat</td><td></td></tr><tr><td>5:</td><td>random sample Z from X - Vt with |Z|= mo</td><td></td></tr><tr><td>6:</td><td>Vt ←VtUz</td><td></td></tr><tr><td>7:</td><td>calculate f,∑t with Vt</td><td>Equation (1) and (4</td></tr><tr><td>8:</td><td>calculate μpt With μPt-1 and ff</td><td>Equation (15</td></tr><tr><td>9:</td><td>St←F(jVt),μt←μpt,Ot←√</td><td></td></tr><tr><td>10:</td><td>m* ← arg maXm u(m, st) where S* is user-specified</td><td></td></tr><tr><td>11:</td><td>until |Vt| ≥ min{m*,|x|}</td><td></td></tr><tr><td>12:</td><td>mt= pmt-1+nfθt</td><td></td></tr><tr><td>13:</td><td>日←日-mt</td><td></td></tr><tr><td>14: 15:</td><td>M←M-|Vtl</td><td></td></tr><tr><td>16:</td><td>t=t+1</td><td></td></tr><tr><td>17:</td><td>end while return θ</td><td></td></tr><tr><td>18:</td><td></td><td></td></tr><tr><td></td><td>end procedure</td><td></td></tr></table>
+
+in practice, we can only gradually increase the batch size until it becomes larger than or equal to a running estimate of the optimal batch size. Lastly, when implementing the algorithm, one may note that it is time-consuming to calculate the covariance matrix, $\hat { \Sigma } _ { t }$ . We will discuss a tradeoff and the computation cost of this algorithm in Appendix C.
+
+# 4 EXPERIMENT
+
+In this section, we present the learning efficiency of different learning algorithms on two deep learning models. One is the CNN for image classification on the dataset of Fashion MNIST (Xiao et al., 2017), and the other is a more complex RNN model for relation extraction on financial documents (Miwa & Bansal, 2016). To evaluate our learning efficiency regardless of the size of the data set, we use epoch as the unit of scanned data and one epoch means all instances in the whole training set. We calculate the training loss on the whole training set each time when the model has scanned one more epoch of data.
+
+# 4.1 MODEL AND DATASET
+
+Fashion MNIST is a data set of Zalando’s article images, which consists of 60000 training samples and 10000 test samples. Each sample is a $2 8 \times 2 8$ grayscale image, associated with a label from 10 classes. We design a CNN model with 3 convolutional layers for this experiment.
+
+Another model we use for relation extraction task is a bi-directional LSTM RNN (Gers, 2001). To train this model, we use 3855 training instances. A detailed description on the specific task and architecture of networks for the two experiments can be found in Appendix A.
+
+# 4.2 LOWER LOSS WITH BUDGET LIMIT
+
+In both experiments, 12 different optimization algorithms are used. They are BA-Momentum, BASGD, mini-batch momentum and mini-batch SGD with a fixed size of 32, 64, 128, 256 respectively, and manually adjusted mini-batch momentum and SGD (denoted as Manual-Momentum and Manual-SGD). Smith et al. (2017) proposed this manually adjusted mini-batch method that increases the batch size after every manually set number of epochs to reduce the noise scale of estimated gradients during training. Here we let “Manual” methods start with batch sizes of 32 and double their sizes every 25 epochs for image classification task (100 epochs as total budget) and every 75 epochs for relation extraction task (300 epochs as total budget), eventually their sizes will reach 256.
+
+For simplicity, we denote mini-batch momentum with a fixed size of 32 as “Mini-32-Momentum”. The same rule applies to “Mini-256-SGD” etc. We choose “Manual” methods and mini-batch methods with different sizes ranging from 32 to 256 as baselines. This is because with a budget limit, the small batch method can have more but less accurate updates, while the large batch method can make fewer but more accurate updates. More updates and accurate updates both can to some extent help the model achieve a lower loss, thus we use these small and large batch methods, together with “Manual” methods as baselines to make the comparative test with “BA” methods more convincing. For “BA” methods, the smallest batch increment, $m _ { 0 }$ , is 32.
+
+The result of image classification task on Fashion MNIST is plotted in Figure 1 and Figure 3a. The observation shows that for six different momentum-based optimizations, BA-Momentum achieves a lower loss than the rest five methods after 100 epochs of training. Furthermore, BA-Momentum has fewer fluctuations in later training stage than most of the methods with fixed batch sizes. For the SGD-based optimizations, BA-SGD achieves a second lowest loss while the lowest one is achieved by Mini-32-SGD.
+
+Now we take a look at the batch size change per iteration, plotted in Figure 3a. For both BAMomentum and BA-SGD, the batch size keeps almost constant at 32 in an early stage, while it more frequently increases to larger sizes in later training stage. The tendency is especially evident for BA-SGD. The lines in Figure 3a for BA-SGD gets denser as iterations increase, indicating the batch size rises more frequently from 32 to larger sizes. Also, the largest possible batch size for BA-SGD enlarges from 64 to almost 500 as learning proceeds.
+
+We display the result of relation extraction task in Figure 2 and Figure 3b. BA-Momentum still achieves the lowest loss. For SGD-based methods, BA-SGD has a similar curve with Mini-32-SGD, while BA-SGD fluctuates much less in later training stage and eventually reach a lower training loss than Mini-32-SGD does. The batch size change for BA-SGD on relation extraction task have the similar trend observed in the image classification result but much less frequent, and the batch size of BA-Momentum stays nearly constant at 32. This might be because each training instance in the relation extraction task is a sentence containing dozens of possible quadruples for binary classification, and a batch of 32 instances is already a relatively large batch in terms of number of binary classifications. Furthermore, the test accuracies in Appendix D show that for this task the larger the batch size is, the worse the model will generalize, thus it is smart for BA-SGD and BAMomentum to choose smaller sizes. In addition, one may note that there is a sudden rise of loss from 0.05 to 0.30 at the 224th epoch in Figure 2b during the training of BA-SGD and the loss soon drops back after this epoch. We presume it is due to encountering some very inaccurate estimates of gradients.
+
+From Figure 3, we can see that BA-SGD tends to have much larger batch sizes than BA-Momentum does on both tasks. This might be because momentum-based method is better at reducing the uncertainty of updates by taking into account previous updates, thus it does not need that large a batch which SGD requires, to further reduce the uncertainty.
+
+Above all, for the four figures below, the proposed “BA” methods reach the lowest loss in three cases and always perform better than the “Manual” methods. As for test accuracies, we present them in Appendix D.
+
+Here we analyze why “BA” methods can achieve the lowest loss in most cases. The “BA” methods adopt a smaller batch in an early stage, which allows them to have more iterations per epoch, then they dynamically enlarge their batch size in later stage to reduce the noise of estimated gradients, because the noise has a larger impact on the accuracy of parameter update in later training stage. Therefore “BA” methods can conserve the fast decrease of Mini-32 methods in early stage and meanwhile keep decreasing rather than severely fluctuate like Mini-32 methods do in later stage.
+
+![](images/62d34abe356430a8bea3c5bda533f38c20a470436ccf1f79ecc96b62ff774b4f.jpg)  
+Figure 1: Training loss per epoch on Fashion MNIST.
+
+![](images/94709bee8477fa56220acf2d8dab723abeb21454f7cca1e2982f1fa7fa131214.jpg)  
+Figure 2: Training loss per epoch on relation extraction.
+
+![](images/7315d4bcb23c8430087f51be0fec205594ed20a394fd35c9fe6ea5c6ce03eb56.jpg)  
+Figure 3: Batch size per iteration on Fashion MNIST and relation extraction.
+
+# 4.3 ROBUSTNESS TO LARGE STEP SIZE
+
+In the fine tuning process of BA-Momentum, we find that BA-Momentum is robust against large step sizes. Specifically, under a certain range of learning rates, when we tune the learning rate to a higher value, BA-Momentum can still achieve the same or even lower loss while the performance of other mini-batch methods will be degraded, converging to higher loss and fluctuating more. For simplicity, we only choose Mini-32-Momentum as baseline. We choose four different learning rates to test the robustness of BA-Momentum. They are 0.005, 0.01, 0.02, and 0.05.
+
+The result is displayed in Figure 4. As shown in Figure 4a, when learning rate rises from 0.005 to 0.01 and then 0.02, BA-Momentum ends up with lower loss from 1.13e-4 to $1 . 6 9 \mathrm { e } { - 5 }$ and then 5.77e6. In contrast, Mini-32-Momentum fluctuates more when the learning rate rises from 0.005 to 0.01, and it ends up with much higher loss when the learning rate increases from 0.01 to 0.02. However, when the learning rate is tuned to 0.05, both BA-Momentum and Mini-32-Momentum suffer from a very high loss. These observations confirm that BA-Momentum is more robust against larger step sizes within a certain reasonable range.
+
+We offer an explanation on the robustness of BA-Momentum. As the density of lines in Figure 4b suggests, the higher the learning rate is given, the larger our batch size tends to become. BAMomentum enlarges the batch size to counteract with the larger uncertainty of parameter updates brought by higher learning rate. In this way, it successfully avoids the fluctuations and meanwhile benefits from the larger step size to converge faster.
+
+![](images/0e9ebffb5d1c0bb156766ad1b6360ed5eae8b72ebd7ce6ada9d3dce73928b3bf.jpg)  
+Figure 4: Effect of different learning rates on BA-Momentum.
+
+# 4.4 BATCH SIZE BOOM
+
+We find an intriguing phenomenon when conducting experiments testing the robustness of BAMomentum. In the process of learning, the batch size of BA-Momentum will experience a batch size boom, a concentrated period where the batch size frequently increases to larger values. For example, the batch size boom in Figure 5a is from 80000 iterations to 110000 iterations, while the batch size boom in Figure 5b is from 60000 iterations to 80000 iterations. In the process of learning, when a batch size boom appears, the curve of BA-Momentum starts to diverge with the curve of Mini-32-Momentum. This makes sense because using a larger batch can help BA-Momentum make more accurate updates and thus decrease to a lower loss. Interestingly, the batch size boom always appears at the point in which Mini-32-Momentum reaches its lowest possible loss and after which it fluctuates around that loss. This can be observed in all three plots in Figure 5. As learning rate increases, Mini-32-Momentum reaches its lowest loss earlier, and the batch size boom also appears earlier, helping BA-Momentum keep decreasing to lower loss.
+
+![](images/42c808016d3b7fccfd57503d755d18d8efd8207b64aea8babead6bdd5a51c13f.jpg)  
+Figure 5: Batch size boom on different learning rates.
+
+# 5 CONCLUSION AND DISCUSSION
+
+In this work we developed BA-Momentum algorithm, an extension of the BA-SGD proposed by Yin et al. (2017). We also evaluate the two algorithms on natural language processing and image classification tasks using RNN and CNN respectively. The experiments show that in most cases both batch adaptive methods can achieve lower loss than mini-batch methods after scanning same epochs of data. Furthermore, we also confirm that within a certain range of step sizes, BA-Momentum is more robust against large step size compared with mini-batch methods.
+
+In the experiments, we did not evaluate the decrease of training loss with respect to training time. This is because, in the BA-SGD and BA-Momentum algorithm, we have to calculate the derivatives of the loss of each instance from a batch with respect to parameters, and then derive a covariance matrix through Equation 4 from the derivatives. Computing derivatives by backpropagation is time consuming, and now we have to compute all the derivatives of every instance in a batch. However, in mini-batch gradient descent, it is a common practice to calculate an average loss from a batch and then the derivative of this average loss, which requires less time. A feasible approach to reduce the computation cost might be to modify the way Theano do the derivation for a batch of instances and return the square sum of the derivatives, which we plan to study in future work.
+
+The batch adaptive framework can have many important applications. It can be adapted to accelerate distributed deep learning. For distributed deep learning, communication cost for synchronizing gradients and parameters among workers and parameter server is its well-known bottleneck (Li et al., 2014a;b; Wen et al., 2017). A larger batch may help make more accurate updates, thus reducing the total number of iterations needed to converge, lowering the communication cost. However, a larger batch also causes a higher computation cost per iteration. In this update-costly environment, the batch adaptive framework may be modified to take both the computation and communication cost into consideration when deciding a proper batch size, which is worth further exploring.
+
+Another application is that the batch adaptive framework may help remedy the generalization degradation of using large batch studied by Keskar et al. (2016). They provided solid numeric evidence suggesting that using a larger batch will degrade the quality of the model, as measured by its ability to generalize. They also studied the cause for this generalization drop and presented evidence supporting the view that large-batch methods tend to converge to sharp minimizers of the training and testing functions, which causes this generalization drop. Several strategies to help large-batch methods eliminate this generalization drop was proposed in their work. The most promising one is to warm-start with certain epochs of small-batch regime, and then use large batch for the rest of the training. However, the number of epochs needed to warm start with small batch varies for different data sets, thus a batch adaptive method that can dynamically change the batch size against the characteristics of data is the key to solving this problem. The batch adaptive framework sheds light on this issue. Difficulty lies in how to identify a sharp minima accurately and efficiently in the process of learning and limit the batch size when encountering a sharp minima, which we plan to study in future work.
+
+# REFERENCES
+
+Theano: A python framework for fast computation of mathematical expressions.
+
+John C. Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. In COLT, 2010.   
+Felix Gers. Long short-term memory in recurrent neural networks. Unpublished PhD dissertation, Ecole Polytechnique Fed´ erale de Lausanne, Lausanne, Switzerland ´ , 2001.   
+Gabriel Goh. Why momentum really works. Distill, 2017. doi: 10.23915/distill.00006. URL http://distill.pub/2017/momentum.   
+Ian J. Goodfellow, Yoshua Bengio, Aaron C. Courville, and Geoffrey E. Hinton. Deep learning. Scholarpedia, 10:32832, 2015.   
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. CoRR, abs/1609.04836, 2016.   
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.   
+Mu Li, David G. Andersen, Alexander J. Smola, and Kai Yu. Communication efficient distributed machine learning with the parameter server. In NIPS, 2014a.   
+Mu Li, Tong Zhang, Yuqiang Chen, and Alexander J. Smola. Efficient mini-batch training for stochastic optimization. In KDD, 2014b.   
+M. Lichman. UCI machine learning repository. http://archive.ics.uci.edu/ml, 2013.   
+Makoto Miwa and Mohit Bansal. End-to-end relation extraction using lstms on sequences and tree structures. CoRR, abs/1601.00770, 2016.   
+Ning Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12 (1):145–151, 1999.   
+Herbert Robbins and Sutton Monro. A stochastic approximation method. Ann. Math. Statist., 22(3): 400–407, 09 1951. doi: 10.1214/aoms/1177729586. URL https://doi.org/10.1214/ aoms/1177729586.   
+Samuel L. Smith, Pieter-Jan Kindermans, and Quoc V. Le. Don’t decay the learning rate, increase the batch size. CoRR, abs/1711.00489, 2017. URL http://arxiv.org/abs/1711.00489.   
+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:1929–1958, 2014.   
+Ilya Sutskever, James Martens, George E. Dahl, and Geoffrey E. Hinton. On the importance of initialization and momentum in deep learning. In ICML, 2013.
+
+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. CoRR, abs/1705.07878, 2017.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms, 2017.
+
+Peifeng Yin, Ping Luo, and Taiga Nakamura. Small batch or large batch?: Gaussian walk with rebound can teach. In KDD, 2017.
+
+Matthew D. Zeiler. Adadelta: An adaptive learning rate method. CoRR, abs/1212.5701, 2012.
+
+Jian Zhang, Ioannis Mitliagkas, and Christopher Re. Yellowfin and the art of momentum tuning. ´ CoRR, abs/1706.03471, 2017. URL http://arxiv.org/abs/1706.03471.
+
+# A ARCHITECTURE OF NETWORKS
+
+For the classification task on Fashion MNIST, we use 3 convolutional layers, where each layer has 32, 64, 128 filters respectively, with MaxPool after each convolutional layer. For all layers, we use ReLU activations and Dropout (Srivastava et al., 2014).
+
+The relation extraction task aims to extract quadruples in which the elements are correctly matched with each other. The input training instance consists of a sequence representing a sentence from financial documents, and all possible quadruples in this sequence. For the model, a bi-directional LSTM RNN is used. There are two layers of bi-directional LSTM, and a softmax outputs the probability of each quadruple being correct.
+
+# B MODEL VERIFICATION
+
+In our BA-Momentum method, we model the decrease of objective value as a random variable satisfying a one-dimensional Gaussian distribution in Equation 13. This derivation is on the basis of first order Taylor extension and central limit theorem, involving some approximation. After modelling the decrease of objective value as normally distributed, we then estimated its mean and variance in Equation 15 and Equation 16. Here we would like to use real data from Fashion-MNIST to verify that the decrease of objective value truly satisfies a Gaussian distribution and our estimation is close to its real mean and variance.
+
+We compute the decrease of objective value on the whole data set after 10 iterations for 500 times with batches randomly sampled and size fixed at 100. The result is plotted in Figure 6. The observation confirms that the decrease of objective value distributes normally. Its mean and standard deviation are -7.94253e-10 and 3.48414e-11 respectively, while its estimated mean and standard deviation are -8.58165e-10 and 4.58062e-12. Therefore, the decrease of objective value in our BA-M algorithm satisfies a Gaussian distribution and our estimation for its mean and variance is close to the real ones.
+
+# C IMPLEMENTATION ISSUES
+
+When calculating the covariance matrix in Equation 4, one should note that it takes a space of $O ( d ^ { 2 } )$ with $d$ denoting the dimension of the model parameter vector to store the covariance matrix. The cost is quite high for complex models with a large amount of parameters. Yin et al. (2017) has proposed a practical tradeoff assuming that model parameters are independent of each other, then the covariance matrix becomes a diagonal one, greatly reducing the space and time cost. Here we use a small data set from UCI machine learning repository (Lichman, 2013) to test whether the tradeoff will affect the performance of BA-Momentum.
+
+We use two different BA-Momentum. One calculates the exact covariance matrix, while the other calculates its estimated diagonal matrix. The task is a classification task with 3 classes and 42 features. The training set is composed of around 60000 data instances. After training for 14 epochs, we yield the following result. The Figure 7a show the batch size change as learning proceeds for matrix method and diagonal method respectively. The Figure 7b demonstrates different training loss per epoch for two different methods. From the figures we can see that the trend of batch size change for two methods are almost the same, therefore they perform equally well on the training loss descent. This indicates estimating the covariance matrix by its diagonal matrix will not cause degradation to the performance of BA-Momentum.
+
+![](images/631a7ece17b02842ed50fb260091e79e25fbb37b6a60b33e7d42134143a4b6f0.jpg)  
+Figure 6: Verification on the distribution of decrease of objective value
+
+![](images/12e4c1d901185c0d1349a93f845f5df1a445f68b1f14a6adb99c8a836ac4ce75.jpg)  
+Figure 7: Effects of calculating exact covariance matrix and its estimated diagonal.
+
+As for the cost of computing the optimal batch size, on average it takes up $1 . 0 3 \%$ and $0 . 6 1 \%$ of the total computing time per iteration for BA-Momentum and BA-SGD respectively on the image classification task, and the percentage on the relation extraction task is $1 . 3 1 \%$ and $0 . 9 2 \%$ for BAMomentum and BA-SGD respectively. Computing the optimal batch size involves calculating some means and variances, and a binary search to find the $m ^ { * }$ that maximizes the utility function. Both operations take little time.
+
+# D TEST ACCURACIES
+
+We show the test accuracies of different methods on the image classification task and relation extraction task in Table 1. For the relation extraction task, we would like to mention that its accuracy is an intersection over union, specifically defined as the ratio of the intersection of the predicted quadruples and the ground truth quadruples to their union. For the evaluation, we record the test accuracies of each method after every epoch’s training and present below the best test accuracies achieved by each method during their whole budget’s training (100 epochs for image classification task and 300 epochs for relation extraction task).
+
+The proposed “BA” methods achieve two best test accuracies in the following four cases (SGD-based on Fashion MNIST and SGD-based on relation extraction). In the other two cases, the test accuracies achieved by “BA” methods, $9 1 . 3 3 \%$ and $8 8 . 4 6 \%$ , are still very close to the best ones, $9 1 . 6 4 \%$ and $8 9 . 0 2 \%$ respectively. What’s more, these results are realized in a self-adaptive way and require no fine tuning, while the best accuracies in the two momentum-based cases are achieved by totally different fixed batch sizes, indicating a tuning process. In contrast with “BA” methods, “Manual” methods which manually increase the batch size performs well on Fashion MNIST, whereas they ends up with the fourth highest test accuracies on the relation extraction task, indicating that “Manual” methods also need fine tuning to realize a satisfactory generalization.
+
+Table 1: Best test accuracies achieved by different methods on Fashion MNIST and relation extraction   
+
+<table><tr><td rowspan="2"></td><td colspan="2">Fashion MNIST</td><td colspan="2">Relation extraction</td></tr><tr><td>Momentum</td><td>SGD</td><td>Momentum</td><td>SGD</td></tr><tr><td>Mini-32</td><td>90.93%</td><td>90.87%</td><td>89.02%</td><td>75.13%</td></tr><tr><td>Mini-64</td><td>91.17%</td><td>90.64%</td><td>87.12%</td><td>58.01%</td></tr><tr><td>Mini-128</td><td>91.64%</td><td>90.37%</td><td>85.33%</td><td>31.21%</td></tr><tr><td>Mini-256</td><td>90.76%</td><td>90.16%</td><td>79.37%</td><td>28.11%</td></tr><tr><td>Manual</td><td>91.35%</td><td>90.84%</td><td>86.31%</td><td>50.02%</td></tr><tr><td>BA</td><td>91.33%</td><td>91.01 %</td><td>88.46%</td><td>75.57%</td></tr></table>

parse/train/SybqeKgA-/SybqeKgA-_content_list.json

@@ -0,0 +1,1454 @@
+[
+    {
+        "type": "text",
+        "text": "ON BATCH ADAPTIVE TRAINING FOR DEEP LEARNING: LOWER LOSS AND LARGER STEP SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            171,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mini-batch gradient descent and its variants are commonly used in deep learning. The principle of mini-batch gradient descent is to use noisy gradient calculated on a batch to estimate the real gradient, thus balancing the computation cost per iteration and the uncertainty of noisy gradient. However, its batch size is a fixed hyper parameter requiring manual setting before training the neural network. Yin et al. (2017) proposed a batch adaptive stochastic gradient descent (BA-SGD) that can dynamically choose a proper batch size as learning proceeds. We extend the BA-SGD to momentum algorithm, and evaluate both the BA-SGD and the batch adaptive momentum (BA-Momentum) on two deep learning tasks from natural language processing to image classification. Experiments confirm that batch adaptive methods can achieve a lower loss compared with mini-batch methods and methods that manually increase the batch size, after scanning the same epochs of data. Furthermore, our BA-Momentum is more robust against larger step sizes, in that it can dynamically enlarge the batch size to reduce the larger uncertainty brought by larger step sizes. We also identified an interesting phenomenon, batch size boom. The code implementing the batch adaptive framework is now open source, applicable to any gradient-based optimization problems. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            501
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            334,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Efficiency of training large neural networks becomes increasingly important as deep neural networks tend to have more parameters and require more training data to achieve the state-of-the-art performance on a wide variety of tasks (Goodfellow et al., 2015). For training deep neural networks, stochastic gradient descent (SGD) (Robbins & Monro, 1951) and its variants, including momentum, which utilizes past updates with an exponential decay (Qian, 1999), and other methods that can adapt different learning rates for each dimension, such as ADAGRAD (Duchi et al., 2010), ADADELTA (Zeiler, 2012) and ADAM (Kingma & Ba, 2014), are commonly used. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            651
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "SGD approximates the gradient by only using a single data instance in each iteration, which may lead to uncertainty of approximation. This uncertainty can be reduced by adopting a batch of instances to do the approximation. In mini-batch SGD, the batch size is a fixed hyper parameter requiring manual setting before training the neural network. Setting the batch size typically involves a tuning procedure in which the best batch size is chosen by a series of attempts. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yin et al. (2017) has developed a batch adaptive stochastic gradient descent (BA-SGD) that can dynamically choose a proper batch size as learning proceeds. BA-SGD models the decrease of objective value as a Gaussian random walk game with rebound on the basis of Taylor extension and central limit theorem. Its core idea is to only update the parameters when the ratio between the expected decrease of objective value and the current batch size is large enough, otherwise enlarge the batch size to better approximate the gradient. It claimed that by smartly choosing the batch size, the BA-SGD not only conserves the fast convergence of SGD algorithm but also avoids too frequent model updates, and compared with mini-batch SGD, its objective value decreases more, after scanning the same amount of data. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, the experiment in Yin et al. (2017) was only conducted on some simple classification tasks using fully connected neural network with one input layer, one output layer and two hidden layers. What about the evaluation on some complex neural networks, such as convolutional neural network (CNN) and recurrent neural network (RNN)? How well would the batch adaptive algorithm perform on other complicated tasks related to natural language processing and computer vision? Furthermore, empirical studies reveal that SGD usually performs not so well in some deep and complex neural networks (Sutskever et al., 2013). Can this batch adaptive framework be extended to other gradient based optimization algorithms except SGD? ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Therefore, in this paper we extend the batch adaptive framework to momentum algorithm, and evaluate both the batch adaptive SGD (BA-SGD) and the batch adaptive momentum (BA-Momentum) on two deep learning tasks from natural language processing to image classification. These two tasks use RNN and CNN respectively, which cover most of the deep learning models. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we have the following observations. First, for batch adaptive methods, their loss functions converge to lower values after scanning same epoches of data, compared with fixedbatch-size methods. Second, BA-Momentum is more robust against large step sizes by dynamically enlarging the batch size to counteract with the larger noise brought by larger step sizes. Third, we observed a batch size boom, a concentrated period where the batch size frequently increases to larger values, in the training of BA-Momentum. The batch size boom is of significance in that it always appears at the point where mini-batch method starts to reach its lowest possible loss and it helps BA-Momentum keep dropping to even lower loss. More details on these observations and their analysis can be found in Section 4. The code implementing the batch adaptive framework using Theano (AlR) is now open source 1, which is applicable to any gradient-based optimization problems. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper is organized as follows. In Section 2, we briefly introduce the batch adaptive framework proposed by Yin et al. (2017). In Section 3, we extend the batch adaptive framework to momentum algorithm. In Section 4, we demonstrate the performance of BA-M and BA-SGD on Fashion-MNIST (Xiao et al., 2017) and relation extraction task, and then reveal the robustness of BA-Momentum against large step sizes. In Section 5, we discuss some efficiency issue concerned with implementing this batch adaptive framework, and also propose several promising applications based on this framework. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PREREQUISITES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            338,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we briefly summarize the batch adaptive stochastic gradient descent proposed by Yin et al. (2017). ",
+        "bbox": [
+            173,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NOTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            295,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use $\\mathcal { X }$ and $\\mathcal { V }$ to respectively denote the training data set and its random subset. The vector of model parameters is denoted by $\\vec { \\theta }$ and is subscripted by $t$ to denote an iteration. F is used to denote objective function, while $\\mathbf { f } _ { \\vec { \\theta } }$ is the partial derivative of function F with model parameters $\\vec { \\theta }$ (i.e. the gradient, computed over the whole data set). ",
+        "bbox": [
+            174,
+            613,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 BATCH ADAPTIVE FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            691,
+            439,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\vec { \\xi _ { j } }$ denote the difference between the approximate gradient computed on an individual instance $\\mathbf { g } _ { \\vec { \\theta } } ^ { j }$ and the real gradient $\\mathbf { f } _ { \\vec { \\theta } }$ , thus, $\\hat { \\mathbf { f } } _ { \\vec { \\theta } }$ , the approximate gradient computed on a batch $\\mathcal { V }$ can be written ",
+        "bbox": [
+            173,
+            718,
+            825,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4aac4f2ff1fb8f9929be4d0135342eb52dd738a2bda31f6313680847302cbdb8.jpg",
+        "text": "$$\n\\hat { \\mathbf { f } } _ { \\vec { \\theta } } = \\frac { \\sum _ { \\mathbf { y } _ { j } \\in \\mathcal { V } } \\mathbf { g } _ { \\vec { \\theta } } ^ { j } } { | \\mathcal { V } | } = \\mathbf { f } _ { \\vec { \\theta } } + \\frac { \\sum _ { \\mathbf { y } _ { j } \\in \\mathcal { V } } \\vec { \\xi _ { j } } } { | \\mathcal { V } | }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            760,
+            620,
+            800
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The term $\\frac { \\sum _ { \\mathbf { y } _ { j } \\in \\mathcal { y } } \\vec { \\xi _ { j } } } { | \\mathcal { y } | }$ can be viewed as a random variable determined by the randomly sampled batch $\\mathcal { V }$ . On the basis of Central Limit Theorem (CLT), it should satisfy a multi-dimension normal distribution $\\begin{array} { r } { \\mathcal { N } ( \\mathbf { 0 } , \\frac { \\Sigma } { | \\mathcal { V } | } ) } \\end{array}$ , where $\\pmb { \\Sigma }$ is the covariance matrix of $\\vec { \\xi _ { j } }$ . $\\mathbf { f } _ { \\vec { \\theta } }$ is the real gradient, computed on the whole data set and treated as a constant given the parameters $\\vec { \\theta }$ . Thus we have $\\hat { \\mathbf { f } } _ { \\vec { \\theta } } \\sim \\mathcal { N } ( \\mathbf { f } _ { \\vec { \\theta } } , \\frac { \\Sigma } { | \\mathcal { V } | } )$ . ",
+        "bbox": [
+            173,
+            805,
+            825,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "After modelling the estimation of gradient on a batch as a normally distributed random variable, Yin et al. (2017) uses first-order Taylor extension to approximate the objective function $\\mathbb { F } ( \\vec { \\theta } )$ at any parameter configuration. The equation is shown below. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            148
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b8d3d59680d053121aa6c696e1f4c102e6fdcfd2fb18d934d6595d25ab4d40d.jpg",
+        "text": "$$\n\\boldsymbol { \\mathsf { F } } ( \\overrightarrow { \\theta } ) = \\boldsymbol { \\mathsf { F } } ( \\overrightarrow { \\theta _ { 0 } } ) + \\mathbf { f } _ { \\overrightarrow { \\theta _ { 0 } } } ^ { T } \\cdot ( \\overrightarrow { \\theta } - \\overrightarrow { \\theta _ { 0 } } ) + \\mathtt { h } _ { \\overrightarrow { \\theta _ { 0 } } } ( \\overrightarrow { \\theta } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            152,
+            632,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the function $\\mathtt { h } _ { \\vec { \\theta } _ { 0 } } ( \\vec { \\theta } )$ is the remainder term satisfying $\\begin{array} { r } { \\operatorname* { l i m } _ { \\vec { \\theta } \\to \\vec { \\theta } _ { 0 } } \\mathtt { h } _ { \\vec { \\theta } _ { 0 } } ( \\vec { \\theta } ) = 0 } \\end{array}$ ",
+        "bbox": [
+            174,
+            183,
+            694,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If SGD optimization algorithm is adopted to update the parameters, with Equation (1) and Equation (2), the decrease of objective value can be expressed as: ",
+        "bbox": [
+            173,
+            207,
+            820,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/90eeb748c7ba707993952bf78c8e248a5bd198ab777403d58ed211d81dc895b9.jpg",
+        "text": "$$\n\\Delta \\mathbf { F } ( \\vec { \\theta } _ { 0 } ) = \\mathbf { F } ( \\vec { \\theta } _ { 0 } - \\eta \\hat { \\mathbf { f } } _ { \\vec { \\theta } _ { 0 } } ) - \\mathbf { F } ( \\vec { \\theta } _ { 0 } ) \\approx - \\eta \\mathbf { f } _ { \\vec { \\theta } _ { 0 } } ^ { T } \\cdot \\left( \\mathbf { f } _ { \\vec { \\theta } _ { 0 } } + \\frac { \\sum _ { \\mathbf { y } _ { j } \\in \\mathcal { N } } \\vec { \\xi } _ { j } } { | \\mathcal { y } | } \\right) = - \\eta \\cdot \\mathbf { f } _ { \\vec { \\theta } _ { 0 } } ^ { T } \\mathbf { f } _ { \\vec { \\theta } _ { 0 } } - \\eta \\cdot \\mathbf { f } _ { \\vec { \\theta } _ { 0 } } ^ { T } \\cdot \\vec { \\varepsilon } _ { \\mathcal { V } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            239,
+            795,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta$ is the learning rate, and the noise term satisfies $\\vec { \\varepsilon } _ { y } \\sim \\mathcal { N } ( \\mathbf { 0 } , \\frac { \\Sigma } { | y | } )$ , then $\\vec { \\varepsilon } _ { y } ^ { T } \\cdot \\mathbf { f } _ { \\vec { \\theta } _ { 0 } }$ can be viewed as a weighted sum of each dimension of vector $\\vec { \\varepsilon } _ { y }$ , thus satisfying a one-dimension Gaussian distribution, i.e. $\\begin{array} { r } { \\vec { \\varepsilon } _ { y } ^ { T } \\cdot \\mathbf { f } _ { \\vec { \\theta _ { 0 } } } \\sim \\mathcal { N } ( 0 , \\frac { \\mathbf { f } _ { \\vec { \\theta _ { 0 } } } ^ { T } \\cdot \\pmb { \\Sigma } \\cdot \\mathbf { f } _ { \\vec { \\theta _ { 0 } } } } { | \\mathcal { V } | } ) } \\end{array}$ Tθ\\~0 ·Σ·fθ\\~0|Y| ). Then ∆F(\\~θ0) also satisfies a Gaussian distribution, i.e. $\\begin{array} { r } { \\Delta \\mathbb { F } ( \\vec { \\theta _ { 0 } } ) \\sim \\mathcal { N } ( - \\eta \\mathbf { f } _ { \\vec { \\theta _ { 0 } } } ^ { T } \\mathbf { f } _ { \\vec { \\theta _ { 0 } } } , \\eta ^ { 2 } \\frac { \\mathbf { f } _ { \\vec { \\theta _ { 0 } } } ^ { T } \\cdot \\Sigma \\cdot \\mathbf { f } _ { \\vec { \\theta _ { 0 } } } } { | \\mathcal { V } | } ) } \\end{array}$ . In practice, they use the approximate gradient $\\hat { \\mathbf { f } } _ { \\vec { \\theta _ { 0 } } }$ to calculate the mean and variance of $\\Delta \\mathbb { F } (  { \\vec { \\theta } } _ { 0 } )$ . ",
+        "bbox": [
+            173,
+            285,
+            826,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For the covariance matrix of $\\vec { \\varepsilon } _ { \\mathcal { Y } } , \\pmb { \\Sigma }$ , its unbiased estimation $\\hat { \\Sigma }$ is: ",
+        "bbox": [
+            173,
+            395,
+            599,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d947c934eb6c6c99273cd7c7519ed1a789c8dfec729dfdc472c8618f365be1e2.jpg",
+        "text": "$$\n\\hat { \\mathbf { \\Sigma } } = \\frac { \\sum _ { \\mathbf { y } _ { j } \\in \\mathcal { Y } } ( \\mathbf { g } _ { \\vec { \\theta _ { 0 } } } ^ { j } - \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { 0 } } } ) ( \\mathbf { g } _ { \\vec { \\theta _ { 0 } } } ^ { j } - \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { 0 } } } ) ^ { T } } { | \\mathcal { Y } | - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            415,
+            629,
+            457
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After modelling the decrease of objective value as a normally distributed random variable, Yin et al.   \n(2017) abstract the process of objective value change as a random walk game with a Gaussian dice. ",
+        "bbox": [
+            171,
+            467,
+            823,
+            497
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the game, the objective value is regarded as a state. For the simplicity of notation, we define a state $s _ { t }$ as below. ",
+        "bbox": [
+            171,
+            502,
+            823,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d8de9eb8847f590938af4b36e5e2d48e4a4056eca18af569748de3e1a8020312.jpg",
+        "text": "$$\ns _ { t } = - \\frac { \\Delta \\mathsf { F } } { \\eta }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            459,
+            535,
+            537,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The decrease of objective value, namely the transfer from the current state to the next state is determined by a Gaussian dice, of which the mean solely depend on the current state and the variance is controlled by the state and the batch to be chosen. They define the domain of game state as a half closed set of real numbers $[ S ^ { * } , + \\infty )$ , where $S ^ { * }$ is the minimum objective value that the learning can possibly achieve. The game starts with a random state and the goal is to move as close as possible to $S ^ { * }$ . There are two ways of state transfer: one directly decreasing from $S _ { i }$ to $S _ { j }$ , another first reaching minimum point $S ^ { * }$ and then rebounding to $S _ { j }$ . ",
+        "bbox": [
+            173,
+            571,
+            825,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, for state $s _ { t }$ , the moving step $\\triangle { s _ { t } }$ is generated by a Gaussian dice $\\begin{array} { r } { \\mathcal { N } ( \\mu _ { t } , \\frac { \\sigma _ { t } ^ { 2 } } { m } ) } \\end{array}$ σ 2t ) , where $\\boldsymbol { \\mu } _ { t } = \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } } ^ { T } \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } }$ , $\\sigma _ { t } ^ { 2 } = \\hat { \\mathbf { f } } _ { \\vec { \\theta } _ { t } } ^ { T } \\hat { \\Sigma } \\hat { \\mathbf { f } } _ { \\vec { \\theta } _ { t } }$ = fˆTθ\\~t , $m = | \\mathcal { V } |$ , denoting the batch size. The state transition equation is presented below. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/feb0a027ad3c59b8e5220e529e474787cb2e455d4374b5fb03ee2d8a990b3e30.jpg",
+        "text": "$$\ns _ { t + 1 } = | s _ { t } - S ^ { * } - \\eta \\triangle s _ { t } | + S ^ { * } = \\left\\{ { s _ { t } } - \\eta \\triangle s _ { t } , \\quad \\quad \\mathrm { i f ~ } s _ { t } - \\eta \\triangle s _ { t } \\geq S ^ { * } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            737,
+            751,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $p _ { m } ^ { s _ { t } } ( \\triangle s _ { t } )$ denote the probability density function for a random moving step $\\begin{array} { r } { \\triangle s _ { t } \\sim \\mathcal N \\left( \\mu _ { t } , \\frac { \\sigma _ { t } ^ { 2 } } { m } \\right) } \\end{array}$ .   \nThe expected value of next state can be expressed as follows. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c6c751fdc7cbc1a488486b6c1c7eec8aa7d764c5e546fe2d89b6d315602be4b7.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle { \\bf E } _ { m } ^ { s _ { t } } ( s _ { t + 1 } ) = \\int _ { - \\infty } ^ { + \\infty } p _ { m } ^ { s _ { t } } ( \\triangle s _ { t } ) ( | s _ { t } - S ^ { * } - \\eta \\cdot \\triangle s _ { t } | + S ^ { * } ) d \\triangle s _ { t } } \\\\ { = ( s _ { t } - S ^ { * } - \\eta \\mu _ { t } ) \\left\\{ \\Phi ( a ) - \\Phi ( - a ) \\right\\} + \\frac { \\eta \\sigma _ { t } } { \\sqrt { m } } \\sqrt { \\frac { 2 } { \\pi } } e ^ { - \\frac { a ^ { 2 } } { 2 } } + S ^ { * } } \\\\ { \\mathrm { w h e r e ~ } a = \\frac { s _ { t } - S ^ { * } - \\eta \\mu _ { t } } { \\eta \\sigma _ { t } } \\sqrt { m } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            821,
+            705,
+            930
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To decide the best batch size, one should consider both the variance of estimated gradients and computation cost. Large batch can reduce the variance and therefore make more accurate updates, whereas it also requires more computations. Yin et al. (2017) then define a utility function to find a balance. Maximizing the utility means achieving the largest expected decrease of loss per data instance. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/067fbf3bf59b45aebcfbb58d210dbe89e92147588ce0a53f30cd5c35b87c8509.jpg",
+        "text": "$$\n\\mathbf { u } ( m , s _ { t } ) = { \\frac { s _ { t } - \\mathbf { E } _ { m } ^ { s _ { t } } \\left( s _ { t + 1 } \\right) } { m } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            170,
+            593,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e60495f60fcfe760a8895af6402ffc9b34ea2d58158f347184445a4d91c4eaa.jpg",
+        "text": "$$\nm ^ { * } \\gets \\arg \\operatorname* { m a x } _ { m } \\mathtt { u } ( m , s _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            212,
+            583,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $m ^ { * }$ is the best batch size for the $( t + 1 )$ -th iteration. ",
+        "bbox": [
+            173,
+            238,
+            558,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For more specifications on the BA-SGD algorithm, see Yin et al. (2017). ",
+        "bbox": [
+            174,
+            260,
+            648,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 BATCH ADAPTIVE MOMENTUM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            295,
+            468,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main appeal of momentum is its ability to reduce oscillations and accelerate convergence (Goh, 2017). The idea behind momentum is that it accelerates learning along dimensions where gradient continues pointing to the same direction, and slows down those where sign of gradient constantly changes (Zeiler, 2012). Recent work on momentum, called YellowFin, an automatic tuner for both momentum and learning rate, helps momentum optimizer converge in even fewer iterations than ADAM on large ResNet and LSTM models (Zhang et al., 2017). Since it is both powerful and popular, we would like to also apply the batch adaptive framework to momentum optimizer. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 MOMENTUM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            443,
+            303,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Momentum utilizes past parameter updates with an exponential decay. Its way of update is given by ",
+        "bbox": [
+            173,
+            468,
+            823,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d32cc351a6ad7f9d9d81fccd3b85025499fa4a1f8b079d6853c6ad7cffa1d57b.jpg",
+        "text": "$$\n { \\vec { \\theta } } _ { t + 1 } =  { \\vec { \\theta } } _ { t } - \\mathtt { m } _ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            493,
+            550,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/70e9e5632b2bbdf1a74f9340e2a8469e76595fb387b782039fa3d73d9c9eb1e9.jpg",
+        "text": "$$\n\\boldsymbol { \\mathfrak { m } } _ { t } = \\rho \\boldsymbol { \\mathfrak { m } } _ { t - 1 } + \\eta \\hat { \\boldsymbol { \\mathfrak { f } } } _ { \\vec { \\theta _ { t } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            530,
+            562,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\mathfrak { m } } _ { t }$ denotes momentum at the $t$ -th iteration and $\\rho$ is the rate controlling the decay of the previous parameter updates. Equation 11 can also be written in the following form. ",
+        "bbox": [
+            169,
+            553,
+            823,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14b9b87d2ae89125f72f0aa982f3a2d0b592c49b03ccd7dd7a15303fabf98a20.jpg",
+        "text": "$$\n\\mathtt { m } _ { t } = \\eta \\sum _ { \\tau = 0 } ^ { t } \\rho ^ { t - \\tau } \\hat { \\mathbf { f } } _ { \\vec { \\theta } _ { \\tau } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            588,
+            563,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            647,
+            303,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Referring to Equation 3, we can analogically estimate the decrease of objective value in the following expression. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/10e4d759b07b7f8941a1ee3d73d85e9544750316cc5d11ce58d243974aa23eca.jpg",
+        "text": "$$\n\\begin{array} { r } { \\Delta \\mathtt { F } _ { t } = \\mathtt { F } ( \\vec { \\theta } _ { t + 1 } ) - \\mathtt { F } ( \\vec { \\theta _ { t } } ) = \\mathtt { f } _ { \\vec { \\theta _ { t } } } ^ { T } ( \\vec { \\theta _ { t + 1 } } - \\vec { \\theta _ { t } } ) = - \\mathtt { f } _ { \\vec { \\theta _ { t } } } ^ { T } \\mathtt { m } _ { t } } \\\\ { = - \\eta \\mathtt { f } _ { \\vec { \\theta _ { t } } } ^ { T } \\displaystyle \\sum _ { \\tau = 0 } ^ { t } \\rho ^ { t - \\tau } \\hat { \\mathtt { f } } _ { \\vec { \\theta _ { \\tau } } } = - \\eta \\mathtt { f } _ { \\vec { \\theta _ { t } } } ^ { T } \\displaystyle \\sum _ { \\tau = 0 } ^ { t } \\rho ^ { t - \\tau } ( \\mathtt { f } _ { \\vec { \\theta _ { \\tau } } } + \\vec { \\varepsilon } _ { \\tau } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            707,
+            673,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\vec { \\varepsilon } _ { \\tau } = \\frac { \\sum _ { \\mathbf { y } _ { j } \\in \\mathcal { y } _ { \\tau } } \\vec { \\xi } _ { j } } { | \\mathcal { y } _ { \\tau } | } } \\end{array}$ is the noise term which represents the difference between the real gradient and the estimated gradient calculated on a batch ${ \\mathcal { D } } _ { \\tau }$ chosen at the $\\tau$ -th iteration. Though the estimated gradient from the previous iterations (i.e. $\\tau = 0 . . . t - 1 )$ has noise, their batches which respectively determine their noise have already been selected, thus their noise is no longer a random variable but a constant. However, for the $t$ -th iteration, we have not decided which batch to be sampled, therefore $\\vec { \\varepsilon _ { t } }$ is indeed a random variable, and on the basis of CLT we know it is normally distributed, i.e. $\\begin{array} { r } { \\vec { \\varepsilon _ { t } } \\sim \\mathcal { N } ( \\mathbf { 0 } , \\frac { \\Sigma _ { t } } { | \\mathcal { V } _ { t } | } ) } \\end{array}$ . Based on this and the fact that real gradients, $\\mathbf { f } _ { \\vec { \\theta } _ { \\tau } }$ $( \\tau = 0 . . . t )$ , are all constants for the $t$ -th iteration, we then have the decrease of objective value, $\\Delta \\mathsf { F } _ { t }$ , satisfying a one-dimensional Gaussian distribution, which is also experimentally verified in Appendix B. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We need to calculate the mean and variance of $\\Delta \\mathsf { F } _ { t }$ , but we prefer not to record all the $\\hat { \\mathbf { f } } _ { \\vec { \\theta } _ { \\tau } }$ from previous iterations. Therefore, we construct a recurrence formula to avoid the trouble. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $\\begin{array} { r } { \\mathcal { P } _ { t } = \\sum _ { \\tau = 0 } ^ { t } \\rho ^ { t - \\tau } \\big ( \\mathbf { f } _ { \\vec { \\theta } _ { \\tau } } + \\vec { \\varepsilon } _ { \\tau } \\big ) } \\end{array}$ , then we have the following recurrence formula. ",
+        "bbox": [
+            176,
+            141,
+            705,
+            159
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43bf954133bf829519105d04548022b13dde0d836f93df4e9d09dd528ac66bce.jpg",
+        "text": "$$\n\\mathcal { P } _ { t } = ( \\pounds _ { \\vec { \\theta _ { t } } } + \\vec { \\varepsilon _ { t } } ) + \\rho \\mathcal { P } _ { t - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            160,
+            584,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus the mean and variance of $\\mathcal { P } _ { t }$ can be calculated in the following forms. ",
+        "bbox": [
+            174,
+            179,
+            668,
+            194
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4ed9e9f5dac49d2b676fd35877188b703549c8dd60cb0852ca7af899a0e9c7c.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle \\mu _ { \\mathcal { P } _ { t } } = \\rho \\mu _ { \\mathcal { P } _ { t - 1 } } + \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } } } \\\\ { \\displaystyle \\Sigma _ { \\mathcal { P } _ { t } } = \\frac { \\hat { \\mathrm { \\Sigma } } _ { t } } { | \\mathcal { V } _ { t } | } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            193,
+            573,
+            260
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now we have trated in Secti $\\Delta \\mathbf { F } _ { t } \\sim \\mathcal { N } ( - \\eta \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } } ^ { T } \\mu _ { \\mathcal { P } _ { t } } , \\eta ^ { 2 } \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } } ^ { T } \\Sigma _ { \\mathcal { P } _ { t } } \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } } )$ ith rebound illus-. $\\begin{array} { r } { \\triangle s _ { t } \\sim \\mathcal N ( \\hat { \\mathbf f } _ { \\vec { \\theta } _ { t } } ^ { T } \\mu _ { \\mathcal P _ { t } } , \\hat { \\mathbf f } _ { \\vec { \\theta _ { t } } } ^ { T } \\Sigma _ { \\mathcal P _ { t } } \\hat { \\mathbf f } _ { \\vec { \\theta _ { t } } } ) } \\end{array}$ ",
+        "bbox": [
+            174,
+            265,
+            821,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, we let $\\sigma _ { t } ^ { 2 } = \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } } ^ { T } \\hat { \\Sigma } _ { t } \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } }$ , $\\mu _ { t } = \\hat { \\mathbf { f } } _ { \\vec { \\theta _ { t } } } ^ { T } \\mu _ { \\mathcal { P } _ { t } }$ , $m = | \\mathcal { D } _ { t } |$ , thus $\\begin{array} { r } { \\triangle s _ { t } \\sim N ( \\mu _ { t } , \\frac { \\sigma _ { t } ^ { 2 } } { m } ) } \\end{array}$ . Then the expected value of the next state shares the same expression with Equation 7, though the mean of $\\triangle { s _ { t } }$ is different. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For batch adaptive momentum algorithm, we also adopt the utility function in Equation 8, and the best batch size is the one that maximizes the utility function, calculated through Equation 9. ",
+        "bbox": [
+            174,
+            369,
+            823,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            414,
+            303,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At the end of this section, we would like to summarize how the batch adaptive momentum algorithm is implemented by presenting the pseudo code below. In the pseudo code, the $M$ stands for the total budget, i.e. the total number of instances used for training, the $m _ { 0 }$ means sampling step, the smallest batch increment. The rest symbols have been introduced before. In this pseudo code, we aim to calculate the optimal batch size for each update step. When an optimal size is determined and it is larger than the current batch size, we need to add more instances to enlarge the batch. However, $s _ { t } , \\mu _ { t } , \\sigma _ { t }$ will change every time we add more instances, leading to a different optimal size. Thus ",
+        "bbox": [
+            173,
+            439,
+            825,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Batch-Adaptive Momentum ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            446,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd16ed44af955b208ed65f2866582434dcb274d8023b45ee06c188b1bab8b4f3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">1: procedure BA-MOMENTUM(X,0,n, ρ, M, mo)</td></tr><tr><td colspan=\"3\">while M&gt;O do</td></tr><tr><td>2: 3:</td><td>Vt←</td><td></td></tr><tr><td>4:</td><td>repeat</td><td></td></tr><tr><td>5:</td><td>random sample Z from X - Vt with |Z|= mo</td><td></td></tr><tr><td>6:</td><td>Vt ←VtUz</td><td></td></tr><tr><td>7:</td><td>calculate f,∑t with Vt</td><td>Equation (1) and (4</td></tr><tr><td>8:</td><td>calculate μpt With μPt-1 and ff</td><td>Equation (15</td></tr><tr><td>9:</td><td>St←F(jVt),μt←μpt,Ot←√</td><td></td></tr><tr><td>10:</td><td>m* ← arg maXm u(m, st) where S* is user-specified</td><td></td></tr><tr><td>11:</td><td>until |Vt| ≥ min{m*,|x|}</td><td></td></tr><tr><td>12:</td><td>mt= pmt-1+nfθt</td><td></td></tr><tr><td>13:</td><td>日←日-mt</td><td></td></tr><tr><td>14: 15:</td><td>M←M-|Vtl</td><td></td></tr><tr><td>16:</td><td>t=t+1</td><td></td></tr><tr><td>17:</td><td>end while return θ</td><td></td></tr><tr><td>18:</td><td></td><td></td></tr><tr><td></td><td>end procedure</td><td></td></tr></table>",
+        "bbox": [
+            174,
+            569,
+            818,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "in practice, we can only gradually increase the batch size until it becomes larger than or equal to a running estimate of the optimal batch size. Lastly, when implementing the algorithm, one may note that it is time-consuming to calculate the covariance matrix, $\\hat { \\Sigma } _ { t }$ . We will discuss a tradeoff and the computation cost of this algorithm in Appendix C. ",
+        "bbox": [
+            173,
+            866,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            316,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the learning efficiency of different learning algorithms on two deep learning models. One is the CNN for image classification on the dataset of Fashion MNIST (Xiao et al., 2017), and the other is a more complex RNN model for relation extraction on financial documents (Miwa & Bansal, 2016). To evaluate our learning efficiency regardless of the size of the data set, we use epoch as the unit of scanned data and one epoch means all instances in the whole training set. We calculate the training loss on the whole training set each time when the model has scanned one more epoch of data. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 MODEL AND DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            247,
+            370,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fashion MNIST is a data set of Zalando’s article images, which consists of 60000 training samples and 10000 test samples. Each sample is a $2 8 \\times 2 8$ grayscale image, associated with a label from 10 classes. We design a CNN model with 3 convolutional layers for this experiment. ",
+        "bbox": [
+            176,
+            273,
+            825,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another model we use for relation extraction task is a bi-directional LSTM RNN (Gers, 2001). To train this model, we use 3855 training instances. A detailed description on the specific task and architecture of networks for the two experiments can be found in Appendix A. ",
+        "bbox": [
+            176,
+            323,
+            825,
+            364
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 LOWER LOSS WITH BUDGET LIMIT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            382,
+            459,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In both experiments, 12 different optimization algorithms are used. They are BA-Momentum, BASGD, mini-batch momentum and mini-batch SGD with a fixed size of 32, 64, 128, 256 respectively, and manually adjusted mini-batch momentum and SGD (denoted as Manual-Momentum and Manual-SGD). Smith et al. (2017) proposed this manually adjusted mini-batch method that increases the batch size after every manually set number of epochs to reduce the noise scale of estimated gradients during training. Here we let “Manual” methods start with batch sizes of 32 and double their sizes every 25 epochs for image classification task (100 epochs as total budget) and every 75 epochs for relation extraction task (300 epochs as total budget), eventually their sizes will reach 256. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, we denote mini-batch momentum with a fixed size of 32 as “Mini-32-Momentum”. The same rule applies to “Mini-256-SGD” etc. We choose “Manual” methods and mini-batch methods with different sizes ranging from 32 to 256 as baselines. This is because with a budget limit, the small batch method can have more but less accurate updates, while the large batch method can make fewer but more accurate updates. More updates and accurate updates both can to some extent help the model achieve a lower loss, thus we use these small and large batch methods, together with “Manual” methods as baselines to make the comparative test with “BA” methods more convincing. For “BA” methods, the smallest batch increment, $m _ { 0 }$ , is 32. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The result of image classification task on Fashion MNIST is plotted in Figure 1 and Figure 3a. The observation shows that for six different momentum-based optimizations, BA-Momentum achieves a lower loss than the rest five methods after 100 epochs of training. Furthermore, BA-Momentum has fewer fluctuations in later training stage than most of the methods with fixed batch sizes. For the SGD-based optimizations, BA-SGD achieves a second lowest loss while the lowest one is achieved by Mini-32-SGD. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now we take a look at the batch size change per iteration, plotted in Figure 3a. For both BAMomentum and BA-SGD, the batch size keeps almost constant at 32 in an early stage, while it more frequently increases to larger sizes in later training stage. The tendency is especially evident for BA-SGD. The lines in Figure 3a for BA-SGD gets denser as iterations increase, indicating the batch size rises more frequently from 32 to larger sizes. Also, the largest possible batch size for BA-SGD enlarges from 64 to almost 500 as learning proceeds. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We display the result of relation extraction task in Figure 2 and Figure 3b. BA-Momentum still achieves the lowest loss. For SGD-based methods, BA-SGD has a similar curve with Mini-32-SGD, while BA-SGD fluctuates much less in later training stage and eventually reach a lower training loss than Mini-32-SGD does. The batch size change for BA-SGD on relation extraction task have the similar trend observed in the image classification result but much less frequent, and the batch size of BA-Momentum stays nearly constant at 32. This might be because each training instance in the relation extraction task is a sentence containing dozens of possible quadruples for binary classification, and a batch of 32 instances is already a relatively large batch in terms of number of binary classifications. Furthermore, the test accuracies in Appendix D show that for this task the larger the batch size is, the worse the model will generalize, thus it is smart for BA-SGD and BAMomentum to choose smaller sizes. In addition, one may note that there is a sudden rise of loss from 0.05 to 0.30 at the 224th epoch in Figure 2b during the training of BA-SGD and the loss soon drops back after this epoch. We presume it is due to encountering some very inaccurate estimates of gradients. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From Figure 3, we can see that BA-SGD tends to have much larger batch sizes than BA-Momentum does on both tasks. This might be because momentum-based method is better at reducing the uncertainty of updates by taking into account previous updates, thus it does not need that large a batch which SGD requires, to further reduce the uncertainty. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Above all, for the four figures below, the proposed “BA” methods reach the lowest loss in three cases and always perform better than the “Manual” methods. As for test accuracies, we present them in Appendix D. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            313
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here we analyze why “BA” methods can achieve the lowest loss in most cases. The “BA” methods adopt a smaller batch in an early stage, which allows them to have more iterations per epoch, then they dynamically enlarge their batch size in later stage to reduce the noise of estimated gradients, because the noise has a larger impact on the accuracy of parameter update in later training stage. Therefore “BA” methods can conserve the fast decrease of Mini-32 methods in early stage and meanwhile keep decreasing rather than severely fluctuate like Mini-32 methods do in later stage. ",
+        "bbox": [
+            173,
+            320,
+            825,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/62d34abe356430a8bea3c5bda533f38c20a470436ccf1f79ecc96b62ff774b4f.jpg",
+        "image_caption": [
+            "Figure 1: Training loss per epoch on Fashion MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            438,
+            745,
+            626
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/94709bee8477fa56220acf2d8dab723abeb21454f7cca1e2982f1fa7fa131214.jpg",
+        "image_caption": [
+            "Figure 2: Training loss per epoch on relation extraction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            695,
+            743,
+            885
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7315d4bcb23c8430087f51be0fec205594ed20a394fd35c9fe6ea5c6ce03eb56.jpg",
+        "image_caption": [
+            "Figure 3: Batch size per iteration on Fashion MNIST and relation extraction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            121,
+            745,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 ROBUSTNESS TO LARGE STEP SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            460,
+            380
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the fine tuning process of BA-Momentum, we find that BA-Momentum is robust against large step sizes. Specifically, under a certain range of learning rates, when we tune the learning rate to a higher value, BA-Momentum can still achieve the same or even lower loss while the performance of other mini-batch methods will be degraded, converging to higher loss and fluctuating more. For simplicity, we only choose Mini-32-Momentum as baseline. We choose four different learning rates to test the robustness of BA-Momentum. They are 0.005, 0.01, 0.02, and 0.05. ",
+        "bbox": [
+            173,
+            393,
+            825,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The result is displayed in Figure 4. As shown in Figure 4a, when learning rate rises from 0.005 to 0.01 and then 0.02, BA-Momentum ends up with lower loss from 1.13e-4 to $1 . 6 9 \\mathrm { e } { - 5 }$ and then 5.77e6. In contrast, Mini-32-Momentum fluctuates more when the learning rate rises from 0.005 to 0.01, and it ends up with much higher loss when the learning rate increases from 0.01 to 0.02. However, when the learning rate is tuned to 0.05, both BA-Momentum and Mini-32-Momentum suffer from a very high loss. These observations confirm that BA-Momentum is more robust against larger step sizes within a certain reasonable range. ",
+        "bbox": [
+            173,
+            483,
+            825,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We offer an explanation on the robustness of BA-Momentum. As the density of lines in Figure 4b suggests, the higher the learning rate is given, the larger our batch size tends to become. BAMomentum enlarges the batch size to counteract with the larger uncertainty of parameter updates brought by higher learning rate. In this way, it successfully avoids the fluctuations and meanwhile benefits from the larger step size to converge faster. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            659
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e9ebffb5d1c0bb156766ad1b6360ed5eae8b72ebd7ce6ada9d3dce73928b3bf.jpg",
+        "image_caption": [
+            "Figure 4: Effect of different learning rates on BA-Momentum. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            694,
+            745,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 BATCH SIZE BOOM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            348,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We find an intriguing phenomenon when conducting experiments testing the robustness of BAMomentum. In the process of learning, the batch size of BA-Momentum will experience a batch size boom, a concentrated period where the batch size frequently increases to larger values. For example, the batch size boom in Figure 5a is from 80000 iterations to 110000 iterations, while the batch size boom in Figure 5b is from 60000 iterations to 80000 iterations. In the process of learning, when a batch size boom appears, the curve of BA-Momentum starts to diverge with the curve of Mini-32-Momentum. This makes sense because using a larger batch can help BA-Momentum make more accurate updates and thus decrease to a lower loss. Interestingly, the batch size boom always appears at the point in which Mini-32-Momentum reaches its lowest possible loss and after which it fluctuates around that loss. This can be observed in all three plots in Figure 5. As learning rate increases, Mini-32-Momentum reaches its lowest loss earlier, and the batch size boom also appears earlier, helping BA-Momentum keep decreasing to lower loss. ",
+        "bbox": [
+            173,
+            131,
+            825,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/42c808016d3b7fccfd57503d755d18d8efd8207b64aea8babead6bdd5a51c13f.jpg",
+        "image_caption": [
+            "Figure 5: Batch size boom on different learning rates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            314,
+            808,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            470,
+            537
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we developed BA-Momentum algorithm, an extension of the BA-SGD proposed by Yin et al. (2017). We also evaluate the two algorithms on natural language processing and image classification tasks using RNN and CNN respectively. The experiments show that in most cases both batch adaptive methods can achieve lower loss than mini-batch methods after scanning same epochs of data. Furthermore, we also confirm that within a certain range of step sizes, BA-Momentum is more robust against large step size compared with mini-batch methods. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            638
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the experiments, we did not evaluate the decrease of training loss with respect to training time. This is because, in the BA-SGD and BA-Momentum algorithm, we have to calculate the derivatives of the loss of each instance from a batch with respect to parameters, and then derive a covariance matrix through Equation 4 from the derivatives. Computing derivatives by backpropagation is time consuming, and now we have to compute all the derivatives of every instance in a batch. However, in mini-batch gradient descent, it is a common practice to calculate an average loss from a batch and then the derivative of this average loss, which requires less time. A feasible approach to reduce the computation cost might be to modify the way Theano do the derivation for a batch of instances and return the square sum of the derivatives, which we plan to study in future work. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The batch adaptive framework can have many important applications. It can be adapted to accelerate distributed deep learning. For distributed deep learning, communication cost for synchronizing gradients and parameters among workers and parameter server is its well-known bottleneck (Li et al., 2014a;b; Wen et al., 2017). A larger batch may help make more accurate updates, thus reducing the total number of iterations needed to converge, lowering the communication cost. However, a larger batch also causes a higher computation cost per iteration. In this update-costly environment, the batch adaptive framework may be modified to take both the computation and communication cost into consideration when deciding a proper batch size, which is worth further exploring. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another application is that the batch adaptive framework may help remedy the generalization degradation of using large batch studied by Keskar et al. (2016). They provided solid numeric evidence suggesting that using a larger batch will degrade the quality of the model, as measured by its ability to generalize. They also studied the cause for this generalization drop and presented evidence supporting the view that large-batch methods tend to converge to sharp minimizers of the training and testing functions, which causes this generalization drop. Several strategies to help large-batch methods eliminate this generalization drop was proposed in their work. The most promising one is to warm-start with certain epochs of small-batch regime, and then use large batch for the rest of the training. However, the number of epochs needed to warm start with small batch varies for different data sets, thus a batch adaptive method that can dynamically change the batch size against the characteristics of data is the key to solving this problem. The batch adaptive framework sheds light on this issue. Difficulty lies in how to identify a sharp minima accurately and efficiently in the process of learning and limit the batch size when encountering a sharp minima, which we plan to study in future work. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            825,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            291,
+            285,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theano: A python framework for fast computation of mathematical expressions. ",
+        "bbox": [
+            173,
+            314,
+            697,
+            329
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John C. Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. In COLT, 2010.   \nFelix Gers. Long short-term memory in recurrent neural networks. Unpublished PhD dissertation, Ecole Polytechnique Fed´ erale de Lausanne, Lausanne, Switzerland ´ , 2001.   \nGabriel Goh. Why momentum really works. Distill, 2017. doi: 10.23915/distill.00006. URL http://distill.pub/2017/momentum.   \nIan J. Goodfellow, Yoshua Bengio, Aaron C. Courville, and Geoffrey E. Hinton. Deep learning. Scholarpedia, 10:32832, 2015.   \nNitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. CoRR, abs/1609.04836, 2016.   \nDiederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.   \nMu Li, David G. Andersen, Alexander J. Smola, and Kai Yu. Communication efficient distributed machine learning with the parameter server. In NIPS, 2014a.   \nMu Li, Tong Zhang, Yuqiang Chen, and Alexander J. Smola. Efficient mini-batch training for stochastic optimization. In KDD, 2014b.   \nM. Lichman. UCI machine learning repository. http://archive.ics.uci.edu/ml, 2013.   \nMakoto Miwa and Mohit Bansal. End-to-end relation extraction using lstms on sequences and tree structures. CoRR, abs/1601.00770, 2016.   \nNing Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12 (1):145–151, 1999.   \nHerbert Robbins and Sutton Monro. A stochastic approximation method. Ann. Math. Statist., 22(3): 400–407, 09 1951. doi: 10.1214/aoms/1177729586. URL https://doi.org/10.1214/ aoms/1177729586.   \nSamuel L. Smith, Pieter-Jan Kindermans, and Quoc V. Le. Don’t decay the learning rate, increase the batch size. CoRR, abs/1711.00489, 2017. URL http://arxiv.org/abs/1711.00489.   \nNitish 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:1929–1958, 2014.   \nIlya Sutskever, James Martens, George E. Dahl, and Geoffrey E. Hinton. On the importance of initialization and momentum in deep learning. In ICML, 2013. ",
+        "bbox": [
+            171,
+            319,
+            826,
+            924
+        ],
+        "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. CoRR, abs/1705.07878, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms, 2017. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peifeng Yin, Ping Luo, and Taiga Nakamura. Small batch or large batch?: Gaussian walk with rebound can teach. In KDD, 2017. ",
+        "bbox": [
+            171,
+            191,
+            825,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew D. Zeiler. Adadelta: An adaptive learning rate method. CoRR, abs/1212.5701, 2012. ",
+        "bbox": [
+            173,
+            229,
+            790,
+            244
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jian Zhang, Ioannis Mitliagkas, and Christopher Re. Yellowfin and the art of momentum tuning. ´ CoRR, abs/1706.03471, 2017. URL http://arxiv.org/abs/1706.03471. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ARCHITECTURE OF NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            308,
+            472,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the classification task on Fashion MNIST, we use 3 convolutional layers, where each layer has 32, 64, 128 filters respectively, with MaxPool after each convolutional layer. For all layers, we use ReLU activations and Dropout (Srivastava et al., 2014). ",
+        "bbox": [
+            174,
+            339,
+            823,
+            381
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The relation extraction task aims to extract quadruples in which the elements are correctly matched with each other. The input training instance consists of a sequence representing a sentence from financial documents, and all possible quadruples in this sequence. For the model, a bi-directional LSTM RNN is used. There are two layers of bi-directional LSTM, and a softmax outputs the probability of each quadruple being correct. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B MODEL VERIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            400,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In our BA-Momentum method, we model the decrease of objective value as a random variable satisfying a one-dimensional Gaussian distribution in Equation 13. This derivation is on the basis of first order Taylor extension and central limit theorem, involving some approximation. After modelling the decrease of objective value as normally distributed, we then estimated its mean and variance in Equation 15 and Equation 16. Here we would like to use real data from Fashion-MNIST to verify that the decrease of objective value truly satisfies a Gaussian distribution and our estimation is close to its real mean and variance. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            607
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We compute the decrease of objective value on the whole data set after 10 iterations for 500 times with batches randomly sampled and size fixed at 100. The result is plotted in Figure 6. The observation confirms that the decrease of objective value distributes normally. Its mean and standard deviation are -7.94253e-10 and 3.48414e-11 respectively, while its estimated mean and standard deviation are -8.58165e-10 and 4.58062e-12. Therefore, the decrease of objective value in our BA-M algorithm satisfies a Gaussian distribution and our estimation for its mean and variance is close to the real ones. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C IMPLEMENTATION ISSUES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            732,
+            424,
+            747
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "When calculating the covariance matrix in Equation 4, one should note that it takes a space of $O ( d ^ { 2 } )$ with $d$ denoting the dimension of the model parameter vector to store the covariance matrix. The cost is quite high for complex models with a large amount of parameters. Yin et al. (2017) has proposed a practical tradeoff assuming that model parameters are independent of each other, then the covariance matrix becomes a diagonal one, greatly reducing the space and time cost. Here we use a small data set from UCI machine learning repository (Lichman, 2013) to test whether the tradeoff will affect the performance of BA-Momentum. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We use two different BA-Momentum. One calculates the exact covariance matrix, while the other calculates its estimated diagonal matrix. The task is a classification task with 3 classes and 42 features. The training set is composed of around 60000 data instances. After training for 14 epochs, we yield the following result. The Figure 7a show the batch size change as learning proceeds for matrix method and diagonal method respectively. The Figure 7b demonstrates different training loss per epoch for two different methods. From the figures we can see that the trend of batch size change for two methods are almost the same, therefore they perform equally well on the training loss descent. This indicates estimating the covariance matrix by its diagonal matrix will not cause degradation to the performance of BA-Momentum. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/631a7ece17b02842ed50fb260091e79e25fbb37b6a60b33e7d42134143a4b6f0.jpg",
+        "image_caption": [
+            "Figure 6: Verification on the distribution of decrease of objective value "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            112,
+            635,
+            289
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            351,
+            825,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/12e4c1d901185c0d1349a93f845f5df1a445f68b1f14a6adb99c8a836ac4ce75.jpg",
+        "image_caption": [
+            "Figure 7: Effects of calculating exact covariance matrix and its estimated diagonal. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            454,
+            743,
+            643
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As for the cost of computing the optimal batch size, on average it takes up $1 . 0 3 \\%$ and $0 . 6 1 \\%$ of the total computing time per iteration for BA-Momentum and BA-SGD respectively on the image classification task, and the percentage on the relation extraction task is $1 . 3 1 \\%$ and $0 . 9 2 \\%$ for BAMomentum and BA-SGD respectively. Computing the optimal batch size involves calculating some means and variances, and a binary search to find the $m ^ { * }$ that maximizes the utility function. Both operations take little time. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D TEST ACCURACIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            369,
+            809
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We show the test accuracies of different methods on the image classification task and relation extraction task in Table 1. For the relation extraction task, we would like to mention that its accuracy is an intersection over union, specifically defined as the ratio of the intersection of the predicted quadruples and the ground truth quadruples to their union. For the evaluation, we record the test accuracies of each method after every epoch’s training and present below the best test accuracies achieved by each method during their whole budget’s training (100 epochs for image classification task and 300 epochs for relation extraction task). ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The proposed “BA” methods achieve two best test accuracies in the following four cases (SGD-based on Fashion MNIST and SGD-based on relation extraction). In the other two cases, the test accuracies achieved by “BA” methods, $9 1 . 3 3 \\%$ and $8 8 . 4 6 \\%$ , are still very close to the best ones, $9 1 . 6 4 \\%$ and $8 9 . 0 2 \\%$ respectively. What’s more, these results are realized in a self-adaptive way and require no fine tuning, while the best accuracies in the two momentum-based cases are achieved by totally different fixed batch sizes, indicating a tuning process. In contrast with “BA” methods, “Manual” methods which manually increase the batch size performs well on Fashion MNIST, whereas they ends up with the fourth highest test accuracies on the relation extraction task, indicating that “Manual” methods also need fine tuning to realize a satisfactory generalization. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a9fda26fe39e529a3cf975829f5c16833e5218869bdfada62044499ae9f18654.jpg",
+        "table_caption": [
+            "Table 1: Best test accuracies achieved by different methods on Fashion MNIST and relation extraction "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Fashion MNIST</td><td colspan=\"2\">Relation extraction</td></tr><tr><td>Momentum</td><td>SGD</td><td>Momentum</td><td>SGD</td></tr><tr><td>Mini-32</td><td>90.93%</td><td>90.87%</td><td>89.02%</td><td>75.13%</td></tr><tr><td>Mini-64</td><td>91.17%</td><td>90.64%</td><td>87.12%</td><td>58.01%</td></tr><tr><td>Mini-128</td><td>91.64%</td><td>90.37%</td><td>85.33%</td><td>31.21%</td></tr><tr><td>Mini-256</td><td>90.76%</td><td>90.16%</td><td>79.37%</td><td>28.11%</td></tr><tr><td>Manual</td><td>91.35%</td><td>90.84%</td><td>86.31%</td><td>50.02%</td></tr><tr><td>BA</td><td>91.33%</td><td>91.01 %</td><td>88.46%</td><td>75.57%</td></tr></table>",
+        "bbox": [
+            271,
+            287,
+            727,
+            404
+        ],
+        "page_idx": 12
+    }
+]