Add files using upload-large-folder tool

parse/train/1_gaHBaRYt/1_gaHBaRYt.md

@@ -0,0 +1,358 @@
+# Fast Federated Learning in the Presence of Arbitrary Device Unavailability
+
+Xinran Gu∗ IIIS Tsinghua University gxr21@mails.tsinghua.edu.cn
+
+Kaixuan Huang∗ ECE Princeton University kaixuanh@princeton.edu
+
+Jingzhao Zhang EECS Massachusetts Institute of Technology jzhzhang@mit.edu
+
+Longbo Huang† IIIS Tsinghua University longbohuang@tsinghua.edu.cn
+
+# Abstract
+
+Federated Learning (FL) coordinates with numerous heterogeneous devices to collaboratively train a shared model while preserving user privacy. Despite its multiple advantages, FL faces new challenges. One challenge arises when devices drop out of the training process beyond the control of the central server. In this case, the convergence of popular FL algorithms such as FedAvg is severely influenced by the straggling devices. To tackle this challenge, we study federated learning algorithms under arbitrary device unavailability and propose an algorithm named Memory-augmented Impatient Federated Averaging (MIFA). Our algorithm efficiently avoids excessive latency induced by inactive devices, and corrects the gradient bias using the memorized latest updates from the devices. We prove that MIFA achieves minimax optimal convergence rates on non-i.i.d. data for both strongly convex and non-convex smooth functions. We also provide an explicit characterization of the improvement over baseline algorithms through a case study, and validate the results by numerical experiments on real-world datasets.
+
+# 1 Introduction
+
+Federated learning is a machine learning setting in which a central server coordinates with a large number of devices to collectively train a shared model [28, 34, 20, 33, 25, 26]. Practical advantages of this training scheme are mainly twofold. First, each device keeps the private data locally and hence preserves its data privacy. Second, federated learning can make use of idle computing resources and lower computation costs. Although federated learning successfully scales up with data sizes and accelerates training via more affordable computing power [43, 38, 36], the collaborative setup leads to new challenges due to large variations among individual computing devices. Our work aims to formulate and investigate the impact of device variations on FL from an optimization perspective.
+
+In FL, a device can differ from its peers in multiple aspects [17, 25]. First, the data distribution and local task can be different among devices. To address the data variation, non-i.i.d. objective models were proposed and analyzed by [26, 18, 19, 42, 25]. We follow this line of work and formulate our optimization objective as a sum of stochastic functions on individual devices (See Eqn. (1)).
+
+A second variation among devices is caused by different computing and communication speeds. One natural way to formulate the variation in computation speeds is to allow asynchronous updates and model the updates as delayed responses. Lots of novel research has studied the problem with different delay models, e.g., [35, 4, 27, 11, 45, 1, 5, 13]. However, the delayed setup assumes that all devices make roughly the same number of (delayed) responses in the end. This behavior may deviate largely from the FL practice, where each device, e.g., personal cell phones, can have very different active duration when participating in the FL training, and hence make different numbers of responses. For this reason, our work aims to address this third discrepancy among devices caused by individual availability patterns.
+
+The third device heterogeneity caused by different availability patterns is less studied in optimization for federated learning problems. In this model, instead of making a delayed response, devices can abort the training halfway, e.g., due to battery level, incoming calls, etc, and fail to return their responses upon the central server’s requests [28, 7, 17]. To handle missing responses, researchers propose algorithms where the central server may collect responses from only a fraction of the devices and make updates [18, 28, 42, 25, 26, 17, 30, 14].
+
+Previous works on collecting responses from a fraction of devices can be divided into two categories. When the response distribution is known, one could collect only the fastest responses and re-weight according to their response probability [17, 26, 30]. This model can be restrictive, as in practice, the exact distribution may not be available and may evolve. Another line of work assumes that the server can arbitrarily decide and sample a set of devices to collect responses accordingly in every communication round [18, 28, 42, 25, 14]. This model does not require knowing the response possibility. However, the response time can be very long if the selected subset contains unavailable devices.
+
+In this work, we address the above limitations by studying federated learning in the presence of arbitrary device unavailability. Within this practical setup, we propose an algorithm that automatically accommodates for the underlying unavailability and allows patterns of the device unavailability to be non-stationary and even adversarial. Furthermore, our algorithm can achieve optimal convergence rates in the presence of device inactivity and automatically reduce to best-known rates if all devices are active. Our contributions are summarized as follows.
+
+• We investigate the federated learning problem with a practical formulation of device participation, which does not require each device to be online according to an (either known or unknown) distribution. • We propose the Memory-augmented Impatient Federated Averaging (MIFA) algorithm that is agnostic to the availability pattern. It efficiently avoids excessive latency induced by inactive devices, successfully exploits the information about the descent direction in stale and noisy gradients, and corrects the gradient bias using the memorized latest updates. • We prove that MIFA achieves minimax optimal convergence rates $\begin{array} { r } { \mathcal { O } \left( \frac { \bar { \tau } _ { T } + 1 } { N K T } \right) } \end{array}$ for smooth, strongly convex functions, and $\mathcal { O } \left( \sqrt { \frac { \bar { \nu } + 1 } { N K T } } \right)$ for smooth, non-convex functions, and establish matching lower bounds. Here, $N , K$ and $T$ stand for the number of devices, local updates and communication rounds respectively. $\bar { \tau } _ { T }$ and $\bar { \nu }$ characterize how actively devices participate in training (see formal definitions in Sections 3, 5 and 6). MIFA also achieves optimal convergence rates in the ideal case when all devices are active. • We provide an explicit characterization of the improvement over baseline algorithms through a case study and empirically verify our results on real-world datasets.
+
+# 2 Related work
+
+Federated learning. Federated Averaging (FedAvg) was first proposed in [28]. [26, 19, 18, 42] provided convergence analysis for FedAvg on non-i.i.d. data and quantified how data heterogeneity degrades the convergence rate. Several variants of FedAvg were designed to deal with data heterogeneity. FedProx [25] adds a proximal term to local objective functions, while FSVRG [21] and SCAFFOLD [18] employ variance reduction techniques.
+
+One line of work focused on variations in computation capabilities among devices [39, 31, 40]. These models assume that responses are delayed but not missing. To address the missing response, some work assumes that the server can actively sample a subset of devices to respond [18, 28, 42, 25, 14] or that the pattern of device availability is known [26, 17, 10, 30]. These results do not generalize to adversarial inactive patterns. [32] discussed the impact of device inactivity on convergence but their proposed algorithm diverges if there exists an inactive device in each round of communication. However, our setup allows adversarial patterns under certain non-distributional assumptions (see Section 5) while our proposed algorithm still achieves convergence.
+
+Asynchronous distributed optimization. Our work is related to literature in the field of traditional asynchronous distributed optimization in that our proposed algorithm uses stale gradients. The problem setup for asynchronous distributed algorithms can be divided into two categories [13]. One is the shared-data (i.i.d.) setting, where all workers can access the whole dataset. In this setting, the local gradient is an unbiased estimator of the global gradient [35, 4, 27, 11, 45, 1]. In contrast, we assume each worker has non-i.i.d. data, and hence the local stochastic gradient can not be viewed as an unbiased estimator of the global gradient.
+
+The other less studied setting in distributed optimization is the distributed-data setting (non-i.i.d.), where data are partitioned among workers. Specifically, [5] proposed an asynchronous incremental aggregated gradient algorithm that uses buffered gradients to update the global model. Unlike our setup, this algorithm evaluates full local gradients, performs only one local step, and was analyzed under the bounded delay assumption. [13] models the delay as stochastic and assumes that the server has knowledge of the distribution, but our formulation is distribution-free. [6] allows workers to perform multiple local steps and communicate with the server at different times, but the authors assume that all workers are available and compute at the same rate.
+
+Comparison with an independent work. While preparing the manuscript, we were unaware of an independent work [41] that investigated the same setup and proposed a similar algorithm called FedLaAvg. Their main theorem established the convergence rate of $\mathcal { O } \left( \sqrt { \frac { \nu _ { \mathrm { m a x } } } { N ^ { 0 . 5 } T } } ( \mathbf { \bar { G } } ^ { 2 } + \sigma ^ { 2 } ) \right)$ for smooth and non-convex problems, where $G ^ { 2 }$ is the uniform upper bound for the squared norm of stochastic gradients and $\nu _ { m a x }$ is the maximum number of inactive rounds. In comparison, we prove the minimax optimal rate of $\mathcal { O } ( \sqrt { \frac { \bar { \nu } } { N K T } } \sigma ^ { 2 } )$ without the bounded gradient assumption, also improving $\nu _ { \mathrm { m a x } }$ to $\bar { \nu }$ . Furthermore, our result achieves a linear speedup in $N$ and $K$ .
+
+Apart from non-convex functions, we also derive the minimax optimal rates for strongly convex smooth functions under the mild assumption that allows for arbitrary and unbounded number of inactive rounds. Both of our results achieve linear speedups in terms of $N$ and $K$ , and automatically recover the best-known rates of FedAvg when all devices are active. We also show that our proposed algorithm achieves acceleration over unbiased baseline algorithms in the presence of stragglers.
+
+# 3 Problem Setup
+
+We consider optimizing the following problem in a Federated Learning setting:
+
+$$
+\begin{array} { r } { \underset { w \in \mathbb { R } ^ { d } } { \operatorname* { m i n } } f ( w ) : = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } f _ { i } ( w ) : = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathbb { E } _ { \xi _ { i } } [ f _ { i } ( w , \xi _ { i } ) ] , } \end{array}
+$$
+
+where $w$ is the optimization variable, e.g., parameters of a machine learning model, $N$ is the number of participating devices, $f _ { i }$ is the local loss function on device $i$ , and $\xi _ { i }$ describes the randomness in local data distribution.
+
+In the ideal federated learning setup (see Figure 1 (a)), all devices return responses within similar time, and hence the central server collects all the local updates. In this case, the computation cost is usually measured by the number of local stochastic oracle evaluations, which is proportional to the number of rounds. In a delayed FL setup (see Figure 1 (b)), devices are always active upon the central server’s request but may return responses with a delay. Here, all devices return almost the same number of responses in the long term.
+
+As we discussed, the above setups do not depict a real-world scenario in which a device can have a longer inactive duration than active duration. In such cases, the communication interval is much longer than the local computation time required for each update, and each device generates an unequal number of responses [28, 17]. This motivates our setup in Figure 1 (c).
+
+![](images/dbec5db87e22ee0dc55043253dc815eff5fd652c994f67ee8a04489f10ef06e1.jpg)  
+Figure 1: An illustration of setup. (a) Ideal setup: all devices return their responses within similar time. (b) Delayed setup: all devices are available, but may return responses with a delay. (c) Our setup: devices can be unavailable arbitrarily, and the communication interval is long enough for active devices to return responses.
+
+In our proposed setup, we use $t$ to index the global communication rounds. We say a device participates or is active at round $t$ if it can complete the computation task and send back the update at the end of round $t$ . We define $\boldsymbol { \mathcal { A } } ( t )$ as the set of all active devices at round $t$ . Notice that we make no assumptions on the distribution of the participation patterns of devices and allow them to be arbitrary.
+
+Directly applying FedAvg to the proposed setup can be problematic due to the existence of inactive devices. To accommodate for inactive devices, we discuss three natural variants of FedAvg and their limitations. The detailed algorithms can be found in Appendix A.
+
+• Biased FedAvg. At each communication round, the global model is updated with a direct average of local updates from the active devices. This naive approach induces bias when data distribution and response patterns vary among devices.   
+• FedAvg with device sampling. The server selects a subset of $S$ devices randomly without replacement, and then waits until all devices in the subset $s$ respond. This is how original FedAvg [28] addresses device unavailability. Note that over $T$ communication rounds, the global model is updated less than $T$ times due to waiting. This approach is prone to stragglers and we refer the readers to Section 5.1 for a detailed discussion.   
+• FedAvg with importance sampling [26, 13, 17]. The local updates from the active devices are weighted by the reciprocal of the participation probabilities to avoid bias. This approach is only applicable when the response of each device is i.i.d. over rounds and it requires the knowledge of participation probabilities.
+
+# 4 Memory-augmented Impatient Federated Averaging (MIFA)
+
+In this section, we introduce our algorithm — Memory-augmented Impatient Federated Averaging (MIFA). MIFA maintains an update-array $\{ G ^ { i } \}$ in the memory that stores the latest updates for all devices. As the name suggests, MIFA has two components. First, the algorithm is impatient and avoids waiting for any specific device when facing heterogeneous devices with arbitrary availability. Second, the algorithm augments the received updates of the active devices with the stored updates of the inactive devices to perform averaging.
+
+Specifically, at the beginning of round $t$ , the server broadcasts the latest model parameter $w _ { t }$ to all active devices $\boldsymbol { \mathcal { A } } ( t )$ . After receiving $w _ { t }$ , each active device, say, the $i$ -th device, sets $w _ { t , 0 } ^ { i } = w _ { t }$ and performs $K$ steps of SGD with respect to the local objective function to get $w _ { t , K } ^ { i }$ :
+
+$$
+\boldsymbol w _ { t , k + 1 } ^ { i } = \boldsymbol w _ { t , k } ^ { i } - \eta _ { t } \tilde { \nabla } f _ { i } ( \boldsymbol w _ { t , k } ^ { i } ) , \boldsymbol k = 0 , \cdots , \boldsymbol K - 1 ,
+$$
+
+where $\eta _ { t }$ is the learning rate and $\tilde { \nabla } f _ { i } ( w _ { t , k } ^ { i } )$ is the stochastic gradient evaluated on device $i$ . Next, the server stores the received update $\begin{array} { r } { \frac { 1 } { \eta _ { t } } \big ( w _ { t } - w _ { t , K } ^ { i } \big ) } \end{array}$ in $G ^ { i }$ . Denote by $\{ G _ { t } ^ { i } \}$ the update-array after round $t$ , then we have
+
+$$
+\begin{array} { r } { G _ { t } ^ { i } = \left\{ \begin{array} { l l } { G _ { t - 1 } ^ { i } , } & { \mathrm { ~ i f ~ } i \notin \mathcal { A } ( t ) , } \\ { \frac { 1 } { \eta _ { t } } ( w _ { t } - w _ { t , K } ^ { i } ) , } & { \mathrm { ~ i f ~ } i \in \mathcal { A } ( t ) . } \end{array} \right. } \end{array}
+$$
+
+At the end of round $t$ , the server updates the global model with the average of $\{ G _ { t } ^ { i } \}$ (line 9). In other words, our algorithm MIFA updates the model with the latest available accumulated gradients for all devices.
+
+Algorithm 1 Memory-augmented Impatient Federated Averaging (MIFA)   
+
+<table><tr><td colspan="2">1: Input: initial wi,learning rate {nt }</td></tr><tr><td>2: Server executes:</td><td>1: DeviceUpdate(i, Wt , nt):</td></tr><tr><td>3: initialize Gi ←O,i∈[N]</td><td>2:w,←Wt</td></tr><tr><td>4: fort=1,.,T-1do</td><td>3: for local step k = O,.,K -1 do</td></tr><tr><td>5: broadcast wt to all active devices i ∈ A(t)</td><td> 4:compute stochastic gradient Vfi(wt,)</td></tr><tr><td>6: for each active device ido</td><td>Wk+1←W,k-ntvfi(w，） 5:</td></tr><tr><td>7: G ←DeviceUpdate(i,Wt, nt) 8: end for</td><td>6: end for</td></tr><tr><td>Wt+1←wt-∑1 N 9: Gi</td><td>7:Return (wt - wi,k) to the server</td></tr></table>
+
+MIFA efficiently progresses without waiting for inactive devices and re-uses their latest updates as the surrogate for missing responses. Being impatient accelerates convergence, whereas memory augmentation corrects the update bias. Our algorithm differs from asynchronous algorithms in traditional distributed optimization [35, 4, 27, 11, 45, 1, 13, 6] in that we utilize the noisy updates of inactive devices more than once to avoid biasing against stragglers. In the following part of the paper, we show that MIFA successfully exploits information about the descent direction contained in the stale and noisy gradients.
+
+Discussion on implementation. In practice, to implement MIFA, the server needs to maintain a huge array to store the latest update for each device, which scales with the model size and the total number of devices. To avoid exhausting the server’s memory, one strategy is to distribute the memory consumption among devices. Specifically, each device, say the $i$ -th, stores its previous update $G _ { t _ { i } ^ { \prime } } ^ { \ i }$ computed at round $t _ { i } ^ { \prime }$ in its local memory. When it becomes active and computes $G _ { t } ^ { i }$ , the device sends $G _ { t } ^ { i } - G _ { t _ { i } ^ { \prime } } ^ { i }$ to the server, which is the difference between the current update and the previous one. In this case, the server only needs to maintain the average $\bar { G }$ in the memory and updates it by $\begin{array} { r } { \bar { G } _ { t } = \bar { G } _ { t - 1 } + \frac { 1 } { N } \sum _ { i \in \mathcal { A } ( t ) } ( G _ { t } ^ { \bar { i } } - G _ { t _ { i } ^ { \prime } } ^ { i } ) } \end{array}$ at round $t$ . Then the server updates the global model by $w _ { t + 1 } = w _ { t } - \eta _ { t } \bar { G } _ { t }$ .
+
+# 5 Convergence Analysis for strongly convex objective functions
+
+In this section, we present the convergence results for MIFA on $\mu$ -strongly convex $L$ -smooth functions. Typical examples for the strongly convex case are $\ell _ { 2 }$ regularized logistic regression and linear regression problems.
+
+In order to capture how the unavailability of devices affects algorithm performance, we introduce the following notion to quantify the dynamics of devices in our setting.
+
+Definition 5.1 (Number of inactive rounds). We define the number of inactive rounds of device $i$ at round $t$ as $\tau ( t , i ) = t - \operatorname* { m a x } \{ t ^ { \prime } \mid t ^ { \prime } \leq t , i \in A ( t ^ { \prime } ) \}$ , which is the difference between current round $t$ and the latest round when device $i$ is active.
+
+It can be seen that $\tau ( t , i ) = 0$ if device $i$ is active at round $t$ and $\tau ( t , i ) = \tau ( t - 1 , i ) + 1$ otherwise. Also, $t - \tau ( t , i )$ is the latest round when the device $i$ is active. Next, we present the assumptions made for establishing our convergence theorem.
+
+Assumption 1. $f _ { 1 } , \cdots , f _ { N }$ are all $L$ -smooth, i.e., for all $w$ and $v _ { \scriptscriptstyle { i } }$ , $\begin{array} { r c l } { f _ { i } ( v ) } & { \leq } & { f _ { i } ( w ) \ + } \end{array}$ $\begin{array} { r } { \left. \nabla f _ { i } ( w ) , v - w \right. + \frac { L } { 2 } \left\| w - v \right\| ^ { 2 } } \end{array}$ .
+
+Assumption 2. $\tilde { \nabla } f _ { i } ( \boldsymbol { w } )$ is an unbiased estimator of $\nabla f _ { i }$ with variance bounded by $\sigma ^ { 2 }$ , i.e., $\mathbb { E } _ { \boldsymbol { \xi } } \left[ \tilde { \nabla } f _ { i } ( \boldsymbol { w } ) \right] = \nabla f _ { i } ( \boldsymbol { w } ) , \mathbb { E } _ { \boldsymbol { \xi } } \left[ \left\| \tilde { \nabla } f _ { i } ( \boldsymbol { w } ) - \nabla f _ { i } ( \boldsymbol { w } ) \right\| ^ { 2 } \right] \leq \sigma ^ { 2 } .$ .
+
+Assumption 3. $f _ { 1 } , \cdots , f _ { N }$ are all $\mu$ -strongly convex: for all $w$ and $v _ { \scriptscriptstyle { i } }$ , $f _ { i } ( v ) \geq f _ { i } ( w ) +$ $\begin{array} { r } { \left. \nabla f _ { i } ( w ) , v - w \right. + \frac { \mu } { 2 } \left\| w - v \right\| ^ { 2 } } \end{array}$ .
+
+Assumption 4. There exists a constant $t _ { 0 } > 0$ , such that for all $t \geq 1$ and $i \in [ N ]$ , the number of inactive rounds of device $i$ at communication round $t$ satisfies $\begin{array} { r } { \tau ( t , i ) \leq t _ { 0 } + \frac { 1 } { b } \dot { t } } \end{array}$ , where $b =$ $4 0 \left( L / \mu \right) ^ { 1 . 5 }$ .
+
+Assumptions 1, 2, and 3 are standard and common in the FL literature, e.g., [26, 18, 19, 42, 36]. In Assumption 2, we relax the bounded gradient assumption that is often required in prior work, e.g., [6, 26, 40, 1]. Lastly, Assumption 4 is a very mild assumption on device availability, since it allows the number of inactive rounds to grow as ${ \mathcal { O } } ( t )$ . In contrast, existing results on asynchronous updates mostly assume a bounded or fixed latency, e.g., [6, 1, 5, 40, 35, 4].
+
+We are now ready to present our first convergence result. Define $\begin{array} { r l } { D = } & { { } \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left. \nabla f _ { i } ( w _ { * } ) \right. ^ { 2 } } \end{array}$ to measure data dissimilarity, where $w _ { * } = \arg \operatorname* { m i n } f ( w )$ is the global optimum. Also, define $\bar { \tau } _ { T }$ and $\tau _ { \operatorname* { m a x } , T }$ to be the average and maximum numbers of inactive rounds $\tau ( t , i )$ across all devices and rounds, respectively. That is,
+
+$$
+\bar { \tau } _ { T } = \frac { 1 } { N ( T - 1 ) } \sum _ { t = 1 } ^ { T - 1 } \sum _ { i = 1 } ^ { N } \tau ( t , i ) , \tau _ { \operatorname* { m a x } , T } = \operatorname* { m a x } _ { i \in [ N ] } \operatorname* { m a x } _ { 1 \leq t \leq T - 1 } \tau ( t , i ) .
+$$
+
+The following theorem summarizes the performance of MIFA in this case.
+
+Theorem 5.1. Assume that Assumptions $^ { l }$ to 3 hold. Further assume that the device availability sequence $\tau ( t , i )$ satisfies Assumption $^ { 4 }$ and $\tau ( 1 , i ) = 0$ for all $i \in [ N ]$ . By setting the learning rate $\begin{array} { r } { \eta _ { t } = \frac { 4 } { \mu K ( t + a ) } } \end{array}$ with $a = \operatorname* { m a x } \{ 1 0 0 , 4 0 t _ { 0 } \} ( L / \mu ) ^ { 1 . 5 }$ , after $T - 1$ communication rounds, MIFA satisfies:
+
+$$
+\mathbb { E } _ { \xi } \left[ f ( \overline { { w } } _ { T } ) \right] - f ( w _ { * } ) = \mathcal { O } \left( \frac { \bar { \tau } _ { T } + 1 } { \mu N K T } \sigma ^ { 2 } + \frac { \tau _ { \operatorname* { m a x } , T } ^ { 2 } A _ { 1 } + ( K - 1 ) ^ { 2 } A _ { 2 } + A _ { 3 } } { \mu ^ { 2 } T ^ { 2 } } \right) ,
+$$
+
+where $\overline { { w } } _ { T }$ is a weighted average of $w _ { t }$ defined as:
+
+$$
+\overline { { w } } _ { T } = \frac { 1 } { W _ { T } } \sum _ { t = 1 } ^ { T } ( t + a - 1 ) ( t + a - 2 ) w _ { t } , W _ { T } = \sum _ { t = 1 } ^ { T } ( t + a - 1 ) ( t + a - 2 ) ,
+$$
+
+Our results hold under Assumption 4, which allows for arbitrary device availability sequences with $\tau _ { \mathrm { m a x } , T } = \mathcal { O } ( T )$ . However, for MIFA to converge, we require $\tau _ { \operatorname* { m a x } , T } = o ( T )$ and $\dot { t _ { 0 } } = \bar { o } ( T )$ . When ( NK(τ2max,T +t20)τ¯+1 ), the first term dominates and the impact of the second O(1/T 2) term is negligible. In fact the first term in Theorem 5.1 is minimax optimal by our information-theoretic lower bound for the problem in the next proposition.
+
+Proposition 5.1. Let $c _ { 0 } > 0$ be a universal constant. For any potentially randomized algorithm, there exists a stochastic strongly convex problem satisfying Assumptions $^ { l }$ to 3, such that the output $w _ { T }$ after $T$ rounds of communication has expected sub-optimality lower bounded by
+
+$$
+\mathbb { E } [ f ( w _ { T } ) - f ( w ^ { * } ) ] \geq c _ { 0 } \frac { \bar { \tau } _ { T } \sigma ^ { 2 } } { \mu N K T } .
+$$
+
+The proof is based on the observation that the number of gradient evaluation can scale inversely with $\bar { \tau } _ { T }$ and that the oracle complexity is tight even for centralized stochastic optimization problems. The optimality of the first term in Theorem 5.1 is independent of the distributed or the FL setup.
+
+The second term in Theorem 5.1 converges at the rate $\mathcal { O } ( 1 / T ^ { 2 } )$ and consists of three parts, where the first part reflects the slowdown caused by device unavailability through $\tau _ { \operatorname* { m a x } , T }$ , the second part shows the effect of multiple $( K > 1 )$ ) local steps, and the third part tells how the initial error decreases.
+
+Remark 5.1. When $\tau ( t , i ) ~ = ~ 0$ for all $i$ and $t _ { : }$ , our setup reduces to FedAvg with full device pbound $\bar { \tau } _ { T } ~ = ~ 0$ d  , $\tau _ { \mathrm { m a x } , T } ~ = ~ 0$ . Iate $\begin{array} { r } { \mathcal { O } \left( \frac { \sigma ^ { 2 } } { \mu K N T } + \frac { L ( \sigma ^ { 2 } / K + D + L ^ { 2 } \| w _ { 1 } - w _ { * } \| ^ { 2 } ) } { \mu ^ { 2 } T ^ { 2 } } \right) } \end{array}$ $\begin{array} { r } { \mathcal { O } \bigg ( \frac { \sigma ^ { 2 } \log T } { \mu K N T } + \frac { L ( \sigma ^ { 2 } / K + D ) ( \log T ) ^ { 2 } } { \mu ^ { 2 } T ^ { 2 } } + } \end{array}$ $\begin{array} { r } { \mu \left. w _ { 1 } - w _ { * } \right. ^ { 2 } \exp ( - \frac { \mu } { 4 8 L } T ) \Bigr ) } \end{array}$ in [18] (Thm. V. $B ^ { 2 } = 2 , \eta _ { g } = 1 ,$ ) up to logarithmic terms. Besides, in the general case, our $\mathcal { O } ( \tau _ { \mathrm { m a x } , T } ^ { 2 } A _ { 1 } / T ^ { 2 } )$ term matches the last term in $I 6 J \left( C o r . 5 \right)$ .
+
+Remark 5.2. Our analysis relies on the technical assumption that all devices respond in the first round. Intuitively, this is because we need at least one valid stochastic gradient evaluation for each device to get a complete picture of the global objective, or otherwise any update would be biased. In practice, this can be achieved by waiting for the updates from all devices on $w _ { 1 }$ at the very beginning.
+
+# 5.1 Case Study: i.i.d. Bernoulli participation
+
+Though our algorithm can be applied to non-stationary and non-independent response patterns, we show in this subsection that even in the simple i.i.d. Bernoulli participation scenario our algorithm can achieve considerable improvement compared to known algorithms. In particular, we consider a setup where each device becomes active independently with a fixed probability $p _ { i }$ . It serves as the first motivating example towards modeling the participation patterns of devices, and provides a clean view of how the heterogeneity of the device participation influences the Federated optimization algorithms.
+
+We will show that in this scenario, Assumption 4 holds with high probability, and the terms involving the inactive rounds $\tau ( t , i )$ in Theorem 5.1 can also be bounded. Furthermore, we theoretically demonstrate that algorithms such as FedAvg [28] and SCAFFOLD [18], which sample $S$ devices for each global update, are more prone to stragglers than our algorithm.
+
+Definition 5.2. Assume that for all $i \in [ N ]$ , the i-th device is assigned with a probability $p _ { i }$ . We say the participation of the devices follows i.i.d. Bernoulli participation model with participation probabilities $\{ p _ { i } \}$ , if (1). at the first round, all devices are active, and (2). at round $t > 1$ , device $i$ is active with probability $p _ { i }$ , which is independent of the history and other devices.
+
+Next theorem shows that under i.i.d. Bernoulli participation scenario, with high probability, $\tau ( t , i )$ only grows logarithmically in $t$ . Also Assumption 4 holds for a mild choice of $t _ { 0 }$ .
+
+Theorem 5.2. For i.i.d. Bernoulli participation model defined in Definition 5.2, given any $\delta > 0$ , with probability at least $1 - \delta$ , we have the following holds for all $t \geq 1$ and $i \in [ N ]$ simultaneously,
+
+$$
+\tau ( t , i ) \leq \mathcal { O } \Big ( \frac { 1 } { p _ { i } } ( \log ( N t / \delta ) + 1 ) \Big ) .
+$$
+
+Furthermore, $( l )$ . Assumption $^ { 4 }$ holds true $\begin{array} { r } { \mathrm { \ddot { \it f } } t _ { 0 } = \Omega \bigg ( \frac { 1 } { p _ { m i n } } \log \frac { b N } { p _ { m i n } \delta } \bigg ) } \end{array}$ , where $p _ { m i n } = \operatorname* { m i n } \{ p _ { i } \}$ , and $b = 4 0 ( L / \mu ) ^ { 1 . 5 }$ ;(2). $\tau _ { \operatorname* { m a x } , T }$ can be upper bounded as
+
+$$
+\tau _ { \operatorname* { m a x } , T } \leq \mathcal { O } \Big ( \frac { 1 } { p _ { m i n } } \cdot \big ( \log ( T N / \delta ) + 1 \big ) \Big ) .
+$$
+
+The next theorem provides a high probability upper bound for $\bar { \tau } _ { T }$ .
+
+Theorem 5.3. For i.i.d. Bernoulli participation model defined in Definition 5.2, given any $\delta > 0$ and $T > 1$ , with probability at least $1 - \delta$ , we have
+
+$$
+\bar { \tau } _ { T } \leq \Big ( \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \frac { 1 } { p _ { i } } \Big ) \cdot \mathcal { O } \Big ( 1 + \log \frac { 1 } { \delta } \Big ) .
+$$
+
+By Theorem 5.2 and Theorem 5.3, we conclude that the dominant term of our convergence bound is $\begin{array} { r } { \stackrel { \triangledown } { \mathcal { O } } \left( \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \frac { 1 } { p _ { i } } \cdot \frac { \sigma ^ { 2 } } { \mu N K T } \right) } \end{array}$ . Therefore, to achieve $\epsilon$ accuracy, the dominant term of the number of the required rounds is
+
+$$
+T _ { \epsilon } ^ { \left( \mathrm { M I F A } \right) } = \widetilde { \mathcal { O } } \Bigl ( \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \frac { 1 } { p _ { i } } \cdot \frac { \sigma ^ { 2 } } { \mu N K \epsilon } \Bigr ) .
+$$
+
+For both FedAvg and SCAFFOLD that sample $S$ devices uniformly at random, [18] (Thm I. & III.) showed that the dominant term of the number of global updates needed to achieve $\epsilon$ accuracy is $\begin{array} { r } { R _ { \epsilon } = \widetilde { \mathcal { O } } \left( \frac { \sigma ^ { 2 } } { \mu S K \epsilon } \right) } \end{array}$ . Notice that in our setting, to accomplish each global update, the server needs to wait for a few rounds for the $S$ devices to respond. Let $T ( S )$ be the expected rounds for which the server needs to wait for the selected devices $\boldsymbol { S }$ to be active. Then the expected total rounds to achieve $\epsilon$ accuracy is $R _ { \epsilon } \cdot \mathbb { E } _ { S } \left[ T ( S ) \right]$ . For i.i.d. Bernoulli participation model, we have $\begin{array} { r } { T ( S ) \geq \frac { 1 } { \operatorname* { m i n } \{ p _ { i } | i \in S \} } } \end{array}$ , and we can further show that $\begin{array} { r } { \mathbb { E } _ { S } \left[ T ( S ) \right] \ge \frac { 1 } { p _ { m i n } } \frac { S } { N } } \end{array}$ ≥ 1p min SN ( see Appendix D.3 for details). Therefore,
+
+$$
+\mathbb { E } \left[ T _ { \epsilon } ^ { ( \mathsf { F e d A v g , S C A F F O L D } ) } \right] \geq \frac { S } { N } \frac { 1 } { p _ { m i n } } \widetilde { \mathcal { O } } \Big ( \frac { \sigma ^ { 2 } } { \mu S K \epsilon } \Big ) = \widetilde { \mathcal { O } } \Big ( \frac { 1 } { p _ { m i n } } \cdot \frac { \sigma ^ { 2 } } { \mu N K \epsilon } \Big ) .
+$$
+
+By comparing Eqn. 2 and Eqn. 3, we see that both FedAvg and SCAFFOLD are more vulnerable to stragglers, that is, the devices with very small participation probabilities; on the contrary, the convergence rate of MIFA only depends on the average of $1 / p _ { i }$ instead of $1 / p _ { m i n }$ . We also provide empirical experiments showing that MIFA converges faster than FedAvg in Section 7.
+
+# 6 Convergence result for non-convex objective functions
+
+In this section, we present the convergence guarantee of MIFA for the non-convex case. First we list the additional assumptions as below.
+
+Assumption 5 (Hessian Lipschitz). $f _ { 1 } , \cdots , f _ { N }$ are all $\rho$ -Hessian Lipschitz: for all $w$ and $v$ $\bigl \| \nabla ^ { 2 } f _ { i } \bigl ( \tilde { \boldsymbol { w } } \bigr ) - \nabla ^ { 2 } f _ { i } ( \boldsymbol { v } ) \bigr \| \leq \dot { \rho } \bigl \| \boldsymbol { w } - \boldsymbol { \tilde { v } } \bigr \|$ .
+
+Assumption 6 (Bounded noise). The noise of the local stochastic gradients is upper bounded by $a$ constant $\delta$ almost surely: $\begin{array} { r } { \left\| \tilde { \nabla } f _ { i } ( w ) - \nabla f _ { i } ( w ) \right\| \le \delta a . s . , \forall i \in [ N ] } \end{array}$ .
+
+Assand y). There exist . Furthermore, $\alpha > 0$ anfine $\beta _ { i } > 0$ at for all . $w$ $\in [ N ] \colon \left\| \nabla f _ { i } ( w ) \right\| ^ { 2 } \leq \alpha \left\| \nabla f ( w ) \right\| ^ { 2 } + \beta _ { i }$ $\begin{array} { r } { \beta = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \beta _ { i } } \end{array}$
+
+Assumption 8. There exists a constant $\nu _ { i }$ such that $\tau ( t , i ) \ \leq \ \nu _ { i }$ , for all $i \in [ N ]$ and $t \geq 1$ Furthermore, define ν¯ = 1N PNi=1 νi and νmax = maxi∈[N] νi.
+
+The analysis of non-convex functions is much more technically involved, and our results rely on strong assumptions that provide a finer control of the gradient difference (Assumption 5), gradient noise (Assumption 6), gradient dissimilarity among devices (Assumption 7), and device unavailability (Assumption 8). We remark that Assumption 5 is also made in [9, 16], and Assumption 7 is also made in [18, 39]. We leave it as future work to study whether and how MIFA converges for non-convex functions with weaker assumptions.
+
+Theorem 6.1. Assume that Assumptions $I , ~ 2 , ~$ , and $^ { 5 }$ to 7 hold. Further assume that the device availability sequence $\tau ( t , i )$ satisfies Assumption 8 and $\tau ( 1 , i ) = 0$ for all $i \in [ N ]$ . By using $a$ learning rate η = q $\begin{array} { r } { \eta = \sqrt { \frac { N } { K T L \left( 1 + \bar { \nu } \right) } } } \end{array}$ NKT L(1+¯ν), for T ≥ max{32αLNK, 16LNK , 8KNν2max(L2+ρδ) }, after T − 1 communication rounds, MIFA satisfies:
+
+$$
+\operatorname* { m i n } _ { 1 \leq t \leq T } \mathbb { E } _ { \xi } \left[ \left\| \nabla f ( w _ { t } ) \right\| ^ { 2 } \right] = \mathcal { O } \left( \sqrt { \frac { ( 1 + \bar { \nu } ) L } { T K N } } ( f ( w _ { 1 } ) - f ^ { * } + \sigma ^ { 2 } ) + \frac { A _ { 4 } + A _ { 5 } } { T } \right) ,
+$$
+
+where $f ^ { * }$ is the optimal value, and:
+
+$$
+\begin{array} { l } { { A _ { 4 } = N K L \left( \alpha \sigma ^ { 2 } \hat { \nu } + \frac { \sigma ^ { 2 } \nu _ { \mathrm { m a x } } } { \sqrt { K N } } + \sigma \nu _ { \mathrm { m a x } } \sqrt { \beta } \right) + \frac { { ( L ^ { 2 } + \rho \delta ) \sigma ^ { 2 } \nu _ { \mathrm { m a x } } } } { L } , } } \\ { { A _ { 5 } = \frac { { ( K - 1 ) N L ( \beta + \sigma ^ { 2 } / K ) } } { \hat { \nu } + 1 } . } } \end{array}
+$$
+
+Next, we show that the leading $\mathcal { O } ( 1 / \sqrt { T } )$ term is theoretically optimal for zero-respecting algorithms.
+
+Proposition 6.1. Let $c _ { 0 } > 0$ be a universal constant. For any randomized zero-respecting algorithm, there exists a stochastic non-convex problem satisfying Assumption1, 2, 5 and 7, such that the output $w _ { T }$ after $T$ rounds of communication has expected sub-optimality lower bounded by
+
+$$
+\mathbb { E } [ \| \nabla f ( w _ { T } ) \| ^ { 2 } ] \ge \mathbb { E } [ \| \nabla f ( w _ { T } ) \| ] ^ { 2 } \ge c _ { 0 } \sqrt { \frac { \bar { \nu } L \sigma ^ { 2 } ( f ( w _ { 0 } ) - f ^ { * } ) } { N K T } } .
+$$
+
+The above proposition show that when $\sigma \sqrt { ( f ( w _ { 0 } ) - f ^ { * } ) } \sim \sigma ^ { 2 } + ( f ( w _ { 0 } ) - f ^ { * } )$ , the result in Theorem 6.1 is tight. However, note that the counter example we used requires the quantity $\delta$ in Assumption 6 to scale with $T$ , hence requiring $\delta$ to be large enough. This does not change the optimality of the first term as the first term is independent of $\delta$ . Whether this requirement can be relaxed is left as an open problem.
+
+Remark 6.1. When all $\nu _ { i } = 0$ (i.e. all the devices are active), our convergence bound reduces to $\begin{array} { r } { \mathcal { O } \Big ( \sqrt { \frac { L } { T K N } } ( f ( w _ { 1 } ) - f ^ { * } + \sigma ^ { 2 } ) + \frac { ( K - 1 ) N L ( \beta + \sigma ^ { 2 } / K ) } { T } \Big ) } \end{array}$ . This matches the result in [42] (Thm. 1, $\begin{array} { r } { \eta = 1 , \eta _ { L } = \sqrt { \frac { N } { K T L } } ) } \end{array}$ .
+
+# 7 Numerical Experiments
+
+In this section, we conduct numerical experiments3. to verify our theoretical results and investigate how the heterogeneity of the device availability influences the Federated optimization algorithms. We compare the performance of the following four algorithms: FedAvg with importance sampling (FedAvg-IS), Biased FedAvg, FedAvg with device sampling, and our proposed MIFA. For the detailed discussions of the algorithms, we refer the readers to Sections 3 and 4. We remark that for a fair comparison, we deliberately include the first few rounds that MIFA needs to wait to receive responses from all devices for initializing the update-array $\{ G ^ { i } \}$ .
+
+Following [26, 25], we construct non-i.i.d. datasets from two commonly used computer vision datasets — MNIST [23] and CIFAR-10 [22] . Specifically, we divide the data into $N = 1 0 0$ devices with each device holding samples of only two classes, which creates a high level of data heterogeneity. For simplicity, we ensure that each device holds the same number of samples. We do not use any data augmentation. We use multinomial logistic regression as the convex model and LeNet-5 [24] with ReLU activations as the non-convex model. For all experiments, we use weight decay in the training process, which corresponds to adding $\ell _ { 2 }$ penalty. We use logistic models for MNIST dataset, while we use LeNet-5 for CIFAR-10. Our code is adapted from [26], which is under MIT License.
+
+We model the availability of the devices as independent Bernoulli random trials. The $i \cdot$ -th device is assigned with a probability $p _ { i }$ , where at each time step, the device becomes active with probability $p _ { i }$ . In our experiments, the $p _ { i }$ ’s are chosen such that devices holding data of smaller labels participate less frequently. Specifically, if the $i$ -th device holds the data of label $j$ and $k$ , we set $\bar { p } _ { i } = \bar { p _ { \operatorname* { m i n } } } \operatorname* { m i n } ( j , k ) / 9 + \bar { ( 1 - p _ { \operatorname* { m i n } } ) }$ , where $p _ { \mathrm { m i n } }$ controls the lower bound of the participation probabilities. The correlation between the participation patterns and local datasets increases the difficulty of the problem [17]. To investigate this phenomenon, we repeat the experiments for $p _ { \mathrm { m i n } } = 0 . 1$ and 0.2. We control the randomness of device participation when testing different algorithms.
+
+In all the experiments, we set the initial learning rate to be $\eta _ { 0 } = 0 . 1$ and decay the learning rate as $\begin{array} { r } { \eta _ { t } = \eta _ { 0 } \cdot \frac { 1 } { t } } \end{array}$ . We set the weight decay to be 0.001. The local batch size is 100 and each local update consists of 2 epochs. Therefore, the actual number of local steps $K$ depends on the size of the dataset. We run all the experiments with 4 GPUs of type GeForce RTX 2080 Ti. We repeat the experiments for 5 different random seeds, and all of the experiments exhibit similar training curves. We report the averaged training loss and test accuracy with error bars in Figure 2.
+
+We observe that FedAvg with device sampling (FedAvg ( $S = 5 0$ ) and FedAvg $S = 1 0 0$ ) in Figure 2) is severely influenced by the straggling devices and makes progress relatively slowly compared to the other algorithms. Although biased FedAvg converges fast at the beginning, this simple algorithm is biased, and the optimality gaps are prominent for the harder CIFAR-10 dataset and when $p _ { \mathrm { m i n } }$ is small. On the contrary, our proposed MIFA avoids waiting for stragglers, converges fast without bias, and is competitive with FedAvg with importance sampling, which requires knowledge of the participation probabilities. We refer the readers to Appendix G for additional experiments on CIFAR-10.
+
+# 8 Conclusions and Discussions
+
+In this paper, we study FL algorithms in the presence of arbitrary device unavailability and propose MIFA, which avoids waiting for straggling devices and re-uses the memorized latest updates as the surrogate when the device is unavailable. We theoretically analyze MIFA without any structural assumptions on the device availability and prove the convergence for strongly convex and non-convex smooth functions. Different from the literature that studies oracle complexity in terms of stochastic gradient evaluations, we argue that in federated learning system, the bottleneck lies in the nonstationary and possibly adversarial pattern of device participation. Therefore, it is important to study how the number of inactive rounds influences the convergence rate. In Theorem 5.1, the dependency upon $\tau _ { \operatorname* { m a x } , T }$ might be an artifact of our analysis, and a future direction is to study whether we can remove this dependency. Another important direction is to analyze algorithms for non-convex functions under weaker assumptions.
+
+![](images/c1142e9ecbf7a3052e86380ac3f4c818747910b17c29f238aaf9134bafeb112a.jpg)  
+Figure 2: Training losses and test accuracies. Fig. 2(a)–2(d): logistic models on non-iid MNIST. Fig. 2(e)–2(h): LeNet-5 on non-iid CIFAR-10. FedAvg $S = 5 0$ ) and FedAvg $S = 1 0 0$ ) refer to FedAvg with device sampling that samples $S$ devices for each global update. FedAvg-IS is short for FedAvg with importance sampling, which requires knowledge of the participation probabilities.
+
+# Acknowledgments and Disclosure of Funding
+
+The work of Xinran Gu and Longbo Huang is supported in part by the Technology and Innovation Major Project of the Ministry of Science and Technology of China under Grant 2020AAA0108400 and2020AAA0108403. Xinran Gu would like to thank Kaifeng Lyu for the discussion on the convergence analysis. The authors would like to thank Sai Praneeth Karimireddy for the discussion on the problem settings.
+
+# References
+
+[1] Alekh Agarwal and John C Duchi. Distributed delayed stochastic optimization. In 2012 IEEE 51st IEEE Conference on Decision and Control (CDC), pages 5451–5452. IEEE, 2012.   
+[2] Alekh Agarwal, Martin J Wainwright, Peter Bartlett, and Pradeep Ravikumar. Informationtheoretic lower bounds on the oracle complexity of convex optimization. Advances in Neural Information Processing Systems, 22:1–9, 2009.   
+[3] Yossi Arjevani, Yair Carmon, John C. Duchi, Dylan J. Foster, Nathan Srebro, and Blake Woodworth. Lower bounds for non-convex stochastic optimization, 2019.   
+[4] Yossi Arjevani, Ohad Shamir, and Nathan Srebro. A tight convergence analysis for stochastic gradient descent with delayed updates. In Algorithmic Learning Theory, pages 111–132. PMLR, 2020.   
+[5] Arda Aytekin, Hamid Reza Feyzmahdavian, and Mikael Johansson. Analysis and implementation of an asynchronous optimization algorithm for the parameter server. arXiv preprint arXiv:1610.05507, 2016.   
+[6] Debraj Basu, Deepesh Data, Can Karakus, and Suhas Diggavi. Qsparse-local-sgd: Distributed sgd with quantization, sparsification, and local computations. arXiv preprint arXiv:1906.02367, 2019.   
+[7] Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloé Kiddon, Jakub Konecný, Stefano Mazzocchi, Brendan McMahan, Timon ˇ
+
+Van Overveldt, David Petrou, Daniel Ramage, and Jason Roselander. Towards federated learning at scale: System design. In A. Talwalkar, V. Smith, and M. Zaharia, editors, Proceedings of Machine Learning and Systems, volume 1, pages 374–388, 2019.
+
+[8] Sébastien Bubeck, Nicolo Cesa-Bianchi, and Gábor Lugosi. Bandits with heavy tail. IEEE Transactions on Information Theory, 59(11):7711–7717, 2013.
+
+[9] Yair Carmon, John C Duchi, Oliver Hinder, and Aaron Sidford. Accelerated methods for nonconvex optimization. SIAM Journal on Optimization, 28(2):1751–1772, 2018.
+
+[10] Hubert Eichner, Tomer Koren, Brendan McMahan, Nathan Srebro, and Kunal Talwar. Semicyclic stochastic gradient descent. In International Conference on Machine Learning, pages 1764–1773. PMLR, 2019.
+
+[11] Hamid Reza Feyzmahdavian, Arda Aytekin, and Mikael Johansson. An asynchronous minibatch algorithm for regularized stochastic optimization. IEEE Transactions on Automatic Control, 61(12):3740–3754, 2016.
+
+[12] Saeed Ghadimi and Guanghui Lan. Optimal stochastic approximation algorithms for strongly convex stochastic composite optimization i: A generic algorithmic framework. SIAM Journal on Optimization, 22(4):1469–1492, 2012.
+
+[13] Margalit Glasgow and Mary Wootters. Asynchronous distributed optimization with stochastic delays. arXiv preprint arXiv:2009.10717, 2020.
+
+[14] Eduard Gorbunov, Konstantin P. Burlachenko, Zhize Li, and Peter Richtarik. Marina: Faster non-convex distributed learning with compression. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 3788–3798. PMLR, 18–24 Jul 2021.
+
+[15] Tzu-Ming Harry Hsu, Hang Qi, and Matthew Brown. Measuring the effects of non-identical data distribution for federated visual classification. arXiv preprint arXiv:1909.06335, 2019.
+
+[16] Chi Jin, Rong Ge, Praneeth Netrapalli, Sham M Kakade, and Michael I Jordan. How to escape saddle points efficiently. In International Conference on Machine Learning, pages 1724–1732. PMLR, 2017.
+
+[17] Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurélien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019.
+
+[18] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank Reddi, Sebastian Stich, and Ananda Theertha Suresh. Scaffold: Stochastic controlled averaging for federated learning. In International Conference on Machine Learning, pages 5132–5143. PMLR, 2020.
+
+[19] Ahmed Khaled, Konstantin Mishchenko, and Peter Richtárik. Tighter theory for local sgd on identical and heterogeneous data. In International Conference on Artificial Intelligence and Statistics, pages 4519–4529. PMLR, 2020.
+
+[20] Jakub Konecnˇ y, Brendan McMahan, and Daniel Ramage. Federated optimization: Distributed \` optimization beyond the datacenter. arXiv preprint arXiv:1511.03575, 2015.
+
+[21] Jakub Konecnˇ y, H Brendan McMahan, Daniel Ramage, and Peter Richtárik. Federated optimiza- \` tion: Distributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016.
+
+[22] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+[23] Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+[24] Yann LeCun et al. Lenet-5, convolutional neural networks. URL: http://yann. lecun. com/exdb/lenet, 20(5):14, 2015.
+
+[25] Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. In I. Dhillon, D. Papailiopoulos, and V. Sze, editors, Proceedings of Machine Learning and Systems, volume 2, pages 429–450, 2020.   
+[26] Xiang Li, Kaixuan Huang, Wenhao Yang, Shusen Wang, and Zhihua Zhang. On the convergence of fedavg on non-iid data. In International Conference on Learning Representations, 2020.   
+[27] Xiangru Lian, Yijun Huang, Yuncheng Li, and Ji Liu. Asynchronous parallel stochastic gradient for nonconvex optimization. In C. Cortes, N. Lawrence, D. Lee, M. Sugiyama, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 28. Curran Associates, Inc., 2015.   
+[28] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial Intelligence and Statistics, pages 1273–1282. PMLR, 2017.   
+[29] Arkadij Semenovic Nemirovskij and David Borisovich Yudin. Problem complexity and method ˇ efficiency in optimization. 1983.   
+[30] Constantin Philippenko and Aymeric Dieuleveut. Bidirectional compression in heterogeneous settings for distributed or federated learning with partial participation: tight convergence guarantees. arXiv preprint arXiv:2006.14591, 2020.   
+[31] Amirhossein Reisizadeh, Isidoros Tziotis, Hamed Hassani, Aryan Mokhtari, and Ramtin Pedarsani. Straggler-resilient federated learning: Leveraging the interplay between statistical accuracy and system heterogeneity. arXiv preprint arXiv:2012.14453, 2020.   
+[32] Yichen Ruan, Xiaoxi Zhang, Shu-Che Liang, and Carlee Joe-Wong. Towards flexible device participation in federated learning. In International Conference on Artificial Intelligence and Statistics, pages 3403–3411. PMLR, 2021.   
+[33] Felix Sattler, Simon Wiedemann, Klaus-Robert Müller, and Wojciech Samek. Robust and communication-efficient federated learning from non-iid data. IEEE transactions on neural networks and learning systems, 31(9):3400–3413, 2019.   
+[34] Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet Talwalkar. Federated multi-task learning. arXiv preprint arXiv:1705.10467, 2017.   
+[35] Sebastian U Stich and Sai Praneeth Karimireddy. The error-feedback framework: Better rates for sgd with delayed gradients and compressed updates. Journal of Machine Learning Research, 21:1–36, 2020.   
+[36] Sebastian Urban Stich. Local sgd converges fast and communicates little. In ICLR 2019- International Conference on Learning Representations, number CONF, 2019.   
+[37] Roman Vershynin. High-dimensional probability: An introduction with applications in data science, volume 47. Cambridge university press, 2018.   
+[38] Jianyu Wang and Gauri Joshi. Cooperative sgd: A unified framework for the design and analysis of communication-efficient sgd algorithms. In ICML Workshop on Coding Theory for Machine Learning, 2019.   
+[39] Jianyu Wang, Qinghua Liu, Hao Liang, Gauri Joshi, and H Vincent Poor. Tackling the objective inconsistency problem in heterogeneous federated optimization. Advances in Neural Information Processing Systems, 33, 2020.   
+[40] Cong Xie, Sanmi Koyejo, and Indranil Gupta. Asynchronous federated optimization. arXiv preprint arXiv:1903.03934, 2019.   
+[41] Yikai Yan, Chaoyue Niu, Yucheng Ding, Zhenzhe Zheng, Fan Wu, Guihai Chen, Shaojie Tang, and Zhihua Wu. Distributed non-convex optimization with sublinear speedup under intermittent client availability. arXiv preprint arXiv:2002.07399, 2020.   
+[42] Haibo Yang, Minghong Fang, and Jia Liu. Achieving linear speedup with partial worker participation in non-iid federated learning. arXiv preprint arXiv:2101.11203, 2021.   
+[43] Hao Yu, Rong Jin, and Sen Yang. On the linear speedup analysis of communication efficient momentum sgd for distributed non-convex optimization. In International Conference on Machine Learning, pages 7184–7193. PMLR, 2019.   
+[44] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why are adaptive methods good for attention models?, 2020.   
+[45] Xin Zhang, Jia Liu, and Zhengyuan Zhu. Taming convergence for asynchronous stochastic gradient descent with unbounded delay in non-convex learning. In 2020 59th IEEE Conference on Decision and Control (CDC), pages 3580–3585. IEEE, 2020.
+
+# 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 8.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A] Our work is mainly theoretical and targets at providing theoretical analysis of the FL algorithms, which has almost no negative societal impacts.   
+(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] The assumptions are rigorously stated in Section 5 and Section 6.   
+(b) Did you include complete proofs of all theoretical results? [Yes] All the proofs are deferred to 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] Our code will be included in the supplemental material. The datasets we use are public. The instructions needed to reproduce the main experimental results are clearly stated in Section 7.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 7.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Section 7.   
+(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 Section 7.
+
+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] See Section 7.   
+(b) Did you mention the license of the assets? [Yes] See Section 7.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We include our code for reproducing the experiments in the supplemental material.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We choose the commonly-used MNIST and CIFAR-10 datasets.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We choose the commonly-used MNIST and CIFAR-10 datasets.
+
+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/1_gaHBaRYt/1_gaHBaRYt_content_list.json

@@ -0,0 +1,1665 @@
+[
+    {
+        "type": "text",
+        "text": "Fast Federated Learning in the Presence of Arbitrary Device Unavailability ",
+        "text_level": 1,
+        "bbox": [
+            238,
+            122,
+            761,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xinran Gu∗ IIIS Tsinghua University gxr21@mails.tsinghua.edu.cn ",
+        "bbox": [
+            245,
+            226,
+            480,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kaixuan Huang∗ ECE Princeton University kaixuanh@princeton.edu ",
+        "bbox": [
+            558,
+            227,
+            751,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jingzhao Zhang EECS Massachusetts Institute of Technology jzhzhang@mit.edu ",
+        "bbox": [
+            225,
+            303,
+            478,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Longbo Huang† IIIS Tsinghua University longbohuang@tsinghua.edu.cn ",
+        "bbox": [
+            537,
+            303,
+            771,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            395,
+            535,
+            411
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Federated Learning (FL) coordinates with numerous heterogeneous devices to collaboratively train a shared model while preserving user privacy. Despite its multiple advantages, FL faces new challenges. One challenge arises when devices drop out of the training process beyond the control of the central server. In this case, the convergence of popular FL algorithms such as FedAvg is severely influenced by the straggling devices. To tackle this challenge, we study federated learning algorithms under arbitrary device unavailability and propose an algorithm named Memory-augmented Impatient Federated Averaging (MIFA). Our algorithm efficiently avoids excessive latency induced by inactive devices, and corrects the gradient bias using the memorized latest updates from the devices. We prove that MIFA achieves minimax optimal convergence rates on non-i.i.d. data for both strongly convex and non-convex smooth functions. We also provide an explicit characterization of the improvement over baseline algorithms through a case study, and validate the results by numerical experiments on real-world datasets. ",
+        "bbox": [
+            233,
+            428,
+            766,
+            621
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            650,
+            310,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Federated learning is a machine learning setting in which a central server coordinates with a large number of devices to collectively train a shared model [28, 34, 20, 33, 25, 26]. Practical advantages of this training scheme are mainly twofold. First, each device keeps the private data locally and hence preserves its data privacy. Second, federated learning can make use of idle computing resources and lower computation costs. Although federated learning successfully scales up with data sizes and accelerates training via more affordable computing power [43, 38, 36], the collaborative setup leads to new challenges due to large variations among individual computing devices. Our work aims to formulate and investigate the impact of device variations on FL from an optimization perspective. ",
+        "bbox": [
+            174,
+            684,
+            823,
+            795
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In FL, a device can differ from its peers in multiple aspects [17, 25]. First, the data distribution and local task can be different among devices. To address the data variation, non-i.i.d. objective models were proposed and analyzed by [26, 18, 19, 42, 25]. We follow this line of work and formulate our optimization objective as a sum of stochastic functions on individual devices (See Eqn. (1)). ",
+        "bbox": [
+            174,
+            801,
+            823,
+            857
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A second variation among devices is caused by different computing and communication speeds. One natural way to formulate the variation in computation speeds is to allow asynchronous updates and model the updates as delayed responses. Lots of novel research has studied the problem with different delay models, e.g., [35, 4, 27, 11, 45, 1, 5, 13]. However, the delayed setup assumes that all devices make roughly the same number of (delayed) responses in the end. This behavior may deviate largely from the FL practice, where each device, e.g., personal cell phones, can have very different active duration when participating in the FL training, and hence make different numbers of responses. For this reason, our work aims to address this third discrepancy among devices caused by individual availability patterns. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The third device heterogeneity caused by different availability patterns is less studied in optimization for federated learning problems. In this model, instead of making a delayed response, devices can abort the training halfway, e.g., due to battery level, incoming calls, etc, and fail to return their responses upon the central server’s requests [28, 7, 17]. To handle missing responses, researchers propose algorithms where the central server may collect responses from only a fraction of the devices and make updates [18, 28, 42, 25, 26, 17, 30, 14]. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Previous works on collecting responses from a fraction of devices can be divided into two categories. When the response distribution is known, one could collect only the fastest responses and re-weight according to their response probability [17, 26, 30]. This model can be restrictive, as in practice, the exact distribution may not be available and may evolve. Another line of work assumes that the server can arbitrarily decide and sample a set of devices to collect responses accordingly in every communication round [18, 28, 42, 25, 14]. This model does not require knowing the response possibility. However, the response time can be very long if the selected subset contains unavailable devices. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we address the above limitations by studying federated learning in the presence of arbitrary device unavailability. Within this practical setup, we propose an algorithm that automatically accommodates for the underlying unavailability and allows patterns of the device unavailability to be non-stationary and even adversarial. Furthermore, our algorithm can achieve optimal convergence rates in the presence of device inactivity and automatically reduce to best-known rates if all devices are active. Our contributions are summarized as follows. ",
+        "bbox": [
+            176,
+            428,
+            825,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We investigate the federated learning problem with a practical formulation of device participation, which does not require each device to be online according to an (either known or unknown) distribution. • We propose the Memory-augmented Impatient Federated Averaging (MIFA) algorithm that is agnostic to the availability pattern. It efficiently avoids excessive latency induced by inactive devices, successfully exploits the information about the descent direction in stale and noisy gradients, and corrects the gradient bias using the memorized latest updates. • We prove that MIFA achieves minimax optimal convergence rates $\\begin{array} { r } { \\mathcal { O } \\left( \\frac { \\bar { \\tau } _ { T } + 1 } { N K T } \\right) } \\end{array}$ for smooth, strongly convex functions, and $\\mathcal { O } \\left( \\sqrt { \\frac { \\bar { \\nu } + 1 } { N K T } } \\right)$ for smooth, non-convex functions, and establish matching lower bounds. Here, $N , K$ and $T$ stand for the number of devices, local updates and communication rounds respectively. $\\bar { \\tau } _ { T }$ and $\\bar { \\nu }$ characterize how actively devices participate in training (see formal definitions in Sections 3, 5 and 6). MIFA also achieves optimal convergence rates in the ideal case when all devices are active. • We provide an explicit characterization of the improvement over baseline algorithms through a case study and empirically verify our results on real-world datasets. ",
+        "bbox": [
+            217,
+            523,
+            825,
+            758
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            318,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Federated learning. Federated Averaging (FedAvg) was first proposed in [28]. [26, 19, 18, 42] provided convergence analysis for FedAvg on non-i.i.d. data and quantified how data heterogeneity degrades the convergence rate. Several variants of FedAvg were designed to deal with data heterogeneity. FedProx [25] adds a proximal term to local objective functions, while FSVRG [21] and SCAFFOLD [18] employ variance reduction techniques. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One line of work focused on variations in computation capabilities among devices [39, 31, 40]. These models assume that responses are delayed but not missing. To address the missing response, some work assumes that the server can actively sample a subset of devices to respond [18, 28, 42, 25, 14] or that the pattern of device availability is known [26, 17, 10, 30]. These results do not generalize to adversarial inactive patterns. [32] discussed the impact of device inactivity on convergence but their proposed algorithm diverges if there exists an inactive device in each round of communication. However, our setup allows adversarial patterns under certain non-distributional assumptions (see Section 5) while our proposed algorithm still achieves convergence. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Asynchronous distributed optimization. Our work is related to literature in the field of traditional asynchronous distributed optimization in that our proposed algorithm uses stale gradients. The problem setup for asynchronous distributed algorithms can be divided into two categories [13]. One is the shared-data (i.i.d.) setting, where all workers can access the whole dataset. In this setting, the local gradient is an unbiased estimator of the global gradient [35, 4, 27, 11, 45, 1]. In contrast, we assume each worker has non-i.i.d. data, and hence the local stochastic gradient can not be viewed as an unbiased estimator of the global gradient. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            289
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The other less studied setting in distributed optimization is the distributed-data setting (non-i.i.d.), where data are partitioned among workers. Specifically, [5] proposed an asynchronous incremental aggregated gradient algorithm that uses buffered gradients to update the global model. Unlike our setup, this algorithm evaluates full local gradients, performs only one local step, and was analyzed under the bounded delay assumption. [13] models the delay as stochastic and assumes that the server has knowledge of the distribution, but our formulation is distribution-free. [6] allows workers to perform multiple local steps and communicate with the server at different times, but the authors assume that all workers are available and compute at the same rate. ",
+        "bbox": [
+            173,
+            294,
+            825,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Comparison with an independent work. While preparing the manuscript, we were unaware of an independent work [41] that investigated the same setup and proposed a similar algorithm called FedLaAvg. Their main theorem established the convergence rate of $\\mathcal { O } \\left( \\sqrt { \\frac { \\nu _ { \\mathrm { m a x } } } { N ^ { 0 . 5 } T } } ( \\mathbf { \\bar { G } } ^ { 2 } + \\sigma ^ { 2 } ) \\right)$ for smooth and non-convex problems, where $G ^ { 2 }$ is the uniform upper bound for the squared norm of stochastic gradients and $\\nu _ { m a x }$ is the maximum number of inactive rounds. In comparison, we prove the minimax optimal rate of $\\mathcal { O } ( \\sqrt { \\frac { \\bar { \\nu } } { N K T } } \\sigma ^ { 2 } )$ without the bounded gradient assumption, also improving $\\nu _ { \\mathrm { m a x } }$ to $\\bar { \\nu }$ . Furthermore, our result achieves a linear speedup in $N$ and $K$ . ",
+        "bbox": [
+            173,
+            421,
+            825,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Apart from non-convex functions, we also derive the minimax optimal rates for strongly convex smooth functions under the mild assumption that allows for arbitrary and unbounded number of inactive rounds. Both of our results achieve linear speedups in terms of $N$ and $K$ , and automatically recover the best-known rates of FedAvg when all devices are active. We also show that our proposed algorithm achieves acceleration over unbiased baseline algorithms in the presence of stragglers. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            607
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Problem Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            330,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider optimizing the following problem in a Federated Learning setting: ",
+        "bbox": [
+            174,
+            660,
+            691,
+            675
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22f078ec690bdea95bad0a3810ee899d3c05899a7210597c3a542826721eabc9.jpg",
+        "text": "$$\n\\begin{array} { r } { \\underset { w \\in \\mathbb { R } ^ { d } } { \\operatorname* { m i n } } f ( w ) : = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } f _ { i } ( w ) : = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\mathbb { E } _ { \\xi _ { i } } [ f _ { i } ( w , \\xi _ { i } ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            683,
+            687,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $w$ is the optimization variable, e.g., parameters of a machine learning model, $N$ is the number of participating devices, $f _ { i }$ is the local loss function on device $i$ , and $\\xi _ { i }$ describes the randomness in local data distribution. ",
+        "bbox": [
+            176,
+            717,
+            825,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the ideal federated learning setup (see Figure 1 (a)), all devices return responses within similar time, and hence the central server collects all the local updates. In this case, the computation cost is usually measured by the number of local stochastic oracle evaluations, which is proportional to the number of rounds. In a delayed FL setup (see Figure 1 (b)), devices are always active upon the central server’s request but may return responses with a delay. Here, all devices return almost the same number of responses in the long term. ",
+        "bbox": [
+            173,
+            765,
+            825,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we discussed, the above setups do not depict a real-world scenario in which a device can have a longer inactive duration than active duration. In such cases, the communication interval is much longer than the local computation time required for each update, and each device generates an unequal number of responses [28, 17]. This motivates our setup in Figure 1 (c). ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/dbec5db87e22ee0dc55043253dc815eff5fd652c994f67ee8a04489f10ef06e1.jpg",
+        "image_caption": [
+            "Figure 1: An illustration of setup. (a) Ideal setup: all devices return their responses within similar time. (b) Delayed setup: all devices are available, but may return responses with a delay. (c) Our setup: devices can be unavailable arbitrarily, and the communication interval is long enough for active devices to return responses. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            82,
+            823,
+            233
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our proposed setup, we use $t$ to index the global communication rounds. We say a device participates or is active at round $t$ if it can complete the computation task and send back the update at the end of round $t$ . We define $\\boldsymbol { \\mathcal { A } } ( t )$ as the set of all active devices at round $t$ . Notice that we make no assumptions on the distribution of the participation patterns of devices and allow them to be arbitrary. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Directly applying FedAvg to the proposed setup can be problematic due to the existence of inactive devices. To accommodate for inactive devices, we discuss three natural variants of FedAvg and their limitations. The detailed algorithms can be found in Appendix A. ",
+        "bbox": [
+            176,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Biased FedAvg. At each communication round, the global model is updated with a direct average of local updates from the active devices. This naive approach induces bias when data distribution and response patterns vary among devices.   \n• FedAvg with device sampling. The server selects a subset of $S$ devices randomly without replacement, and then waits until all devices in the subset $s$ respond. This is how original FedAvg [28] addresses device unavailability. Note that over $T$ communication rounds, the global model is updated less than $T$ times due to waiting. This approach is prone to stragglers and we refer the readers to Section 5.1 for a detailed discussion.   \n• FedAvg with importance sampling [26, 13, 17]. The local updates from the active devices are weighted by the reciprocal of the participation probabilities to avoid bias. This approach is only applicable when the response of each device is i.i.d. over rounds and it requires the knowledge of participation probabilities. ",
+        "bbox": [
+            217,
+            417,
+            825,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Memory-augmented Impatient Federated Averaging (MIFA) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            709,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce our algorithm — Memory-augmented Impatient Federated Averaging (MIFA). MIFA maintains an update-array $\\{ G ^ { i } \\}$ in the memory that stores the latest updates for all devices. As the name suggests, MIFA has two components. First, the algorithm is impatient and avoids waiting for any specific device when facing heterogeneous devices with arbitrary availability. Second, the algorithm augments the received updates of the active devices with the stored updates of the inactive devices to perform averaging. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Specifically, at the beginning of round $t$ , the server broadcasts the latest model parameter $w _ { t }$ to all active devices $\\boldsymbol { \\mathcal { A } } ( t )$ . After receiving $w _ { t }$ , each active device, say, the $i$ -th device, sets $w _ { t , 0 } ^ { i } = w _ { t }$ and performs $K$ steps of SGD with respect to the local objective function to get $w _ { t , K } ^ { i }$ : ",
+        "bbox": [
+            174,
+            743,
+            825,
+            789
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c0127a5706cf7944f95df9680a24f67da0062cc0709e170f05907f9d6d3a845.jpg",
+        "text": "$$\n\\boldsymbol w _ { t , k + 1 } ^ { i } = \\boldsymbol w _ { t , k } ^ { i } - \\eta _ { t } \\tilde { \\nabla } f _ { i } ( \\boldsymbol w _ { t , k } ^ { i } ) , \\boldsymbol k = 0 , \\cdots , \\boldsymbol K - 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            799,
+            666,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta _ { t }$ is the learning rate and $\\tilde { \\nabla } f _ { i } ( w _ { t , k } ^ { i } )$ is the stochastic gradient evaluated on device $i$ . Next, the server stores the received update $\\begin{array} { r } { \\frac { 1 } { \\eta _ { t } } \\big ( w _ { t } - w _ { t , K } ^ { i } \\big ) } \\end{array}$ in $G ^ { i }$ . Denote by $\\{ G _ { t } ^ { i } \\}$ the update-array after round $t$ , then we have ",
+        "bbox": [
+            173,
+            830,
+            826,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72c964c9acb692ffa258397e5523d41c405bf9354c410c37349066a92c8e4d6d.jpg",
+        "text": "$$\n\\begin{array} { r } { G _ { t } ^ { i } = \\left\\{ \\begin{array} { l l } { G _ { t - 1 } ^ { i } , } & { \\mathrm { ~ i f ~ } i \\notin \\mathcal { A } ( t ) , } \\\\ { \\frac { 1 } { \\eta _ { t } } ( w _ { t } - w _ { t , K } ^ { i } ) , } & { \\mathrm { ~ i f ~ } i \\in \\mathcal { A } ( t ) . } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            880,
+            627,
+            916
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At the end of round $t$ , the server updates the global model with the average of $\\{ G _ { t } ^ { i } \\}$ (line 9). In other words, our algorithm MIFA updates the model with the latest available accumulated gradients for all devices. ",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/5471198ff0b654b45b8a140b5c46c5f6e75ff5794c1529023b59736618813d80.jpg",
+        "table_caption": [
+            "Algorithm 1 Memory-augmented Impatient Federated Averaging (MIFA) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">1: Input: initial wi,learning rate {nt }</td></tr><tr><td>2: Server executes:</td><td>1: DeviceUpdate(i, Wt , nt):</td></tr><tr><td>3: initialize Gi ←O,i∈[N]</td><td>2:w,←Wt</td></tr><tr><td>4: fort=1,.,T-1do</td><td>3: for local step k = O,.,K -1 do</td></tr><tr><td>5: broadcast wt to all active devices i ∈ A(t)</td><td> 4:compute stochastic gradient Vfi(wt,)</td></tr><tr><td>6: for each active device ido</td><td>Wk+1←W,k-ntvfi(w，） 5:</td></tr><tr><td>7: G ←DeviceUpdate(i,Wt, nt) 8: end for</td><td>6: end for</td></tr><tr><td>Wt+1←wt-∑1 N 9: Gi</td><td>7:Return (wt - wi,k) to the server</td></tr></table>",
+        "bbox": [
+            178,
+            164,
+            810,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "MIFA efficiently progresses without waiting for inactive devices and re-uses their latest updates as the surrogate for missing responses. Being impatient accelerates convergence, whereas memory augmentation corrects the update bias. Our algorithm differs from asynchronous algorithms in traditional distributed optimization [35, 4, 27, 11, 45, 1, 13, 6] in that we utilize the noisy updates of inactive devices more than once to avoid biasing against stragglers. In the following part of the paper, we show that MIFA successfully exploits information about the descent direction contained in the stale and noisy gradients. ",
+        "bbox": [
+            173,
+            320,
+            825,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Discussion on implementation. In practice, to implement MIFA, the server needs to maintain a huge array to store the latest update for each device, which scales with the model size and the total number of devices. To avoid exhausting the server’s memory, one strategy is to distribute the memory consumption among devices. Specifically, each device, say the $i$ -th, stores its previous update $G _ { t _ { i } ^ { \\prime } } ^ { \\ i }$ computed at round $t _ { i } ^ { \\prime }$ in its local memory. When it becomes active and computes $G _ { t } ^ { i }$ , the device sends $G _ { t } ^ { i } - G _ { t _ { i } ^ { \\prime } } ^ { i }$ to the server, which is the difference between the current update and the previous one. In this case, the server only needs to maintain the average $\\bar { G }$ in the memory and updates it by $\\begin{array} { r } { \\bar { G } _ { t } = \\bar { G } _ { t - 1 } + \\frac { 1 } { N } \\sum _ { i \\in \\mathcal { A } ( t ) } ( G _ { t } ^ { \\bar { i } } - G _ { t _ { i } ^ { \\prime } } ^ { i } ) } \\end{array}$ at round $t$ . Then the server updates the global model by $w _ { t + 1 } = w _ { t } - \\eta _ { t } \\bar { G } _ { t }$ . ",
+        "bbox": [
+            173,
+            422,
+            825,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 Convergence Analysis for strongly convex objective functions ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            582,
+            714,
+            599
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the convergence results for MIFA on $\\mu$ -strongly convex $L$ -smooth functions. Typical examples for the strongly convex case are $\\ell _ { 2 }$ regularized logistic regression and linear regression problems. ",
+        "bbox": [
+            173,
+            613,
+            826,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to capture how the unavailability of devices affects algorithm performance, we introduce the following notion to quantify the dynamics of devices in our setting. ",
+        "bbox": [
+            173,
+            660,
+            823,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 5.1 (Number of inactive rounds). We define the number of inactive rounds of device $i$ at round $t$ as $\\tau ( t , i ) = t - \\operatorname* { m a x } \\{ t ^ { \\prime } \\mid t ^ { \\prime } \\leq t , i \\in A ( t ^ { \\prime } ) \\}$ , which is the difference between current round $t$ and the latest round when device $i$ is active. ",
+        "bbox": [
+            174,
+            693,
+            826,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It can be seen that $\\tau ( t , i ) = 0$ if device $i$ is active at round $t$ and $\\tau ( t , i ) = \\tau ( t - 1 , i ) + 1$ otherwise. Also, $t - \\tau ( t , i )$ is the latest round when the device $i$ is active. Next, we present the assumptions made for establishing our convergence theorem. ",
+        "bbox": [
+            173,
+            746,
+            826,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1. $f _ { 1 } , \\cdots , f _ { N }$ are all $L$ -smooth, i.e., for all $w$ and $v _ { \\scriptscriptstyle { i } }$ , $\\begin{array} { r c l } { f _ { i } ( v ) } & { \\leq } & { f _ { i } ( w ) \\ + } \\end{array}$ $\\begin{array} { r } { \\left. \\nabla f _ { i } ( w ) , v - w \\right. + \\frac { L } { 2 } \\left\\| w - v \\right\\| ^ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            791,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2. $\\tilde { \\nabla } f _ { i } ( \\boldsymbol { w } )$ is an unbiased estimator of $\\nabla f _ { i }$ with variance bounded by $\\sigma ^ { 2 }$ , i.e., $\\mathbb { E } _ { \\boldsymbol { \\xi } } \\left[ \\tilde { \\nabla } f _ { i } ( \\boldsymbol { w } ) \\right] = \\nabla f _ { i } ( \\boldsymbol { w } ) , \\mathbb { E } _ { \\boldsymbol { \\xi } } \\left[ \\left\\| \\tilde { \\nabla } f _ { i } ( \\boldsymbol { w } ) - \\nabla f _ { i } ( \\boldsymbol { w } ) \\right\\| ^ { 2 } \\right] \\leq \\sigma ^ { 2 } .$ . ",
+        "bbox": [
+            173,
+            829,
+            826,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3. $f _ { 1 } , \\cdots , f _ { N }$ are all $\\mu$ -strongly convex: for all $w$ and $v _ { \\scriptscriptstyle { i } }$ , $f _ { i } ( v ) \\geq f _ { i } ( w ) +$ $\\begin{array} { r } { \\left. \\nabla f _ { i } ( w ) , v - w \\right. + \\frac { \\mu } { 2 } \\left\\| w - v \\right\\| ^ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            880,
+            826,
+            914
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 4. There exists a constant $t _ { 0 } > 0$ , such that for all $t \\geq 1$ and $i \\in [ N ]$ , the number of inactive rounds of device $i$ at communication round $t$ satisfies $\\begin{array} { r } { \\tau ( t , i ) \\leq t _ { 0 } + \\frac { 1 } { b } \\dot { t } } \\end{array}$ , where $b =$ $4 0 \\left( L / \\mu \\right) ^ { 1 . 5 }$ . ",
+        "bbox": [
+            173,
+            90,
+            825,
+            137
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumptions 1, 2, and 3 are standard and common in the FL literature, e.g., [26, 18, 19, 42, 36]. In Assumption 2, we relax the bounded gradient assumption that is often required in prior work, e.g., [6, 26, 40, 1]. Lastly, Assumption 4 is a very mild assumption on device availability, since it allows the number of inactive rounds to grow as ${ \\mathcal { O } } ( t )$ . In contrast, existing results on asynchronous updates mostly assume a bounded or fixed latency, e.g., [6, 1, 5, 40, 35, 4]. ",
+        "bbox": [
+            173,
+            146,
+            826,
+            217
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We are now ready to present our first convergence result. Define $\\begin{array} { r l } { D = } & { { } \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\left. \\nabla f _ { i } ( w _ { * } ) \\right. ^ { 2 } } \\end{array}$ to measure data dissimilarity, where $w _ { * } = \\arg \\operatorname* { m i n } f ( w )$ is the global optimum. Also, define $\\bar { \\tau } _ { T }$ and $\\tau _ { \\operatorname* { m a x } , T }$ to be the average and maximum numbers of inactive rounds $\\tau ( t , i )$ across all devices and rounds, respectively. That is, ",
+        "bbox": [
+            173,
+            222,
+            826,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/733c5805d202f72a1df49e8a211f10a98cbaf3e0246f5f2ede823112da4e143c.jpg",
+        "text": "$$\n\\bar { \\tau } _ { T } = \\frac { 1 } { N ( T - 1 ) } \\sum _ { t = 1 } ^ { T - 1 } \\sum _ { i = 1 } ^ { N } \\tau ( t , i ) , \\tau _ { \\operatorname* { m a x } , T } = \\operatorname* { m a x } _ { i \\in [ N ] } \\operatorname* { m a x } _ { 1 \\leq t \\leq T - 1 } \\tau ( t , i ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            282,
+            717,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The following theorem summarizes the performance of MIFA in this case. ",
+        "bbox": [
+            174,
+            335,
+            655,
+            351
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.1. Assume that Assumptions $^ { l }$ to 3 hold. Further assume that the device availability sequence $\\tau ( t , i )$ satisfies Assumption $^ { 4 }$ and $\\tau ( 1 , i ) = 0$ for all $i \\in [ N ]$ . By setting the learning rate $\\begin{array} { r } { \\eta _ { t } = \\frac { 4 } { \\mu K ( t + a ) } } \\end{array}$ with $a = \\operatorname* { m a x } \\{ 1 0 0 , 4 0 t _ { 0 } \\} ( L / \\mu ) ^ { 1 . 5 }$ , after $T - 1$ communication rounds, MIFA satisfies: ",
+        "bbox": [
+            173,
+            352,
+            825,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a586eb10027a5e2bde1e4b791106324315628fa6d12e02e2e3e3c1ae021cee54.jpg",
+        "text": "$$\n\\mathbb { E } _ { \\xi } \\left[ f ( \\overline { { w } } _ { T } ) \\right] - f ( w _ { * } ) = \\mathcal { O } \\left( \\frac { \\bar { \\tau } _ { T } + 1 } { \\mu N K T } \\sigma ^ { 2 } + \\frac { \\tau _ { \\operatorname* { m a x } , T } ^ { 2 } A _ { 1 } + ( K - 1 ) ^ { 2 } A _ { 2 } + A _ { 3 } } { \\mu ^ { 2 } T ^ { 2 } } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            412,
+            754,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\overline { { w } } _ { T }$ is a weighted average of $w _ { t }$ defined as: ",
+        "bbox": [
+            173,
+            463,
+            501,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/467ef08efd364fd1d849ca3dc16aa8bd25b2ad4ef2f4136b25ee850e32438dab.jpg",
+        "text": "$$\n\\overline { { w } } _ { T } = \\frac { 1 } { W _ { T } } \\sum _ { t = 1 } ^ { T } ( t + a - 1 ) ( t + a - 2 ) w _ { t } , W _ { T } = \\sum _ { t = 1 } ^ { T } ( t + a - 1 ) ( t + a - 2 ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            481,
+            751,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our results hold under Assumption 4, which allows for arbitrary device availability sequences with $\\tau _ { \\mathrm { m a x } , T } = \\mathcal { O } ( T )$ . However, for MIFA to converge, we require $\\tau _ { \\operatorname* { m a x } , T } = o ( T )$ and $\\dot { t _ { 0 } } = \\bar { o } ( T )$ . When ( NK(τ2max,T +t20)τ¯+1 ), the first term dominates and the impact of the second O(1/T 2) term is negligible. In fact the first term in Theorem 5.1 is minimax optimal by our information-theoretic lower bound for the problem in the next proposition. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proposition 5.1. Let $c _ { 0 } > 0$ be a universal constant. For any potentially randomized algorithm, there exists a stochastic strongly convex problem satisfying Assumptions $^ { l }$ to 3, such that the output $w _ { T }$ after $T$ rounds of communication has expected sub-optimality lower bounded by ",
+        "bbox": [
+            173,
+            640,
+            823,
+            683
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15944ea925ca625bc0c3fb0cf5ed413d2deb8aa7ced28f61f9ba449d3ce641aa.jpg",
+        "text": "$$\n\\mathbb { E } [ f ( w _ { T } ) - f ( w ^ { * } ) ] \\geq c _ { 0 } \\frac { \\bar { \\tau } _ { T } \\sigma ^ { 2 } } { \\mu N K T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            685,
+            611,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proof is based on the observation that the number of gradient evaluation can scale inversely with $\\bar { \\tau } _ { T }$ and that the oracle complexity is tight even for centralized stochastic optimization problems. The optimality of the first term in Theorem 5.1 is independent of the distributed or the FL setup. ",
+        "bbox": [
+            174,
+            727,
+            823,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The second term in Theorem 5.1 converges at the rate $\\mathcal { O } ( 1 / T ^ { 2 } )$ and consists of three parts, where the first part reflects the slowdown caused by device unavailability through $\\tau _ { \\operatorname* { m a x } , T }$ , the second part shows the effect of multiple $( K > 1 )$ ) local steps, and the third part tells how the initial error decreases. ",
+        "bbox": [
+            173,
+            775,
+            826,
+            818
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 5.1. When $\\tau ( t , i ) ~ = ~ 0$ for all $i$ and $t _ { : }$ , our setup reduces to FedAvg with full device pbound $\\bar { \\tau } _ { T } ~ = ~ 0$ d  , $\\tau _ { \\mathrm { m a x } , T } ~ = ~ 0$ . Iate $\\begin{array} { r } { \\mathcal { O } \\left( \\frac { \\sigma ^ { 2 } } { \\mu K N T } + \\frac { L ( \\sigma ^ { 2 } / K + D + L ^ { 2 } \\| w _ { 1 } - w _ { * } \\| ^ { 2 } ) } { \\mu ^ { 2 } T ^ { 2 } } \\right) } \\end{array}$ $\\begin{array} { r } { \\mathcal { O } \\bigg ( \\frac { \\sigma ^ { 2 } \\log T } { \\mu K N T } + \\frac { L ( \\sigma ^ { 2 } / K + D ) ( \\log T ) ^ { 2 } } { \\mu ^ { 2 } T ^ { 2 } } + } \\end{array}$ $\\begin{array} { r } { \\mu \\left. w _ { 1 } - w _ { * } \\right. ^ { 2 } \\exp ( - \\frac { \\mu } { 4 8 L } T ) \\Bigr ) } \\end{array}$ in [18] (Thm. V. $B ^ { 2 } = 2 , \\eta _ { g } = 1 ,$ ) up to logarithmic terms. Besides, in the general case, our $\\mathcal { O } ( \\tau _ { \\mathrm { m a x } , T } ^ { 2 } A _ { 1 } / T ^ { 2 } )$ term matches the last term in $I 6 J \\left( C o r . 5 \\right)$ . ",
+        "bbox": [
+            173,
+            819,
+            826,
+            915
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 5.2. Our analysis relies on the technical assumption that all devices respond in the first round. Intuitively, this is because we need at least one valid stochastic gradient evaluation for each device to get a complete picture of the global objective, or otherwise any update would be biased. In practice, this can be achieved by waiting for the updates from all devices on $w _ { 1 }$ at the very beginning. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Case Study: i.i.d. Bernoulli participation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            164,
+            498,
+            180
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Though our algorithm can be applied to non-stationary and non-independent response patterns, we show in this subsection that even in the simple i.i.d. Bernoulli participation scenario our algorithm can achieve considerable improvement compared to known algorithms. In particular, we consider a setup where each device becomes active independently with a fixed probability $p _ { i }$ . It serves as the first motivating example towards modeling the participation patterns of devices, and provides a clean view of how the heterogeneity of the device participation influences the Federated optimization algorithms. ",
+        "bbox": [
+            173,
+            189,
+            825,
+            287
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We will show that in this scenario, Assumption 4 holds with high probability, and the terms involving the inactive rounds $\\tau ( t , i )$ in Theorem 5.1 can also be bounded. Furthermore, we theoretically demonstrate that algorithms such as FedAvg [28] and SCAFFOLD [18], which sample $S$ devices for each global update, are more prone to stragglers than our algorithm. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            349
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Definition 5.2. Assume that for all $i \\in [ N ]$ , the i-th device is assigned with a probability $p _ { i }$ . We say the participation of the devices follows i.i.d. Bernoulli participation model with participation probabilities $\\{ p _ { i } \\}$ , if (1). at the first round, all devices are active, and (2). at round $t > 1$ , device $i$ is active with probability $p _ { i }$ , which is independent of the history and other devices. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next theorem shows that under i.i.d. Bernoulli participation scenario, with high probability, $\\tau ( t , i )$ only grows logarithmically in $t$ . Also Assumption 4 holds for a mild choice of $t _ { 0 }$ . ",
+        "bbox": [
+            174,
+            420,
+            821,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.2. For i.i.d. Bernoulli participation model defined in Definition 5.2, given any $\\delta > 0$ , with probability at least $1 - \\delta$ , we have the following holds for all $t \\geq 1$ and $i \\in [ N ]$ simultaneously, ",
+        "bbox": [
+            171,
+            454,
+            825,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/39aa0a52372df38b6d9e71e222db332e84efa7cdb81235ae00a0fb9752de5e1b.jpg",
+        "text": "$$\n\\tau ( t , i ) \\leq \\mathcal { O } \\Big ( \\frac { 1 } { p _ { i } } ( \\log ( N t / \\delta ) + 1 ) \\Big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            489,
+            614,
+            522
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, $( l )$ . Assumption $^ { 4 }$ holds true $\\begin{array} { r } { \\mathrm { \\ddot { \\it f } } t _ { 0 } = \\Omega \\bigg ( \\frac { 1 } { p _ { m i n } } \\log \\frac { b N } { p _ { m i n } \\delta } \\bigg ) } \\end{array}$ , where $p _ { m i n } = \\operatorname* { m i n } \\{ p _ { i } \\}$ , and $b = 4 0 ( L / \\mu ) ^ { 1 . 5 }$ ;(2). $\\tau _ { \\operatorname* { m a x } , T }$ can be upper bounded as ",
+        "bbox": [
+            173,
+            530,
+            825,
+            570
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/922e99211cb7c2d1fd2b59ad614767b49e2270e68185e6f77ea7f51093a5ac80.jpg",
+        "text": "$$\n\\tau _ { \\operatorname* { m a x } , T } \\leq \\mathcal { O } \\Big ( \\frac { 1 } { p _ { m i n } } \\cdot \\big ( \\log ( T N / \\delta ) + 1 \\big ) \\Big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            577,
+            637,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The next theorem provides a high probability upper bound for $\\bar { \\tau } _ { T }$ . ",
+        "bbox": [
+            173,
+            622,
+            606,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.3. For i.i.d. Bernoulli participation model defined in Definition 5.2, given any $\\delta > 0$ and $T > 1$ , with probability at least $1 - \\delta$ , we have ",
+        "bbox": [
+            173,
+            642,
+            825,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79e3a5996cb3f7b4c46ca91911907e624b79420e705c6142b9338d5386fc6e5b.jpg",
+        "text": "$$\n\\bar { \\tau } _ { T } \\leq \\Big ( \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\frac { 1 } { p _ { i } } \\Big ) \\cdot \\mathcal { O } \\Big ( 1 + \\log \\frac { 1 } { \\delta } \\Big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            678,
+            619,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "By Theorem 5.2 and Theorem 5.3, we conclude that the dominant term of our convergence bound is $\\begin{array} { r } { \\stackrel { \\triangledown } { \\mathcal { O } } \\left( \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\frac { 1 } { p _ { i } } \\cdot \\frac { \\sigma ^ { 2 } } { \\mu N K T } \\right) } \\end{array}$ . Therefore, to achieve $\\epsilon$ accuracy, the dominant term of the number of the required rounds is ",
+        "bbox": [
+            173,
+            734,
+            825,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d6f389bee97e0f3555558010eb2588b9917d901810a517b05b4f4f415bf814cb.jpg",
+        "text": "$$\nT _ { \\epsilon } ^ { \\left( \\mathrm { M I F A } \\right) } = \\widetilde { \\mathcal { O } } \\Bigl ( \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\frac { 1 } { p _ { i } } \\cdot \\frac { \\sigma ^ { 2 } } { \\mu N K \\epsilon } \\Bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            785,
+            617,
+            828
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For both FedAvg and SCAFFOLD that sample $S$ devices uniformly at random, [18] (Thm I. & III.) showed that the dominant term of the number of global updates needed to achieve $\\epsilon$ accuracy is $\\begin{array} { r } { R _ { \\epsilon } = \\widetilde { \\mathcal { O } } \\left( \\frac { \\sigma ^ { 2 } } { \\mu S K \\epsilon } \\right) } \\end{array}$ . Notice that in our setting, to accomplish each global update, the server needs to wait for a few rounds for the $S$ devices to respond. Let $T ( S )$ be the expected rounds for which the server needs to wait for the selected devices $\\boldsymbol { S }$ to be active. Then the expected total rounds to achieve $\\epsilon$ accuracy is $R _ { \\epsilon } \\cdot \\mathbb { E } _ { S } \\left[ T ( S ) \\right]$ . For i.i.d. Bernoulli participation model, we have $\\begin{array} { r } { T ( S ) \\geq \\frac { 1 } { \\operatorname* { m i n } \\{ p _ { i } | i \\in S \\} } } \\end{array}$ , and we can further show that $\\begin{array} { r } { \\mathbb { E } _ { S } \\left[ T ( S ) \\right] \\ge \\frac { 1 } { p _ { m i n } } \\frac { S } { N } } \\end{array}$ ≥ 1p min SN ( see Appendix D.3 for details). Therefore, ",
+        "bbox": [
+            173,
+            830,
+            825,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            89,
+            828,
+            128
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ba801327622edadc3d535bd6d82d30aa8d7d969b43ccdf1e9db7ea55271f48d.jpg",
+        "text": "$$\n\\mathbb { E } \\left[ T _ { \\epsilon } ^ { ( \\mathsf { F e d A v g , S C A F F O L D } ) } \\right] \\geq \\frac { S } { N } \\frac { 1 } { p _ { m i n } } \\widetilde { \\mathcal { O } } \\Big ( \\frac { \\sigma ^ { 2 } } { \\mu S K \\epsilon } \\Big ) = \\widetilde { \\mathcal { O } } \\Big ( \\frac { 1 } { p _ { m i n } } \\cdot \\frac { \\sigma ^ { 2 } } { \\mu N K \\epsilon } \\Big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            130,
+            728,
+            164
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "By comparing Eqn. 2 and Eqn. 3, we see that both FedAvg and SCAFFOLD are more vulnerable to stragglers, that is, the devices with very small participation probabilities; on the contrary, the convergence rate of MIFA only depends on the average of $1 / p _ { i }$ instead of $1 / p _ { m i n }$ . We also provide empirical experiments showing that MIFA converges faster than FedAvg in Section 7. ",
+        "bbox": [
+            173,
+            165,
+            825,
+            222
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Convergence result for non-convex objective functions ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            238,
+            656,
+            256
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the convergence guarantee of MIFA for the non-convex case. First we list the additional assumptions as below. ",
+        "bbox": [
+            173,
+            268,
+            823,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Assumption 5 (Hessian Lipschitz). $f _ { 1 } , \\cdots , f _ { N }$ are all $\\rho$ -Hessian Lipschitz: for all $w$ and $v$ $\\bigl \\| \\nabla ^ { 2 } f _ { i } \\bigl ( \\tilde { \\boldsymbol { w } } \\bigr ) - \\nabla ^ { 2 } f _ { i } ( \\boldsymbol { v } ) \\bigr \\| \\leq \\dot { \\rho } \\bigl \\| \\boldsymbol { w } - \\boldsymbol { \\tilde { v } } \\bigr \\|$ . ",
+        "bbox": [
+            176,
+            299,
+            825,
+            329
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Assumption 6 (Bounded noise). The noise of the local stochastic gradients is upper bounded by $a$ constant $\\delta$ almost surely: $\\begin{array} { r } { \\left\\| \\tilde { \\nabla } f _ { i } ( w ) - \\nabla f _ { i } ( w ) \\right\\| \\le \\delta a . s . , \\forall i \\in [ N ] } \\end{array}$ . ",
+        "bbox": [
+            173,
+            330,
+            823,
+            368
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Assand y). There exist . Furthermore, $\\alpha > 0$ anfine $\\beta _ { i } > 0$ at for all . $w$ $\\in [ N ] \\colon \\left\\| \\nabla f _ { i } ( w ) \\right\\| ^ { 2 } \\leq \\alpha \\left\\| \\nabla f ( w ) \\right\\| ^ { 2 } + \\beta _ { i }$ $\\begin{array} { r } { \\beta = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\beta _ { i } } \\end{array}$ ",
+        "bbox": [
+            173,
+            369,
+            823,
+            402
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Assumption 8. There exists a constant $\\nu _ { i }$ such that $\\tau ( t , i ) \\ \\leq \\ \\nu _ { i }$ , for all $i \\in [ N ]$ and $t \\geq 1$ Furthermore, define ν¯ = 1N PNi=1 νi and νmax = maxi∈[N] νi. ",
+        "bbox": [
+            173,
+            404,
+            821,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The analysis of non-convex functions is much more technically involved, and our results rely on strong assumptions that provide a finer control of the gradient difference (Assumption 5), gradient noise (Assumption 6), gradient dissimilarity among devices (Assumption 7), and device unavailability (Assumption 8). We remark that Assumption 5 is also made in [9, 16], and Assumption 7 is also made in [18, 39]. We leave it as future work to study whether and how MIFA converges for non-convex functions with weaker assumptions. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 6.1. Assume that Assumptions $I , ~ 2 , ~$ , and $^ { 5 }$ to 7 hold. Further assume that the device availability sequence $\\tau ( t , i )$ satisfies Assumption 8 and $\\tau ( 1 , i ) = 0$ for all $i \\in [ N ]$ . By using $a$ learning rate η = q $\\begin{array} { r } { \\eta = \\sqrt { \\frac { N } { K T L \\left( 1 + \\bar { \\nu } \\right) } } } \\end{array}$ NKT L(1+¯ν), for T ≥ max{32αLNK, 16LNK , 8KNν2max(L2+ρδ) }, after T − 1 communication rounds, MIFA satisfies: ",
+        "bbox": [
+            173,
+            529,
+            826,
+            594
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ffd78cf10bfd3d236632f49cd6b6cd64bc3d08d3e2f60866f445ed97510c80b.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { 1 \\leq t \\leq T } \\mathbb { E } _ { \\xi } \\left[ \\left\\| \\nabla f ( w _ { t } ) \\right\\| ^ { 2 } \\right] = \\mathcal { O } \\left( \\sqrt { \\frac { ( 1 + \\bar { \\nu } ) L } { T K N } } ( f ( w _ { 1 } ) - f ^ { * } + \\sigma ^ { 2 } ) + \\frac { A _ { 4 } + A _ { 5 } } { T } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            597,
+            759,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $f ^ { * }$ is the optimal value, and: ",
+        "bbox": [
+            174,
+            640,
+            406,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/068374b3ecfcb8e112e697b4b2961eec732c2ae914494131485a106df94ed394.jpg",
+        "text": "$$\n\\begin{array} { l } { { A _ { 4 } = N K L \\left( \\alpha \\sigma ^ { 2 } \\hat { \\nu } + \\frac { \\sigma ^ { 2 } \\nu _ { \\mathrm { m a x } } } { \\sqrt { K N } } + \\sigma \\nu _ { \\mathrm { m a x } } \\sqrt { \\beta } \\right) + \\frac { { ( L ^ { 2 } + \\rho \\delta ) \\sigma ^ { 2 } \\nu _ { \\mathrm { m a x } } } } { L } , } } \\\\ { { A _ { 5 } = \\frac { { ( K - 1 ) N L ( \\beta + \\sigma ^ { 2 } / K ) } } { \\hat { \\nu } + 1 } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            656,
+            727,
+            727
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, we show that the leading $\\mathcal { O } ( 1 / \\sqrt { T } )$ term is theoretically optimal for zero-respecting algorithms. ",
+        "bbox": [
+            171,
+            733,
+            825,
+            751
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Proposition 6.1. Let $c _ { 0 } > 0$ be a universal constant. For any randomized zero-respecting algorithm, there exists a stochastic non-convex problem satisfying Assumption1, 2, 5 and 7, such that the output $w _ { T }$ after $T$ rounds of communication has expected sub-optimality lower bounded by ",
+        "bbox": [
+            173,
+            752,
+            825,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca9299cdc027e71b6e299a9e1e31a7cd5c2809df369d439bba1b7aba2e00a1ef.jpg",
+        "text": "$$\n\\mathbb { E } [ \\| \\nabla f ( w _ { T } ) \\| ^ { 2 } ] \\ge \\mathbb { E } [ \\| \\nabla f ( w _ { T } ) \\| ] ^ { 2 } \\ge c _ { 0 } \\sqrt { \\frac { \\bar { \\nu } L \\sigma ^ { 2 } ( f ( w _ { 0 } ) - f ^ { * } ) } { N K T } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            796,
+            707,
+            830
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The above proposition show that when $\\sigma \\sqrt { ( f ( w _ { 0 } ) - f ^ { * } ) } \\sim \\sigma ^ { 2 } + ( f ( w _ { 0 } ) - f ^ { * } )$ , the result in Theorem 6.1 is tight. However, note that the counter example we used requires the quantity $\\delta$ in Assumption 6 to scale with $T$ , hence requiring $\\delta$ to be large enough. This does not change the optimality of the first term as the first term is independent of $\\delta$ . Whether this requirement can be relaxed is left as an open problem. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Remark 6.1. When all $\\nu _ { i } = 0$ (i.e. all the devices are active), our convergence bound reduces to $\\begin{array} { r } { \\mathcal { O } \\Big ( \\sqrt { \\frac { L } { T K N } } ( f ( w _ { 1 } ) - f ^ { * } + \\sigma ^ { 2 } ) + \\frac { ( K - 1 ) N L ( \\beta + \\sigma ^ { 2 } / K ) } { T } \\Big ) } \\end{array}$ . This matches the result in [42] (Thm. 1, $\\begin{array} { r } { \\eta = 1 , \\eta _ { L } = \\sqrt { \\frac { N } { K T L } } ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            90,
+            826,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Numerical Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            171,
+            405,
+            189
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct numerical experiments3. to verify our theoretical results and investigate how the heterogeneity of the device availability influences the Federated optimization algorithms. We compare the performance of the following four algorithms: FedAvg with importance sampling (FedAvg-IS), Biased FedAvg, FedAvg with device sampling, and our proposed MIFA. For the detailed discussions of the algorithms, we refer the readers to Sections 3 and 4. We remark that for a fair comparison, we deliberately include the first few rounds that MIFA needs to wait to receive responses from all devices for initializing the update-array $\\{ G ^ { i } \\}$ . ",
+        "bbox": [
+            173,
+            202,
+            825,
+            300
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Following [26, 25], we construct non-i.i.d. datasets from two commonly used computer vision datasets — MNIST [23] and CIFAR-10 [22] . Specifically, we divide the data into $N = 1 0 0$ devices with each device holding samples of only two classes, which creates a high level of data heterogeneity. For simplicity, we ensure that each device holds the same number of samples. We do not use any data augmentation. We use multinomial logistic regression as the convex model and LeNet-5 [24] with ReLU activations as the non-convex model. For all experiments, we use weight decay in the training process, which corresponds to adding $\\ell _ { 2 }$ penalty. We use logistic models for MNIST dataset, while we use LeNet-5 for CIFAR-10. Our code is adapted from [26], which is under MIT License. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We model the availability of the devices as independent Bernoulli random trials. The $i \\cdot$ -th device is assigned with a probability $p _ { i }$ , where at each time step, the device becomes active with probability $p _ { i }$ . In our experiments, the $p _ { i }$ ’s are chosen such that devices holding data of smaller labels participate less frequently. Specifically, if the $i$ -th device holds the data of label $j$ and $k$ , we set $\\bar { p } _ { i } = \\bar { p _ { \\operatorname* { m i n } } } \\operatorname* { m i n } ( j , k ) / 9 + \\bar { ( 1 - p _ { \\operatorname* { m i n } } ) }$ , where $p _ { \\mathrm { m i n } }$ controls the lower bound of the participation probabilities. The correlation between the participation patterns and local datasets increases the difficulty of the problem [17]. To investigate this phenomenon, we repeat the experiments for $p _ { \\mathrm { m i n } } = 0 . 1$ and 0.2. We control the randomness of device participation when testing different algorithms. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In all the experiments, we set the initial learning rate to be $\\eta _ { 0 } = 0 . 1$ and decay the learning rate as $\\begin{array} { r } { \\eta _ { t } = \\eta _ { 0 } \\cdot \\frac { 1 } { t } } \\end{array}$ . We set the weight decay to be 0.001. The local batch size is 100 and each local update consists of 2 epochs. Therefore, the actual number of local steps $K$ depends on the size of the dataset. We run all the experiments with 4 GPUs of type GeForce RTX 2080 Ti. We repeat the experiments for 5 different random seeds, and all of the experiments exhibit similar training curves. We report the averaged training loss and test accuracy with error bars in Figure 2. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            623
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We observe that FedAvg with device sampling (FedAvg ( $S = 5 0$ ) and FedAvg $S = 1 0 0$ ) in Figure 2) is severely influenced by the straggling devices and makes progress relatively slowly compared to the other algorithms. Although biased FedAvg converges fast at the beginning, this simple algorithm is biased, and the optimality gaps are prominent for the harder CIFAR-10 dataset and when $p _ { \\mathrm { m i n } }$ is small. On the contrary, our proposed MIFA avoids waiting for stragglers, converges fast without bias, and is competitive with FedAvg with importance sampling, which requires knowledge of the participation probabilities. We refer the readers to Appendix G for additional experiments on CIFAR-10. ",
+        "bbox": [
+            173,
+            628,
+            825,
+            727
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 Conclusions and Discussions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            444,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study FL algorithms in the presence of arbitrary device unavailability and propose MIFA, which avoids waiting for straggling devices and re-uses the memorized latest updates as the surrogate when the device is unavailable. We theoretically analyze MIFA without any structural assumptions on the device availability and prove the convergence for strongly convex and non-convex smooth functions. Different from the literature that studies oracle complexity in terms of stochastic gradient evaluations, we argue that in federated learning system, the bottleneck lies in the nonstationary and possibly adversarial pattern of device participation. Therefore, it is important to study how the number of inactive rounds influences the convergence rate. In Theorem 5.1, the dependency upon $\\tau _ { \\operatorname* { m a x } , T }$ might be an artifact of our analysis, and a future direction is to study whether we can remove this dependency. Another important direction is to analyze algorithms for non-convex functions under weaker assumptions. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1142e9ecbf7a3052e86380ac3f4c818747910b17c29f238aaf9134bafeb112a.jpg",
+        "image_caption": [
+            "Figure 2: Training losses and test accuracies. Fig. 2(a)–2(d): logistic models on non-iid MNIST. Fig. 2(e)–2(h): LeNet-5 on non-iid CIFAR-10. FedAvg $S = 5 0$ ) and FedAvg $S = 1 0 0$ ) refer to FedAvg with device sampling that samples $S$ devices for each global update. FedAvg-IS is short for FedAvg with importance sampling, which requires knowledge of the participation probabilities. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            80,
+            818,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            459,
+            553,
+            478
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The work of Xinran Gu and Longbo Huang is supported in part by the Technology and Innovation Major Project of the Ministry of Science and Technology of China under Grant 2020AAA0108400 and2020AAA0108403. Xinran Gu would like to thank Kaifeng Lyu for the discussion on the convergence analysis. The authors would like to thank Sai Praneeth Karimireddy for the discussion on the problem settings. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            560
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            580,
+            266,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Alekh Agarwal and John C Duchi. Distributed delayed stochastic optimization. In 2012 IEEE 51st IEEE Conference on Decision and Control (CDC), pages 5451–5452. IEEE, 2012.   \n[2] Alekh Agarwal, Martin J Wainwright, Peter Bartlett, and Pradeep Ravikumar. Informationtheoretic lower bounds on the oracle complexity of convex optimization. Advances in Neural Information Processing Systems, 22:1–9, 2009.   \n[3] Yossi Arjevani, Yair Carmon, John C. Duchi, Dylan J. Foster, Nathan Srebro, and Blake Woodworth. Lower bounds for non-convex stochastic optimization, 2019.   \n[4] Yossi Arjevani, Ohad Shamir, and Nathan Srebro. A tight convergence analysis for stochastic gradient descent with delayed updates. In Algorithmic Learning Theory, pages 111–132. PMLR, 2020.   \n[5] Arda Aytekin, Hamid Reza Feyzmahdavian, and Mikael Johansson. Analysis and implementation of an asynchronous optimization algorithm for the parameter server. arXiv preprint arXiv:1610.05507, 2016.   \n[6] Debraj Basu, Deepesh Data, Can Karakus, and Suhas Diggavi. Qsparse-local-sgd: Distributed sgd with quantization, sparsification, and local computations. arXiv preprint arXiv:1906.02367, 2019.   \n[7] Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloé Kiddon, Jakub Konecný, Stefano Mazzocchi, Brendan McMahan, Timon ˇ ",
+        "bbox": [
+            179,
+            603,
+            828,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Van Overveldt, David Petrou, Daniel Ramage, and Jason Roselander. Towards federated learning at scale: System design. In A. Talwalkar, V. Smith, and M. Zaharia, editors, Proceedings of Machine Learning and Systems, volume 1, pages 374–388, 2019. ",
+        "bbox": [
+            205,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[8] Sébastien Bubeck, Nicolo Cesa-Bianchi, and Gábor Lugosi. Bandits with heavy tail. IEEE Transactions on Information Theory, 59(11):7711–7717, 2013. ",
+        "bbox": [
+            179,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[9] Yair Carmon, John C Duchi, Oliver Hinder, and Aaron Sidford. Accelerated methods for nonconvex optimization. SIAM Journal on Optimization, 28(2):1751–1772, 2018. ",
+        "bbox": [
+            179,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[10] Hubert Eichner, Tomer Koren, Brendan McMahan, Nathan Srebro, and Kunal Talwar. Semicyclic stochastic gradient descent. In International Conference on Machine Learning, pages 1764–1773. PMLR, 2019. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[11] Hamid Reza Feyzmahdavian, Arda Aytekin, and Mikael Johansson. An asynchronous minibatch algorithm for regularized stochastic optimization. IEEE Transactions on Automatic Control, 61(12):3740–3754, 2016. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            309
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[12] Saeed Ghadimi and Guanghui Lan. Optimal stochastic approximation algorithms for strongly convex stochastic composite optimization i: A generic algorithmic framework. SIAM Journal on Optimization, 22(4):1469–1492, 2012. ",
+        "bbox": [
+            173,
+            316,
+            823,
+            359
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[13] Margalit Glasgow and Mary Wootters. Asynchronous distributed optimization with stochastic delays. arXiv preprint arXiv:2009.10717, 2020. ",
+        "bbox": [
+            171,
+            367,
+            825,
+            396
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[14] Eduard Gorbunov, Konstantin P. Burlachenko, Zhize Li, and Peter Richtarik. Marina: Faster non-convex distributed learning with compression. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 3788–3798. PMLR, 18–24 Jul 2021. ",
+        "bbox": [
+            173,
+            404,
+            826,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Tzu-Ming Harry Hsu, Hang Qi, and Matthew Brown. Measuring the effects of non-identical data distribution for federated visual classification. arXiv preprint arXiv:1909.06335, 2019. ",
+        "bbox": [
+            171,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Chi Jin, Rong Ge, Praneeth Netrapalli, Sham M Kakade, and Michael I Jordan. How to escape saddle points efficiently. In International Conference on Machine Learning, pages 1724–1732. PMLR, 2017. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurélien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019. ",
+        "bbox": [
+            173,
+            555,
+            826,
+            612
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank Reddi, Sebastian Stich, and Ananda Theertha Suresh. Scaffold: Stochastic controlled averaging for federated learning. In International Conference on Machine Learning, pages 5132–5143. PMLR, 2020. ",
+        "bbox": [
+            171,
+            619,
+            821,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] Ahmed Khaled, Konstantin Mishchenko, and Peter Richtárik. Tighter theory for local sgd on identical and heterogeneous data. In International Conference on Artificial Intelligence and Statistics, pages 4519–4529. PMLR, 2020. ",
+        "bbox": [
+            171,
+            670,
+            823,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[20] Jakub Konecnˇ y, Brendan McMahan, and Daniel Ramage. Federated optimization: Distributed \\` optimization beyond the datacenter. arXiv preprint arXiv:1511.03575, 2015. ",
+        "bbox": [
+            171,
+            720,
+            821,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[21] Jakub Konecnˇ y, H Brendan McMahan, Daniel Ramage, and Peter Richtárik. Federated optimiza- \\` tion: Distributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016. ",
+        "bbox": [
+            173,
+            758,
+            823,
+            801
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[22] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            809,
+            823,
+            838
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[23] Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            845,
+            823,
+            876
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[24] Yann LeCun et al. Lenet-5, convolutional neural networks. URL: http://yann. lecun. com/exdb/lenet, 20(5):14, 2015. ",
+        "bbox": [
+            171,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[25] Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. In I. Dhillon, D. Papailiopoulos, and V. Sze, editors, Proceedings of Machine Learning and Systems, volume 2, pages 429–450, 2020.   \n[26] Xiang Li, Kaixuan Huang, Wenhao Yang, Shusen Wang, and Zhihua Zhang. On the convergence of fedavg on non-iid data. In International Conference on Learning Representations, 2020.   \n[27] Xiangru Lian, Yijun Huang, Yuncheng Li, and Ji Liu. Asynchronous parallel stochastic gradient for nonconvex optimization. In C. Cortes, N. Lawrence, D. Lee, M. Sugiyama, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 28. Curran Associates, Inc., 2015.   \n[28] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial Intelligence and Statistics, pages 1273–1282. PMLR, 2017.   \n[29] Arkadij Semenovic Nemirovskij and David Borisovich Yudin. Problem complexity and method ˇ efficiency in optimization. 1983.   \n[30] Constantin Philippenko and Aymeric Dieuleveut. Bidirectional compression in heterogeneous settings for distributed or federated learning with partial participation: tight convergence guarantees. arXiv preprint arXiv:2006.14591, 2020.   \n[31] Amirhossein Reisizadeh, Isidoros Tziotis, Hamed Hassani, Aryan Mokhtari, and Ramtin Pedarsani. Straggler-resilient federated learning: Leveraging the interplay between statistical accuracy and system heterogeneity. arXiv preprint arXiv:2012.14453, 2020.   \n[32] Yichen Ruan, Xiaoxi Zhang, Shu-Che Liang, and Carlee Joe-Wong. Towards flexible device participation in federated learning. In International Conference on Artificial Intelligence and Statistics, pages 3403–3411. PMLR, 2021.   \n[33] Felix Sattler, Simon Wiedemann, Klaus-Robert Müller, and Wojciech Samek. Robust and communication-efficient federated learning from non-iid data. IEEE transactions on neural networks and learning systems, 31(9):3400–3413, 2019.   \n[34] Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet Talwalkar. Federated multi-task learning. arXiv preprint arXiv:1705.10467, 2017.   \n[35] Sebastian U Stich and Sai Praneeth Karimireddy. The error-feedback framework: Better rates for sgd with delayed gradients and compressed updates. Journal of Machine Learning Research, 21:1–36, 2020.   \n[36] Sebastian Urban Stich. Local sgd converges fast and communicates little. In ICLR 2019- International Conference on Learning Representations, number CONF, 2019.   \n[37] Roman Vershynin. High-dimensional probability: An introduction with applications in data science, volume 47. Cambridge university press, 2018.   \n[38] Jianyu Wang and Gauri Joshi. Cooperative sgd: A unified framework for the design and analysis of communication-efficient sgd algorithms. In ICML Workshop on Coding Theory for Machine Learning, 2019.   \n[39] Jianyu Wang, Qinghua Liu, Hao Liang, Gauri Joshi, and H Vincent Poor. Tackling the objective inconsistency problem in heterogeneous federated optimization. Advances in Neural Information Processing Systems, 33, 2020.   \n[40] Cong Xie, Sanmi Koyejo, and Indranil Gupta. Asynchronous federated optimization. arXiv preprint arXiv:1903.03934, 2019.   \n[41] Yikai Yan, Chaoyue Niu, Yucheng Ding, Zhenzhe Zheng, Fan Wu, Guihai Chen, Shaojie Tang, and Zhihua Wu. Distributed non-convex optimization with sublinear speedup under intermittent client availability. arXiv preprint arXiv:2002.07399, 2020.   \n[42] Haibo Yang, Minghong Fang, and Jia Liu. Achieving linear speedup with partial worker participation in non-iid federated learning. arXiv preprint arXiv:2101.11203, 2021.   \n[43] Hao Yu, Rong Jin, and Sen Yang. On the linear speedup analysis of communication efficient momentum sgd for distributed non-convex optimization. In International Conference on Machine Learning, pages 7184–7193. PMLR, 2019.   \n[44] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why are adaptive methods good for attention models?, 2020.   \n[45] Xin Zhang, Jia Liu, and Zhengyuan Zhu. Taming convergence for asynchronous stochastic gradient descent with unbounded delay in non-convex learning. In 2020 59th IEEE Conference on Decision and Control (CDC), pages 3580–3585. IEEE, 2020. ",
+        "bbox": [
+            171,
+            45,
+            828,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            220
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            242,
+            254,
+            258
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            268,
+            339,
+            281
+        ],
+        "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] See Section 8.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A] Our work is mainly theoretical and targets at providing theoretical analysis of the FL algorithms, which has almost no negative societal impacts.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            285,
+            825,
+            402
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            405,
+            493,
+            420
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] The assumptions are rigorously stated in Section 5 and Section 6.   \n(b) Did you include complete proofs of all theoretical results? [Yes] All the proofs are deferred to the appendix. ",
+        "bbox": [
+            238,
+            422,
+            825,
+            481
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            484,
+            393,
+            498
+        ],
+        "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 included in the supplemental material. The datasets we use are public. The instructions needed to reproduce the main experimental results are clearly stated in Section 7.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 7.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Section 7.   \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 Section 7. ",
+        "bbox": [
+            238,
+            503,
+            825,
+            645
+        ],
+        "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,
+            650,
+            823,
+            664
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] See Section 7.   \n(b) Did you mention the license of the assets? [Yes] See Section 7.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We include our code for reproducing the experiments in the supplemental material.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We choose the commonly-used MNIST and CIFAR-10 datasets.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We choose the commonly-used MNIST and CIFAR-10 datasets. ",
+        "bbox": [
+            238,
+            667,
+            825,
+            797
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            803,
+            705,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            820,
+            825,
+            909
+        ],
+        "page_idx": 12
+    }
+]

parse/train/7R7fAoUygoa/7R7fAoUygoa.md

@@ -0,0 +1,698 @@
+# OPTIMAL REGULARIZATION CAN MITIGATE DOUBLE DESCENT
+
+Preetum Nakkiran   
+Harvard University   
+preetum@cs.harvard.edu   
+Prayaag Venkat   
+Harvard University   
+pvenkat@g.harvard.edu
+
+# Sham Kakade
+
+Microsoft Research & University of Washington sham@cs.washington.edu
+
+Tengyu Ma   
+Stanford University   
+tengyuma@stanford.edu
+
+# ABSTRACT
+
+Recent empirical and theoretical studies have shown that many learning algorithms – from linear regression to neural networks – can have test performance that is non-monotonic in quantities such the sample size and model size. This striking phenomenon, often referred to as “double descent”, has raised questions of if we need to re-think our current understanding of generalization. In this work, we study whether the double-descent phenomenon can be avoided by using optimal regularization. Theoretically, we prove that for certain linear regression models with isotropic data distribution, optimally-tuned $\ell _ { 2 }$ regularization achieves monotonic test performance as we grow either the sample size or the model size. We also demonstrate empirically that optimally-tuned $\ell _ { 2 }$ regularization can mitigate double descent for more general models, including neural networks. Our results suggest that it may also be informative to study the test risk scalings of various algorithms in the context of appropriately tuned regularization.
+
+# 1 INTRODUCTION
+
+Recent works have demonstrated a ubiquitous “double descent” phenomenon present in a range of machine learning models, including decision trees, random features, linear regression, and deep neural networks (Opper, 1995; 2001; Advani & Saxe, 2017; Spigler et al., 2018; Belkin et al., 2018; Geiger et al., 2019b; Nakkiran et al., 2020; Belkin et al., 2019; Hastie et al., 2019; Bartlett et al., 2019; Muthukumar et al., 2019; Bibas et al., 2019; Mitra, 2019; Mei & Montanari, 2019; Liang & Rakhlin, 2018; Liang et al., 2019; Xu & Hsu, 2019; Derezinski et al., 2019; Lampinen & Ganguli, ´ 2018; Deng et al., 2019; Nakkiran, 2019). The phenomenon is that models exhibit a peak of high test risk when they are just barely able to fit the train set, that is, to interpolate. For example, as we increase the size of models, test risk first decreases, then increases to a peak around when effective model size is close to the training data size, and then decreases again in the overparameterized regime. Also surprising is that Nakkiran et al. (2020) observe a double descent as we increase sample size, i.e. for a fixed model, training the model with more data can hurt test performance.
+
+These striking observations highlight a potential gap in our understanding of generalization and an opportunity for improved methods. Ideally, we seek to use learning algorithms which robustly improve performance as the data or model size grow and do not exhibit such unexpected nonmonotonic behaviors. In other words, we aim to improve the test performance in situations which would otherwise exhibit high test risk due to double descent. Here, a natural strategy would be to use a regularizer and tune its strength on a validation set. This motivates the central question of this work:
+
+When does optimally tuned regularization mitigate or remove the double-descent phenomenon?
+
+Another motivation is the fact that double descent is largely observed for unregularized or under regularized models in practice. As an example, Figure 1 shows a simple linear ridge regression setting in which the unregularized estimator exhibits double descent, but an optimally-tuned regularizer has monotonic test performance.
+
+![](images/b5edb5b47ed8f04264d90917cb098c4913b1a417a4d6db231609364ffb35c0c9.jpg)  
+Figure 1: Test Risk vs. Num. Samples for Isotropic Ridge Regression in $d \_ =$ 500 dimensions. Unregularized regression is non-monotonic in samples, but optimallyregularized regression $( \lambda = \lambda _ { o p t } )$ is monotonic. In this setting, the optimal regularizer $\lambda _ { o p t }$ does not depend on number of samples $n$ (Lemma 2), but this is not always true – see Figure 2.
+
+Our Contributions: We study this question from both a theoretical and empirical perspective. Theoretically, we start with the setting of high-dimensional linear regression. Linear regression is a sensible starting point to study these questions, since it already exhibits many of the qualitative features of double descent in more complex models (e.g. Belkin et al. (2019); Hastie et al. (2019) and further related works in Section 1.1). Our work shows that optimally-tuned ridge regression can achieve both sample-wise monotonicity and model-size-wise monotonicity under certain assumptions. Concretely, we show
+
+1. Sample-wise monotonicity: In the setting of well-specified linear regression with isotropic features/covariates (Figure 1), we prove that optimally-tuned ridge regression yields monotonic test performance with increasing samples. That is, more data never hurts for optimally-tuned ridge regression. (See Theorem 1).
+
+2. Model-wise monotonicity: We consider a setting where the input/covariate lives in a highdimensional ambient space with isotropic covariance. Given a fixed model size $d$ (which might be much smaller than ambient dimension), we consider the family of models which first project the input to a random $d$ -dimensional subspace, and then compute a linear function in this projected “feature space.” (This is nearly identical to models of double-descent considered in Hastie et al. (2019, Section 5.1)). We prove that in this setting, as we grow the model-size, optimally-tuned ridge regression over the projected features has monotone test performance. That is, with optimal regularization, bigger models are always better or the same. (See Theorem 3).
+
+3. Monotonicity in the real-world: We also demonstrate several richer empirical settings where optimal $\ell _ { 2 }$ regularization induces monotonicity, including random feature classifiers and convolutional neural networks. This suggests that the mitigating effect of optimal regularization may hold more generally in broad machine learning contexts. (See Section 5).
+
+A few remarks are in order:
+
+Problem-specific vs Minimax and Bayesian. It is worth noting that our results hold for all linear ground-truths, rather than holding for only the worst-case ground-truth or a random ground-truth. Indeed, the minimax optimal estimator or the Bayes optimal estimator are both trivially sample-wise and model-wise monotonic with respect to the minimax risk or the Bayes risk. However, they do not guarantee monotonicity of the risk itself for a given fixed problem. In particular, there exist minimax optimal estimators which are not sample-monotonic in the sense we desire.
+
+Universal vs Asymptotic. We also remark that our analysis is not only non-asymptotic but also works for all possible input dimensions, model sizes, and sample sizes. To our knowledge, the results herein are the first non-asymptotic sample-wise and model-wise monotonicity results for linear regression. (See discussion of related works Hastie et al. (2019); Mei & Montanari (2019) for related results in the asymptotic setting). Our work reveals aspects of the problem that were not present in prior asymptotic works. For example, we empirically show that optimal regularization can eliminate even “triple descent” in ridge regression (Figure 2). Moreover, we show that for nonGaussian covariates, optimally-tuned ridge regression is not always sample-monotonic: we give a counterexample in Section 4.
+
+Towards a more general characterization. Our theoretical results crucially rely on the covariance of the data being isotropic. A natural next question is if and when the same results can hold more generally. A full answer to this question is beyond the scope of this paper, though we give the following results:
+
+1. Optimally-tuned ridge regression is not always sample-monotonic: we show a counterexample for a certain non-Gaussian data distribution and heteroscedastic noise. We are not aware of prior work pointing out this fact. (See Section 4 for the counterexample and intuitions.)   
+2. For non-isotropic Gaussian covariates, we can achieve sample-wise monotonicity with a regularizer that depends on the population covariance matrix of data. This suggests unlabeled data might also help mitigate double descent in some settings, because the population covariance can be estimated from unlabeled data. (See Appendix B).   
+3. For non-isotropic Gaussian covariates, we conjecture that optimally-tuned ridge regression is sample-monotonic even with a standard $\ell _ { 2 }$ regularizer (as in Figure 2). We derive a sufficient condition for this conjecture. Due to that current random matrix theory may be insufficient to verify this conjecture, we verify it numerically on a wide variety of cases. (See Appendix B for details).
+
+The last two results above highlight the importance of the form of the regularizer, which leads to the open question: “How do we design good regularizers which mitigate or remove double descent?” We hope that our results can motivate future work on mitigating the double descent phenomenon, and allow us to train high performance models which do not exhibit nonmonotonic behaviors.
+
+# 1.1 RELATED WORKS
+
+The study of nonmonotonicity in learning algorithms existed prior to double descent and has a long history going back to (at least) Trunk (1979) and LeCun et al. (1991); Le Cun et al. (1991), where the former was largely empirical observations and the latter studied the sample non-nonmonotonicity of unregularized linear regression in terms of the eigenspectrum of the covariance matrix; the difference to our works is that we study this in the context of optimal regularization. In fact, Duin (1995; 2000); Opper (2001); Loog & Duin (2012). Loog et al. (2019) introduces the same notion of risk monotonicity which we consider, and studies several examples of monotonic and non-monotonic procedures.
+
+Double descent of test risk as a function of model size was considered recently in more generality by Belkin et al. (2018). Similar behavior was observed empirically in earlier work in somewhat more restricted settings Trunk (1979); Opper (1995; 2001); Skurichina & Duin (2002); Le Cun et al. (1991); LeCun et al. (1991) and more recently in Advani & Saxe (2017); Geiger et al. (2019a); Spigler et al. (2018); Neal et al. (2018). Recently Nakkiran et al. (2020) demonstrated a generalized double descent phenomenon on modern deep networks, and highlighted “sample non-monotonicity” as an aspect of double descent.
+
+A recent stream of theoretical works consider model-wise double descent in simplified settings— often via linear models for regression or classification. This also connects to works on highdimentional regression in the statistics literature. A partial list of works in these areas include Belkin et al. (2019); Hastie et al. (2019); Bartlett et al. (2019); Muthukumar et al. (2019); Bibas et al. (2019); Mitra (2019); Mei & Montanari (2019); Liang & Rakhlin (2018); Liang et al. (2019); Xu & Hsu (2019); Derezinski et al. (2019); Lampinen & Ganguli (2018); Deng et al. (2019); Nakki- ´ ran (2019); Mahdaviyeh & Naulet (2019); Dobriban et al. (2018); Dobriban & Sheng (2019); Kobak et al. (2018). Of these, most closely related to our work are Hastie et al. (2019); Dobriban et al. (2018); Mei & Montanari (2019). Specifically, Hastie et al. (2019) considers the risk of unregularized and regularized linear regression in an asymptotic regime, where dimension $d$ and number of samples $n$ scale to infinity together, at a constant ratio $d / n$ . In contrast, we show non-asymptotic results, and are able to consider increasing the number of samples for a fixed model, without scaling both together. Mei & Montanari (2019) derive similar results for unregularized and regularized random features, also in an asymptotic limit. The non-asymptotic versions of the settings considered in Hastie et al. (2019) are almost identical to ours— for example, our projection model in Section 3 is nearly identical to the model in Hastie et al. (2019, Section 5.1). Finally, subsequent to our work, d’Ascoli et al. (2020) identified triple descent in an asymptotic setting.
+
+# 2 SAMPLE MONOTONICITY IN RIDGE RIDGRESSION
+
+In this section, we prove that optimally-regularized ridge regression has test risk that is monotonic in samples, for isotropic gaussian covariates and linear response. This confirms the behavior empirically observed in Figure 1. We also show that this monotonicity is not “fragile”, and using larger than larger regularization is still sample-monotonic (consistent with Figure 1).
+
+Formally, we consider the following linear regression problem in $d$ dimensions. The input/covariate $x \in \mathbb { R } ^ { d }$ is generated from $\mathcal { N } ( 0 , I _ { d } )$ , and the output/response is generated by $y = \langle x , \beta ^ { * } \rangle + \varepsilon$ with $\varepsilon \sim \mathcal { N } ( 0 , \bar { \sigma } ^ { 2 } )$ for some unknown parameter $\beta ^ { * } \in \mathbb { R } ^ { d }$ . We denote the joint distribution of $( x , y )$ by $\mathcal { D }$ . We are given $n$ training examples $\{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ i.i.d sampled from $\mathcal { D }$ . We aim to learn a linear model $f _ { \beta } ( x ) = \langle x , \beta \rangle$ with small population risk $\bar { R } ( \beta ) : = \mathbb { E } _ { ( x , y ) \sim \mathcal { D } } [ ( \langle x , \beta \rangle - y ) ^ { 2 } ]$ . For simplicity, let $\ b { X } \in \mathbb { R } ^ { n \times d }$ be the data matrix that contains $x _ { i } ^ { \top }$ ’s as rows and let $\vec { y } \in \mathbb R ^ { n }$ be column vector that contains the responses $y _ { i }$ ’s as entries. For any estimator $\hat { \beta } _ { n } ( X , \vec { y } )$ as a function of $n$ samples, define the expected risk of the estimator as:
+
+$$
+{ \overline { { R } } } ( { \hat { \beta } } _ { n } ) : = \operatorname * { \mathbb { E } } _ { X , y \sim { \mathcal { D } } ^ { n } } [ R ( { \hat { \beta } } _ { n } ( X , { \vec { y } } ) ) ]
+$$
+
+We consider the regularized least-squares estimator, also known as the ridge regression estimator. For a given $\lambda > 0$ , define
+
+$$
+\hat { \beta } _ { n , \lambda } : = \underset { \beta } { \operatorname { a r g m i n } } | | X \beta - \vec { y } | | _ { 2 } ^ { 2 } + \lambda | | \beta | | _ { 2 } ^ { 2 } = ( X ^ { T } X + \lambda I _ { d } ) ^ { - 1 } X ^ { T } \vec { y }
+$$
+
+Here $I _ { d }$ denotes the $d$ dimensional identity matrix. Let $\lambda _ { n } ^ { \mathrm { o p t } }$ be the optimal ridge parameter (that achieves the minimum expected risk) given $n$ samples: $\begin{array} { r } { \lambda _ { n } ^ { \mathrm { o p t } } : = \operatorname * { a r g m i n } _ { \lambda : \lambda \geq 0 } \overline { { R } } ( \hat { \beta } _ { n , \lambda } ) ) } \end{array}$ . Let $\hat { \beta } _ { n } ^ { \mathrm { { o p t } } }$ be the estimator that corresponds to the $\lambda _ { n } ^ { \mathrm { o p t } }$ . That is, $\begin{array} { r } { \hat { \beta } _ { n } ^ { \mathrm { o p t } } : = \operatorname * { a r g m i n } _ { \beta } | | X \beta - \vec { y } | | _ { 2 } ^ { 2 } + \lambda _ { n } ^ { \mathrm { o p t } } | | \beta | | _ { 2 } ^ { 2 } } \end{array}$ . Our main theorem in this section shows that the expected risk of $\hat { \beta } _ { n } ^ { \mathrm { { o p t } } }$ monotonically decreases as $n$ increases.
+
+Theorem 1. In the setting above, the expected test risk of optimally-regularized well-specified isotropic linear regression is monotonic in samples. That is, for all $\beta ^ { * } \in \mathbb { R } ^ { d }$ and all $d \in \mathbb { N } , n \in$ $\mathbb { N } , \sigma > 0$ ,
+
+$$
+\overline { { R } } ( \hat { \beta } _ { n + 1 } ^ { \mathrm { o p t } } ) \leq \overline { { R } } ( \hat { \beta } _ { n } ^ { \mathrm { o p t } } )
+$$
+
+The above theorem shows a strong form of monotonicity, since it holds for every fixed groundtruth $\beta ^ { * }$ , and does not require averaging over any prior on ground-truths. Moreover, it holds nonasymptotically, for every fixed $n , d \in \mathbb { N }$ . Obtaining such non-asymptotic results is nontrivial, since we cannot rely on concentration properties of the involved random variables.
+
+In particular, evaluating $\overline { { R } } ( \hat { \beta } _ { n } ^ { \mathrm { { o p t } } } )$ as a function of the problem parameters $( n , \sigma , \beta ^ { * }$ , and $d$ ) is technically challenging. In fact, we suspect that a simple closed form expression does not exist. The key idea towards proving the theorem is to derive a “partial evaluation” — the following lemmas shows that we can write $\overline { { R } } ( \hat { \beta } _ { n } ^ { \mathrm { { o p t } } } )$ in the form of $\mathbb { E } [ g ( \gamma , \sigma , n , d , \beta ^ { * } ) ]$ where $\gamma \in \mathbb { R } ^ { d }$ contains the singular values of $X$ . We will then couple the randomness of data matrices obtained by adding a single sample, and use singular value interlacing to compare their singular values.
+
+Lemma 1. In the setting of Theorem $^ { l }$ , let $\gamma = ( \gamma _ { 1 } , \ldots , \gamma _ { d } )$ be the singular values of the data matrix $\ b { X } \in \mathbb { R } ^ { n \times d }$ . (If $n < d$ , we pad the $\gamma _ { i } = 0$ for $i > n .$ .) Let $\Gamma _ { n }$ be the distribution of $\gamma .$ . Then, the expected test risk is
+
+$$
+\overline { { R } } ( \hat { \beta } _ { n , \lambda } ) = \operatorname * { \mathbb { E } } _ { ( \gamma _ { 1 } , \dots \gamma _ { d } ) \sim \Gamma _ { n } } \left[ \sum _ { i = 1 } ^ { d } \frac { | | \beta ^ { * } | | _ { 2 } ^ { 2 } \lambda ^ { 2 } / d + \sigma ^ { 2 } \gamma _ { i } ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } \right] + \sigma ^ { 2 }
+$$
+
+From Lemma 1, the below lemma follows directly by taking derivatives to find the optimal $\lambda$ .
+
+Lemma 2. In the setting of Theorem 1, the optimal ridge parameter is constant for all $n$ : $\lambda _ { n } ^ { \mathrm { o p t } } =$ $\frac { d \sigma ^ { 2 } } { | | \beta ^ { * } | | _ { 2 } ^ { 2 } }$ . Moreover, the optimal expected test risk can be written as
+
+$$
+\overline { { R } } ( \hat { \beta } _ { n } ^ { \mathrm { o p t } } ) = \operatorname * { l } _ { ( \gamma _ { 1 } , \ldots \gamma _ { d } ) \sim \Gamma _ { n } } \left[ \sum _ { i = 1 } ^ { d } \frac { \sigma ^ { 2 } } { \gamma _ { i } ^ { 2 } + d \sigma ^ { 2 } / | | \beta ^ { * } | | _ { 2 } ^ { 2 } } \right] + \sigma ^ { 2 }
+$$
+
+Proofs of Lemma 1 and 2 are deferred to the Appendix, Section A.1. Now we are ready to prove Theorem 1.
+
+Proof of Theorem $^ { l }$ . Let $\widetilde { X } \ \in \ \mathbb { R } ^ { ( n + 1 ) \times d }$ and $\boldsymbol { X } \in \mathbb { R } ^ { n \times d }$ be any two matrices which differ by only the last row of $\widetilde { X }$ . By the Cauchy interlacing theorem Theorem 4.3.4 of Horn et al. (1990) (c.f.,Lemma 3.4 of Marcus et al. (2014)), the singular values of $X$ and $\widetilde { X }$ are interlaced: $\forall i$ : $\gamma _ { i - 1 } ( X ) \geq \gamma _ { i } ( { \widetilde { X } } ) \geq \gamma _ { i } ( X )$ where $\gamma _ { i } ( \cdot )$ is the $i$ -th singular value.
+
+If we couple $\widetilde { X }$ and $X$ , it will induce a coupling $\Pi$ between the distributions $\Gamma _ { n + 1 }$ and $\Gamma _ { n }$ , of the singular values of the data matrix for $n + 1$ and $n$ samples. This coupling satisfies that $\widetilde { \gamma } _ { i } \geq \gamma _ { i }$ with probability 1 for $( \{ \widetilde { \gamma } _ { i } \} , \{ \gamma _ { i } \} ) \sim \Pi$ e. Now, expand the test risk using Lemma 2, and observe that each eterm in the sum of Equation (4) below is monotone decreasing with $\gamma _ { i }$ . Thus:
+
+$$
+\begin{array} { r l } & { \overline { { R } } ( \hat { \beta } _ { n } ^ { \mathrm { o p t } } ) = \underset { ( \gamma _ { 1 } , \ldots , \gamma _ { d } ) \sim \Gamma _ { n } } { \mathbb { E } } \left[ \displaystyle \sum _ { i = 1 } ^ { d } \frac { \sigma ^ { 2 } } { \gamma _ { i } ^ { 2 } + d \sigma ^ { 2 } / | | \beta ^ { * } | | _ { 2 } ^ { 2 } } \right] + \sigma ^ { 2 } } \\ & { \qquad \quad \overset { \mathbb { E } } { \ge } \underset { ( \widetilde { \gamma } _ { 1 } , \ldots , \widetilde { \gamma } _ { d } ) \sim \Gamma _ { n + 1 } } { \mathbb { E } } \left[ \displaystyle \sum _ { i = 1 } ^ { d } \frac { \sigma ^ { 2 } } { \widetilde { \gamma } _ { i } ^ { 2 } + d \sigma ^ { 2 } / | | \beta ^ { * } | | _ { 2 } ^ { 2 } } \right] + \sigma ^ { 2 } } \\ & { \qquad = \overline { { R } } ( \hat { \beta } _ { n + 1 } ^ { \mathrm { o p t } } ) } \end{array}
+$$
+
+By similar techniques, we can also prove that overregularization —that is, using ridge parameters $\lambda$ larger than the optimal value— is still monotonic. This proves the behavior empirically observed in Figure 1.
+
+Theorem 2. In the same setting as Theorem $I$ , over-regularized regression is also monotonic in samples. That is, for all $d \in \mathbb { N } , n \in \mathbb { N } , \sigma > 0 , \beta ^ { * } \in \mathbb { R } ^ { d }$ , the following holds
+
+$$
+\forall \lambda \geq \lambda ^ { * } : \quad \overline { { { R } } } ( \widehat { \beta } _ { n + 1 , \lambda } ) \leq \overline { { { R } } } ( \widehat { \beta } _ { n , \lambda } )
+$$
+
+where $\begin{array} { r } { \lambda ^ { * } = \frac { d \sigma ^ { 2 } } { | | \beta ^ { * } | | _ { 2 } ^ { 2 } } } \end{array}$
+
+Proof. In Section A.1.
+
+# 3 MODEL-WISE MONOTONICITY IN RIDGE REGRESSION
+
+In this section, we show that for a certain family of linear models, optimal regularization prevents model-wise double descent. That is, for a fixed number of samples, larger models are not worse than smaller models.
+
+We consider the following learning problem. Informally, covariates live in a $p$ -dimensional ambient space, and we consider models which first linearly project down to a random $d$ -dimensional subspace, then perform ridge regression in that subspace for some $d \leq p$ . Formally, the covariate $x \in \mathbb { R } ^ { p }$ is generated from $\bar { \mathcal { N } } ( 0 , I _ { p } )$ , and the response is generated by $y = \langle x , \theta \rangle + \varepsilon$ with $\varepsilon \sim \mathcal { N } ( 0 , \sigma ^ { 2 } )$ and for some unknown parameter $\theta \in \mathbb { R } ^ { p }$ . Next, $n$ examples $\{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ are sampled i.i.d from this distribution. For a given model size $d \leq p$ , we first sample a random orthonormal matrix $P \in \mathbb { R } ^ { d \times p }$ which specifies our model. We then consider models which operate on $( \widetilde { x } _ { i } , y _ { i } ) \in \mathbb { R } ^ { d } \times \mathbb { R }$ , where $\widetilde { x _ { i } } = P x _ { i }$ . We denote the joint distribution of $( \widetilde { x } , y )$ by $\mathcal { D }$ . Here, we eemphasize that $p$ eis some large ambient dimension and $d \leq p$ eis the size of the model we learn.
+
+For a fixed $P$ , we want to learn a linear model $f _ { \hat { \beta } } ( \tilde { x } ) = \langle \tilde { x } , \hat { \beta } \rangle$ for estimating $y$ , with small mean squared error on distribution: $R _ { P } ( \hat { \beta } ) : = \mathbb { E } _ { ( \tilde { x } , y ) \sim \mathcal { D } } [ ( \langle \tilde { x } , \hat { \beta } \rangle - y ) ^ { 2 } ]$ . For $n$ samples $( x _ { i } , y _ { i } )$ , let $X \in$ $\mathbb { R } ^ { n \times p }$ be the data matrix, $\widetilde { X } \ = X P ^ { T } \ \in \ \mathbb { R } ^ { n \times d }$ be the projected data matrix and $\vec { y } \in \mathbb R ^ { n }$ be the responses. For any estimator $\hat { \beta } ( \widetilde { X } , \vec { y } )$ as a function of the observed samples, define the expected risk of the estimator as:
+
+$$
+\overline { { R } } ( \hat { \beta } ) : = \operatorname * { \mathbb { E } } _ { P } \operatorname * { \mathbb { E } } _ { \tilde { X } , \vec { y } \sim \mathcal { D } ^ { n } } [ R _ { P } ( \hat { \beta } ( \tilde { X } , \vec { y } ) ]
+$$
+
+We consider the regularized least-squares estimator. For a given $\lambda > 0$ , define
+
+$$
+\hat { \beta } _ { d , \lambda } : = \underset { \beta } { \mathrm { a r g m i n } } | | \widetilde { X } \beta - \vec { y } | | _ { 2 } ^ { 2 } + \lambda | | \beta | | _ { 2 } ^ { 2 } = ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I _ { d } ) ^ { - 1 } \widetilde { X } ^ { T } \vec { y }
+$$
+
+Let $\lambda _ { d } ^ { \mathrm { o p t } }$ be the optimal ridge parameter (that achieves the minimum expected risk) for a model of size $d$ d, with $n$ samples: $\lambda _ { d } ^ { \mathrm { o p t } } : = \mathrm { a r g m i n } _ { \lambda \ge 0 } \overline { { R } } ( \hat { \beta } _ { d , \lambda } ) )$ . Let $\hat { \beta } _ { d } ^ { \mathrm { { o p t } } }$ be the estimator that corresponds to the $\lambda _ { d } ^ { \mathrm { o p t } }$ , that is $\begin{array} { r } { \hat { \beta } _ { d } ^ { \mathrm { o p t } } : = \operatorname * { a r g m i n } _ { \beta } | | \widetilde { X } \beta - \vec { y } | | _ { 2 } ^ { 2 } + \lambda _ { d } ^ { \mathrm { o p t } } | | \beta | | _ { 2 } ^ { 2 } } \end{array}$ . Now, our main theorem in this setting shows that with optimal $\ell _ { 2 }$ regularization, test performance is monotonic in model size.
+
+Theorem 3. In the setting above, the expected test risk of the optimally-regularized model is monotonic in the model size $d .$ . That is, for all $p \in \mathbb { N } , \theta \in \mathbb { R } ^ { p } , d \leq p , n \in \mathbb { N } , \sigma > 0$ , we have
+
+$$
+\overline { { R } } ( \hat { \beta } _ { d + 1 } ^ { \mathrm { o p t } } ) \leq \overline { { R } } ( \hat { \beta } _ { d } ^ { \mathrm { o p t } } )
+$$
+
+The proof of Theorem 3 is in Appendix A.2, and follows closely the proof of Theorem 1.
+
+# 4 COUNTEREXAMPLES TO MONOTONICITY
+
+In this section, we show that optimally-regularized ridge regression is not always monotonic in samples. We give a numeric counterexample in $d = 2$ dimensions, with non-gaussian covariates and heteroscedastic noise. This does not contradict our main theorem in Section 2, since this distribution is not jointly Gaussian with isotropic marginals.
+
+Counterexample. Here we give an example of a distribution $( x , y )$ for which the expected error of optimally-regularized ridge regression with $n = 2$ samples is worse than with $n = 1$ samples. This counterexample is most intuitive to understand when the ridge parameter $\lambda$ is allowed to depend on the specific sample instance $( X , { \vec { y } } )$ as well as $n ^ { 1 }$ . We sketch the intuition for this below. Consider the following distribution on $( x , y )$ in $d = 2$ dimensions. This distribution has one “clean” coordinate and one “noisy” coordinate. The distribution is: $( x , y ) = ( { \vec { e } } _ { 1 } , 1 )$ with probability $1 / 2$ , and $( x , y ) =$ $( \vec { e } _ { 2 } , \pm 1 0 )$ w.p. 1/2. Where $\pm 1 0$ is uniformly random independent noise. This distribution is “wellspecified” in that the optimal predictor is linear in $x$ $: \mathbb { E } [ y | x ] = \langle \beta ^ { * } , x \rangle$ for $\beta ^ { * } = [ 1 , 0 ]$ . However, the noise is heteroscedastic.
+
+For $n = 1$ samples, the estimator can decide whether to use small $\lambda$ or large $\lambda$ depending on if the sampled coordinate is the “clean” or “noisy” one. Specifically, for the sample $( x , y )$ : If $x = \vec { e } _ { 1 }$ , then the optimal ridge parameter is $\lambda = 0$ . If $x = \vec { e } _ { 2 }$ , then the optimal parameter is $\lambda = \infty$ .
+
+For $n = 2$ samples, with probability $1 / 2$ the two samples will hit both coordinates. In this case, the estimator must chose a single value of $\lambda$ uniformly for both coordinates. This yields to a suboptimal tradeoff, since the “noisy” coordinate demands large regularization, but this hurts estimation on the “clean” coordinate.
+
+It turns out that a slight modification to the above also serves as a counterexample to monotonicity when the regularization parameter $\lambda$ is chosen only depending on $n$ (and not on the instance $X , y )$ . The distribution is: $( x , y ) = ( \vec { e } _ { 1 } , 1 )$ w.p. 0.98 and $( x , y ) = ( \vec { e } _ { 2 } , \pm 2 0 )$ w.p. 0.02. This distribution has the following property.
+
+Theorem 4. There exists a distribution $\mathcal { D }$ over $( x , y )$ for $x \in \mathbb { R } ^ { 2 } , y \in \mathbb { R }$ with the following properties. Let $\hat { \beta } _ { n } ^ { \mathrm { { o p t } } }$ be the optimally-regularized ridge regression solution for $n$ samples $( X , { \vec { y } } )$ from $\mathcal { D }$ . Then:
+
+1. D is “well-specified” in that $\mathbb { E } p [ y | x ]$ is a linear function of $x$ ,
+
+2. The expected test risk increases as a function of $n _ { \ast }$ , between $n = 1$ and $n = 2$ . Specifically
+
+$$
+\overline { { R } } ( \hat { \beta } _ { n = 1 } ^ { \mathrm { o p t } } ) < \overline { { R } } ( \hat { \beta } _ { n = 2 } ^ { \mathrm { o p t } } )
+$$
+
+Proof. For $n = 1$ samples, it can be confirmed analytically that the expected risk $\overline { { { R } } } ( \hat { \beta } _ { n = 1 } ^ { \mathrm { o p t } } ) ~ <$ 8.157. This is achieved with $\lambda = 4 0 0 / 2 4 0 1 \approx 0 . 1 6 6 5 9 7 .$ For $n = 2$ samples, it can be confirmed numerically (via Mathematica) that the expected risk $\overline { { R } } ( \hat { \beta } _ { n = 2 } ^ { \mathrm { o p t } } ) ~ > ~ 8 . 1 7 9$ . This is achieved with $\lambda = 0 . 6 4 2 5 2 5$ . □
+
+# 5 EXPERIMENTS
+
+We now experimentally demonstrate that optimal $\ell _ { 2 }$ regularization can mitigate double descent, in more general settings than Theorems 1 and 3.
+
+# 5.1 SAMPLE MONOTONICITY
+
+Here we show various settings where optimal $\ell _ { 2 }$ regularization empirically induces samplemonotonic performance.
+
+Nonisotropic Regression. We first consider the setting of Theorem 1, but with non-isotropic covariantes $x$ . That is, we perform ridge regression on samples $( x , y )$ , where the covariate $\boldsymbol { x } \in \mathbb { R } ^ { d }$ is generated from $\mathcal { N } ( 0 , \Sigma )$ for $\Sigma \neq I _ { d }$ . As before, the response is generated by $y = \langle x , \beta ^ { * } \rangle + \varepsilon$ with $\varepsilon \sim \mathcal { N } ( 0 , \sigma ^ { 2 } )$ for some unknown parameter $\beta ^ { * } \in \mathbb { R } ^ { d }$ . We consider the same ridge regression estimator, $\begin{array} { r } { \hat { \beta } _ { n , \lambda } : = \operatorname * { a r g m i n } _ { \boldsymbol { \beta } } \| X { \boldsymbol { \beta } } - \vec { y } \| _ { 2 } ^ { 2 } + \lambda \| { \boldsymbol { \beta } } \| _ { 2 } ^ { 2 } } \end{array}$ .
+
+![](images/6bbe45f3d0113a0cbb86e816d67e9834573c85c456540349b12e6e02c25001ba.jpg)  
+Figure 2: Test Risk vs. Num. Samples for Non-Isotropic Ridge Regression in $d = 3 0$ dimensions. Unregularized regression is non-monotonic in samples, but optimally-regularized regression is monotonic. Note the optimal regularization $\lambda$ depends on the number of samples $n$ .   
+Figure 2 shows one instance of this, for a particular choice of $\Sigma$ and $\beta ^ { * }$ . The covariance $\Sigma$ is diagonal, with $\Sigma _ { i , i } = 1 0$ for $i \leq 1 5$ and $\Sigma _ { i , i } = 1$ for $i > 1 5$ . That is, the covariance has one “large” eigenspace and one “small” eigenspace. The ground-truth $\beta ^ { * } = 0 . 1 \vec { e _ { 1 } } + e _ { 3 0 } ^ {  }$ , which lies almost entirely within the “small” eigenspace of $\Sigma$ . The noise parameter is $\sigma = 0 . 5$ .
+
+We see that unregularized regression $\lambda = 0$ ) actually undergoes “triple descent”2 in this setting, with the first peak around $n = 1 5$ samples due to the 15-dimensional large eigenspace, and the second peak at $n = d$ . In this setting, optimally-regularized ridge regression is empirically monotonic in samples (Figure 2). Unlike the isotropic setting of Section 2, the optimal ridge parameter $\lambda _ { n }$ is no longer a constant, but varies with number of samples $n$ .
+
+Random ReLU Features. We consider random ReLU features, in the random features framework of Rahimi & Recht (2008). For a given number of features $D$ , and number of samples $n$ , the random feature classifier is obtained by performing regularized linear regression on the embedding√ $\tilde { x } : = \mathrm { R e L U } ( W x )$ , where $W \in \mathbb { R } ^ { D \times d }$ is a matrix with each entry sampled i.i.d $\mathcal { N } ( 0 , 1 / \sqrt { d } )$ and ReLU applies pointwise. This is equivalent to a 2-layer fully-connected neural network with a frozen (randomly-initialized) first layer, trained with $\ell _ { 2 }$ loss and weight decay. In Appendix A.4, we apply random features to Fashion-MNIST Xiao et al. (2017). From Appendix Figure 4a, we see that underregularized models are non-monotonic, but optimal $\ell _ { 2 }$ regularization is monotonic in samples. Moreover, the optimal ridge parameter $\lambda$ appears to be constant for all $n$ , similar to our results from the isotropic setting in Theorem 1.
+
+# 5.2 MODEL-SIZE MONOTONICITY
+
+Here we empirically show that optimal $\ell _ { 2 }$ regularization can mitigate model-wise double descent.
+
+Random ReLU Features. We consider the same experimental setup as in Section 5.1, but now fix the number of samples $n$ , and vary the number of random features $D$ . This corresponds to varying the width of the corresponding 2-layer neural network. Figure 4b in Appendix A.4 shows the test error of the random features classifier, for $n = 5 0 0$ train samples and varying number of random features. We see that underregularized models undergo model-wise double descent, but optimal $\ell _ { 2 }$ regularization prevents double descent.
+
+Convolutional Neural Networks. We follow the experimental setup of Nakkiran et al. (2020) for modelwise double descent, and add varying amounts of $\ell _ { 2 }$ regularization (weight decay). We chose the following setting from Nakkiran et al. (2020), because it exhibits double descent even with no added label noise. We consider the same family of 5-layer convolutional neural networks (CNNs) from Nakkiran et al. (2020), consisting of 4 convolutional layers of widths $[ k , 2 k , 4 k , 8 k ]$ for varying $k \in$ $\mathbb { N }$ . We train and test on CIFAR100 (Krizhevsky et al., 2009), an image classification problem with 100 classes. Inputs are normalized to
+
+![](images/b59ffa519889838486fdb1bea9435eca85527fcc4c5ff780a6f8610321941a4b.jpg)  
+Figure 3: Test Error vs. Model Size for 5-layer CNNs on CIFAR-100, with $\ell _ { 2 }$ regularization (weight decay). Note that the optimal regularization $\lambda$ varies with $n$ .
+
+$[ - 1 , 1 ] ^ { d }$ , and we use standard data-augmentation of random horizontal flip and random crop with 4- pixel padding. All models are trained using Stochastic Gradient Descent (SGD) on the cross-entropy loss, with step size $0 . 1 / \sqrt { \lfloor { T / 5 1 2 } \rfloor + 1 }$ at step $T$ . We train for 1e6 gradient steps, and use weight decay $\lambda$ for varying $\lambda$ . Due to optimization instabilities for large $\lambda$ , we use the model with the minimum train loss among the last 5K gradient steps. Figure 3 shows the test error of these models on CIFAR-100. Although unregularized and under-reguarized models exhibit double descent, the test error of optimally-regularized models is largely monotonic. Note that the optimal regularization $\lambda$ varies with the model size — no single regularization value is optimal for all models.
+
+# 6 DISCUSSION AND CONCLUSION
+
+In this work, we study the double descent phenomenon in the context of optimal regularization. We show that, while unregularized or under-regularized models often have non-monotonic behavior, appropriate regularization can eliminate this effect.
+
+Theoretically, we prove that for certain linear regression models with isotropic covariates, optimallytuned $\ell _ { 2 }$ regularization achieves monotonic test performance as we grow either the sample size or the model size. These are the first non-asymptotic monotonicity results we are aware of in linear regression. We also demonstrate empirically that optimally-tuned $\ell _ { 2 }$ regularization can mitigate double descent for more general models, including neural networks. We hope that our results can motivate future work on mitigating the double descent phenomenon, and allow us to train high performance models which do not exhibit unexpected nonmonotonic behaviors.
+
+Open Questions. Our work suggests a number of natural open questions. First, it is open to prove (or disprove) that optimal ridge regression is sample-monotonic for non-isotropic Gaussian covariates. We conjecture that it is, and outline a potential route to proving this (via Conjectures 1 and 2 in the Appendix). Second, more broadly, it is open to prove sample-wise or model-wise monotonicity for more general (non-linear) models with appropriate regularizers. Finally, it is open to understand why large neural networks in practice are often sample-monotonic in realistic regimes of sample sizes, even without careful choice of regularization.
+
+# REFERENCES
+
+Madhu S Advani and Andrew M Saxe. High-dimensional dynamics of generalization error in neural networks. arXiv preprint arXiv:1710.03667, 2017.   
+Peter L Bartlett, Philip M Long, Gabor Lugosi, and Alexander Tsigler. Benign overfitting in linear ´ regression. arXiv preprint arXiv:1906.11300, 2019.   
+Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machine learning and the bias-variance trade-off. arXiv preprint arXiv:1812.11118, 2018.   
+Mikhail Belkin, Daniel Hsu, and Ji Xu. Two models of double descent for weak features. arXiv preprint arXiv:1903.07571, 2019.   
+Koby Bibas, Yaniv Fogel, and Meir Feder. A new look at an old problem: A universal learning approach to linear regression. arXiv preprint arXiv:1905.04708, 2019.   
+Stephane d’Ascoli, Levent Sagun, and Giulio Biroli. Triple descent and the two kinds of overfitting: ´ Where & why do they appear? arXiv preprint arXiv:2006.03509, 2020.   
+Zeyu Deng, Abla Kammoun, and Christos Thrampoulidis. A model of double descent for highdimensional binary linear classification. arXiv preprint arXiv:1911.05822, 2019.   
+Michał Derezinski, Feynman Liang, and Michael W. Mahoney. Exact expressions for double descent ´ and implicit regularization via surrogate random design, 2019.   
+Edgar Dobriban and Yue Sheng. Wonder: Weighted one-shot distributed ridge regression in high dimensions. arXiv preprint arXiv:1903.09321, 2019.   
+Edgar Dobriban, Stefan Wager, et al. High-dimensional asymptotics of prediction: Ridge regression and classification. The Annals of Statistics, 46(1):247–279, 2018.   
+Robert PW Duin. Small sample size generalization. In Proceedings of the Scandinavian Conference on Image Analysis, volume 2, pp. 957–964. PROCEEDINGS PUBLISHED BY VARIOUS PUBLISHERS, 1995.   
+Robert PW Duin. Classifiers in almost empty spaces. In Proceedings 15th International Conference on Pattern Recognition. ICPR-2000, volume 2, pp. 1–7. IEEE, 2000.   
+Mario Geiger, Arthur Jacot, Stefano Spigler, Franck Gabriel, Levent Sagun, Stephane d’Ascoli, ´ Giulio Biroli, Clement Hongler, and Matthieu Wyart. Scaling description of generalization with ´ number of parameters in deep learning. arXiv preprint arXiv:1901.01608, 2019a.   
+Mario Geiger, Stefano Spigler, Stephane d’Ascoli, Levent Sagun, Marco Baity-Jesi, Giulio Biroli, ´ and Matthieu Wyart. Jamming transition as a paradigm to understand the loss landscape of deep neural networks. Physical Review E, 100(1):012115, 2019b.   
+Trevor Hastie, Andrea Montanari, Saharon Rosset, and Ryan J. Tibshirani. Surprises in high
+
+dimensional ridgeless least squares interpolation, 2019.
+
+Roger A Horn, Roger A Horn, and Charles R Johnson. Matrix Analysis. Cambridge University Press, 1990.
+
+Dmitry Kobak, Jonathan Lomond, and Benoit Sanchez. Optimal ridge penalty for real-world highdimensional data can be zero or negative due to the implicit ridge regularization. arXiv preprint arXiv:1805.10939, 2018.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Andrew K Lampinen and Surya Ganguli. An analytic theory of generalization dynamics and transfer learning in deep linear networks. arXiv preprint arXiv:1809.10374, 2018.
+
+Yann Le Cun, Ido Kanter, and Sara A Solla. Eigenvalues of covariance matrices: Application to neural-network learning. Physical Review Letters, 66(18):2396, 1991.
+
+Yann LeCun, Ido Kanter, and Sara A Solla. Second order properties of error surfaces: Learning time and generalization. In Advances in neural information processing systems, pp. 918–924, 1991.
+
+Tengyuan Liang and Alexander Rakhlin. Just interpolate: Kernel” ridgeless” regression can generalize. arXiv preprint arXiv:1808.00387, 2018.
+
+Tengyuan Liang, Alexander Rakhlin, and Xiyu Zhai. On the risk of minimum-norm interpolants and restricted lower isometry of kernels. arXiv preprint arXiv:1908.10292, 2019.
+
+Tengyuan Liang, Alexander Rakhlin, and Xiyu Zhai. On the multiple descent of minimum-norm interpolants and restricted lower isometry of kernels. 2020.
+
+Marco Loog and Robert PW Duin. The dipping phenomenon. In Joint IAPR International Workshops on Statistical Techniques in Pattern Recognition (SPR) and Structural and Syntactic Pattern Recognition (SSPR), pp. 310–317. Springer, 2012.
+
+Marco Loog, Tom Viering, and Alexander Mey. Minimizers of the empirical risk and risk monotonicity. In Advances in Neural Information Processing Systems, pp. 7476–7485, 2019.
+
+Yasaman Mahdaviyeh and Zacharie Naulet. Asymptotic risk of least squares minimum norm estimator under the spike covariance model. arXiv preprint arXiv:1912.13421, 2019.
+
+Adam W Marcus, Daniel A Spielman, and Nikhil Srivastava. Ramanujan graphs and the solution of the kadison-singer problem. arXiv preprint arXiv:1408.4421, 2014.
+
+Song Mei and Andrea Montanari. The generalization error of random features regression: Precise asymptotics and double descent curve. arXiv preprint arXiv:1908.05355, 2019.
+
+Partha P. Mitra. Understanding overfitting peaks in generalization error: Analytical risk curves for l2 and l1 penalized interpolation. ArXiv, abs/1906.03667, 2019.
+
+Vidya Muthukumar, Kailas Vodrahalli, and Anant Sahai. Harmless interpolation of noisy data in regression. arXiv preprint arXiv:1903.09139, 2019.
+
+Preetum Nakkiran. More data can hurt for linear regression: Sample-wise double descent. arXiv preprint arXiv:1912.07242, 2019.
+
+Preetum Nakkiran, Gal Kaplun, Yamini Bansal, Tristan Yang, Boaz Barak, and Ilya Sutskever. Deep double descent: Where bigger models and more data hurt. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ B1g5sA4twr.
+
+Brady Neal, Sarthak Mittal, Aristide Baratin, Vinayak Tantia, Matthew Scicluna, Simon LacosteJulien, and Ioannis Mitliagkas. A modern take on the bias-variance tradeoff in neural networks. arXiv preprint arXiv:1810.08591, 2018.
+
+Manfred Opper. Statistical mechanics of learning: Generalization. The Handbook of Brain Theory and Neural Networks, 922-925., 1995.
+
+Manfred Opper. Learning to generalize. Frontiers of Life, 3(part 2), pp.763-775., 2001.
+
+Ali Rahimi and Benjamin Recht. Random features for large-scale kernel machines. In Advances in neural information processing systems, pp. 1177–1184, 2008.
+
+Marina Skurichina and Robert PW Duin. Bagging, boosting and the random subspace method for linear classifiers. Pattern Analysis & Applications, 5(2):121–135, 2002.
+
+Stefano Spigler, Mario Geiger, Stephane d’Ascoli, Levent Sagun, Giulio Biroli, and Matthieu Wyart.´ A jamming transition from under-to over-parametrization affects loss landscape and generalization. arXiv preprint arXiv:1810.09665, 2018.
+
+Gerard V Trunk. A problem of dimensionality: A simple example. IEEE Transactions on pattern analysis and machine intelligence, (3):306–307, 1979.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.
+
+Ji Xu and Daniel J Hsu. On the number of variables to use in principal component regression. In Advances in Neural Information Processing Systems, pp. 5095–5104, 2019.
+
+# A APPENDIX
+
+In Section A.1 and A.2 we provide the proofs for sample-monotonicity and model-size monotonicity. In Section A.4 we include additional and omitted plots. In Section B we investigate whether monotonicity provably holds in more general models, and present a monotonicity conjecture for non-isotropic covariates.
+
+# A.1 SAMPLE MONOTONICITY PROOFS
+
+First we prove Lemma 1.
+
+Proof of Lemma $^ { l }$ . For isotropic $x$ , the test risk is related to the parameter error as:
+
+$$
+\begin{array} { r l } & { R ( \hat { \beta } ) : = \underset { ( x , y ) \sim \mathcal { D } } { \mathbb { E } } [ ( \langle x , \hat { \beta } \rangle - y ) ^ { 2 } ] } \\ & { \quad \quad = \underset { x \sim \mathcal { N } ( 0 , I _ { d } ) , \eta \sim \mathcal { N } ( 0 , \sigma ^ { 2 } ) } { \mathbb { E } } [ ( \langle x , \hat { \beta } - \beta ^ { * } \rangle + \eta ) ^ { 2 } ] } \\ & { \quad \quad = | | \hat { \beta } - \beta ^ { * } | | _ { 2 } ^ { 2 } + \sigma ^ { 2 } } \end{array}
+$$
+
+Plugging in the form of $\hat { \beta } _ { n , \lambda }$ and expanding:
+
+$$
+\begin{array} { r l } & { \bar { R } ( \hat { \beta } _ { n , \lambda } ) : = \underset { X , y \sim \mathcal { D } ^ { n } } { \mathbb { E } } [ R ( \hat { \beta } _ { n , \lambda } ) ] } \\ & { = \mathbb { E } [ \| \hat { \beta } _ { n , \lambda } - \beta ^ { * } \| _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { = \underset { X , y } { \mathbb { E } } [ \| ( X ^ { T } X + \lambda I ) ^ { - 1 } X ^ { T } y - \beta \| _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { = \underset { X , \eta \sim \mathcal { N } ( 0 , \sigma ^ { 2 } I _ { n } ) } { \mathbb { E } } [ \| ( X ^ { T } X + \lambda I ) ^ { - 1 } X ^ { T } ( X \beta ^ { * } + \eta ) - \beta ^ { * } \| _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { = \underset { X } { \mathbb { E } } [ \| ( X ^ { T } X + \lambda I ) ^ { - 1 } X ^ { T } X \beta ^ { * } - \beta ^ { * } \| _ { 2 } ^ { 2 } ] + \underset { X , \eta } { \mathbb { E } } [ \| ( X ^ { T } X + \lambda I ) ^ { - 1 } X ^ { T } \eta \| _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { = \underset { X } { \mathbb { E } } [ \| ( X ^ { T } X + \lambda I ) ^ { - 1 } X ^ { T } X \beta ^ { * } - \beta ^ { * } \| _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } \underset { X } { \mathbb { E } } [ \| ( X ^ { T } X + \lambda I ) ^ { - 1 } X ^ { T } \| _ { F } ^ { 2 } ] + \sigma ^ { 2 } } \end{array}
+$$
+
+Now let $X \ = \ U \Sigma V ^ { T }$ be the full singular value decomposition of $X$ , with $U \ \in \ \mathbb { R } ^ { n \times n } , \Sigma \ \in$ $\mathbb { R } ^ { n \times d } , V \in \mathbb { R } ^ { d \times d }$ . Let $( \gamma _ { 1 } , \ldots \gamma _ { d } )$ denote the singular values, defining $\gamma _ { i } = 0$ for $i > \operatorname* { m i n } ( n , d )$ . Then, continuing:
+
+$$
+\begin{array} { r l } & { \overline { { R } } ( \hat { \beta } _ { n , \lambda } ) = \underset { V , \Sigma } { \mathbb { E } } [ | | \mathrm { d i a g } ( \{ \frac { - \lambda } { \gamma _ { i } ^ { 2 } + \lambda } \} ) V ^ { T } \beta ^ { * } | | _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } \underset { \Sigma } { \mathbb { E } } [ \sum _ { i } \frac { \gamma _ { i } ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } ] + \sigma ^ { 2 } } \\ & { \quad \quad = \underset { z \sim \mathrm { U n i f } ( 1 ) \frac { \mathbb { E } } { \delta } } { \underbrace { \mathrm { U } \mathrm { E } } } [ | | \mathrm { d i a g } ( \{ \frac { - \lambda } { \gamma _ { i } ^ { 2 } + \lambda } \} ) z | | _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } \underset { \Sigma } { \mathbb { E } } [ \sum _ { i } \frac { \gamma _ { i } ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } ] + \sigma ^ { 2 } } \\ & { \quad \quad = \frac { | | \beta ^ { * } | | _ { 2 } ^ { 2 } } { d } \underset { \Sigma } { \mathbb { E } } [ \sum _ { i } \frac { \lambda ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } ] + \sigma ^ { 2 } \underset { \Sigma } { \mathbb { E } } [ \sum _ { i } \frac { \gamma _ { i } ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } ] + \sigma ^ { 2 } } \\ & { \quad \quad = \underset { \Sigma } { \mathbb { E } } [ \sum _ { i } \frac { | | \beta ^ { * } | | _ { 2 } ^ { 2 } \lambda ^ { 2 } / d + \sigma ^ { 2 } \gamma _ { i } ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } ] + \sigma ^ { 2 } } \end{array}
+$$
+
+In Line (10) follows because by symmetry, the distribution of $V$ is a uniformly random orthonormal matrix, and $\Sigma$ is independent of $V$ . Thus, $z : = V ^ { T } \beta ^ { * }$ is distributed as a uniformly random point on the unit sphere of radius $| | \beta ^ { * } | | _ { 2 }$ .
+
+Next we prove Lemma 2.
+
+Proof of Lemma 2. First, we determine the optimal ridge parameter. Using Lemma 1, we have
+
+$$
+\begin{array} { r l } & { \frac { \partial } { \partial \lambda } \overline { { R } } ( \hat { \beta } _ { n , \lambda } ) = \frac { \partial } { \partial \lambda } _ { ( \gamma _ { 1 } , \dots \gamma _ { d } ) \sim \Gamma } \left[ \displaystyle \sum _ { i } \frac { | | \beta | | _ { 2 } ^ { 2 } \lambda ^ { 2 } / d + \sigma ^ { 2 } \gamma _ { i } ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } \right] } \\ & { = 2 ( | | \beta ^ { * } | | _ { 2 } ^ { 2 } \lambda / d - \sigma ^ { 2 } ) _ { ( \underbrace { ( \gamma _ { 1 } , \dots \gamma _ { d } ) \sim \Gamma } _ { > 0 } } \left[ \displaystyle \sum _ { i } \frac { \gamma _ { i } ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 3 } } \right] } \end{array}
+$$
+
+Thus, $\begin{array} { r } { \frac { \partial } { \partial \lambda } \overline { { R } } ( \widehat { \beta } _ { n , \lambda } ) = 0 \implies \lambda = \frac { d \sigma ^ { 2 } } { | | \beta ^ { * } | | _ { 2 } ^ { 2 } } } \end{array}$ and we conclude that $\begin{array} { r } { \lambda _ { n } ^ { \mathrm { o p t } } = \frac { d \sigma ^ { 2 } } { | | \beta ^ { * } | | _ { 2 } ^ { 2 } } } \end{array}$
+
+For this optimal parameter, the test risk follows from Lemma 1 as
+
+$$
+\begin{array} { l } { \displaystyle \overline { { R } } ( \hat { \beta } _ { n } ^ { \mathrm { o p t } } ) = \overline { { R } } ( \hat { \beta } _ { n , \lambda _ { n } ^ { \mathrm { o p t } } } ) } \\ { \displaystyle = \frac { \mathbb { E } } { ( \gamma _ { 1 } , \dots \gamma _ { d } ) \sim \Gamma _ { n } } \left[ \sum _ { i = 1 } ^ { d } \frac { \sigma ^ { 2 } } { \gamma _ { i } ^ { 2 } + d \sigma ^ { 2 } / | | \beta ^ { * } | | _ { 2 } ^ { 2 } } \right] + \sigma ^ { 2 } } \end{array}
+$$
+
+Proof of Theorem 2. We follow a similar proof strategy as in Theorem 1: we invoke singular value interlacing $( \widetilde { \gamma } _ { i } \geq \gamma _ { i } )$ for the data matrix when adding a single sample. We then apply Lemma 1 to eargue that the test risk varies monotonically with the singular values.
+
+We have
+
+$$
+{ \overline { { R } } } ( \hat { \beta } _ { n , \lambda } ) = \operatorname * { \mathbb { E } } _ { ( \gamma _ { 1 } , \dots \gamma _ { d } ) \sim \Gamma } [ \sum _ { i } \underbrace { | | \beta ^ { * } | | _ { 2 } ^ { 2 } \lambda ^ { 2 } / d + \sigma ^ { 2 } \gamma _ { i } ^ { 2 } } _ { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } ]
+$$
+
+and we compute how each term in the sum varies with $\gamma _ { i }$ :
+
+$$
+\begin{array} { l } { \displaystyle { \frac { \partial } { \partial \gamma _ { i } } \sum _ { i } S ( \gamma _ { i } ) = \frac { \partial } { \partial \gamma _ { i } } S ( \gamma _ { i } ) } } \\ { \displaystyle { \quad = ( \frac { - 2 \gamma _ { i } } { d } ) \frac { 2 | | \beta ^ { * } | | _ { 2 } ^ { 2 } \lambda ^ { 2 } + d \sigma ^ { 2 } ( \gamma _ { i } ^ { 2 } - \lambda ) } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 3 } } } } \end{array}
+$$
+
+Thus we have
+
+$$
+\lambda \geq \frac { d \sigma ^ { 2 } } { 2 \vert \vert \beta ^ { * } \vert \vert ^ { 2 } } \implies \frac { \partial } { \partial \gamma _ { i } } S ( \gamma _ { i } ) \leq 0
+$$
+
+By the coupling argument in Theorem 1, this implies that the test risk is monotonic:
+
+$$
+\begin{array} { r l } & { \overline { { R } } ( \hat { \beta } _ { n + 1 , \lambda } ) - \overline { { R } } ( \hat { \beta } _ { n , \lambda } ) } \\ & { \quad = \underset { ( \widetilde { \gamma } _ { 1 } , \dots , \widetilde { \gamma } _ { d } ) \sim \Gamma _ { n + 1 } } { \mathbb { E } } \left[ \displaystyle \sum _ { i = 1 } ^ { d } S ( \widetilde { \gamma } _ { i } ) \right] - \underset { ( \gamma _ { 1 } , \dots , \gamma _ { d } ) \sim \Gamma _ { n } } { \mathbb { E } } \left[ \displaystyle \sum _ { i = 1 } ^ { d } S ( \gamma _ { i } ) \right] } \\ & { \quad = \underset { ( \{ \widetilde { \gamma } _ { i } \} , \{ \gamma _ { i } \} ) \sim \Pi } { \mathbb { E } } \left[ \displaystyle \sum _ { i = 1 } ^ { d } S ( \widetilde { \gamma } _ { i } ) - S ( \gamma _ { i } ) \right] } \\ & { \quad \le 0 } \end{array}
+$$
+
+where $\Pi$ is the coupling. Line (17) follows from Equation (15), and the fact that the coupling obeys $\widetilde { \gamma } _ { i } \geq \gamma _ { i }$ . □
+
+# A.2 PROJECTION MODEL PROOFS
+
+Lemma 3. For all $\theta \in \mathbb { R } ^ { p }$ , $d , n \in \mathbb { N } ,$ , and $\lambda > 0 ;$ , let $\ b { X } \in \mathbb { R } ^ { n \times p }$ be a matrix with i.i.d. $\mathcal { N } ( 0 , 1 )$ entries. Let $P \in \mathbb { R } ^ { d \times p }$ be a random orthonormal matrix. Define $\widetilde { X } : = X P ^ { T }$ . Let $\left( \gamma _ { 1 } , \dots , \gamma _ { m } \right)$ be the singular values of the data matrix $\tilde { X } \in \mathbb { R } ^ { n \times d }$ , for $m : = \operatorname* { m a x } ( n , d )$ (with $\gamma _ { i } ~ = ~ 0$ for $i > \operatorname* { m i n } ( n , d ) )$ . Let $\Gamma _ { d }$ be the distribution of singular values $\left( \gamma _ { 1 } , \ldots , \gamma _ { m } \right)$ .
+
+Then, the optimal ridge parameter is constant for all $d$ : $\begin{array} { r } { \lambda _ { d } ^ { \mathrm { o p t } } = \frac { p ^ { 2 } \widetilde \sigma ^ { 2 } } { d | | \theta | | _ { 2 } ^ { 2 } } } \end{array}$ . where we define $\widetilde { \sigma } ^ { 2 } : = \ :$ $\begin{array} { r } { \sigma ^ { 2 } + \frac { p - d } { p } | | \boldsymbol { \theta } | | _ { 2 } ^ { 2 } } \end{array}$ . Moreover, the optimal expected test risk can be written as
+
+$$
+\overline { { R } } ( \hat { \beta } _ { d } ^ { \mathrm { o p t } } ) = \widetilde { \sigma } ^ { 2 } + \underset { ( \gamma _ { 1 } , \ldots , \gamma _ { m } ) \sim \Gamma _ { d } } { \mathbb { E } } \left[ \sum _ { i = 1 } ^ { p } \frac { \widetilde { \sigma } ^ { 2 } } { \gamma _ { i } ^ { 2 } + \frac { \widetilde { \sigma } ^ { 2 } p ^ { 2 } } { d | | \theta | | _ { 2 } ^ { 2 } } } \right]
+$$
+
+Proof. This proof follows exactly analogously as the proof of Lemma 2 from Lemma 1, in Section A.1. □
+
+Lemma 4. For all $\theta \in \mathbb { R } ^ { p }$ , $d , n \in \mathbb { N } ,$ , and $\lambda > 0$ , let $\ b { X } \in \mathbb { R } ^ { n \times p }$ be a matrix with i.i.d. $\mathcal { N } ( 0 , 1 )$   
+entries. Let $P \in \mathbb { R } ^ { d \times p }$ be a random orthonormal matrix. Define $\widetilde X : = X P ^ { T }$ and $\beta ^ { * } : = P \theta$ .
+
+Let $\left( \gamma _ { 1 } , \dots , \gamma _ { m } \right)$ be the singular values of the data matrix $\tilde { X } \in \mathbb { R } ^ { n \times d }$ , for $m : = \operatorname* { m a x } ( n , d )$ (with $\gamma _ { i } = 0$ for $i > \operatorname* { m i n } ( n , d ) )$ . Let $\Gamma _ { d }$ be the distribution of singular values $\left( \gamma _ { 1 } , \dots , \gamma _ { m } \right)$ .
+
+Then, the expected test risk is
+
+$$
+\begin{array} { r l } & { \overline { { R } } ( \hat { \beta } _ { d , \lambda } ) : = \underset { P } { \mathbb { E } } \underset { \widetilde { X } , \widetilde { y } \sim \mathcal { D } ^ { n } } { \mathbb { E } } [ R _ { P } ( \hat { \beta } _ { d , \lambda } ( \widetilde { X } , \overrightarrow { y } ) ] } \\ & { = \sigma ^ { 2 } + ( 1 - \frac { d } { p } ) | | \theta | | _ { 2 } ^ { 2 } } \\ & { + \underset { ( \gamma _ { 1 } , \dotsc , \gamma _ { m } ) \sim \Gamma _ { d } } { \mathbb { E } } \left[ \underset { i = 1 } { \overset { p } { \sum } } \frac { ( \sigma ^ { 2 } + \frac { p - d } { p } | | \theta | | _ { 2 } ^ { 2 } ) \gamma _ { i } ^ { 2 } + \frac { d } { p ^ { 2 } } | | \theta | | _ { 2 } ^ { 2 } \lambda ^ { 2 } } { ( \gamma _ { i } ^ { 2 } + \lambda ) ^ { 2 } } \right] } \end{array}
+$$
+
+Proof of Lemma 4. We first define the parameter that minimizes the population risk. It follows directly that:
+
+$$
+\beta _ { P } ^ { * } : = \underset { \beta \in \mathbb { R } ^ { d } } { \mathrm { a r g m i n } } R _ { P } ( \beta ) = P \theta
+$$
+
+First, we can expand the risk as
+
+$$
+\begin{array} { r l } & { R ( \hat { \beta } ) = \underset { ( \bar { x } , y ) \sim \mathcal { D } } { \mathbb { E } } [ ( \langle P x , \hat { \beta } \rangle - y ) ^ { 2 } ] } \\ & { \quad = \underset { ( \bar { x } , y ) \sim \mathcal { D } , \eta \sim \mathcal { N } ( 0 , \sigma ^ { 2 } ) } { \mathbb { E } } [ ( \langle x , P ^ { T } \hat { \beta } - \theta \rangle + \eta ) ^ { 2 } ] } \\ & { \quad = \sigma ^ { 2 } + \vert \vert \theta - P ^ { T } \hat { \beta } \vert \vert _ { 2 } ^ { 2 } } \\ & { \quad = \sigma ^ { 2 } + \vert \vert \theta - P ^ { T } \beta ^ { * } \vert \vert _ { 2 } ^ { 2 } + \vert \vert P ^ { T } \beta ^ { * } - P ^ { T } \hat { \beta } \vert \vert _ { 2 } ^ { 2 } } \\ & { \quad + 2 \langle ( \theta - P ^ { T } \beta ^ { * } ) , P ^ { T } \beta ^ { * } - P ^ { T } \hat { \beta } \rangle } \\ & { \quad = \sigma ^ { 2 } + \vert \vert \theta - P ^ { T } \beta ^ { * } \vert \vert _ { 2 } ^ { 2 } + \vert \vert P ^ { T } \beta ^ { * } - P ^ { T } \hat { \beta } \vert \vert _ { 2 } ^ { 2 } } \\ & { \quad = \sigma ^ { 2 } + \vert \vert \vert \theta - P ^ { T } P \theta \vert \vert _ { 2 } ^ { 2 } + \vert \vert \beta ^ { * } - \hat { \beta } \vert \vert _ { 2 } ^ { 2 } } \end{array}
+$$
+
+The cross terms in Line (22) vanish because the first-order optimality condition for $\beta ^ { * }$ implies that $\beta ^ { * }$ satisfies $P ( \theta ^ { * } - P ^ { T } \beta ^ { * } ) = 0$ . We now simplify each of the two remaining terms.
+
+First, we have that:
+
+$$
+\underset { P } { \mathbb { E } } | | \theta - P ^ { T } P \theta | | _ { 2 } ^ { 2 } = ( 1 - \frac { d } { p } ) | | \theta | | _ { 2 } ^ { 2 }
+$$
+
+since $P ^ { T } P$ is an orthogonal projection onto a random $d$ -dimensional subspace.
+
+Now, recall we have ${ \vec { y } } = X \theta + \eta$ where $\eta \sim \mathcal { N } ( 0 , \sigma ^ { 2 } I _ { n } )$ . Expand this as:
+
+$$
+\begin{array} { l } { { \vec { y } = X \theta + \eta } } \\ { { \ = X P ^ { T } P \theta + X ( 1 - P ^ { T } P ) \theta + \eta } } \\ { { \ = \widetilde { X } \beta ^ { * } + \varepsilon + \eta } } \end{array}
+$$
+
+where $\varepsilon : = X ( 1 - P ^ { T } P ) \theta$ . Note that conditioned on $P$ , the three terms $\widetilde { X } , \varepsilon$ and $\eta$ are conditionally independent, since $P ^ { T } P$ and $( I - P ^ { T } P )$ project $X$ onto orthogonal subspaces. And further, $\varepsilon \sim$ $\mathcal { N } ( \dot { 0 _ { \cdot } } | | ( 1 - P ^ { T } P ) \theta | | ^ { 2 } I _ { n } )$ .
+
+$$
+\begin{array} { r l } & { \frac { \mathbb { E } } { P } \underset { \tilde { X } , y } { \mathbb { E } } | | \hat { \boldsymbol { \beta } } - \boldsymbol { \beta } ^ { * } | | _ { 2 } ^ { 2 } } \\ & { = \underset { P } { \mathbb { E } } \underset { \tilde { X } , y } { \mathbb { E } } | | ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } \boldsymbol { y } - \boldsymbol { \beta } ^ { * } | | _ { 2 } ^ { 2 } } \\ & { = \underset { P } { \mathbb { E } } \underset { \tilde { X } , y , \varepsilon , \eta } { \mathbb { E } } | | ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } ( \widetilde { X } \boldsymbol { \beta } ^ { * } + \varepsilon + \eta ) - \boldsymbol { \beta } ^ { * } | | _ { 2 } ^ { 2 } } \\ & { = \underset { P } { \overset { \mathbb { E } } { \mathbb { X } } } \underset { y , \varepsilon , \eta } { \mathbb { E } } | | ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } \widetilde { X } \boldsymbol { \beta } ^ { * } - \boldsymbol { \beta } ^ { * } | | _ { 2 } ^ { 2 } } \\ & { = \underset { P } { \overset { \mathbb { E } } { \mathbb { X } } } \underset { y , \varepsilon , \eta } { \mathbb { E } } | | ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } \widetilde { X } \boldsymbol { \beta } ^ { * } - \boldsymbol { \beta } ^ { * } | | _ { 2 } ^ { 2 } } \\ & { + \| ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } \varepsilon | | _ { 2 } ^ { 2 } + | | ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } \eta | | _ { 2 } ^ { 2 } ] } \end{array}
+$$
+
+Now, since $\widetilde { X }$ is conditionally independent of $\varepsilon$ conditioned on $P$ ,
+
+$$
+\begin{array} { r l } & { \frac { \mathbb { E } } { F } \underset { \tilde { X } , y , \varepsilon | P } { \mathbb { E } } \ \lVert ( \tilde { X } ^ { T } \tilde { X } + \lambda I ) ^ { - 1 } \tilde { X } ^ { T } \varepsilon \rVert _ { 2 } ^ { 2 } } \\ & { = \mathbb { E } \ \underset { \tilde { Y } } { \mathbb { E } } \ [ \lVert ( \tilde { X } ^ { T } \tilde { X } + \lambda I ) ^ { - 1 } \tilde { X } ^ { T } \rVert _ { F } ^ { 2 } \ \underset { \varepsilon | P } { \mathbb { E } } [ \lVert \varepsilon \rVert _ { 2 } ^ { 2 } ] } \\ & { = \frac { \mathbb { E } } { \frac { \mathbb { E } } { \tilde { X } } } \lVert ( \tilde { X } ^ { T } \tilde { X } + \lambda I ) ^ { - 1 } \tilde { X } ^ { T } \rVert _ { F } ^ { 2 } \ \underset { \varepsilon , \varepsilon } { \mathbb { E } } [ \lVert \varepsilon \rVert _ { 2 } ^ { 2 } ] } \\ & { = \underset { \tilde { X } } { \mathbb { E } } [ \lVert ( \tilde { X } ^ { T } \tilde { X } + \lambda I ) ^ { - 1 } \tilde { X } ^ { T } \rVert _ { F } ^ { 2 } ] \cdot \underset { { P } , X } { \mathbb { E } } [ \lVert X ( 1 - P ^ { T } P ) \theta \rVert _ { 2 } ^ { 2 } ] } \\ & { = \underset { \tilde { X } } { \mathbb { E } } [ \lVert ( \tilde { X } ^ { T } \tilde { X } + \lambda I ) ^ { - 1 } \tilde { X } ^ { T } \rVert _ { F } ^ { 2 } ] ( \frac { p - d } { p } | \theta \rVert _ { 2 } ^ { 2 } ) } \end{array}
+$$
+
+where Line (37) holds because the marginal distribution of $\widetilde { X }$ does not depend on $P$ .
+
+Similarly,
+
+$$
+\begin{array} { r l } & { \frac { \mathbb { E } } { P } \underset { \widetilde { X } , y , \eta | P } { \mathbb { E } } | | ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } \eta | | _ { 2 } ^ { 2 } } \\ & { = \sigma ^ { 2 } \underset { \widetilde { X } } { \mathbb { E } } [ | | ( \widetilde { X } ^ { T } \widetilde { X } + \lambda I ) ^ { - 1 } \widetilde { X } ^ { T } | | _ { F } ^ { 2 } ] } \end{array}
+$$
+
+Now let $\tilde { \cal X } \ = \ { \cal U } \Sigma { \cal V } ^ { T }$ be the full singular value decomposition of $\widetilde { X }$ , with $U \ \in \ \mathbb { R } ^ { n \times n } , \Sigma \ \in$ $\mathbb { R } ^ { n \times d } , V \in \mathbb { R } ^ { d \times d }$ . Let $( \gamma _ { 1 } , \dots \gamma _ { m } )$ denote the singular values, where $m = \operatorname* { m a x } ( n , d )$ and defining $\gamma _ { i } = 0$ for $i > \operatorname* { m i n } ( n , d )$ .
+
+Observe that by symmetry, $\widetilde { X } = X P ^ { T }$ and $P$ are independent, because the joint distribution $( \widetilde { X } , P )$ is equivalent to the distribution $( \widetilde { X } Q , P Q )$ for a random orthonormal $Q \in \mathbb { R } ^ { p \times p }$ . Thus $\widetilde { X }$ and
+
+$\beta ^ { * } = P \theta$ are also independent, and we have:
+
+$$
+\begin{array} { r l } & { \mathbb { E } \mathbb { E } \| \{ \hat { X } ^ { \prime } \} \hat { X } + \lambda \mathcal { I } \} ^ { - 1 } \hat { X } ^ { \prime } \hat { X } ^ { \prime } - \delta ^ { * } \} \| _ { 2 } ^ { 2 } } \\ & { = \frac { 1 } { b } \mathbb { E } \hat { X } ^ { \prime } \| \mathrm { H i s s } ( \hat { \mathcal { Z } } _ { \frac { e } { 2 } } ^ { - 1 } \lambda ) b ^ { \mathcal { N } / 2 } \| _ { 2 } ^ { 2 } } \\ & { = \mathbb { E } \mathbb { E } \mathbb { E } \mathbb { E } \mathbb { E } \bigg [ \| \mathrm { H i s s } ( \hat { \mathcal { Z } } _ { \frac { e } { 2 } } ^ { - 1 } \lambda ) \| ^ { \mathcal { N } / 2 } b ^ { \mathcal { N } / 2 } \| _ { 2 } ^ { 2 } } \\ & { - \mathbb { E } \mathbb { E } \mathbb { E } \mathbb { E } \bigg [ \| \mathrm { H i s s } ( \hat { \mathcal { Z } } _ { \frac { e } { 2 } } ^ { - 1 } \lambda ) \| ^ { \mathcal { N } / 2 } \bigg ] \| _ { 2 } ^ { 2 } } \\ & { = \mathbb { E } _ { \hat { X } ^ { \prime } \sim \mathrm { N } \times \mathrm { W } ( \hat { \mathcal { Z } } ) } \mathbb { E } \| \mathrm { H i s s } ( \hat { \mathcal { Z } } _ { \frac { e } { 2 } } ^ { - 1 } \lambda ) \| ^ { \mathcal { N } / 2 } } \\ & { = \mathbb { E } \mathbb { E } \| \hat { X } ^ { \prime } \| ^ { 2 } \mathbb { E } \| \mathrm { H } ^ { 2 } \mathbb { E } \bigg [ \mathrm { H } _ { \frac { e } { 2 } } ^ { - 1 } \lambda \Big ] ^ { \| \mathcal { N } / 2 } } \\ & { = \frac { 1 } { b } \mathbb { E } \hat { X } ^ { \prime } \| ^ { 2 } \mathbb { E } \bigg [ \mathcal { P } _ { \frac { e } { 2 } } ^ { - 1 } \frac { \lambda ^ { 2 } } { b } \Big ] ^ { 2 } } \\ &  = \frac { 1 } { b } \mathbb { E } \frac { \hat { X } ^ { \prime } } { \| \mathcal { P } \| \mathcal { P } \| ^ { 2 } \| _ { 2 } ^ { 2 } } \mathbb { E } \bigg [ \int _ { 0 } ^ { \mathcal { N } / 2 } \frac { \lambda ^ { 2 } }  \| \mathcal { P } \| _ { 2 } ^ { 2 } \end{array}
+$$
+
+Finally, continuing from Line (33), we can use Lines (38), (40), and (47) to write:
+
+$$
+\begin{array} { r l } & { \frac { \mathbb { E } } { \rho } \frac { \| \tilde { \rho } - \tilde { \rho } ^ { - 1 } \| ^ { 2 } } { \mathcal { F } _ { x , y } } } \\ & { = ( \sigma ^ { 2 } + \frac { \rho - \tilde { \rho } - d } { p } \| \theta \| _ { 2 } ^ { 2 } \frac { \mathbb { E } \| ( \tilde { X } ^ { \mathcal { T } } \tilde { X } + \lambda I ) ^ { - 1 } \tilde { X } ^ { \mathcal { T } } \| _ { \mathcal { F } _ { x } ^ { 1 } } ^ { 2 } } { \mathcal { F } _ { x } ^ { 1 } } } \\ & { + \frac { d } { \gamma } \| \theta \| _ { 2 } ^ { 2 } \frac { \mathbb { E } } { \varepsilon } \| \sum _ { i } ^ { 2 } \frac { \lambda ^ { 2 } } { ( \sqrt { d } ^ { 2 } + \lambda I ) ^ { 2 } } | } \\ & { = ( \sigma ^ { 2 } + \frac { p - d } { p } \| \theta \| _ { 2 } ^ { 2 } ) \frac { \mathbb { E } } { \Sigma } \frac { \gamma ^ { 2 } } { \varepsilon } \langle \frac { \eta _ { i } ^ { 2 } } { ( \sqrt { d } ^ { 2 } + \lambda I ) ^ { 2 } } | } \\ & { + \frac { d } { \gamma ^ { 2 } } \| \theta \| _ { 2 } ^ { 2 } \frac { \mathbb { E } } { \Sigma } \frac { \lambda ^ { 2 } } { \langle \frac { \eta _ { i } ^ { 2 } + \lambda I \rangle ^ { 2 } } { \varepsilon } } | } \\ &  = \frac { \mathbb { E } } { \nu } \langle \frac { ( \sigma ^ { 2 } + \frac { p - d - \tilde { \rho } - \tilde { \rho } - \tilde { \rho } - \tilde { \rho } } { i } ) | \theta \rangle _ { 2 } ^ { 2 } \sqrt { \frac { \lambda ^ { 2 } } { \varepsilon } + \frac { d } { \gamma ^ { 2 } } | \theta | _ { 2 } ^ { 2 } \lambda ^ { 2 } } } \end{array}
+$$
+
+Now, we can continue from Line (24), and apply lines (25), to conclude:
+
+$$
+\begin{array} { r l } & { \mathbb { E } \big [ R ( \hat { \beta } ) \big ] = \sigma ^ { 2 } + \mathbb { E } [ | | \theta - P ^ { T } P \theta | | _ { 2 } ^ { 2 } ] + \mathbb { E } [ | | \beta ^ { * } - \hat { \beta } | | _ { 2 } ^ { 2 } ] } \\ & { \qquad = \sigma ^ { 2 } + ( 1 - \frac { d } { p } ) | | \theta | | _ { 2 } ^ { 2 } } \\ & { \qquad + \mathbb { E } \left[ \displaystyle \sum _ { i = 1 } ^ { p } \frac { \big ( \sigma ^ { 2 } + \frac { p - d } { p } | | \theta | | _ { 2 } ^ { 2 } \big ) \gamma _ { i } ^ { 2 } + \frac { d } { p ^ { 2 } } | | \theta | | _ { 2 } ^ { 2 } \lambda ^ { 2 } } { \big ( \gamma _ { i } ^ { 2 } + \lambda \big ) ^ { 2 } } \right] } \end{array}
+$$
+
+Proof of Theorem 3. This follows analogously to the proof of Theorem 1, Let $\widetilde { X } _ { d }$ and $\widetilde { X } _ { d + 1 }$ be the observed data matrices for $d$ and $d + 1$ e emodel size. As in Theorem 1, there exists a coupling $\Pi$ between the distributions $\Gamma _ { d }$ and $\Gamma _ { d + 1 }$ of the singular values of $\widetilde { X } _ { d }$ and $\widetilde { X } _ { d + 1 }$ such that these singular values are interlaced.
+
+Thus by Lemma 3,
+
+$$
+\begin{array} { l } { \overline { { R } } ( \hat { \beta } _ { d } ^ { \mathrm { o p t } } ) = \widetilde { \sigma } ^ { 2 } + \underset { ( \gamma _ { 1 } , \ldots , \gamma _ { m } ) \sim \Gamma _ { d + 1 } } { \mathbb { E } } \left[ \overset { p } { \underset { i = 1 } { \sum } } \frac { \widetilde { \sigma } ^ { 2 } } { \gamma _ { i } ^ { 2 } + \frac { \widetilde { \sigma } ^ { 2 } p ^ { 2 } } { d | \boldsymbol { \theta } | | _ { 2 } ^ { 2 } } } \right] } \\ { \geq \widetilde { \sigma } ^ { 2 } + \underset { ( \widetilde { \gamma } _ { 1 } , \ldots , \widetilde { \gamma } _ { m } ) \sim \Gamma _ { d + 1 } } { \mathbb { E } } \left[ \overset { p } { \underset { i = 1 } { \sum } } \frac { \widetilde { \sigma } ^ { 2 } } { \widetilde { \gamma } _ { i } ^ { 2 } + \frac { \widetilde { \sigma } ^ { 2 } p ^ { 2 } } { d | \boldsymbol { \theta } | | _ { 2 } ^ { 2 } } } \right] } \\ { = \overline { { R } } ( \hat { \beta } _ { d + 1 } ^ { \mathrm { o p t } } ) } \end{array}
+$$
+
+# A.3 NONISOTROPIC REDUCTION
+
+Here we observe that results on isotropic regression in Section 2 also imply that ridge regression can be made sample-monotonic even for non-isotropic covariates, if an appropriate regularzier is applied. Specifically, the regularizer depends on the covariance on the inputs. This follows from a general equivalence between the non-isotropic and isotropic problems.
+
+Lemma 5. For all $n \in \mathbb { N } , d \in \mathbb { N } , \lambda \in \mathbb { R } , \sigma \in \mathbb { R } ,$ covariance $\Sigma \in \mathbb { R } ^ { d \times d }$ , PSD matrix $M \in \mathbb { R } ^ { d \times d }$ and ground-truth $\beta ^ { * } \in \mathbb { R } ^ { d }$ , the following holds.
+
+Consider the following two problems:
+
+1. Regularized regression on isotropic covariates, and an $M$ -regularizer. That is, suppose $n$ samples $( x , y )$ are drawn with covariates $x \sim \mathcal { N } ( 0 , I _ { d } )$ and response $y = \langle \beta ^ { * } , x \rangle +$ $\mathcal { N } ( 0 , \bar { \sigma } ^ { 2 } )$ . Let $\ b { \hat { X } } \in \mathbb { R } ^ { n \times d }$ be the matrix of covariates, and $\vec { y }$ the vector of responses. Consider
+
+$$
+{ \hat { \beta } } _ { \lambda } : = \operatorname * { a r g m i n } _ { \beta } | | X \beta - { \vec { y } } | | _ { 2 } ^ { 2 } + \lambda | | \beta | | _ { M } ^ { 2 }
+$$
+
+Let $\overline { { R } } = \mathbb { E } _ { X , y } [ | | \hat { \beta } - \beta ^ { * } | | _ { 2 } ^ { 2 } ] + \sigma ^ { 2 }$ be the expected test risk of the above estimator.
+
+2. Regularized regression with covariance $\Sigma$ , and an $( \Sigma ^ { 1 / 2 } M \Sigma ^ { 1 / 2 } )$ -regularizer. That is, suppose $n$ samples $( \widetilde { x } , y )$ are drawn with covariates $\widetilde { x } \sim \mathcal { N } ( 0 , \Sigma )$ and response $y =$ $\langle z ^ { \ast } , \widetilde { x } \rangle + \mathcal { N } ( 0 , \widetilde { \sigma } ^ { 2 } )$ e, for
+
+$$
+z ^ { * } = \Sigma ^ { - 1 / 2 } \beta ^ { * }
+$$
+
+Let $\widetilde { X } \in \mathbb { R } ^ { n \times d }$ be the matrix of covariates, and $\vec { y }$ the vector of responses. Consider
+
+$$
+\hat { z } _ { \lambda } : = \operatorname * { a r g m i n } _ { z } | | \widetilde { X } z - \vec { y } | | _ { 2 } ^ { 2 } + \lambda | | z | | _ { \Sigma ^ { 1 / 2 } M \Sigma ^ { 1 / 2 } } ^ { 2 }
+$$
+
+Let $\widetilde { R } = \mathbb { E } _ { \widetilde { X } , y } [ | | \hat { z } - z ^ { * } | | _ { \Sigma } ^ { 2 } ] + \sigma ^ { 2 }$ be the expected test risk of the above estimator.
+
+Then, the expected test risks of the above two problems are identical:
+
+$$
+\overline { { R } } = \widetilde { R }
+$$
+
+Proof of Lemma 5. The distribution of $\widetilde { X }$ in the Problem 2 is equivalent to $X \Sigma ^ { 1 / 2 }$ , where $X$ is as in Problem 1. Thus, the two settings are equivalent by the change-of-variable $\beta = \Sigma ^ { 1 / 2 } z$ . Specifically,
+
+$$
+\begin{array} { r l } & { \hat { z } _ { \lambda } : = \underset { z } { \mathrm { a r g m i n } } \left| \lvert \tilde { X } z - \bar { y } \rvert \right| _ { 2 } ^ { 2 } + \lambda \lvert | z \rvert | _ { \Sigma ^ { 1 / 2 } M \Sigma ^ { 1 / 2 } } ^ { 2 } } \\ & { = \underset { z } { \mathrm { a r g m i n } } \left| \lvert X \Sigma ^ { 1 / 2 } z - \bar { y } \rvert \right| _ { 2 } ^ { 2 } + \lambda z ^ { T } \Sigma ^ { 1 / 2 } M \Sigma ^ { 1 / 2 } z } \\ & { = \underset { z } { \mathrm { a r g m i n } } \left| \lvert X \Sigma ^ { 1 / 2 } z - \bar { y } \rvert \right| _ { 2 } ^ { 2 } + \lambda z ^ { T } \Sigma ^ { 1 / 2 } M \Sigma ^ { 1 / 2 } z } \\ & { = \Sigma ^ { - 1 / 2 } \underset { \beta = \Sigma ^ { 1 / 2 } z } { \mathrm { a r g m i n } } \left| \lvert X \beta - \bar { y } \rvert \right| _ { 2 } ^ { 2 } + \lambda \beta ^ { T } M \beta } \end{array}
+$$
+
+Further, the response $\langle z ^ { * } , { \widetilde { x } } \rangle = \langle \beta , x \rangle$ , and the test risk transforms identically:
+
+$$
+\begin{array} { r } { \widetilde { R } = \underset { \widetilde { X } , y } { \mathbb { E } } \left[ \vert \vert \hat { z } - z ^ { * } \vert \vert _ { \Sigma } ^ { 2 } \right] + \sigma ^ { 2 } } \\ { = \underset { X , y } { \mathbb { E } } \left[ \vert \vert \hat { \beta } - \beta ^ { * } \vert \vert _ { 2 } ^ { 2 } \right] + \sigma ^ { 2 } } \\ { = \overline { { R } } } \end{array}
+$$
+
+This implies that if the covariance $\Sigma$ is known, then ridge regression with a $\Sigma ^ { - 1 }$ regularizer is sample-monotonic.
+
+Theorem 5. For all $n \in \mathbb { N } , d \in \mathbb { N } , \sigma \in \mathbb { R } ,$ , covariance $\Sigma \in \mathbb { R } ^ { d \times d }$ , and ground-truths $\beta ^ { * } \in \mathbb { R } ^ { d }$ , th e following holds.
+
+Suppose $n$ samples $( x , y )$ are drawn with covariates $x \sim \mathcal { N } ( 0 , \Sigma )$ and response $y = \langle \beta ^ { * } , x \rangle +$ ${ \mathcal { N } } ( 0 , \sigma ^ { 2 } )$ . Let $\ b { X } \in \mathbb { R } ^ { n \times d }$ be the matrix of covariates, and $\vec { y }$ the vector of responses. For $\lambda > 0$ , consider the ridge regression estimator with $\Sigma ^ { - 1 }$ -regularizer:
+
+$$
+\hat { \beta } _ { n , \lambda } : = \operatorname * { a r g m i n } _ { \boldsymbol { \beta } } \| X \boldsymbol { \beta } - \vec { y } \| _ { 2 } ^ { 2 } + \lambda \| \boldsymbol { \beta } \| _ { \Sigma ^ { - 1 } } ^ { 2 }
+$$
+
+Let $\overline { { R } } ( \hat { \beta } _ { n , \lambda } ) : = \mathbb { E } _ { \hat { \beta } } \| \hat { \beta } - \beta ^ { * } \| _ { \Sigma } + \sigma ^ { 2 }$ be the expected test risk of the above estimator. Let $\lambda _ { n } ^ { \mathrm { o p t } }$ be the optimal ridge parameter (that achieves the minimum expected risk) given $n$ samples:
+
+$$
+\lambda _ { n } ^ { \mathrm { o p t } } : = \operatorname * { a r g m i n } _ { \lambda } \overline { { R } } ( \hat { \beta } _ { n , \lambda } ) )
+$$
+
+And let $\hat { \beta } _ { n } ^ { \mathrm { { o p t } } }$ be the estimator that corresponds to the $\lambda _ { n } ^ { \mathrm { o p t } }$ . Then, the expected test risk of optimallyregularized linear regression is monotonic in samples:
+
+$$
+\overline { { R } } ( \hat { \beta } _ { n + 1 } ^ { \mathrm { o p t } } ) \leq \overline { { R } } ( \hat { \beta } _ { n } ^ { \mathrm { o p t } } )
+$$
+
+Proof. This follows directly by applying the reduction in Lemma 5 for $M = I _ { d }$ to reduce to the isotropic case, and then applying the monotonicity of isotropic regression from Theorem 1. □
+
+# A.4 ADDITIONAL PLOTS
+
+We apply random features to Fashion-MNIST Xiao et al. (2017), an image classification problem with 10 classes. Input images $x \in \mathbb { R } ^ { d }$ are normalized and flattened to $[ - \bar { 1 } , 1 ] ^ { d }$ for $d = 7 8 4$ . Class labels are encoded as one-hot vectors $y \in \{ \vec { e _ { 1 } } , \dots e _ { 1 0 } ^ {  } \} \subset \mathbb { R } ^ { 1 0 }$ .
+
+# B TOWARDS MONOTONICITY WITH GENERAL COVARIATES
+
+Here we investigate whether monotonicity provably holds in more general models, inspired by the experimental results. As a first step, we consider Gaussian (but not isotropic) covariances and homeostatic noise. That is, we consider ridge regression in the setting of Section 2, but with $x \sim \mathcal { N } ( 0 , \Sigma )$ , and $y \sim \langle x , \beta ^ { * } \rangle + N ( 0 , \sigma ^ { 2 } )$ . In this section, we observe that ridge regression can be made sample-monotonic with a modified regularizer. We also conjecture that ridge regression is sample-monotonic without modifying the regularizer, and we outline a potential proof strategy along with numerical evidence.
+
+# B.1 ADAPTIVE REGULARIZATION
+
+The results on isotropic regression in Section 2 imply that ridge regression can be made samplemonotonic even for non-isotropic covariates, if an appropriate regularizer is applied. Specifically, the appropriate regularizer depends on the covariance of the inputs. For $\boldsymbol { x } \sim \mathcal { N } ( 0 , \Sigma )$ , the following estimator is sample-monotonic for optimally-tuned $\lambda$ : $\begin{array} { r } { \hat { \beta } _ { n , \lambda } : = \operatorname * { a r g m i n } _ { \boldsymbol { \beta } } \| X \boldsymbol { \beta } - \vec { y } \| _ { 2 } ^ { 2 } + \lambda \| \boldsymbol { \beta } \| _ { \Sigma ^ { - 1 } } ^ { 2 } } \end{array}$ . This follows directly from Theorem 1 by applying a change-of-variable; full details of this equivalence are in Section A.3. Note that if the population covariance $\Sigma$ is not known, it can potentially be estimated from unlabeled data.
+
+![](images/6d706f197addd390fb2defce66fd1cd5af413a8242fbc58ab89186d03af9186f.jpg)  
+Test Error for Regularized Random Features
+
+(a) Test Classification Error vs. Number of Training Samples.
+
+![](images/ce3f799d5bd5415e26ca617c4e47e654875a8b6c2557b5bf3b3c7007b6a14a4f.jpg)  
+Test Errorfor Regularized Random Features   
+(b) Test Classification Error vs. Model Size (Number of Random Features).
+
+Figure 4: Double-descent for Random ReLU Features. Test classification error as a function of model size and sample size for Random ReLU Features on Fashion-MNIST. Left: with $D = 5 0 0$ features. Right: with $n = 5 0 0$ samples. See Figures 7, 8 for the corresponding test Mean Squared Error. See Appendix D of Nakkiran et al. (2020) for the performance of these unregularized models plotted across Num. Samples $\times$ Model Size simultaneously.
+
+![](images/05df2a46592e323dc1205edaa5fa11d2355d7bba6df96212a7b9f700cd4a121b.jpg)  
+Figure 5: Train Error vs. Model Size for 5-layer CNNs on CIFAR-100, with $\ell _ { 2 }$ regularization (weight decay).
+
+# B.2 TOWARDS PROVING MONOTONICITY
+
+We conjecture that optimally-regularized ridge regression is sample-monotonic for non-isotropic covariates, even without modifying the regularizer (as suggested by the experiment in Figure 2). We derive a sufficient condition for monotonicity, which we have numerically verified in a variety of instances. Specifically, we conjecture the following.
+
+Conjecture 1. For all $d \in \mathbb { N }$ , and all PSD covariances $\Sigma \in \mathbb { R } ^ { d \times d }$ , consider the distribution on $( x , y )$ where $x \sim \mathcal { N } ( 0 , \Sigma )$ , and $y \sim \langle x , \beta ^ { * } \rangle + \mathcal { N } ( 0 , \sigma ^ { 2 } )$ . Then, we conjecture that the expected test risk of the ridge regression estimator: $\begin{array} { r } { \hat { \beta } _ { n , \lambda } : = \operatorname * { a r g m i n } _ { \boldsymbol { \beta } } \| X { \boldsymbol { \beta } } - \vec { y } \| _ { 2 } ^ { 2 } + \lambda \| { \boldsymbol { \beta } } \| _ { 2 } ^ { 2 } } \end{array}$ for optimally-tuned $\lambda \geq 0$ , is monotone non-increasing in number of samples $n$ . That is, for all $n \in \mathbb { N }$ ,
+
+$$
+\operatorname * { i n f } _ { \lambda \geq 0 } \overline { { { R } } } ( \hat { \beta } _ { n + 1 , \lambda } ) \leq \operatorname * { i n f } _ { \lambda \geq 0 } \overline { { { R } } } ( \hat { \beta } _ { n , \lambda } )
+$$
+
+where we define $\begin{array} { r } { \hat { \beta } _ { n , 0 } : = \operatorname* { l i m } _ { \lambda \to 0 + } \hat { \beta } _ { n , \lambda } = X ^ { \dagger } y } \end{array}$ .
+
+![](images/d4048491df9a41611fd80fea0aeac569328ee316a77886c71b4c9d4ba9170d40.jpg)  
+Figure 6: Train MSE vs. Num. Samples for Non-Isotropic Ridge Regression in $d = 3 0$ dimensions, in the setting of Figure 2. Plotting train MSE: $\begin{array} { r } { \frac { 1 } { n } | | X \hat { \boldsymbol { \beta } } - \vec { y } | | _ { 2 } ^ { 2 } } \end{array}$ .
+
+![](images/aa84a8ffbd2beefb1d745ab29a4ccc613c56c1dfa1eef8d51380a0483dcffecb.jpg)  
+Figure 7: Test Mean Squared Error vs. Num Train Samples for Random ReLU Features on FashionMNIST, with $D = 5 0 0$ features.
+
+In Appendix B.3 we present a technical conjecture in random matrix theory (Conjecture 2) which suffices to prove Conjecture 1. Proving this Conjecture 2 presents a number of technical challenges, but we have numerically verified it in a variety of cases. It can also be shown that Conjecture 2 is true when $Q = I$ , corresponding to isotropic covariates. We prove the reduction between Conjecture 2 and 1 in Appendix B.3.
+
+# B.3 MONOTONICITY CONJECTURE PROOFS
+
+In order to establish Conjecture 1, it is sufficient to prove the following technical conjecture.
+
+![](images/8eda0db61a5bd63cb07df9565b6981c5a80a7fd865e013f9ce281e419515418e.jpg)  
+Figure 8: Test Mean Squared Error vs. Num Features for Random ReLU Features on FashionMNIST, with $n = 5 0 0$ samples.
+
+Conjecture 2. For all $n \in \mathbb { N } , d \geq n , \lambda > 0$ , symmetric positive definite matrix $Q \in \mathbb { R } ^ { d \times d }$ , the following holds.
+
+Define
+
+$$
+G _ { \lambda } ^ { n } : = \lambda ^ { 2 } \underset { X } { \mathbb { E } } [ ( X ^ { T } X + \lambda Q ) ^ { - 2 } ]
+$$
+
+where $\ b { X } \in \mathbb { R } ^ { n \times d }$ is sampled with each entry i.i.d. $\mathcal { N } ( 0 , 1 )$ . Similarly, define
+
+$$
+H _ { \lambda } ^ { n } : = \mathbb { E } [ | | X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } | | _ { F } ^ { 2 } ]
+$$
+
+The expected test risk for $n$ samples can be expressed as:
+
+$$
+\overline { { { R } } } ( \hat { \beta } _ { n , \lambda } ) = ( \beta ^ { * } ) ^ { T } G _ { \lambda } ^ { n } \beta ^ { * } + \sigma ^ { 2 } H _ { \lambda } ^ { n } + \sigma ^ { 2 }
+$$
+
+Then, we conjecture that the following two conditions hold.
+
+1.
+
+$$
+G _ { \lambda } ^ { n } \succeq G _ { \lambda } ^ { n + 1 }
+$$
+
+2.
+
+$$
+( G _ { \lambda } ^ { n } - G _ { \lambda } ^ { n + 1 } ) - ( H _ { \lambda } ^ { n } - H _ { \lambda } ^ { n + 1 } ) \frac { d G _ { \lambda } ^ { n } / d \lambda } { d H _ { \lambda } ^ { n } / d \lambda } \succeq 0
+$$
+
+Lemma 6. Conjecture 2 implies Conjecture $^ { l }$
+
+Proof. By the reduction in Section A.3, showing monotonicity for non-isotropic regression with an isotropic regularizer is equivalent to showing monotonicity for isotropic regression with a nonisotropic regularizer. Thus, we consider the latter. Specifically, Conjecture 1 is equivalent to showing monotonicity for the estimator
+
+$$
+\begin{array} { r l } {  { \hat { \beta } _ { n , \lambda } : = \operatorname * { a r g m i n } _ { \beta } \| X \beta - \vec { y } \| _ { 2 } ^ { 2 } + \lambda \| \beta \| _ { \Sigma ^ { - 1 } } ^ { 2 } } } \\ & { = ( X ^ { T } X + \lambda \Sigma ^ { - 1 } ) ^ { - 1 } X ^ { T } y } \end{array}
+$$
+
+where $x \sim \mathcal { N } ( 0 , I )$ is isotropic, and $y \sim \langle x , \beta ^ { * } \rangle + \mathcal { N } ( 0 , \sigma ^ { 2 } )$ .
+
+Now, letting $\boldsymbol { Q } : = \boldsymbol { \Sigma } ^ { - 1 }$ , the expected test risk of this estimator for $n$ samples is:
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ \left. \hat { \beta } _ { n , \lambda } \right. = \underset { X , y } { \mathbb { E } } [ \left. \hat { \beta } _ { n , \lambda } - \beta ^ { * } \right. _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { \quad = \underset { X , y } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } y - \beta ^ { * } \right. _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { \quad = \underset { X , \eta = N ; 0 } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } ( X \beta ^ { * } + \eta ) - \beta ^ { * } \right. _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { \quad = \underset { X , \eta = N ; 0 } { \mathbb { E } } [ ( 0 , \lambda ^ { 2 } Y ^ { T } \eta _ { n } ^ { 2 } ) ] \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } ( X \beta ^ { * } + \eta ) - \beta ^ { * } \right. _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { \quad = \underset { X } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } X \beta ^ { * } - \beta ^ { * } ) \right. _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } \underset { X } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } \right. _ { F } ^ { 2 } ] + \sigma ^ { 2 } } \\ & { \quad = \underset { X } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } ( X ^ { T } X + \lambda Q - \lambda Q ) \beta ^ { * } - \beta ^ { * } ) \right. _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } \underset { X } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } \right. _ { F } ^ { 2 } ] } \\ &  \quad = \lambda ^ { 2 } \underset { X } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } \right. _ { 2 } ^ { 2 } ] + \sigma ^ { 2 } \underset { X } { \mathbb { E } } [ \left. ( X ^ { T } X + \lambda Q ) ^ { - 1 } X ^ { T } \right. _ { F } ^ { 2 } ] + \sigma \end{array}
+$$
+
+Consider the infimum
+
+$$
+\operatorname* { i n f } _ { \lambda \geq 0 } { \overline { { R } } } ( { \hat { \beta } } _ { n , \lambda } )
+$$
+
+We consider several cases below.
+
+Case (1). Suppose the infimum in Equation 71 is achieved in the limit $\lambda \to + \infty$ . In this case, monotonicity trivially holds, since
+
+$$
+\operatorname* { l i m } _ { \lambda \to \infty } \overline { { { R } } } ( \hat { \beta } _ { n , \lambda } ) = \overline { { { R } } } ( \vec { 0 } ) = \operatorname* { l i m } _ { \lambda \to \infty } \overline { { { R } } } ( \hat { \beta } _ { n + 1 , \lambda } )
+$$
+
+Case (2). Suppose the infimum in Equation 71 is achieved by some $\lambda = \lambda _ { n } ^ { \mathrm { o p t } }$ in the interior of the set $( 0 , \infty )$ .
+
+Because $\overline { { R } } ( \hat { \beta } _ { n , \lambda } )$ is continuous and differentiable in $\lambda$ for all $\lambda \in ( 0 , \infty )$ , we have that $\lambda _ { n } ^ { \mathrm { o p t } }$ must satisfy the following first-order optimality condition:
+
+$$
+\begin{array} { r } { \frac { d \overline { { R } } ( \hat { \beta } _ { n , \lambda } ) } { d \lambda } \Big | _ { \lambda = \lambda _ { n } ^ { \mathrm { o p t } } } = 0 } \\ { \implies ( \beta ^ { * } ) ^ { T } \frac { d G _ { \lambda } ^ { n } } { d \lambda } \beta ^ { * } + \sigma ^ { 2 } \frac { d H _ { \lambda } ^ { n } } { d \lambda } \Big | _ { \lambda = \lambda _ { n } ^ { \mathrm { o p t } } } = 0 } \end{array}
+$$
+
+We will later use this condition to show monotonicity.
+
+Case (3). Suppose the infimum in Equation 71 is achieved at $\lambda _ { n } ^ { \mathrm { o p t } } = 0$ . Recall, we define $\hat { \beta } _ { n , 0 } : =$ $\mathrm { l i m } _ { \lambda \to 0 + } \hat { \beta } _ { n , \lambda }$ . This means that,
+
+$$
+\frac { d \overline { { R } } ( \hat { \beta } _ { n , \lambda } ) } { d \lambda } \Big | _ { \lambda = 0 } = ( \beta ^ { * } ) ^ { T } \frac { d G _ { \lambda } ^ { n } } { d \lambda } \beta ^ { * } + \sigma ^ { 2 } \frac { d H _ { \lambda } ^ { n } } { d \lambda } \Big | _ { \lambda = 0 } \geq 0
+$$
+
+Note that since $\begin{array} { r } { \frac { d H _ { \lambda } ^ { n } } { d \lambda } \leq 0 } \end{array}$ , both Equations (73) and (74) in Case (2) and Case (3) respectively imply that
+
+$$
+\sigma ^ { 2 } \leq - \frac { ( \beta ^ { * } ) ^ { T } ( \frac { d G _ { \lambda } ^ { n } } { d \lambda } ) \beta ^ { * } } { d H _ { \lambda } ^ { n } / d \lambda } \Big \vert _ { \lambda = \lambda _ { n } ^ { \mathrm { o p t } } }
+$$
+
+Now, assuming Conjecture 2, we will show that the choice of $\lambda _ { n } ^ { \mathrm { o p t } }$ in Cases (2) and (3) has nonincreasing test risk for $( n + 1 )$ samples. That is,
+
+$$
+\overline { { R } } ( \widehat { \beta } _ { n , \lambda _ { n } ^ { \mathrm { o p t } } } ) \geq \overline { { R } } ( \widehat { \beta } _ { n + 1 , \lambda _ { n } ^ { \mathrm { o p t } } } )
+$$
+
+This implies the desired monotonicity, since R(βˆn+1,λoptn ) ≥ R(βˆn+1,λoptn+1 ).
+
+We first consider the case when $H _ { \lambda } ^ { n } - H _ { \lambda } ^ { n + 1 } | _ { \lambda = \lambda _ { n } ^ { \mathrm { o p t } } } \geq 0$ . In this case, because $G _ { \lambda } ^ { n } - G _ { \lambda } ^ { n + 1 } \succeq 0$ by assumption, we have
+
+$$
+\begin{array} { r l r } {  { \overline { { R } } ( \widehat { \beta } _ { n , \lambda _ { n } ^ { \mathrm { o p t } } } ) - \overline { { R } } ( \widehat { \beta } _ { n + 1 , \lambda _ { n } ^ { \mathrm { o p t } } } ) = ( \beta ^ { * } ) ^ { T } ( G _ { \lambda } ^ { n } - G _ { \lambda } ^ { n + 1 } ) \beta ^ { * } + \sigma ^ { 2 } ( H _ { \lambda } ^ { n } - H _ { \lambda } ^ { n + 1 } ) \Big | _ { \lambda = \lambda _ { n } ^ { \mathrm { o p t } } } } } \\ & { } & { \geq 0 \quad \quad } \end{array}
+$$
+
+Otherwise, assume. $H _ { \lambda } ^ { n } - H _ { \lambda } ^ { n + 1 } | _ { \lambda = \lambda _ { n } ^ { \mathrm { o p t } } } \leq 0$ . Then we have:
+
+$$
+\begin{array} { r l } { \overline { { R } } ( \hat { \beta } _ { n , \lambda _ { n } ^ { \smash { \mathrm { o u t } } } } ) - \overline { { R } } ( \hat { \beta } _ { n + 1 , \lambda _ { n } ^ { \smash { \mathrm { o u t } } } } ) = ( \beta ^ { * } ) ^ { T } ( G _ { \lambda } ^ { m } - G _ { \lambda } ^ { m + 1 } ) \beta ^ { * } + \sigma ^ { 2 } ( H _ { \lambda } ^ { n } - H _ { \lambda } ^ { n + 1 } ) \Big | _ { \lambda = \lambda _ { n } ^ { \smash { \mathrm { o u t } } } } } & { \qquad \mathrm { ( } } \\ & { \qquad \geq ( \beta ^ { * } ) ^ { T } ( G _ { \lambda } ^ { m } - G _ { \lambda } ^ { m + 1 } ) \beta ^ { * } - ( \beta ^ { * } ) ^ { T } ( \frac { d G _ { \lambda } ^ { n } } { d \lambda } ) \beta ^ { * } \frac { ( H _ { \lambda } ^ { n } - H _ { \lambda } ^ { n + 1 } ) } { d H _ { \lambda } ^ { \lambda } / d \lambda } \Big | _ { \lambda = \lambda _ { n } ^ { \smash { \mathrm { o u t } } } } } \\ & { \qquad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { = ( \beta ^ { * } ) ^ { T } \underbrace { \Bigg ( ( G _ { \lambda } ^ { m } - G _ { \lambda } ^ { n + 1 } ) - ( H _ { \lambda } ^ { n } - H _ { \lambda } ^ { n + 1 } ) \frac { d G _ { \lambda } ^ { m } / d \lambda } { d H _ { \lambda } ^ { n } / d \lambda } \Big ) \Big | _ { \lambda = \lambda _ { n } ^ { \mathrm { o u t } } } \beta ^ { * } } _ { \geq 0 \mathrm { b y c o n j e c u r e 2 } } } \\ & { \qquad \quad \quad \quad \quad \quad \quad \quad \quad \geq 0 } \end{array}
+$$
+
+as desired.

parse/train/ByRWCqvT-/ByRWCqvT-.md

@@ -0,0 +1,384 @@
+# LEARNING TO CLUSTER IN ORDER TO TRANSFER ACROSS DOMAINS AND TASKS
+
+Yen-Chang Hsu, Zhaoyang Lv   
+Georgia Institute of Technology   
+Atlanta, GA 30332, USA   
+{yenchang.hsu, zhaoyang.lv}@gatech.edu
+
+Zsolt Kira Georgia Tech Research Institute Atlanta, GA 30318, USA zkira@gatech.edu
+
+# ABSTRACT
+
+This paper introduces a novel method to perform transfer learning across domains and tasks, formulating it as a problem of learning to cluster. The key insight is that, in addition to features, we can transfer similarity information and this is sufficient to learn a similarity function and clustering network to perform both domain adaptation and cross-task transfer learning. We begin by reducing categorical information to pairwise constraints, which only considers whether two instances belong to the same class or not (pairwise semantic similarity). This similarity is category-agnostic and can be learned from data in the source domain using a similarity network. We then present two novel approaches for performing transfer learning using this similarity function. First, for unsupervised domain adaptation, we design a new loss function to regularize classification with a constrained clustering loss, hence learning a clustering network with the transferred similarity metric generating the training inputs. Second, for cross-task learning (i.e., unsupervised clustering with unseen categories), we propose a framework to reconstruct and estimate the number of semantic clusters, again using the clustering network. Since the similarity network is noisy, the key is to use a robust clustering algorithm, and we show that our formulation is more robust than the alternative constrained and unconstrained clustering approaches. Using this method, we first show state of the art results for the challenging cross-task problem, applied on Omniglot and ImageNet. Our results show that we can reconstruct semantic clusters with high accuracy. We then evaluate the performance of cross-domain transfer using images from the Office-31 and SVHN-MNIST tasks and present top accuracy on both datasets. Our approach doesn’t explicitly deal with domain discrepancy. If we combine with a domain adaptation loss, it shows further improvement.
+
+# 1 INTRODUCTION
+
+Supervised learning has made significant strides in the past decade, with substantial advancements arising from the use of deep neural networks. However, a large part of this success has come from the existence of extensive labeled datasets. In many situations, it is not practical to obtain such data due to the amount of effort required or when the task or data distributions change dynamically. To deal with these situations, the fields of transfer learning and domain adaptation have explored how to transfer learned knowledge across tasks or domains. Many approaches have focused on cases where the distributions of the features and labels have changed, but the task is the same (e.g., classification across datasets with the same categories). Cross-task transfer learning strategies, on the other hand, have been widely adopted especially in the computer vision community where features learned by a deep neural network on a large classification task have been applied to a wide variety of other tasks (Donahue et al., 2014).
+
+Most of the prior cross-task transfer learning works, however, require labeled target data to learn classifiers for the new task. If labels of the target data are absent, there is little choice other than to apply unsupervised approaches such as clustering on the target data with pre-trained feature representations. In this paper, we focus on the question of what can be transferred (besides features) to support both cross-domain and cross-task transfer learning. We address it with a learned similarity function as the fundamental component of clustering. Clustering can then be realized using a neural network trained using the output of the similarity function, which can be successfully used to achieve both cross-task and cross-domain transfer.
+
+The key idea is to formulate the clustering objective to use a learnable (and transferable) term, which in our proposed work is a similarity prediction function. Our proposed objective function can be easily combined with deep neural networks and optimized end-to-end. The features and clustering are optimized jointly, hence taking advantage of such side information in a robust way. Using this method, we show that unsupervised learning can benefit from learning performed on a distinct task, and demonstrate the flexibility of further combining it with a classification loss and domain discrepancy loss.
+
+In summary, we make several contributions. First, we propose to use predictive pairwise similarity as the knowledge that is transferred and formulate a learnable objective function to utilize the pairwise information in a fashion similar to constrained clustering. We then provide the methodologies to deploy the objective function in both cross-task and cross-domain scenarios with deep neural networks. The experimental results for cross-task learning on Omniglot and ImageNet show that we can achieve state of the art clustering results with predicted similarities. On the standard domain adaptation benchmark Office-31 dataset, we demonstrate improvements over state-of-art even when not performing any explicit domain adaptation, and further improvements if we do. Finally, on another domain adaptation task, SVHN-to-MNIST, our approach using Omniglot as the auxiliary dataset achieves top performance with a large margin.
+
+# 2 RELATED WORK
+
+Transfer Learning: Transfer learning aims to leverage knowledge from the source domain to help learn in the target domain, while only focusing on the performance on the target domain. The type of transferred knowledge includes training instances, features, model parameters and relational knowledge (Pan & Yang, 2010). Pairwise similarity is the meta-knowledge we propose to transfer, which falls in between the last two types. The similarity prediction function is a neural network with learned parameters, while the output is the most simplified form of relational knowledge, i.e., only considering pairwise semantic similarity.
+
+Cross-task Transfer Learning: Features learned when trained for ImageNet classification (Russakovsky et al., 2015) have boosted the performance of a variety of vision tasks in a supervised setting. For example, new classification tasks (Donahue et al., 2014; Yosinski et al., 2014), object detection (Girshick et al., 2014), semantic segmentation (Long et al., 2015a), and image captioning (Vinyals et al., 2015). Translated Learning (Dai et al., 2009) has an unsupervised setting similar to ours, but it again focuses only on transferring features across tasks. Our work explores how learning could benefit from transferring pairwise similarity in an unsupervised setting.
+
+Cross-domain Transfer Learning: Also known as domain adaptation (Pan & Yang, 2010), there has recently been a large body of work dealing with domain shift between image datasets by minimizing domain discrepancy (Tzeng et al., 2014; Long et al., 2015b; Ganin et al., 2016; Sun et al., 2016; Long et al., 2016; Sener et al., 2016; Carlucci et al., 2017; Long et al., 2017; Zellinger et al., 2017; Bousmalis et al., 2017). We address the problem in a complementary way that transfers extra information from the auxiliary dataset and show a larger performance boost with further gains using an additional domain discrepancy loss.
+
+Constrained Clustering: Constrained clustering algorithms can be categorized by how they utilize constraints (e.g. pairwise information). The first set of work use the constraints to learn a distance metric. For example, DML (Xing et al., 2003), ITML (Davis et al., 2007), SKMS (Anand et al., 2014), SKKm (Anand et al., 2014; Amid et al., 2016), and SKLR (Amid et al., 2016). This group of approaches closely relates to metric learning and needs a clustering algorithm such as K-means in a separate stage to obtain cluster assignments. The second group of work use constraints to formulate the clustering loss. For example, CSP (Wang et al., 2014) and COSC (Rangapuram & Hein, 2012). The third group uses constraints for both metric learning and the clustering objective, such as MPCKMeans (Bilenko et al., 2004) and CECM (Antoine et al., 2012). The fourth group does not use constraints at all. A generic clustering algorithms such as K-means (MacQueen et al., 1967), LSC (Chen & Cai, 2011), and LPNMF (Cai et al., 2009) all belong to this category. There is a long list of associated works and they are summarized in survey papers, e.g. Davidson & Basu (2007) and Dinler & Tural (2016). Our proposed clustering strategy belongs to the third group. The constrained clustering methods above are applied to the semi-supervised setting where the groundtruth constraints are sparsely available. In our unsupervised setting, the ground-truth is unavailable but predicted constraints are densely available. We include all four groups of algorithms in our comparison and show the advantages of the third group.
+
+![](images/e45febb1495b4ec74c335fc4134b2e9707a9552a0aad1ab6b240e7e63479843e.jpg)  
+Figure 1: Overview of the transfer scheme with a learnable clustering objective (LCO). The LCO and pairwise similarity are the two key components of our approach and are described in section 4. The dashed rectangles and light gray arrows are only available in cross-domain transfer. Details are described in section 3.
+
+# 3 THE TRANSFER LEARNING TASKS
+
+To define the transfer learning problem addressed in this work, we follow the notations used by Pan & Yang (2010). The goal is to transfer knowledge from source data $\boldsymbol { S } = ( X _ { S } , Y _ { S } )$ , where $X _ { S }$ is the set of data instances and $Y _ { S }$ is the corresponding categorical labels, to a target data noted as $T = \left( X _ { T } , Y _ { T } \right)$ . The learning is unsupervised since $Y _ { T }$ is unknown. The scenario is divided into two cases. One is $\{ Y _ { T } \} \ne \{ { \bar { Y } } _ { S } \}$ , which means the set of categories are not the same and hence the transfer is across tasks. The second case is $\{ Y _ { T } \} = \{ Y _ { S } \}$ , but with a domain shift. In other words, the marginal probability distributions of the input data are different, i.e., $P ( X _ { T } ) \neq P ( X _ { S } )$ . The latter is a cross-domain learning problem also called transductive learning. The domain adaptation approaches which have gained significant attention recently belong to the second scenario.
+
+To align with common benchmarks for evaluating transfer learning performance, we further use the notion of an auxiliary dataset and split the source data into $S = { \bar { S } } ^ { \prime } \cup A$ . $S ^ { \prime } = ( X _ { S } ^ { \prime } , Y _ { S } ^ { \prime } )$ which is only present in the cross-domain transfer scheme and has $\{ Y _ { S } ^ { \prime } \} = \{ Y _ { T } \}$ . $A = ( X _ { A } , Y _ { A } )$ is the auxiliary dataset which has a large amount of labeled data and potentially categories as well, and may or may not contain the categories of $Y _ { T }$ . For the cross task scenario, only $A$ and unlabeled $T$ are included, while cross-domain transfer involves $A$ , $S ^ { \prime }$ , and $T$ . In the following sections we use the above notations and describe the two transfer learning tasks in detail. Figure 1 illustrates how our approach relates to both tasks.
+
+Transfer across tasks: If the target task has different categories, we cannot directly transfer the classifier from source to target, and there is no labeled target data to use for fine-tuning transferred features. Here we propose to first reduce the categorization problem to a surrogate same-task problem. We can directly apply transductive transfer learning (Pan & Yang, 2010) to the transformed task. The cluster structure in the target data is then reconstructed using the predictions in the transformed task. See figure 2 for an illustration.
+
+The source involves a labeled auxiliary dataset $A$ and an unlabeled target dataset $T$ . $Y _ { T }$ is the target that must be inferred. In this scenario the set of categories $\{ Y _ { A } \} \ne \{ Y _ { T } \}$ , and $Y _ { T }$ is unknown. We first transform the problem of categorization into a pairwise similarity prediction problem. In other words, we specify a transformation function $R$ such that $R ( A ) = ( X _ { A } ^ { R ^ { \prime } } , \bar { Y } ^ { R } )$ , and $\dot { X } _ { A } ^ { R } = \{ ( x _ { A , i } , x _ { A , j } ) \} _ { \forall i , j }$ contains all pairs of data, where $\{ Y ^ { R } \} = \{ d i s s i m i l a r , s i m i l a r \}$ . The transformation on the labeled auxiliary data is straightforward. It will be similar if two data instances are from the same category, and vice versa. We then use it to learn a pairwise similarity prediction function $G ( x _ { i } , x _ { j } ) = \mathbf { \bar { \Gamma } } y _ { i , j }$
+
+![](images/2b04f9cd1aa8b76244e957c10c6c523af984b0b1e4ea8542e4f1f432440b0e65.jpg)  
+Figure 2: The concept for reconstructing clusters of unseen categories. The proposed approach follows the arrows in the counter-clockwise direction, which converts cross-task transfer learning to cross-domain transfer learning. The colors of dots represent data of different categories. The hollow circle and cross symbol represent similar and dissimilar data pairs. The $G$ function and the cluster reconstruction (via constrained clustering) are the two key components in the diagram.
+
+By applying $G$ on $T$ , we can obtain $G ( x _ { T , i } , x _ { T , j } ) = y _ { T , i , j }$ . The last step is to infer $Y _ { T }$ from $Y _ { T } ^ { R } = \{ y _ { T , i , j } \} _ { \forall i , j }$ , which can be solved using constrained clustering algorithms. Note that since the actual $Y _ { T }$ is unknown, the algorithm only infers the indices of categories, which could be in arbitrary order. The resulting clusters are expected to contain coherent semantic categories.
+
+Transfer across domains: The problem setting we consider here is the same as unsupervised domain adaptation. Following the standard evaluation procedure (Long et al., 2017; Ganin et al., 2016), the labeled datasets $A$ is ImageNet and $S ^ { \prime }$ is one domain in the Office-31 dataset. The unlabeled $T$ is another domain in Office-31. The goal is to enhance classification performance on $T$ by utilizing $A$ , $S ^ { \prime }$ , and $T$ together.
+
+# 4 THE LEARNABLE CLUSTERING OBJECTIVE (LCO)
+
+The key to our approach is the design of a learning objective that can use (noisy) predicted pairwise similarities, and is inspired from constrained clustering which involves using pairwise information in the loss function. The pairwise information is called must-link/cannot-link constraints or similar/dissimilar pairs (we use the latter). Note that the information is binarized to one and zero for similar and dissimilar pairs, accordingly.
+
+Although many constrained clustering algorithms have been developed, few of them are scalable with respect to the number of pairwise relationships. Further, none of them can be easily integrated into deep neural networks. Inspired by the work of Hsu & Kira (2016), we construct a contrastive loss for clustering on the probability outputs of a softmax classifier. However, each output node does not have to map to a fixed category but instead each output node represents a probabilistic assignment of a data point to a cluster. The assignment between output nodes and clusters are formed stochastically during the optimization and is guided by the pairwise similarity. If there is a similar pair, their output distribution should be similar, and vice-versa.
+
+Specifically, we use the pair-wise KL-divergence to evaluate the distance between $k$ cluster assignment distributions of two data instances, and use predicted similarity to construct the contrastive loss. Given a pair of data $x _ { p } , x _ { q }$ , their corresponding output distributions are defined as $\mathcal { P } = f ( x _ { p } )$ and $\mathcal { Q } = f ( x _ { q } )$ , while $f$ is the neural network. The cost of a similar pair is described as :
+
+$$
+\mathcal { L } ( \boldsymbol { x } _ { p } , \boldsymbol { x } _ { q } ) ^ { + } = \mathcal { D } _ { K L } ( \mathcal { P } ^ { \star } | | \boldsymbol { \mathcal { Q } } ) + \mathcal { D } _ { K L } ( \mathcal { Q } ^ { \star } | | \mathcal { P } )
+$$
+
+$$
+\mathcal { D } _ { K L } ( \mathcal { P } ^ { \star } | | \mathcal { Q } ) = \sum _ { c = 1 } ^ { k } p _ { c } l o g ( \frac { p _ { c } } { q _ { c } } )
+$$
+
+![](images/b7321399ab1bca7f870eb89cd648d445662c407854095766daa46df0319beb58.jpg)  
+Figure 3: The similarity prediction network (the $G$ function).
+
+The cost $\mathcal { L } ( x _ { p } , x _ { q } ) ^ { + }$ is symmetric w.r.t. $x _ { p } , x _ { q }$ , in which ${ \mathcal { P } } ^ { \star }$ and $\mathcal { Q } ^ { \star }$ are alternatively assumed to be constant. Each KL-divergence factor $\hat { \mathcal { D } } _ { K L } ^ { \star } ( \hat { \mathcal { P } } ^ { \star } | | \mathcal { Q } )$ becomes a unary function whose gradient is simply $\partial { \cal D } _ { K L } ( { \mathcal { P } } ^ { \star } | | { \mathcal { Q } } ) / \partial { \mathcal { Q } }$ .
+
+If $x _ { p } , x _ { q }$ comes from a pair which is dissimilar, their output distributions are expected to be different, which can be defined as a hinge-loss function:
+
+$$
+\mathcal { L } ( \boldsymbol { x } _ { p } , \boldsymbol { x } _ { q } ) ^ { - } = L _ { h } ( \mathcal { D } _ { K L } ( \mathcal { P } ^ { \star } | | \boldsymbol { \mathcal { Q } } ) , \boldsymbol { \sigma } ) + L _ { h } ( \mathcal { D } _ { K L } ( \mathcal { Q } ^ { \star } | | \mathcal { P } ) , \boldsymbol { \sigma } )
+$$
+
+$$
+L _ { h } ( e , \sigma ) = m a x ( 0 , \sigma - e )
+$$
+
+Given a pair of data with similarity prediction function $G ( x _ { p } , x _ { q } ) \in \{ 0 , 1 \}$ , which is introduced in section 3, the total loss can be defined as a contrastive loss (where we use integer 1 to represent a similar pair):
+
+$$
+\mathcal { L } ( x _ { p } , x _ { q } ) = G ( x _ { p } , x _ { q } ) \mathcal { L } ( x _ { p } , x _ { q } ) ^ { + } + ( 1 - G ( x _ { p } , x _ { q } ) ) \mathcal { L } ( x _ { p } , x _ { q } ) ^ { - }
+$$
+
+We refer to equation 5 as LCO. Function $G$ is the learnable part that utilizes prior knowledge and is trained with auxiliary dataset $A$ before optimizing LCO. Two particular characteristics of the clustering criterion are worth mentioning: (1) There is no need to define cluster centers. (2) There is no predefined metric applied on the feature representation. Instead, the divergence is calculated directly on the cluster assignment; therefore, both feature representation and clustering are jointly optimized using back-propagation through the deep neural networks.
+
+# 4.1 THE PAIRWISE SIMILARITY PREDICTION NETWORK
+
+Although there is no restriction of how $G$ should be constructed, we choose deep convolution neural networks due to their efficiency in vision tasks. We design a network architecture inspired from Zagoruyko & Komodakis (2015). While they use it to predict image patch similarity, we use it to predict image-level semantic similarity. However, the Siamese architecture used in Zagoruyko & Komodakis (2015) is not efficient in both training and inference, especially when pairwise information is dense. Therefore, instead of using Siamese architecture, we keep the single column backbone but add a pair-enumeration layer on top of the feature extraction network. The pair-enumeration layer enumerates all pairs of feature vectors within a mini-batch and concatenates the features. Suppose the input of the layer is $1 0 \times 5 1 2$ with the mini-batch size 10 and the feature dimension 512; then the output of the pair-enumeration layer will be $1 0 0 \times 1 0 2 4$ (self-pairs included).
+
+The architecture is illustrated in figure 3. We add one hidden fully connected layer on top of the enumeration layer and a binary classifier at the end. We use the standard cross-entropy loss and train it end-to-end. The supervision for training was obtained by converting the ground-truth category labels into binary similarity, i.e., if two samples are from the same class then their label will be similar, otherwise dissimilar. The inference is also end-to-end, and it outputs predictions among all similarity pairs in a mini-batch. The output probability $g \in [ 0 , 1 ]$ with 1 means more similar. We binarize $g$ at 0.5 to obtain discrete similarity predictions. In the following sections, we simplified the notation of the pairwise similarity prediction network as $G$ . Once $G$ is learned, it then works as a static function in our experiments.
+
+# 4.2 THE OBJECTIVE FUNCTION WITH DENSE SIMILARITY PREDICTION
+
+Since the pairwise prediction of a mini-batch can be densely obtained from $G$ , to efficiently utilize the pair-wise information without forwarding each data multiple times we also combine the pairenumeration layer described in section 4.1 with equation 5. In this case, the outputs of softmax are
+
+![](images/6ee14a32f3d38107f344e558ad27ba8aa4c6dd2a6632d85ddac1a4bb2284c5fa.jpg)  
+Figure 4: The constrained clustering network (CCN) for transfer learning across tasks. The input is unlabeled target data $T$ . The cluster assignment block contains two fully connected layers and has the number of output nodes equal to $k$ . The $f$ described in section 4 is the backbone network plus the cluster assignment block. To optimize LCO, the full pipeline in the diagram is used. After the optimization, it uses another forward propagation with only $f$ to obtain the final cluster assignment.
+
+![](images/480735bbbbbc31b0524612dd6b214d318a05c8bfdb6bc3ec5a4e395d164bbae6.jpg)  
+Figure 5: The network for transfer learning across domains. The input is the mix of $S ^ { \prime }$ and $T$ . The architecture is a direct extension of CCN. We use $\mathrm { C C N ^ { + } }$ to represent the mandatory parts (upper branch) which implements eq. (7). $\mathrm { C C N ^ { + + } }$ includes the domain adaptation method (optional branch).
+
+enumerated in pairs. Let $D$ be the set of all tuples $( p , q )$ , while $p$ and $q$ are the indices of a sample in a mini-batch. The dense clustering loss $\mathcal { L } _ { d }$ for a mini-batch is calculated by:
+
+$$
+\mathcal { L } _ { d } = \sum _ { \forall ( p , q ) \in D } \mathcal { L } ( x _ { p } , x _ { q } ) .
+$$
+
+We use $\mathcal { L } _ { d }$ standalone with deep neural networks to reconstruct semantic clusters and for transfer learning across tasks (figure 4). We call the architecture the constrained clustering network (CCN).
+
+# 4.3 COMBINING WITH OTHER OBJECTIVES
+
+In the cross-domain case, we additionally have labeled source data. This enables us to use LCO for $T$ while using classification loss for $S ^ { \prime }$ . The overall training procedure is similar to previous domain adaptation approaches in that both source and target data are mixed in a mini-batch, but different losses are applied. We denote the source domain images in a mini-batch $b$ as $X _ { b ^ { S } }$ and the target domain images $X _ { b ^ { T } }$ with its set of dense pairs $D _ { b ^ { T } }$ . The loss function $\mathcal { L } _ { c d }$ for cross-domain transfer in a mini-batch can then be formulated as:
+
+$$
+\mathcal { L } _ { c d } = \mathcal { L } _ { c l s } + \mathcal { L } _ { c l u s t e r }
+$$
+
+$$
+\mathcal { L } _ { c l s } = \frac { 1 } { | b ^ { S } | } \sum _ { \forall x _ { i } \in X _ { b } s } C r o s s E n t r o p y L o s s ( f ( x _ { i } ) ) .
+$$
+
+$$
+\mathcal { L } _ { c l u s t e r } = \frac { 1 } { | b ^ { T } | ^ { 2 } } \sum _ { \forall ( i , j ) \in D _ { b ^ { T } } } \mathcal { L } ( x _ { i } , x _ { j } ) .
+$$
+
+The $\mathcal { L } _ { c l u s t e r }$ and $\mathcal { L } _ { c l s }$ share the same outputs from network $f$ . Although $\mathcal { L } _ { c l u s t e r }$ does not force the mapping between clusters and categories, $\mathcal { L } _ { c l s }$ does. Therefore the learned classifier can be applied on target data directly and picks the maximum probability for the predicted class. Note that in our loss function, there is no term to explicitly match the feature distribution between source and target; it merely transfers more knowledge in the form of constraints to regularize the learning of the classifier. There is also no requirement for the architecture to utilize hidden layers. Therefore our approach has the large flexibility to be combined with other domain adaptation strategies. Figure 5 illustrates the architectures $\mathrm { C C N ^ { + } }$ and $\mathrm { C C N ^ { + + } }$ used in our cross-domain experiments.
+
+# 5 EXPERIMENTS
+
+This section contains evaluations with four image datasets and covers both cross-task and crossdomain schemes. The details are described below, and the differences between experimental settings are illustrated in appendix A.
+
+# 5.1 UNSUPERVISED CROSS-TASK TRANSFER LEARNING
+
+# 5.1.1 SETUP
+
+The Omniglot dataset (Lake et al., 2015) contains 1623 different handwritten characters and each of them has 20 images drawn by different people. The characters are from 50 different alphabets and were separated to 30 background sets $O m n i g l o t _ { b g }$ and 20 evaluation sets $O m n i g l o t _ { e v a l }$ by the author. We use the $O m n i g l o t _ { b g }$ as the auxiliary dataset $( A )$ and the $O m n i g l o t _ { e v a l }$ as the target data $( T )$ . The total number of characters in $O m n g l o t _ { b g }$ is 964, which can be regarded as the number of categories available to learn the semantic similarity. The goal is to cluster Omniglot $_ { e v a l }$ to reconstruct its semantic categories, without ever having any labels.
+
+The $G$ function has a backbone neural network with four $3 \mathrm { x } 3$ convolution layers followed by $2 \mathbf { x } 2$ max-pooling with stride 2. All hidden layers are followed by batch normalization (Ioffe & Szegedy, 2015) and rectified linear unit. To prepare the inputs for training, the images from $O m n i g l o t _ { b g }$ were resized to $3 2 \mathrm { x } 3 2$ and normalized to zero mean with unit standard deviation. Each mini-batch has a size of 100 and is sampled from a random 20 characters to make sure the amount of similar pairs is reasonable. After pair enumeration, there are 10000 pairs subject to the loss function, which is a two-class cross entropy loss. The ground-truth similarity is obtained by converting the categorical labels. The loss of $G$ is optimized by stochastic gradient descent and is the only part trained in a supervised manner in this section.
+
+The Constrained Clustering Network (CCN) is used to reconstruct the semantic clusters in the target dataset using outputs from $G$ . The network has four 3x3 convolution layers followed by $2 \mathbf { x } 2$ max-pooling with stride 2, one hidden fully-connected layer, and one cluster assignment layer which is also fully connected. The number of output nodes in the last layer is equal to the number of potential clusters in the target data. The output distribution is enumerated in pairs before sending to LCO. The network is randomly initialized, trained end-to-end, and optimized by stochastic gradient descent with randomly sampled 100 images per mini-batch. Note the $G$ function used by LCO is fixed during the optimization. The input data preparation is the same as above, except now the data is from $O m n i g l o t _ { e v a l }$ . Specifically, during the training, the same mini-batch is given to both $G$ and CCN. The dense pairwise similarity predictions from $G$ are sent to LCO and are then fully utilized. The only hyper-parameter in LCO is $\sigma$ , and we set it to 2 for all our experiments.
+
+Omniglot $e v a l$ contains 20 alphabets and each one can be used as a standalone dataset. The 20 target datasets contain a varied number (20 to 47) of characters. Therefore we can evaluate the reconstruction performance under a varied number of ground-truth clusters. We tested the situations when the number of character $( K )$ in an alphabet is known and unknown. When $K$ is known, we set the target number of clusters in the clustering algorithm equal to the true number of characters. If $K$ is unknown, the common practice is to set it to a large number so that the data from different categories will not be forced to be in the same cluster. In the experiment, we merely set $K$ to 100, which is much larger than the largest dataset (47).
+
+All constrained clustering algorithms can be used to reconstruct the semantic clusters for our problem. Since there are mis-predictions in $G$ , robustness to noise is the most important factor. Here we include all four types of constrained clustering algorithms introduced in section 2 as the baselines. We provide the full set of pairwise constraints to all algorithms including ours. In other words, given an alphabet of 20 characters, it contains 400 images and 160000 predicted similarities from $G$ (note that $G$ makes predictions for both orders of a pair and for self-pairs). The full pairwise similarities were presented to all algorithms in random order, while we empirically found it has no noticeable effect on results. We pick the baseline approaches based on code availability and scalability concerning the number of pairwise constraints. Therefore we have shown results for K-means (MacQueen et al., 1967), LPNMF (Cai et al., 2009), LSC (Chen & Cai, 2011), ITML (Davis et al., 2007), SKKm (Anand et al., 2014), SKLR (Amid et al., 2016), SKMS (Anand et al., 2014), CSP (Wang et al., 2014) , and MPCK-means (Bilenko et al., 2004) as our baselines. We use the default parameters for each algorithm provided by the original author except for $K$ , the number of clusters. We use the same normalized images used in CCN for all algorithms.
+
+Table 1: Unsupervised cross-task transfer from Omniglot $b g$ to $O m n i g l o t _ { e v a l }$ . The performance is averaged across 20 alphabets which have 20 to 47 letters. The ACC and NMI without brackets have the number of clusters equal to ground-truth. The "(100)" means the algorithms use $K = 1 0 0$ . The characteristics of how each algorithm utilizes the pairwise constraints are marked in the "Constraints in" column, where metric stands for the metric learning of feature representation.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">Constraints in</td><td rowspan="2">ACC</td><td rowspan="2">ACC (100)</td><td rowspan="2">NMI</td><td rowspan="2">NMI (100)</td></tr><tr><td>Metric</td><td>Clustering</td></tr><tr><td>K-means</td><td></td><td></td><td>21.7%</td><td>18.9%</td><td>0.353</td><td>0.464</td></tr><tr><td>LPNMF</td><td></td><td></td><td>22.2%</td><td>16.3%</td><td>0.372</td><td>0.498</td></tr><tr><td>LSC</td><td></td><td></td><td>23.6%</td><td>18.0%</td><td>0.376</td><td>0.500</td></tr><tr><td>ITML</td><td>0</td><td></td><td>56.7%</td><td>47.2%</td><td>0.674</td><td>0.727</td></tr><tr><td>SKMS</td><td>0</td><td></td><td>=</td><td>45.5%</td><td>1</td><td>0.693</td></tr><tr><td>SKKm</td><td>0</td><td></td><td>62.4%</td><td>46.9%</td><td>0.770</td><td>0.781</td></tr><tr><td>SKLR</td><td>0</td><td></td><td>66.9%</td><td>46.8%</td><td>0.791</td><td>0.760</td></tr><tr><td>CSP</td><td></td><td>0</td><td>62.5%</td><td>65.4%</td><td>0.812</td><td>0.812</td></tr><tr><td>MPCK-means</td><td>0</td><td>0</td><td>81.9%</td><td>53.9%</td><td>0.871</td><td>0.816</td></tr><tr><td>CCN (Ours)</td><td>0</td><td>0</td><td>82.4%</td><td>78.1%</td><td>0.889</td><td>0.874</td></tr></table>
+
+The evaluation uses two clustering metrics. The first is normalized-mutual information (NMI) (Strehl & Ghosh, 2002) which is widely used for clustering. The second one is the clustering accuracy (ACC) (Yang et al., 2010). The ACC metric first finds the one-to-one matching between predicted clusters and ground-truth labels, and then calculates the classification accuracy based on the mapping. All data outside the matched clusters will be regarded as mis-predictions. To get high ACC, the algorithm has to generate coherent clusters where each cluster includes most of the data in a category; otherwise the score drops quickly. Therefore ACC provides better discrimination to evaluate whether the semantic clusters have been reconstructed well.
+
+# 5.1.2 RESULTS AND DISCUSSIONS
+
+We report the average performance over the 20 alphabets in table 1. Our approach achieved the top performance on both metrics. The CCN demonstrates strong robustness on the challenging scenario of unknown $K$ . It achieved $7 8 . 1 \%$ average accuracy. Compared with $8 2 . 4 \%$ when $K$ is known, CCN has a relatively small drop. Compared to the second best algorithm, CSP, which is $6 5 . 4 \%$ , CCN outperforms it with a large gap. The classical approach MPCK-means works surprisingly well when the number of clusters is known, but its performance dropped dramatically from $8 1 . 9 \%$ to $5 3 . 9 \%$ when $K = 1 0 0$ . In the performance breakdown for the 20 individual alphabets, CCN achieved $94 \%$ clustering accuracy on Old Church Slavonic Cyrillic, which has 45 characters (appendix table 5). Therefore the results show the feasibility of reconstructing semantic clusters using only noisy similarity predictions.
+
+When to use the semantic similarity? The experiments in table 1 show a clear trend that utilizing the pairwise constraints jointly for both metric learning and minimizing the clustering loss achieves the best performance, including both MPCK-means and CCN. In the case of unknown number of clusters, where we set $K = 1 0 0$ , the algorithms that use constraints to optimize clustering loss have better robustness, for example, CSP and CCN. The group that only use constraints for metric learning (ITML, SKMS, SKKm, and SKLR) significantly outperform the group that does not use it (K-means, LPNMF, LSC). However, their performance are still far behind CCN. Our results confirm the importance of jointly optimizing the metric and clustering.
+
+The robustness against noisy similarity prediction is the key factor to enable the cross-task transfer framework. To the best of our knowledge, table 1 is the first comprehensive robustness comparisons using predicted constraints learned from real data instead of converting from ground-truth labels. The accuracy of $G$ in our experiment is shown in appendix table 7 and demonstrates the reasonable performance of $G$ which is on par with Matching-Net (Vinyals et al., 2016). After binarizing the prediction at 0.5 probability, the similar pair precision, similar pair recall, dissimilar pair precision, and dissimilar pair recall among the 659 characters are (0.392, 0.927, 0.999, 0.995), accordingly. The binarized predictions are better than uniform random guess (0.002, 0.500, 0.998, 0.500), but are still noisy. Therefore it is very challenging for constrained clustering. The visualization of the robustness range of CCN are provided in appendix D, and shows that the robustness is related to the density of pairs involved in a mini-batch. We hypothesize that during the optimization, the gradients from wrongly predicted pairs are canceled out by each other or by the correctly predicted pairs. Therefore the overall gradient still moves the solution towards a better clustering result.
+
+How to predict $K ?$ Inferring the number of clusters $( N C )$ is a hard problem, but with the pairwise similarity information, it becomes feasible. For evaluation, we compute the difference between the number of dominant clusters $( N D C )$ and the true number of categories $( N C ^ { g t } )$ in a dataset. We use a naive definition for $N D C$ , which is the number of clusters that have a size larger than expected size when data is sampled uniformly. In other words, $\begin{array} { r } { N D C = \sum _ { i = 1 } ^ { K } \left[ C _ { i } > = \bar { E } [ C _ { i } ] \right] } \end{array}$ where $[ \cdot ]$ is an Iverson Bracket and $C _ { i }$ is the size of cluster $i$ . For example, $\bar { E } [ \bar { C } _ { i } ]$ will be 10 if the alphabet has 1000 images and $K = 1 0 0$ . Then the average difference $( A D i f )$ is calculated by $\begin{array} { r } { A D i f = \frac { 1 } { | D | } \sum _ { d \in D } { | N D C _ { d } - N C _ { d } ^ { g t } | } } \end{array}$ , where $d$ (i.e., alphabet) is a dataset in $D$ . A smaller $A D i f$ indicates a better estimate of $K$ . CCN achieves a score of 6.35 (appendix table 6). We compare this with the baseline approach SKMS (Anand et al., 2014), which does not require a given $K$ and supports a pipeline to estimate $K$ automatically (therefore we only put it into the column $K = 1 0 0$ in table 1.). SKMS gets 16.3. Furthermore, 10 out of 20 datasets from CCN’s prediction have a difference between $N D C _ { d }$ and $N C _ { d } ^ { g t }$ smaller or equal to 3, which shows the feasibility of estimating $K$ with predicted similarity.
+
+# 5.1.3 EXPERIMENTS USING THE IMAGENET DATASET
+
+To demonstrate the scalability of our approach, we applied the same scheme on the ImageNet dataset. The 1000-class dataset is separated into 882-class (ImageNet882) and 118-class (ImageNet118) subsets as the random split in Vinyals et al. (2016). We use ImageN et882 for $A$ and 30 classes $\mathrm { \sim } 3 9 \mathrm { k }$ images) are randomly sampled from $I m a g e N e t _ { 1 1 8 }$ for $T$ . The difference from section 5.1.1 is that here we use Resnet-18 for both $G$ and CCN, and the weights of the backbone are pre-trained with ImageN et882. Since the number of pairs is high and it is not feasible to feed them into other constrained clustering algorithms, we compare CCN with K-means, LSC(Chen & Cai, 2011), and LPNMF (Cai et al., 2009). We use the output from the average pooling layer of Resnet-18 as the input to these clustering algorithms. CCN gives the top performance with average ACC $7 3 . 8 \%$ when $K$ is known, and $6 5 . 2 \%$ when the number of clusters is unknown, which outperforms the second $( 3 4 . 5 \%$ by K-means) with a large margin. The full comparison is in appendix table 8. And the performance of $G$ is provided in appendix table 9.
+
+# 5.2 UNSUPERVISED CROSS-DOMAIN TRANSFER LEARNING
+
+# 5.2.1 SETUP
+
+Office-31 (Saenko et al., 2010) has images from 31 categories of office objects. The 4652 images are obtained from three domains: Amazon $( a )$ , DSLR $( d )$ , and Webcam $( w )$ . The dataset is the standard benchmark for evaluating domain adaptation performance in computer vision. We experiment with all six combinations (source $S ^ { \prime } \to \mathrm { t a r g e t } T$ ): $a  w$ , $a \to d$ , $d \to a$ , $d \to w$ , $w  a$ , $w \to d$ , and report the average accuracy based on five random experiments for each setting.
+
+The $G$ function learns the semantic similarity function from the auxiliary dataset $A$ , which is ImageNet with all 1000 categories. The backbone network of $G$ is Resnet-18 and has the weights initialized by ImageNet classification. The training process is the same as section 5.1.1 except the images are resized to 224.
+
+We follow the standard protocols using deep neural networks (Long et al., 2017; Ganin et al., 2016) for unsupervised domain adaptation. The backbone network of $\mathrm { C C N ^ { + } }$ is pre-trained with ImageNet. Appendix figure 7 illustrates the scheme. During the training, all source data and target data are used. Each mini-batch is constructed by 32 labeled samples from source and 96 unlabeled samples from target. Since the target dataset has no labels and could only be randomly sampled, it is crucial to have sufficient mini-batch size to ensure that similar pairs are sampled. The loss function used in our approach is equation (7) and is optimized by stochastic gradient descent. The $\mathrm { C C N ^ { + / + + } }$ and DANN (RevGrad) with ResNet backbone are implemented with Torch. We use the code from original author for JAN. Both DANN and JAN use a 256-dimension bottleneck feature layer.
+
+Table 2: Unsupervised cross-domain transfer (domain adaptation) on the Office-31 dataset. The backbone network used here is Resnet-18 (He et al., 2016) pre-trained with ImageNet.   
+
+<table><tr><td></td><td>A→W</td><td>D→W</td><td>W→D</td><td>A→D</td><td>D→A</td><td>W→A</td><td>Avg</td></tr><tr><td>Source-Only</td><td>66.8</td><td>92.8</td><td>96.8</td><td>67.1</td><td>51.4</td><td>53.0</td><td>71.3</td></tr><tr><td>DANN (Ganin et al., 2016)</td><td>73.2</td><td>97.0</td><td>99.0</td><td>69.3</td><td>58.0</td><td>57.8</td><td>75.7</td></tr><tr><td>JAN (Long et al., 2017)</td><td>74.5</td><td>94.1</td><td>99.6</td><td>75.9</td><td>58.7</td><td>59.0</td><td>76.9</td></tr><tr><td>CCN+ (ours)</td><td>76.7</td><td>97.3</td><td>98.2</td><td>71.2</td><td>61.0</td><td>60.5</td><td>77.5</td></tr><tr><td>CCN++ (with DANN)</td><td>78.2</td><td>97.4</td><td>98.6</td><td>73.5</td><td>62.8</td><td>60.6</td><td>78.5</td></tr></table>
+
+# 5.2.2 RESULTS AND DISCUSSIONS
+
+The results are summarized in table 2. Our approach $\mathrm { ( C C N ^ { + } ) }$ demonstrates a strong performance boost for the unsupervised cross-domain transfer problem. It reaches $7 7 . 5 \%$ average accuracy which gained 6.2 points from the $7 1 . 3 \%$ source-only baseline. Although our approach merely transfers more information from the auxiliary dataset, it outperforms the strong approach DANN $( 7 5 . 7 \% )$ , and state-of-the-art JAN $( 7 6 . 9 \% )$ . When combining ours with DANN $\mathrm { ( C C N ^ { + + } ) }$ , the performance is further boosted. This indicates that LCO helps mitigate the transfer problem in a certain way that is orthogonal to minimizing the domain discrepancy. We observe the same trend when using a deeper backbone network, i.e., ResNet-34. In such a case the average accuracy achieved is $7 7 . 9 \%$ , $8 1 . 1 \%$ and $82 \%$ for source-only, $\mathrm { C C N ^ { + } }$ and $\mathrm { C C N ^ { + + } }$ , respectively, though we used exactly the same $G$ as before (with ResNet-18 backbone for $G$ ). This indicates that the information carried in the similarity predictions is not equivalent to transferring features with deeper networks. More discussions are in appendix C and the performance of $G$ is provided in appendix table 11 to show that although the prediction has low precision for similar pairs $( \sim 0 . 2 )$ , our approach still benefits from the dense similarity predictions.
+
+# 5.2.3 EXPERIMENTS USING SVHN-TO-MNIST
+
+We also evaluated the $\mathrm { C C N ^ { + } }$ on another widely compared scenario, which uses color Street View House Numbers images (SVHN) (Netzer et al., 2011) as $S ^ { \prime }$ , the gray-scale hand-written digits (MNIST) (LeCun, 1998) as $T$ . To learn $G$ , we use the $O m n g l o t _ { b g }$ as $A$ . We train all the networks in this section from scratch. Our experimental setting is similar to Sener et al. (2016). We achieve the top performance with $8 9 . 1 \%$ accuracy. The performance gain from source-only in our approach is $+ 3 7 . 1 \%$ , which wins by a large margin compared to the $+ 2 3 . 9 \%$ of LTR (Sener et al., 2016). The full comparison is presented in appendix table 12.
+
+# 6 CONCLUSION AND OUTLOOK
+
+In this paper, we demonstrated the usefulness of transferring information in the form of pairwise similarity predictions. Such information can be transferred as a function and utilized by a loss formulation inspired from constrained clustering, but implemented more robustly within a neural network that can jointly optimize both features and clustering outputs based on these noisy predictions. The experiments for both cross-task and cross-domain transfer learning show strong benefits of using the semantic similarity predictions resulting in new state of the art results across several datasets. This is true even without explicit domain adaptation for the cross-domain task, and if we add a domain discrepancy loss the benefits increase further.
+
+There are two key factors that determine the performance of the proposed framework. The first is the robustness of the constrained clustering and second is the performance of the similarity prediction function. We show robustness of CCN empirically, but we do not explore situations where learning the similarity function is harder. For example, such cases arise when there are a small number of categories in source or a large domain discrepancy between source and target. One idea to deal with such a situation is learning G with domain adaptation strategies. We leave these aspects for future work.
+
+# ACKNOWLEDGMENTS
+
+This work was supported by the National Science Foundation and National Robotics Initiative (grant # IIS-1426998).
+
+# REFERENCES
+
+Ehsan Amid, Aristides Gionis, and Antti Ukkonen. Semi-supervised kernel metric learning using relative comparisons. arXiv preprint arXiv:1612.00086, 2016.
+
+Saket Anand, Sushil Mittal, Oncel Tuzel, and Peter Meer. Semi-supervised kernel mean shift clustering. IEEE transactions on pattern analysis and machine intelligence, 36(6):1201–1215, 2014.
+
+Violaine Antoine, Benjamin Quost, M-H Masson, and Thierry Denoeux. Cecm: Constrained evidential c-means algorithm. Computational Statistics & Data Analysis, 56(4):894–914, 2012.
+
+Mikhail Bilenko, Sugato Basu, and Raymond J Mooney. Integrating constraints and metric learning in semi-supervised clustering. In Proceedings of the twenty-first international conference on Machine learning, pp. 11. ACM, 2004.
+
+Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Deng Cai, Xiaofei He, Xuanhui Wang, Hujun Bao, and Jiawei Han. Locality preserving nonnegative matrix factorization. In IJCAI, volume 9, pp. 1010–1015, 2009.
+
+Fabio Maria Carlucci, Lorenzo Porzi, Barbara Caputo, Elisa Ricci, and Samuel Rota Bulò. Autodial: Automatic domain alignment layers. In International Conference on Computer Vision, 2017.
+
+Xinlei Chen and Deng Cai. Large scale spectral clustering with landmark-based representation. In AAAI, volume 5, pp. 14, 2011.
+
+Wenyuan Dai, Yuqiang Chen, Gui rong Xue, Qiang Yang, and Yong Yu. Translated learning: Transfer learning across different feature spaces. In Advances in Neural Information Processing Systems 21. 2009.
+
+Ian Davidson and Sugato Basu. A survey of clustering with instance level. Constraints, 1:2, 2007.
+
+Jason V Davis, Brian Kulis, Prateek Jain, Suvrit Sra, and Inderjit S Dhillon. Information-theoretic metric learning. In Proceedings of the 24th international conference on Machine learning, pp. 209–216. ACM, 2007.
+
+Derya Dinler and Mustafa Kemal Tural. A survey of constrained clustering. In Unsupervised Learning Algorithms, pp. 207–235. Springer, 2016.
+
+Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. In Icml, volume 32, pp. 647–655, 2014.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. Journal of Machine Learning Research, 17(59):1–35, 2016.
+
+Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In Computer Vision and Pattern Recognition, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Yen-Chang Hsu and Zsolt Kira. Neural network-based clustering using pairwise constraints. ICLR workshop, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+
+Gregory Koch, Richard Zemel, and Ruslan Salakhutdinov. Siamese neural networks for one-shot image recognition. In ICML Deep Learning Workshop, 2015.
+
+Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.
+
+Yann LeCun. The mnist database of handwritten digits. 1998.
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3431–3440, 2015a.
+
+Mingsheng Long, Yue Cao, Jianmin Wang, and Michael I. Jordan. Learning transferable features with deep adaptation networks. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 97–105, 2015b.
+
+Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I Jordan. Unsupervised domain adaptation with residual transfer networks. In Advances in Neural Information Processing Systems, 2016.
+
+Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I. Jordan. Deep transfer learning with joint adaptation networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 2208–2217, 2017.
+
+James MacQueen et al. Some methods for classification and analysis of multivariate observations. In Proceedings of the fifth Berkeley symposium on mathematical statistics and probability, volume 1, pp. 281–297. Oakland, CA, USA., 1967.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.
+
+Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Trans. on Knowl. and Data Eng., 22(10):1345–1359, October 2010. ISSN 1041-4347. doi: 10.1109/TKDE.2009.191. URL http://dx.doi.org/10.1109/TKDE.2009.191.
+
+Syama Sundar Rangapuram and Matthias Hein. Constrained 1-spectral clustering. In AISTATS, volume 30, pp. 90, 2012.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
+
+Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting Visual Category Models to New Domains, pp. 213–226. Springer Berlin Heidelberg, Berlin, Heidelberg, 2010.
+
+Kuniaki Saito, Yoshitaka Ushiku, and Tatsuya Harada. Asymmetric tri-training for unsupervised domain adaptation. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 2988–2997, 2017.
+
+Ozan Sener, Hyun Oh Song, Ashutosh Saxena, and Silvio Savarese. Learning transferrable representations for unsupervised domain adaptation. In Advances in Neural Information Processing Systems, pp. 2110–2118, 2016.
+
+Alexander Strehl and Joydeep Ghosh. Cluster ensembles—a knowledge reuse framework for combining multiple partitions. Journal of machine learning research, 3(Dec):583–617, 2002.
+
+Baochen Sun, Jiashi Feng, and Kate Saenko. Return of frustratingly easy domain adaptation. In AAAI, 2016.
+
+Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014.
+
+Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Adversarial discriminative domain adaptation. In Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan. Show and tell: A neural image caption generator. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3156–3164, 2015.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. 2016.
+
+Xiang Wang, Buyue Qian, and Ian Davidson. On constrained spectral clustering and its applications. Data Mining and Knowledge Discovery, pp. 1–30, 2014.
+
+Eric P Xing, Michael I Jordan, Stuart J Russell, and Andrew Y Ng. Distance metric learning with application to clustering with side-information. In Advances in neural information processing systems, pp. 521–528, 2003.
+
+Yi Yang, Dong Xu, Feiping Nie, Shuicheng Yan, and Yueting Zhuang. Image clustering using local discriminant models and global integration. IEEE Transactions on Image Processing, 19(10): 2761–2773, 2010.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? 2014.
+
+Sergey Zagoruyko and Nikos Komodakis. Learning to compare image patches via convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4353–4361, 2015.
+
+Werner Zellinger, Thomas Grubinger, Edwin Lughofer, Thomas Natschläger, and Susanne SamingerPlatz. Central moment discrepancy (cmd) for domain-invariant representation learning. ICLR, 2017.
+
+# APPENDICES
+
+# A COMPARISON OF EXPERIMENTAL SETTINGS
+
+Table 3: The list of datasets involved in each experiment. $G$ learns the similarity function from dataset A. The $\mathbf { C C N } ^ { * }$ is optimized with dataset T or T∪S’, while $\mathbf { C C N } ^ { * }$ means CCN for cross-task transfer and $\mathrm { C C N ^ { + / + + } }$ for cross-domain transfer. The rows for network initialization indicate whether the network has weights initialized by training a classification task with the specified dataset. The weights are randomly initialized if not specified.   
+
+<table><tr><td colspan="2">Scheme</td><td colspan="2">Cross-Task Transfer</td><td colspan="2">Cross-Domain Transfer</td></tr><tr><td colspan="2">Experiment Section</td><td>Omniglot 5.1.1</td><td>ImageNet 5.1.3</td><td>Office-31 5.2.1</td><td>SVHN-MNIST 5.2.3</td></tr><tr><td rowspan="3">Datasets</td><td>A</td><td>Omniglotbg</td><td>ImageNet882</td><td>ImageNet1000</td><td>Omniglotbg</td></tr><tr><td>S’</td><td></td><td></td><td>Office-31 {a,d,w}</td><td>SVHN</td></tr><tr><td>T</td><td>Omnigloteval</td><td>ImageNet118</td><td>Office-31 {a,d,w)</td><td>MNIST</td></tr><tr><td rowspan="2">Network Initialization</td><td>G</td><td></td><td>ImageNet882</td><td>ImageNet1000</td><td>1</td></tr><tr><td>CCN*</td><td></td><td>ImageNet882</td><td>ImageNet1000</td><td>1</td></tr></table>
+
+Table 4: The list of loss functions used for training networks. The similarity prediction function (network) $G$ uses the cross-entropy (CE) loss with two classes (similar/dissimilar). The training of constrained clustering network $( \mathbf { C C N } ^ { * } )$ involves the combinations of the learnable clustering objective (LCO), cross-entropy, and domain adaptation loss (DA).   
+
+<table><tr><td></td><td>LCO</td><td>CE</td><td>DA</td></tr><tr><td>G</td><td></td><td>√</td><td></td></tr><tr><td>CCN</td><td></td><td></td><td></td></tr><tr><td>CCN+</td><td>广</td><td>√</td><td></td></tr><tr><td>CCN++</td><td>√</td><td></td><td>√</td></tr></table>
+
+![](images/6077c2618b017816b79d4cf6b62b30b24d7ebf9ecfe529286747a494f9f155c8.jpg)  
+Figure 6: A diagram depicting the cross-task transfer experiment. Two experiments follow this flow: Omniglot $b g$ to $O m n i g l o t _ { e v a l }$ , and $I m a g e N e t _ { 8 8 2 }$ to ImageNet118. Both have exclusive classes between source and target domain. In the ImageNet experiment, the backbone network is initialized with the weights pre-trained with ImageN et882.
+
+![](images/62fef6aa1814051042be0542b4068cc2863de90390604a41a4bf68f744e5059c.jpg)  
+Figure 7: Comparison between domain adaptation approaches (a) Transferring semantic similarity from auxiliary data (our method), and (b) Minimizing the domain discrepancy. The diagram uses office-31 benchmark as the scenario of transferring.
+
+# B SUPPLEMENTARY FOR UNSUPERVISED CROSS TASK TRANSFER LEARNING
+
+Table 5: A breakdown of the results for each alphabet in Omnigloteval. The unsupervised cross task transfer experiment is described in section 5.1. This table shows the clustering accuracy with $K = 1 0 0$ to simulate the situation of unknown number of clusters.   
+
+<table><tr><td>Alphabet</td><td>K-means</td><td>LPNMF</td><td>LSC</td><td>ITML</td><td>SKMS</td><td>SKKm</td><td>SKLR</td><td>CSP</td><td>MPCK-means</td><td>CCN</td></tr><tr><td>Angelic</td><td>24%</td><td>26%</td><td>27%</td><td>48%</td><td>78%</td><td>40%</td><td>38%</td><td>72%</td><td>50%</td><td>82%</td></tr><tr><td>Atemayar_Qelisayer</td><td>19%</td><td>14%</td><td>17%</td><td>51%</td><td>61%</td><td>51%</td><td>44%</td><td>61%</td><td>50%</td><td>82%</td></tr><tr><td>Atlantean</td><td>19%</td><td>15%</td><td>19%</td><td>57%</td><td>72%</td><td>55%</td><td>51%</td><td>77%</td><td>47%</td><td>72%</td></tr><tr><td>Aurek_Besh</td><td>23%</td><td>18%</td><td>21%</td><td>45%</td><td>49%</td><td>44%</td><td>45%</td><td>76%</td><td>71%</td><td>90%</td></tr><tr><td>Avesta</td><td>22%</td><td>18%</td><td>19%</td><td>47%</td><td>29%</td><td>39%</td><td>38%</td><td>65%</td><td>52%</td><td>76%</td></tr><tr><td>Ge_ez</td><td>19%</td><td>17%</td><td>17%</td><td>56%</td><td>58%</td><td>47%</td><td>42%</td><td>72%</td><td>55%</td><td>82%</td></tr><tr><td>Glagolitic</td><td>22%</td><td>19%</td><td>21%</td><td>42%</td><td>38%</td><td>58%</td><td>62%</td><td>66%</td><td>61%</td><td>85%</td></tr><tr><td>Gurmukhi</td><td>15%</td><td>13%</td><td>15%</td><td>44%</td><td>26%</td><td>54%</td><td>48%</td><td>60%</td><td>56%</td><td>80%</td></tr><tr><td>Kannada</td><td>18%</td><td>14%</td><td>16%</td><td>48%</td><td>37%</td><td>46%</td><td>53%</td><td>60%</td><td>48%</td><td>62%</td></tr><tr><td>Keble</td><td>20%</td><td>14%</td><td>18%</td><td>44%</td><td>60%</td><td>46%</td><td>44%</td><td>75%</td><td>68%</td><td>90%</td></tr><tr><td>Malayalam</td><td>18%</td><td>15%</td><td>16%</td><td>36%</td><td>24%</td><td>49%</td><td>52%</td><td>50%</td><td>54%</td><td>72%</td></tr><tr><td>Manipuri</td><td>17%</td><td>15%</td><td>16%</td><td>49%</td><td>40%</td><td>53%</td><td>54%</td><td>66%</td><td>62%</td><td>85%</td></tr><tr><td>Mongolian</td><td>18%</td><td>18%</td><td>19%</td><td>50%</td><td>40%</td><td>37%</td><td>48%</td><td>75%</td><td>57%</td><td>86%</td></tr><tr><td>Old_Church_Slavonic_Cyrilic</td><td>19%</td><td>16%</td><td>19%</td><td>42%</td><td>41%</td><td>52%</td><td>67%</td><td>71%</td><td>67%</td><td>94%</td></tr><tr><td>Oriya</td><td>15%</td><td>13%</td><td>14%</td><td>46%</td><td>40%</td><td>54%</td><td>45%</td><td>57%</td><td>52%</td><td>67%</td></tr><tr><td>Sylheti</td><td>14%</td><td>13%</td><td>14%</td><td>49%</td><td>32%</td><td>35%</td><td>37%</td><td>59%</td><td>43%</td><td>64%</td></tr><tr><td>Syriac_Serto</td><td>20%</td><td>18%</td><td>19%</td><td>55%</td><td>70%</td><td>42%</td><td>35%</td><td>70%</td><td>47%</td><td>73%</td></tr><tr><td>Tengwar</td><td>18%</td><td>18%</td><td>18%</td><td>51%</td><td>44%</td><td>49%</td><td>40%</td><td>61%</td><td>44%</td><td>66%</td></tr><tr><td>Tibetan</td><td>18%</td><td>14%</td><td>16%</td><td>44%</td><td>31%</td><td>47%</td><td>54%</td><td>59%</td><td>55%</td><td>84%</td></tr><tr><td>ULOG</td><td>20%</td><td>18%</td><td>18%</td><td>41%</td><td>41%</td><td>40%</td><td>41%</td><td>56%</td><td>38%</td><td>70%</td></tr><tr><td>Average</td><td>19%</td><td>16%</td><td>18%</td><td>47%</td><td>46%</td><td>47%</td><td>47%</td><td>65%</td><td>54%</td><td>78%</td></tr></table>
+
+Table 6: Estimates for the number of characters across the 20 datasets in Omniglot $e v a l$ . The bold number means the prediction has error smaller or equal to 3. The $A D i f$ is defined in section 5.1.2.   
+
+<table><tr><td>Alphabet</td><td>True #class</td><td>SKMS</td><td>CCN (K=100)</td></tr><tr><td>Angelic</td><td>20</td><td>16</td><td>26</td></tr><tr><td>Atemayar_Qelisayer</td><td>26</td><td>17</td><td>34</td></tr><tr><td>Atlantean</td><td>26</td><td>21</td><td>41</td></tr><tr><td>Aurek_Besh</td><td>26</td><td>14</td><td>28</td></tr><tr><td>Avesta</td><td>26</td><td>8</td><td>32</td></tr><tr><td>Ge_ez</td><td>26</td><td>18</td><td>32</td></tr><tr><td>Glagolitic</td><td>45</td><td>18</td><td>45</td></tr><tr><td>Gurmukhi</td><td>45</td><td>12</td><td>43</td></tr><tr><td>Kannada</td><td>41</td><td>19</td><td>44</td></tr><tr><td>Keble</td><td>26</td><td>16</td><td>28</td></tr><tr><td>Malayalam</td><td>47</td><td>12</td><td>47</td></tr><tr><td>Manipuri</td><td>40</td><td>17</td><td>41</td></tr><tr><td>Mongolian</td><td>30</td><td>28</td><td>36</td></tr><tr><td>Old_Church_Slavonic_Cyrillic</td><td>45</td><td>23</td><td>45</td></tr><tr><td>Oriya</td><td>46</td><td>22</td><td>49</td></tr><tr><td>Sylheti</td><td>28</td><td>11</td><td>50</td></tr><tr><td>Syriac_Serto</td><td>23</td><td>19</td><td>38</td></tr><tr><td>Tengwar</td><td>25</td><td>12</td><td>41</td></tr><tr><td>Tibetan</td><td>42</td><td>15</td><td>42</td></tr><tr><td>ULOG</td><td>26</td><td>15</td><td>40</td></tr><tr><td>ADif</td><td></td><td>16.3</td><td>6.35</td></tr></table>
+
+Table 7: The performance of the similarity prediction function used in section 5.1. We leverage the N-way test which is commonly used in one-shot learning evaluation. The similarity is learned with Omniglot $b g$ and has N-way test with $O m n i g l o t _ { e v a l }$ and MNIST. The experimental settings follow Vinyals et al. (2016). The raw probability output (without binarization) from our $G$ is used to find the nearest exemplar in the N-way test.   
+
+<table><tr><td>Method</td><td colspan="2">Omniglot-eval 5-way</td><td>MNIST 10-way</td></tr><tr><td>Siamese-Nets (Koch et al., 2015)</td><td>0.967</td><td>20-way 0.880</td><td>0.703</td></tr><tr><td>Match-Net (Vinyals et al., 2016)</td><td>0.981</td><td>0.938</td><td>0.720</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Ours</td><td>0.979</td><td>0.935</td><td>0.720</td></tr></table>
+
+Table 8: Unsupervised cross-task transfer learning on ImageNet. The values are the average of three random subsets in $I m a g e N e t _ { 1 1 8 }$ . Each subset has 30 classes. The "ACC" has $K = 3 0$ while the "ACC (100)" sets $K = 1 0 0$ . All methods use the features (outputs of average pooling) from Resnet-18 pre-trained with ImageNet882 classification.   
+
+<table><tr><td>Method</td><td>ACC</td><td>ACC(100)</td><td>NMI</td><td>NMI(100)</td></tr><tr><td>K-means</td><td>71.9%</td><td>34.5%</td><td>0.713</td><td>0.671</td></tr><tr><td>LSC</td><td>73.3%</td><td>33.5%</td><td>0.733</td><td>0.655</td></tr><tr><td>LPNMF</td><td>43.0%</td><td>21.8%</td><td>0.526</td><td>0.500</td></tr><tr><td>CCN (ours)</td><td>73.8%</td><td>65.2%</td><td>0.750</td><td>0.715</td></tr></table>
+
+Table 9: Performance of the similarity prediction function ( $G$ , trained with ImageN et882) applied to three subsets of $I m a g e N e t _ { 1 1 8 }$ . Each subset contains 30 random classes of $I m a g e N e t _ { 1 1 8 }$ . The predictions are binarized at 0.5 to calculate the precision and recall. Random\*: The expected performance when classes are uniformly distributed and make uniform random guess for similarity. It is an approximation since the number of images in each class is only roughly equal in ImageNet. We sampled 12M pairs for each set to collect the statistics. Sampling more pairs has no noticeable change to the values.   
+
+<table><tr><td>Set</td><td>Similar Precision</td><td> Similar Recall</td><td>Dissimilar Precision</td><td>Dissimilar Recall</td></tr><tr><td>Random*</td><td>0.033</td><td>0.500</td><td>0.967</td><td>0.500</td></tr><tr><td>Set A</td><td>0.840</td><td>0.664</td><td>0.983</td><td>0.994</td></tr><tr><td>SetB</td><td>0.825</td><td>0.631</td><td>0.981</td><td>0.993</td></tr><tr><td>Set C</td><td>0.771</td><td>0.671</td><td>0.983</td><td>0.990</td></tr><tr><td>Average</td><td>0.812</td><td>0.655</td><td>0.982</td><td>0.992</td></tr></table>
+
+# C SUPPLEMENTARY FOR UNSUPERVISED CROSS DOMAIN TRANSFER LEARNING
+
+# C.1 MORE DISCUSSION FOR THE OFFICE-31 EXPERIMENTS
+
+Our experiment (table 10) shows that simply using deeper pre-trained networks produces a significant performance boost. Specifically, using Resnet-50 increases the performance 8.4 points from Alexnet, which surpasses the 6.2 points gained by using one of the state-of-the-art domain adaptation algorithms (JAN (Long et al., 2017)). If we regard pre-training with deeper networks as transferring more information, our approach is similar in this aspect since both transfer more information from the auxiliary dataset. In this case, memory limitations precluded the application of LCO to such models, and multi-GPU implementations for this problem is an area of future work.
+
+Table 10: The performance of unsupervised transfer across domains on Office-31 dataset. The backbone networks in the comparison have different numbers of convolutional layers. AlexNet has 5 layers and the ResNets have $1 8 { \sim } 5 0$ layers. SO is the abbreviation for source-only, which simply trains on $S ^ { \prime }$ and directly applies the classifier on $T$ . The first two rows are directly copied from Long et al. (2017). The features learned with deeper networks generalize better across domains.   
+
+<table><tr><td colspan="8">A→W D→W W→D A→D D→A W→A</td></tr><tr><td>AlexNet SO</td><td>61.6</td><td>95.4</td><td>99.0</td><td>63.8</td><td>51.1</td><td>49.8</td><td>Avg 70.1</td><td>1</td></tr><tr><td>AlexNet (JAN-A)</td><td>75.2</td><td>96.6</td><td>99.6</td><td>72.8</td><td>57.5</td><td>56.3</td><td>76.3</td><td>+6.2</td></tr><tr><td>Resnet-18 SO</td><td>66.8</td><td>92.8</td><td>96.8</td><td>67.1</td><td>51.4</td><td>53.0</td><td>71.3</td><td>+1.2</td></tr><tr><td>Resnet-34 SO</td><td>73.1</td><td>96.4</td><td>98.8</td><td>73.8</td><td>63.2</td><td>62.1</td><td>77.9</td><td>+7.8</td></tr><tr><td>Resnet-50 SO</td><td>74.3</td><td>96.8</td><td>98.8</td><td>79.5</td><td>61.2</td><td>60.6</td><td>78.5</td><td>+8.4</td></tr></table>
+
+Table 11: Performance of the similarity prediction function ( $G$ , trained with ImageNet882) applied on three domains of the Office-31 dataset. In total, 1.4M pairs are examined to calculate the table.   
+
+<table><tr><td>Domain</td><td>Similar Precision</td><td>Similar Recall</td><td>Dissimilar Precision</td><td>Dissimilar Recall</td></tr><tr><td>Amazon</td><td>0.194</td><td>0.696</td><td>0.988</td><td>0.894</td></tr><tr><td>DSLR</td><td>0.196</td><td>0.882</td><td>0.995</td><td>0.858</td></tr><tr><td>Webcam</td><td>0.213</td><td>0.865</td><td>0.994</td><td>0.876</td></tr></table>
+
+Table 12: Unsupervised transferring across domains (S’: SVHN, T: MNIST A: Omniglotbg) without pre-trained backbone network weights. Our setup is similar to Sener et al. (2016) and Ganin et al. (2016) which therefore has a similar source-only performance.   
+
+<table><tr><td colspan="2">Method</td><td>SVHN-&gt;MNIST</td><td>Gain</td></tr><tr><td>Ganin et al. (2016)</td><td>Source-Only DANN</td><td>54.9 73.9</td><td>1 +19.0</td></tr><tr><td>Sener et al. (2016)</td><td>Source-Only LTR</td><td>54.9 78.8</td><td>1 +23.9</td></tr><tr><td>Saito et al. (2017)</td><td>Source-Only ATDA</td><td>70.1 86.2</td><td>- +16.1</td></tr><tr><td>Tzeng et al. (2017)</td><td>Source-Only ADDA</td><td>60.1 76.0</td><td>- +15.9</td></tr><tr><td>Ours</td><td>Source-Only CCN+</td><td>52.0 89.1</td><td>1 +37.1</td></tr></table>
+
+Table 13: Performance of the similarity prediction function ( $G$ , trained with Omniglotbg) applied on the MNIST dataset. In total, 5M pairs are sampled to calculate the table.   
+
+<table><tr><td></td><td>Similar Precision</td><td>Similar Recall</td><td>Dissimilar Precision</td><td>Dissimilar Recall</td></tr><tr><td>Random</td><td>0.100</td><td>0.500</td><td>0.900</td><td>0.500</td></tr><tr><td>MNIST</td><td>0.782</td><td>0.509</td><td>0.946</td><td>0.984</td></tr></table>
+
+# D ROBUSTNESS ANALYSIS OF CONSTRAINED CLUSTERING NETWORK
+
+# D.1 SETUP
+
+To quickly explore the large combination of factors that may affect the clustering, we use a small dataset (MNIST) and a small network which has two convolution layers followed by two fully connected layers. The MNIST dataset is a dataset of handwritten digits that contains 60k training and 10k testing images with size $2 8 \mathbf { x } 2 8$ . Only the training set is used in this section and the raw pixels, which were normalized to zero mean and unit standard deviation, were fed into networks directly.
+
+The networks were randomly initialized and the clustering training was run five times under each combination of factors; we show the best final results, as is usual in the random restart regime. The mini-batch size was set to 256, thus up to 65536 pairs were presented to the LCO per mini-batch if using full density $\mathrm { ( D } { = } 1 \mathrm { ) }$ ). There were 235 mini-batches in an epoch and the optimization proceeded for 15 epochs. The clustering loss was minimized by stochastic gradient descent with learning rate 0.1 and momentum 0.9. The predicted cluster was assigned at the end by forwarding samples through the clustering networks. The best result in the five runs was reported.
+
+To simulate different performance of the similarity prediction, the label of pairs were flipped according to the designated recall. For example, to simulate a $90 \%$ recall of similar pair, $10 \%$ of the ground truth similar pair in a mini-batch were flipped. The precision of similar/dissimilar pairs is a function of the recall of both type of pairs, thus controlling the recall is sufficient for the evaluation. The recalls for both similar and dissimilar pairs were gradually reduced from one to zero at intervals of 0.1.
+
+# D.2 DISCUSSION
+
+The resulting performance w.r.t different values of recall, density, and number of clusters is visualized in Figure 8. A bright color means high NMI score and is desired. The larger the bright region, the more robust the clustering is against the noise of similarity prediction. The ACC score shows almost the same trend and is thus not shown here.
+
+How does similarity prediction affect clustering? Looking at the top-left heat map in figure 8, which has $D = 1$ and 10 clusters, it can be observed that the NMI score is very robust to low similar pair recall, even lower than 0.5. For recall of dissimilar pairs, the effect of recall is divided at the 0.5 value: the clustering performance can be very robust to noise in dissimilar pairs if the recall is greater than 0.5; however, it can completely fail if recall is below 0.5. For similar pairs, the clustering works on a wide range of recalls when the recall of dissimilar pairs is high.
+
+In practical terms, robustness to the recall of similar pairs is desirable because it is much easier to predict dissimilar pairs than similar pairs in real scenarios. In a dataset with 10 categories e.g. Cifar-10, we can easily get $90 \%$ recall for dissimilar pairs with purely random guess if the number of classes is known, while the recall for similar pairs will be $10 \%$ .
+
+How does the density of the constraints affect clustering? We argue that the density of pairwise relationships is the key factor to improving the robustness of clustering. The density $D = 1$ means that every pair in a mini-batch is utilized by the clustering loss. For density $D = 0 . 1$ , it means only 1 out of 10 possible constraints is used. We could regard the higher density as better utilization of the pairwise information in a mini-batch, thus more learning instances contribute to the gradients at once. Consider a scenario where there is one sample associated with 5 true similar pairs and 3 false similar pairs. In such a case, the gradients introduced by the false similar pairs have a higher chance to be overridden by true similar pairs within the mini-batch, thus the loss can converge faster and is less affected by errors. In Figure 8, we could see when density decreases, the size of the bright region shrinks significantly.
+
+![](images/12cec765ecdee0ae03b658c3f3798b3d511e16695116130fd85ecccd06d459c9.jpg)  
+Figure 8: The clustering performance with different pairwise density and number of clusters. A bright color means that the NMI score is close to 1 while black corresponds to 0. The density is defined as a ratio compared to the total number of pair-wise combinations in a mini-batch. The number of clusters defines the final softmax output dimensionality. In each sub-figure, we show how the scores change w.r.t. the similar pair recall and dissimiliar pair recall.
+
+In our implementation, enumerating the full pairwise relationships introduces negligible overhead in computation time using GPU. Although there is overhead for memory consumption, it is limited because only the vector of predicted distributions has to be enumerated for calculating the clustering loss.
+
+The effect of varying the number of Clusters In the MNIST experiments, the number of categories is 10. We augment the softmax output number up to 100. The rows of figure 8 show that even when the number of output categories is significant larger than the number of true object categories, e.g. $1 0 0 > 1 0$ , the clustering performance NMI score only degrades slightly.

parse/train/BygzbyHFvB/BygzbyHFvB.md

@@ -0,0 +1,313 @@
+# FREELB: ENHANCED ADVERSARIAL TRAINING FOR NATURAL LANGUAGE UNDERSTANDING
+
+Chen $\mathbf { Z } \mathbf { h } \mathbf { u } ^ { \mathbf { 1 } }$ , Yu Cheng2, Zhe $\mathbf { G a n } ^ { 2 }$ , Siqi $\mathbf { S u n } ^ { 2 }$ , Tom Goldstein1, Jingjing Liu2 1University of Maryland, College Park 2Microsoft Dynamics 365 AI Research {chenzhu,tomg}@cs.umd.edu, {yu.cheng,zhe.gan,siqi.sun,jingjl}@microsoft.com
+
+# ABSTRACT
+
+Adversarial training, which minimizes the maximal risk for label-preserving input perturbations, has proved to be effective for improving the generalization of language models. In this work, we propose a novel adversarial training algorithm, FreeLB, that promotes higher invariance in the embedding space, by adding adversarial perturbations to word embeddings and minimizing the resultant adversarial risk inside different regions around input samples. To validate the effectiveness of the proposed approach, we apply it to Transformer-based models for natural language understanding and commonsense reasoning tasks. Experiments on the GLUE benchmark show that when applied only to the finetuning stage, it is able to improve the overall test scores of BERT-base model from 78.3 to 79.4, and RoBERTa-large model from 88.5 to 88.8. In addition, the proposed approach achieves state-of-the-art single-model test accuracies of $8 5 . 4 4 \%$ and $6 7 . 7 5 \%$ on ARC-Easy and ARC-Challenge. Experiments on CommonsenseQA benchmark further demonstrate that FreeLB can be generalized and boost the performance of RoBERTa-large model on other tasks as well. 1
+
+# 1 INTRODUCTION
+
+Adversarial training is a method for creating robust neural networks. During adversarial training, mini-batches of training samples are contaminated with adversarial perturbations (alterations that are small and yet cause misclassification), and then used to update network parameters until the resulting model learns to resist such attacks. Adversarial training was originally proposed as a means to enhance the security of machine learning systems (Goodfellow et al., 2015), especially for safety-critical systems like self-driving cars (Xiao et al., 2018) and copyright detection (Saadatpanah et al., 2019).
+
+In this paper, we turn our focus away from the security benefits of adversarial training, and instead study its effects on generalization. While adversarial training boosts the robustness, it is widely accepted by computer vision researchers that it is at odds with generalization, with classification accuracy on non-corrupted images dropping as much as $1 0 \%$ on CIFAR-10, and $1 5 \%$ on Imagenet (Madry et al., 2018; Xie et al., 2019). Surprisingly, people observe the opposite result for language models (Miyato et al., 2017; Cheng et al., 2019), showing that adversarial training can improve both generalization and robustness.
+
+We will show that adversarial training significantly improves performance of state-of-the-art models for many language understanding tasks. In particular, we propose a novel adversarial training algorithm, called FreeLB (Free Large-Batch), which adds adversarial perturbations to word embeddings and minimizes the resultant adversarial loss around input samples. The method leverages recently proposed “free” training strategies (Shafahi et al., 2019; Zhang et al., 2019) to enrich the training data with diversified adversarial samples under different norm constraints at no extra cost than PGD-based (Projected Gradient Descent) adversarial training (Madry et al., 2018), which enables us to perform such diversified adversarial training on large-scale state-of-the-art models. We observe improved invariance in the embedding space for models trained with FreeLB, which is positively correlated with generalization.
+
+We perform comprehensive experiments to evaluate the performance of a variety of adversarial training algorithms on state-of-the-art language understanding models and tasks. In the comparisons with standard PGD (Madry et al., 2018), FreeAT (Shafahi et al., 2019) and YOPO (Zhang et al., 2019), FreeLB stands out to be the best for the datasets and models we evaluated. With FreeLB, we achieve state-of-the-art results on several important language understanding benchmarks. On the GLUE benchmark, FreeLB pushes the performance of the BERT-base model from 78.3 to 79.4. The overall score of the RoBERTa-large models on the GLUE benchmark is also lifted from 88.5 to 88.8, achieving best results on most of its sub-tasks. Experiments also show that FreeLB can boost the performance of RoBERTa-large on question answering tasks, such as the ARC and CommonsenseQA benchmarks. We also provide a comprehensive ablation study and analysis to demonstrate the effectiveness of our training process.
+
+# 2 RELATED WORK
+
+# 2.1 ADVERSARIAL TRAINING
+
+To improve the robustness of neural networks against adversarial examples, many defense strategies and models have been proposed, in which PGD-based adversarial training (Madry et al., 2018) is widely considered to be the most effective, since it largely avoids the the obfuscated gradient problem (Athalye et al., 2018). It formulates a class of adversarial training algorithms (Kurakin et al., 2017) into solving a minimax problem on the cross-entropy loss, which can be achieved reliably through multiple projected gradient ascent steps followed by a SGD (Stochastic Gradient Descent) step.
+
+Despite being verified by Athalye et al. (2018) to avoid obfuscated gradients, Qin et al. (2019) shows that PGD-based adversarial training still leads to highly convolved and non-linear loss surfaces when $K$ is small, which could be readily broken under stronger adversaries. Thus, to be effective, the cost of PGD-based adversarial training is much higher than conventional training. To mitigate this cost, Shafahi et al. (2019) proposed a “free” adversarial training algorithm that simultaneously updates both model parameters and adversarial perturbations on a single backward pass. Using a similar formulation, Zhang et al. (2019) effectively reduce the total number of full forward and backward propagations for obtaining adversarial examples by restricting most of its adversarial updates in the first layer.
+
+# 2.2 ADVERSARIAL EXAMPLES IN NATURAL LANGUAGES
+
+Adversarial examples have been explored primarily in the image domain, and received many attention in text domain recently. Previous works on text adversaries have focused on heuristics for creating adversarial examples in the black-box setting, or on specific tasks. Jia & Liang (2017) propose to add distracting sentences to the input document in order to induce mis-classification. Zhao et al. (2018) generate text adversaries by projecting the input data to a latent space using GANs, and searching for adversaries close to the original instance. Belinkov & Bisk (2018) manipulate every word in a sentence with synthetic or natural noise in machine translation systems. Iyyer et al. (2018) propose a neural paraphrase model based on back-translated data to produce paraphrases that have different sentence structures. Different from previous work, ours is not to produce actual adversarial examples, but only take the benefit of adversarial training for natural language understanding.
+
+We are not the first to observe that robust language models may perform better on clean test data. Miyato et al. (2017) extend adversarial and virtual adversarial training (Miyato et al., 2019) to the text domain to improve the performance on semi-supervised classification tasks. Ebrahimi et al. (2018) propose a character/word replacement for crafting attacks, and show employing adversarial examples in training renders the models more robust. Ribeiro et al. (2018) show that adversarial attacks can be used as a valuable tool for debugging NLP models. Cheng et al. (2019) also find that crafting adversarial examples can help neural machine translation significantly. Notably, these studies have focused on simple models or text generation tasks. Our work explores how to efficiently use the gradients obtained in adversarial training to boost the performance of state-of-the-art transformer-based models.
+
+# 3 ADVERSARIAL TRAINING FOR LANGUAGE UNDERSTANDING
+
+Pre-trained large-scale language models, such as BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019b), ALBERT (Lan et al., 2020) and T5 (Raffel et al., 2019), have proven to be highly effective for downstream tasks. We aim to further improve the generalization of these pre-trained language models on the downstream language understanding tasks by enhancing their robustness in the embedding space during finetuning on these tasks. We achieve this goal by creating “virtual” adversarial examples in the embedding space, and then perform parameter updates on these adversarial embeddings. Creating actual adversarial examples for language is difficult; even with state-of-theart language models as guidance (e.g., (Cheng et al., 2019)), it remains unclear how to construct label-preserving adversarial examples via word/character replacement without human evaluations, because the meaning of each word/character depends on the context (Ribeiro et al., 2018). Since we are only interested in the effects of adversarial training, rather than producing actual adversarial examples, we add norm-bounded adversarial perturbations to the embeddings of the input sentences using a gradient-based method. Note that our embedding-based adversary is strictly stronger than a more conventional text-based adversary, as our adversary can make manipulations on word embeddings that are not possible in the text domain.
+
+For models that incorporate various input representations, including word or subword embeddings, segment embeddings and position embeddings, our adversaries only modify the concatenated word or sub-word embeddings, leaving other components of the sentence representation unchanged. 2 Denote the sequence of one-hot representations of the input subwords as $\pmb { Z } = [ z _ { 1 } , z _ { 2 } , . . . , z _ { n } ]$ , the embedding matrix as $V$ , and the language model (encoder) as a function ${ \pmb y } = f _ { \pmb \theta } ( { \pmb X } )$ , where $\dot { \boldsymbol { X } } = \boldsymbol { V } \boldsymbol { Z }$ is the subword embeddings, $\textbf {  { y } }$ is the output of the model (e.g., class probabilities for classification models), and $\pmb \theta$ denotes all the learnable parameters including the embedding matrix $V$ . We add adversarial perturbations $\delta$ to the embeddings such that the prediction becomes $\pmb { y } ^ { \prime } = f _ { \pmb { \theta } } ( \pmb { X } + \pmb { \delta } )$ . To preserve the semantics, we constrain the norm of $\pmb { \delta }$ to be small, and assume the model’s prediction should not change after the perturbation. This formulation is analogous to Miyato et al. (2017), with the difference that we do not require $\boldsymbol { X }$ to be normalized.
+
+# 3.1 PGD FOR ADVERSARIAL TRAINING
+
+Standard adversarial training seeks to find optimal parameters $\pmb { \theta } ^ { * }$ to minimize the maximum risk for any $\pmb { \delta }$ within a norm ball as:
+
+$$
+\operatorname* { m i n } _ { \theta } \mathbb { E } _ { ( Z , y ) \sim \mathcal { D } } \left[ \operatorname* { m a x } _ { \| \delta \| \leq \epsilon } L ( f _ { \theta } ( X + \delta ) , y ) \right] ,
+$$
+
+where $\mathcal { D }$ is the data distribution, $y$ is the label, and $L$ is some loss function. We use the Frobenius norm to constrain $\delta$ . For neural networks, the outer “min” is non-convex, and the inner “max” is non-concave. Nonetheless, Madry et al. (2018) demonstrated that this saddle-point problem can be solved reliably with SGD for the outer minimization and PGD (a standard method for large-scale constrained optimization, see (Combettes & Pesquet, 2011) and (Goldstein et al., 2014)), for the inner maximization. In particular, for the constraint $\| \delta \| _ { F } \le \epsilon$ , with an additional assumption that the loss function is locally linear, PGD takes the following step (with step size $\alpha$ ) in each iteration:
+
+$$
+\delta _ { t + 1 } = \Pi _ { \| \pmb { \delta } \| _ { F } \leq \epsilon } \left( \pmb { \delta } _ { t } + \alpha g ( \pmb { \delta } _ { t } ) / \| g ( \pmb { \delta } _ { t } ) \| _ { F } \right) ,
+$$
+
+where $g ( \delta _ { t } ) = \nabla _ { \delta } L ( f _ { \theta } ( X + \delta _ { t } ) , y )$ is the gradient of the loss with respect to $\delta$ , and $\Pi _ { \| \delta \| _ { F } \leq \epsilon }$ performs a projection onto the $\epsilon$ -ball. To achieve high-level robustness, multi-step adversarial examples are needed during training, which is computationally expensive. The $K$ -step PGD ( $K$ -PGD) requires $K$ forward-backward passes through the network, while the standard SGD update requires only one. As a result, the adversary generation step in adversarial training increases run-time by an order of magnitude—a catastrophic amount when training large state-of-the-art language models.
+
+# 3.2 LARGE-BATCH ADVERSARIAL TRAINING FOR FREE
+
+In the inner ascent steps of PGD, the gradients of the parameters can be obtained with almost no overhead when computing the gradients of the inputs. From this observation, FreeAT (Shafahi et al.,
+
+# Algorithm 1 “Free” Large-Batch Adversarial Training (FreeLB- $K$ )
+
+<table><tr><td>ascent step size α</td><td>Require: Training samples X = {(Z,y)}, perturbation bound ε, learning rate T, ascent steps K,</td></tr><tr><td>1:Initialize 0</td><td></td></tr><tr><td>2: for epoch =1... Nep do</td><td></td></tr><tr><td>3:</td><td>for minibatchB ℃Xdo</td></tr><tr><td>4:</td><td>U(-∈,∈)</td></tr><tr><td>5:</td><td>90↑0</td></tr><tr><td>6:</td><td></td></tr><tr><td>7:</td><td>fort=1...K do</td></tr><tr><td>8:</td><td>Accumulate gradient of parameters θ</td></tr><tr><td>9:</td><td>gt←gt-1+kE(z,y)∈B[VθL(fe(X+δt-1),y)]</td></tr><tr><td>10:</td><td>Update the perturbation δ via gradient ascend</td></tr><tr><td>11:</td><td>gadu ←VsL(fθ(X+δt-1),y) δt ←II|δ|lr≤e(δt-1+α:gadu/llgadullF)</td></tr><tr><td>12:</td><td></td></tr><tr><td>13:</td><td>end for</td></tr><tr><td>14:</td><td>0←0-TgK</td></tr><tr><td>end for 15: end for</td><td></td></tr></table>
+
+2019) and YOPO (Zhang et al., 2019) have been proposed to accelerate adversarial training. They achieve comparable robustness and generalization as standard PGD-trained models using only the same or a slightly larger number of forward-backward passes as natural training (i.e., SGD on clean samples). FreeAT takes one descent step on the parameters together with each of the $K$ ascent steps on the perturbation. As a result, FreeAT may suffer from the “stale gradient” problem (Dutta et al., 2018), where in every step $t$ , $\delta _ { t }$ does not necessarily maximize the model with parameter $\theta _ { t }$ since its update is based on $\nabla _ { \delta } L \big ( f _ { \pmb { \theta } _ { t - 1 } } ( \pmb { X } + \delta _ { t - 1 } ) , y \big )$ , and vice versa, $\theta _ { t }$ does not necessarily minimize the adversarial risk with adversary $\delta _ { t }$ since its update is based on $\nabla _ { \pmb { \theta } } L \big ( f _ { \pmb { \theta } _ { t - 1 } } ( \pmb { X } + \delta _ { t - 1 } ) , y \big )$ . Such a problem may be more significant when the step size is large.
+
+Different from FreeAT, YOPO accumulates the gradient of the parameters from each of the ascent steps, and updates the parameters only once after the $K$ inner ascent steps. YOPO also advocates that after each back-propagation, one should take the gradient of the first hidden layer as a constant and perform several additional updates on the adversary using the product of this constant and the Jacobian of the first layer of the network to obtain strong adversaries. However, when the first hidden layer is a linear layer as in their implementation, such an operation is equivalent to taking a larger step size on the adversary. The analysis backing the extra update steps also assumes a twice continuously differentiable loss, which does not hold for ReLU-based neural networks they experimented with, and thus the reasons for the success of such an algorithm remains obscure. We give empirical comparisons between YOPO and our approach in Sec. 4.3.
+
+To obtain better solutions for the inner max and avoid fundamental limitations on the function class, we propose FreeLB, which performs multiple PGD iterations to craft adversarial examples, and simultaneously accumulates the “free” parameter gradients $\nabla _ { \boldsymbol { \theta } } L$ in each iteration. After that, it updates the model parameter $\pmb \theta$ all at once with the accumulated gradients. The overall procedure is shown in Algorithm 1, in which $X + \delta _ { t }$ is an approximation to the local maximum within the intersection of two balls $\mathcal { T } _ { t } = \mathcal { B } _ { X + \delta _ { 0 } } ( \alpha t ) \cap \mathcal { B } _ { X } ( \epsilon )$ . By taking a descent step along the averaged gradients at $X + \delta _ { 0 } , . . . , X + \delta _ { K - 1 }$ , we approximately optimize the following objective:
+
+$$
+\underset { \pmb { \theta } } { \operatorname* { m i n } } \mathbb { E } _ { ( Z , y ) \sim \mathcal { D } } \left[ \frac { 1 } { K } \sum _ { t = 0 } ^ { K - 1 } \underset { \delta _ { t } \in \mathcal { Z } _ { t } } { \operatorname* { m a x } } L \big ( f _ { \pmb { \theta } } \big ( \pmb { X } + \delta _ { t } \big ) , y \big ) \right] ,
+$$
+
+which is equivalent to replacing the original batch $\boldsymbol { X }$ with a $K$ -times larger virtual batch, consisting of samples whose embeddings are $X + \delta _ { 0 } , . . . , X + \delta _ { K - 1 }$ . Compared with PGD-based adversarial training (Eq. 1), which minimizes the maximum risk at a single estimated point in the vicinity of each training sample, FreeLB minimizes the maximum risk at each ascent step at almost no overhead.
+
+Intuitively, FreeLB could be a learning method with lower generalization error than PGD. Sokolic et al. (2017) have proved that the generalization error of a learning method invariant to a set of√ $T$ transformations may be up to $\sqrt { T }$ smaller than a non-invariant learning method. According to their theory, FreeLB could have a more significant improvement over natural training, since FreeLB enforces the invariance to $K$ adversaries from a set of up to $K$ different norm constraints,3 while PGD only enforces invariance to a single norm constraint $\epsilon$ .
+
+Empirically, FreeLB does lead to higher robustness and invariance than PGD in the embedding space, in the sense that the maximum increase of loss in the vicinity of $\boldsymbol { X }$ for models trained with FreeLB is smaller than that with PGD. See Sec. 4.3 for details. In theory, such improved robustness can lead to better generalization (Xu & Mannor, 2012), which is consistent with our experiments. Qin et al. (2019) also demonstrated that PGD-based method leads to highly convolved and non-linear loss surfaces in the vicinity of input samples when $K$ is small, indicating a lack of robustness.
+
+# 3.3 WHEN ADVERSARIAL TRAINING MEETS DROPOUT
+
+Usually, adversarial training is not used together with dropout (Srivastava et al., 2014). However, for some language models like RoBERTa (Liu et al., 2019b), dropout is used during the finetuning stage. In practice, when dropout is turned on, each ascent step of Algorithm 1 is optimizing $\delta$ for a different network. Specifically, denote the dropout mask as $_ { m }$ with each entry $m _ { i } \sim \mathrm { B e r n o u l l i } ( p )$ . Similar to our analysis for FreeAT, the ascent step from $\delta _ { t - 1 }$ to $\delta _ { t }$ is based on $\nabla _ { \delta } L \big ( f _ { \theta ( m _ { t - 1 } ) } \big ( \boldsymbol { X } + \delta _ { t - 1 } \big ) , \boldsymbol { y } \big )$ , so $\delta _ { t }$ is sub-optimal for $L ( f _ { \theta ( m _ { t } ) } ( \boldsymbol { X } + \delta ) , y )$ . Here $\theta ( m )$ is the effective parameters under dropout mask $_ { m }$ .
+
+The more plausible solution is to use the same $_ { \mathbf { \nabla } } \mathbf { m }$ in each step. When applying dropout to any network, the objective for $\pmb \theta$ is to minimize the expectation of loss under different networks determined by the dropout masks, which is achieved by minimizing the Monte Carlo estimation of the expected loss. In our case, the objective becomes:
+
+$$
+\operatorname* { m i n } _ { \theta } \mathbb { E } _ { ( Z , y ) \sim \mathcal { D } , m \sim \mathcal { M } } \left[ \frac { 1 } { K } \sum _ { t = 0 } ^ { K - 1 } \operatorname* { m a x } _ { \delta _ { t } \in \mathcal { T } _ { t } } L \big ( f _ { \theta ( m ) } ( X + \delta _ { t } ) , y \big ) \right] ,
+$$
+
+where the 1-sample Monte Carlo estimation should be $\begin{array} { r } { \frac { 1 } { K } \sum _ { t = 0 } ^ { K - 1 } \operatorname* { m a x } _ { \delta _ { t } \in \mathcal { T } _ { t } } L ( f _ { \theta ( m _ { 0 } ) } ( X + \delta _ { t } ) , y ) } \end{array}$ and can be minimized by using FreeLB with dropout mask $m _ { 0 }$ in each ascent step. This is similar to applying Variational Dropout to RNNs as used in Gal & Ghahramani (2016).
+
+# 4 EXPERIMENTS
+
+In this section, we provide comprehensive analysis on FreeLB through extensive experiments on three Natural Language Understanding benchmarks: GLUE (Wang et al., 2019), ARC (Clark et al., 2018) and CommonsenseQA (Talmor et al., 2019). We also compare the robustness and generalization of FreeLB with other adversarial training algorithms to demonstrate its strength. Additional experimental details are provided in the Appendix.
+
+# 4.1 DATASETS
+
+GLUE Benchmark. The GLUE benchmark is a collection of 9 natural language understanding tasks, namely Corpus of Linguistic Acceptability (CoLA; Warstadt et al. (2018)), Stanford Sentiment Treebank (SST; Socher et al. (2013)), Microsoft Research Paraphrase Corpus (MRPC; Dolan & Brockett (2005)), Semantic Textual Similarity Benchmark (STS; Agirre et al. (2007)), Quora Question Pairs (QQP; Iyer et al. (2017)), Multi-Genre NLI (MNLI; Williams et al. (2018)), Question NLI (QNLI; Rajpurkar et al. (2016)), Recognizing Textual Entailment (RTE; Dagan et al. (2006); Bar Haim et al. (2006); Giampiccolo et al. (2007); Bentivogli et al. (2009)) and Winograd NLI (WNLI; Levesque et al. (2011)). 8 of the tasks are formulated as classification problems and only STS-B is formulated as regression, but FreeLB applies to all of them. For BERT-base, we use the HuggingFace implementation4, and follow the single-task finetuning procedure as in Devlin et al. (2019). For RoBERTa, we use the fairseq implementation5. Same as Liu et al. (2019b), we also use single-task finetuning for all dev set results, and start with MNLI-finetuned models on RTE, MRPC and STS-B for the test submissions.
+
+Table 1: Results (median and variance) on the dev sets of GLUE based on the RoBERTa-large model, from 5 runs with the same hyperparameter but different random seeds. ReImp is our reimplementation of RoBERTalarge. The training process can be very unstable even with the vanilla version. Here, both PGD on STS-B and FreeAT on RTE demonstrates such instability, with one unconverged instance out of five.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>MNLI(Acc)</td><td rowspan=1 colspan=1>QNLI(Acc)</td><td rowspan=1 colspan=1>QQP(Acc)</td><td rowspan=1 colspan=1>RTE(Acc)</td><td rowspan=1 colspan=1>SST-2(Acc)</td><td rowspan=1 colspan=1>MRPC(Acc)</td><td rowspan=1 colspan=1>CoLA(Mcc)</td><td rowspan=1 colspan=1>STS-B(Pearson)</td></tr><tr><td rowspan=1 colspan=1>Reported</td><td rowspan=1 colspan=1>90.2</td><td rowspan=1 colspan=1>94.7</td><td rowspan=1 colspan=1>92.2</td><td rowspan=1 colspan=1>86.6</td><td rowspan=1 colspan=1>96.4</td><td rowspan=1 colspan=1>90.9</td><td rowspan=1 colspan=1>68.0</td><td rowspan=1 colspan=1>92.4</td></tr><tr><td rowspan=1 colspan=1>ReImp</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>85.61 (1.7)</td><td rowspan=1 colspan=1>96.56 (.3)</td><td rowspan=1 colspan=1>90.69(.5)</td><td rowspan=1 colspan=1>67.57 (1.3)</td><td rowspan=1 colspan=1>92.20 (.2)</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>90.53 (.2)</td><td rowspan=1 colspan=1>94.87 (.2)</td><td rowspan=1 colspan=1>92.49 (.07)</td><td rowspan=1 colspan=1>87.41 (.9)</td><td rowspan=1 colspan=1>96.44 (.1)</td><td rowspan=1 colspan=1>90.93 (.2)</td><td rowspan=1 colspan=1>69.67 (1.2)</td><td rowspan=1 colspan=1>92.43 (7.)</td></tr><tr><td rowspan=1 colspan=1>FreeAT</td><td rowspan=1 colspan=1>90.02 (.2)</td><td rowspan=1 colspan=1>94.66 (.2)</td><td rowspan=1 colspan=1>92.48(.08)</td><td rowspan=1 colspan=1>86.69 (15.)</td><td rowspan=1 colspan=1>96.10 (.2)</td><td rowspan=1 colspan=1>90.69 (.4)</td><td rowspan=1 colspan=1>68.80 (1.3)</td><td rowspan=1 colspan=1>92.40 (.3)</td></tr><tr><td rowspan=1 colspan=1>FreeLB</td><td rowspan=1 colspan=1>90.61 (.1)</td><td rowspan=1 colspan=1>94.98 (.2)</td><td rowspan=1 colspan=1>92.60 (.03)</td><td rowspan=1 colspan=1>88.13 (1.2)</td><td rowspan=1 colspan=1>96.79 (.2)</td><td rowspan=1 colspan=1>91.42 (.7)</td><td rowspan=1 colspan=1>71.12 (.9)</td><td rowspan=1 colspan=1>92.67 (.08)</td></tr></table>
+
+Table 2: Results on GLUE from the evaluation server, as of Sep 25, 2019. Metrics are the same as the leaderboard. Number under each task’s name is the size of the training set. FreeLB-BERT is the single-model results of BERT-base finetuned with FreeLB, and FreeLB-RoB is the ensemble of 7 RoBERTa-Large models for each task. References: 1: (Devlin et al., 2019); 2: (Liu et al., 2019a); 3: (Yang et al., 2019); 4: (Liu et al., 2019b).   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Score</td><td rowspan=1 colspan=1>CoLA8.5k</td><td rowspan=1 colspan=1>SST-267k</td><td rowspan=1 colspan=1>MRPC3.7k</td><td rowspan=1 colspan=1>STS-B7k</td><td rowspan=1 colspan=1>QQP364k</td><td rowspan=1 colspan=1>MNLI-m/mm393k</td><td rowspan=1 colspan=1>QNLI108k</td><td rowspan=1 colspan=1>RTE2.5k</td><td rowspan=1 colspan=1>WNLI634</td><td rowspan=1 colspan=1>AX</td></tr><tr><td rowspan=1 colspan=1>BERT-base1</td><td rowspan=1 colspan=1>78.3</td><td rowspan=1 colspan=1>52.1</td><td rowspan=1 colspan=1>93.5</td><td rowspan=1 colspan=1>88.9/84.8</td><td rowspan=1 colspan=1>87.1/85.8</td><td rowspan=1 colspan=1>71.2/89.2</td><td rowspan=1 colspan=1>84.6/83.4</td><td rowspan=1 colspan=1>90.5</td><td rowspan=1 colspan=1>66.4</td><td rowspan=1 colspan=1>65.1</td><td rowspan=1 colspan=1>34.2</td></tr><tr><td rowspan=1 colspan=1>FreeLB-BERT</td><td rowspan=1 colspan=1>79.4</td><td rowspan=1 colspan=1>54.5</td><td rowspan=1 colspan=1>93.6</td><td rowspan=1 colspan=1>88.1/83.5</td><td rowspan=1 colspan=1>87.7/86.7</td><td rowspan=1 colspan=1>72.7/89.6</td><td rowspan=1 colspan=1>85.7/84.6</td><td rowspan=1 colspan=1>91.8</td><td rowspan=1 colspan=1>70.1</td><td rowspan=1 colspan=1>65.1</td><td rowspan=1 colspan=1>36.9</td></tr><tr><td rowspan=1 colspan=1>MT-DNN2</td><td rowspan=1 colspan=1>87.6</td><td rowspan=1 colspan=1>68.4</td><td rowspan=1 colspan=1>96.5</td><td rowspan=1 colspan=1>92.7/90.3</td><td rowspan=1 colspan=1>91.1/90.7</td><td rowspan=1 colspan=1>73.7789.9</td><td rowspan=1 colspan=1>87.9/87.4</td><td rowspan=1 colspan=1>96.0</td><td rowspan=1 colspan=1>86.3</td><td rowspan=1 colspan=1>89.0</td><td rowspan=1 colspan=1>42.8</td></tr><tr><td rowspan=1 colspan=1>XLNet-Large</td><td rowspan=1 colspan=1>88.4</td><td rowspan=1 colspan=1>67.8</td><td rowspan=1 colspan=1>96.8</td><td rowspan=1 colspan=1>93.0/90.7</td><td rowspan=1 colspan=1>91.6/91.1</td><td rowspan=1 colspan=1>74.2/90.3</td><td rowspan=1 colspan=1>90.2/89.8</td><td rowspan=1 colspan=1>98.6</td><td rowspan=1 colspan=1>86.3</td><td rowspan=1 colspan=1>90.4</td><td rowspan=1 colspan=1>47.5</td></tr><tr><td rowspan=1 colspan=1>RoBERTa4</td><td rowspan=1 colspan=1>88.5</td><td rowspan=1 colspan=1>67.8</td><td rowspan=1 colspan=1>96.7</td><td rowspan=1 colspan=1>92.3/89.8</td><td rowspan=1 colspan=1>92.2/91.9</td><td rowspan=1 colspan=1>74.3/90.2</td><td rowspan=1 colspan=1>90.8/90.2</td><td rowspan=1 colspan=1>98.9</td><td rowspan=1 colspan=1>88.2</td><td rowspan=1 colspan=1>89.0</td><td rowspan=1 colspan=1>48.7</td></tr><tr><td rowspan=1 colspan=1>FreeLB-RoB</td><td rowspan=1 colspan=1>88.8</td><td rowspan=1 colspan=1>68.0</td><td rowspan=1 colspan=1>96.8</td><td rowspan=1 colspan=1>93.1/90.8</td><td rowspan=1 colspan=1>92.4/92.2</td><td rowspan=1 colspan=1>74.8/90.3</td><td rowspan=1 colspan=1>91.1/90.7</td><td rowspan=1 colspan=1>98.8</td><td rowspan=1 colspan=1>88.7</td><td rowspan=1 colspan=1>89.0</td><td rowspan=1 colspan=1>50.1</td></tr><tr><td rowspan=1 colspan=1>Human</td><td rowspan=1 colspan=1>87.1</td><td rowspan=1 colspan=1>66.4</td><td rowspan=1 colspan=1>97.8</td><td rowspan=1 colspan=1>86.3/80.8</td><td rowspan=1 colspan=1>92.7/92.6</td><td rowspan=1 colspan=1>59.5/80.4</td><td rowspan=1 colspan=1>92.0/92.8</td><td rowspan=1 colspan=1>91.2</td><td rowspan=1 colspan=1>93.6</td><td rowspan=1 colspan=1>95.9</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+ARC Benchmark. The ARC dataset (Clark et al., 2018) is a collection of multi-choice science questions from grade-school level exams. It is further divided into ARC-Challenge set with 2,590 question answer (QA) pairs and ARC-Easy set with 5,197 QA pairs. Questions in ARC-Challenge are more difficult and cannot be handled by simply using a retrieval and co-occurence based algorithm (Clark et al., 2018). A typical question is:
+
+Which property of a mineral can be determined just by looking at it?
+
+(A) luster [correct] $( B )$ mass $( C )$ weight $( D )$ hardness.
+
+CommonsenseQA Benchmark. The CommonsenseQA dataset (Talmor et al., 2019) consists of 12,102 natural language questions that require human commonsense reasoning ability to answer. A typical question is :
+
+Where can I stand on a river to see water falling without getting wet?
+
+(A) waterfall, (B) bridge [correct], (C) valley, $( D )$ stream, (E) bottom.
+
+Each question has five candidate answers from ConceptNet (Speer et al., 2017). To make the question more difficult to solve, most answers have the same relation in ConceptNet to the key concept in the question. As shown in the above example, most answers can be connected to “river” by “AtLocation” relation in ConceptNet. For a fair comparison with the reported results in papers and leaderboard6, we use the official random split 1.11.
+
+# 4.2 EXPERIMENTAL RESULTS
+
+GLUE We summarize results on the dev sets of GLUE in Table 1, comparing the proposed FreeLB against other adversatial training algorithms (PGD (Madry et al., 2018) and FreeAT (Shafahi et al., 2019)). We use the same step size $\alpha$ and number of steps $m$ for PGD, FreeAT and FreeLB. FreeLB is consistently better than the two baselines. Comparisons and detailed discussions about
+
+Table 3: Results on ARC and CommonsenseQA (CQA). ARC-Merge is the combination of ARC-Easy and ARC-Challenge, “MTL” stands for multi-task learning and “Ens” stands for ensemble. Results of XLNet $^ +$ RoBERTa $\left( \mathbf { M } \mathbf { T } \mathbf { L } { + } \mathbf { E } \mathbf { n } \mathbf { s } \right)$ and AristoRoBERTaV7 (MTL) are from the ARC leaderboards. Test (E) denotes the test set results with ensembles. For CQA, we report the highest dev and test accuracies among all models. The models with 78.81/72.19 dev/test accuracy (as in the table) have 71.84/78.64 test/dev accuracies respectively.   
+
+<table><tr><td rowspan=2 colspan=1></td><td rowspan=2 colspan=9>ARC-Easy    ARC-Challenge   ARC-Merge            CQADev   Test   Dev    Test    Dev   Test   Dev  Test Test (E)</td></tr><tr><td rowspan=1 colspan=1>Test</td><td rowspan=1 colspan=1>Dev</td><td rowspan=1 colspan=1>Test</td><td rowspan=1 colspan=1>Dev</td><td rowspan=1 colspan=2>Test   Dev</td><td rowspan=1 colspan=1>Test</td></tr><tr><td rowspan=1 colspan=1>RoBERTa(Reported)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>78.43</td><td rowspan=1 colspan=1>72.1</td><td rowspan=1 colspan=1>72.5</td></tr><tr><td rowspan=1 colspan=1>RoBERTa (ReImp)</td><td rowspan=1 colspan=1>84.39</td><td rowspan=1 colspan=1>84.13</td><td rowspan=1 colspan=1>64.54</td><td rowspan=1 colspan=1>64.44</td><td rowspan=1 colspan=1>77.83</td><td rowspan=1 colspan=1>77.62</td><td rowspan=1 colspan=1>77.56</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>FreeLB-RoBERTa</td><td rowspan=1 colspan=1>84.91</td><td rowspan=1 colspan=1>84.81</td><td rowspan=1 colspan=1>65.89</td><td rowspan=1 colspan=1>65.36</td><td rowspan=1 colspan=1>78.37</td><td rowspan=1 colspan=1>78.39</td><td rowspan=1 colspan=1>78.81</td><td rowspan=1 colspan=1>72.2</td><td rowspan=1 colspan=1>73.1</td></tr><tr><td rowspan=1 colspan=1>AristoRoBERTaV7(MTL)</td><td rowspan=1 colspan=1>:</td><td rowspan=1 colspan=1>85.02</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>66.47</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>78.89</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>:</td></tr><tr><td rowspan=1 colspan=1>XLNet +RoBERTa (MTL+Ens)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>67.06</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>二</td></tr><tr><td rowspan=1 colspan=1>FreeLB-RoBERTa(MTL)</td><td rowspan=1 colspan=1>84.91</td><td rowspan=1 colspan=1>85.44</td><td rowspan=1 colspan=1>70.23</td><td rowspan=1 colspan=1>67.75</td><td rowspan=1 colspan=1>79.86</td><td rowspan=1 colspan=1>79.60</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr></table>
+
+YOPO (Zhang et al., 2019) are provided in Sec. 4.3. We have also submitted our results to the evaluation server, results provided in Table 2. FreeLB lifts the performance of the BERT-base model from 78.3 to 79.4, and RoBERTa-large model from 88.5 to 88.8 on overall scores.
+
+ARC For ARC, a corpus of 14 million related science documents (from ARC Corpus, Wikipedia and other sources) is provided. For each QA pair, we first use a retrieval model to select top 10 related documents. Then, given these retrieved documents7, we use RoBERTa-large model to encode $\langle s \rangle$ Retrieved Documents $\langle / s \rangle$ Question $^ +$ Answer $\langle / s \rangle$ , where $\langle \mathbf { s } \rangle$ and $\langle / \mathrm { s } \rangle$ are special tokens for RoBERTa model8. We then apply a fully-connected layer to the representation of the [CLS] token to compute the final logit, and use standard cross-entropy loss for model training.
+
+Results are summarized in Table 3. Following Sun et al. (2018), we first finetune the RoBERTa model on the RACE dataset (Lai et al., 2017). The finetuned RoBERTa model achieves $8 5 . 7 0 \%$ and $8 5 . 2 4 \%$ accuracy on the development and test set of RACE, respectively. Based on this, we further finetune the model on both ARC-Easy and ARC-Challenge datasets with the same hyper-parameter searching strategy (for 5 epochs), which achieves $8 4 . 1 3 \% / 6 4 . 4 4 \%$ test accuracy on ARC-Easy/ARCChallenge. And by adding FreeLB finetuning, we can reach $8 4 . 8 1 \% / 6 5 . 3 6 \%$ , a significant boost on ARC benchmark, demonstrating the effectiveness of FreeLB.
+
+To further improve the results, we apply a multi-task learning (MTL) strategy using additional datasets. We first finetune the model on RACE (Lai et al., 2017), and then finetune on a joint dataset of ARC-Easy, ARC-Challenge, OpenbookQA (Mihaylov et al., 2018) and Regents Living Environment9. Based on this, we further finetune our model on ARC-Easy and ARC-Challenge with FreeLB. After finetuning, our single model achieves $6 7 . 7 5 \%$ test accuracy on ARC-Challenge and $8 5 . 4 4 \%$ on ARC-Easy, both outperforming the best submission on the official leaderboard10.
+
+CommonsenseQA Similar to the training strategy in Liu et al. (2019b), we construct five inputs for each question by concatenating the question and each answer separately, then encode each input with the representation of the [CLS] token. A final score is calculated by applying the representation of [CLS] to a fully-connected layer. Following the fairseq repository11, the input is formatted as: ${ \mathfrak { n } } ( s ) Q$ : Where can I stand on a river to see water falling without getting wet? $\langle / s \rangle A$ : waterfall $\langle \langle s \rangle ^ { \ast } \cdot \mathbf { \vec { \mathbf { \mu } } }$ , where $\cdot _ { Q }$ :’ and $^ { , } A$ :’ are the prefix for question and answer, respectively.
+
+Results are summarized in Table 3. We obtained a dev-set accuracy of $7 7 . 5 6 \%$ with the RoBERTalarge model. When using FreeLB finetuning, we achieved $7 8 . 8 1 \%$ , a $1 . 2 5 \%$ absolute gain. Compared with the results reported from fairseq repository, which obtains $7 8 . 4 3 \%$ accuracy on the devset, FreeLB still achieves better performance. Our submission to the CommonsenseQA leaderboard achieves $7 2 . 2 \%$ single-model test set accuracy, and the result of a 20-model ensemble is $7 3 . 1 \%$ , which achieves No.1 among all the submissions without making use of ConceptNet.
+
+Table 4: The median and standard deviation of the scores on the dev sets of RTE, CoLA and MRPC from the GLUE benchmark, computed from 5 runs with the same hyper-parameters except for the random seeds. We use FreeLB- $\mathbf { \nabla } m$ to denote FreeLB with $m$ ascent steps, and FreeLB- ${ . 3 ^ { * } }$ to denote the version without reusing the dropout mask.   
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>FreeLB-3*</td><td rowspan=1 colspan=1>FreeLB-3</td><td rowspan=1 colspan=1>YOPO-3-2</td><td rowspan=1 colspan=1>YOPO-3-3</td></tr><tr><td rowspan=1 colspan=1>RTE</td><td rowspan=1 colspan=1>85.61 (1.67)</td><td rowspan=1 colspan=1>87.14 (1.29)</td><td rowspan=1 colspan=1>88.13 (1.21)</td><td rowspan=1 colspan=1>87.05 (1.36)</td><td rowspan=1 colspan=1>87.05 (0.20)</td></tr><tr><td rowspan=1 colspan=1>CoLA</td><td rowspan=1 colspan=1>67.57 (1.30)</td><td rowspan=1 colspan=1>69.31 (1.16)</td><td rowspan=1 colspan=1>71.12 (0.90)</td><td rowspan=1 colspan=1>70.40 (0.91)</td><td rowspan=1 colspan=1>69.91 (1.16)</td></tr><tr><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>90.69 (0.54)</td><td rowspan=1 colspan=1>90.93 (0.66)</td><td rowspan=1 colspan=1>91.42 (0.72)</td><td rowspan=1 colspan=1>90.44 (0.62)</td><td rowspan=1 colspan=1>90.69 (0.37)</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=3>RTE</td><td rowspan=1 colspan=3>CoLA</td><td rowspan=1 colspan=3>MRPC</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4)</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4)</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-3)</td><td rowspan=1 colspan=1>M-Inc (R)(10-3)</td><td rowspan=1 colspan=1>N-Loss(10-3)</td></tr><tr><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>5.1</td><td rowspan=1 colspan=1>5.3</td><td rowspan=1 colspan=1>4.5</td><td rowspan=1 colspan=1>6.1</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>5.2</td><td rowspan=1 colspan=1>10.2</td><td rowspan=1 colspan=1>10.2</td><td rowspan=1 colspan=1>1.9</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>4.7</td><td rowspan=1 colspan=1>4.9</td><td rowspan=1 colspan=1>6.2</td><td rowspan=1 colspan=1>128.2</td><td rowspan=1 colspan=1>130.1</td><td rowspan=1 colspan=1>436.1</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>5.4</td></tr><tr><td rowspan=1 colspan=1>FreeLB</td><td rowspan=1 colspan=1>3.0</td><td rowspan=1 colspan=1>2.6</td><td rowspan=1 colspan=1>4.1</td><td rowspan=1 colspan=1>1.4</td><td rowspan=1 colspan=1>1.3</td><td rowspan=1 colspan=1>7.2</td><td rowspan=1 colspan=1>3.6</td><td rowspan=1 colspan=1>3.6</td><td rowspan=1 colspan=1>2.7</td></tr></table>
+
+Table 5: Median of the maximum increase in loss in the vicinity of the dev set samples for RoBERTa-Large model finetuned with different methods. Vanilla models are naturally trained RoBERTa’s. M-Inc: Max Inc, MInc (R): Max Inc (R). Nat Loss (N-Loss) is the loss value on clean samples. Notice we require all clean samples here to be correctly classified by all models, which results in 227, 850 and 355 samples for RTE, CoLA and MRPC, respectively. We also give the variance in the Appendix.
+
+# 4.3 ABLATION STUDY AND ANALYSIS
+
+In this sub-section, we first show the importance of reusing dropout mask, then conduct a thorough ablation study on FreeLB over the GLUE benchmark to analyze the robustness and generalization strength of different approaches. We observe that it is unnecessary to perform shallow-layer updates on the adversary as YOPO for our case, and FreeLB results in improved robustness and generalization compared with PGD.
+
+Importance of Reusing Mask Table 4 (columns 2 to 4) compares the results of FreeLB with and without reusing the same dropout mask in each ascent step, as proposed in Sec. 3.3. With reusing, FreeLB can achieve a larger improvement over the naturally trained models. Thus, we enable mask reusing for all experiments involving RoBERTa.
+
+Comparing the Robustness Table 5 provides the comparisons of the maximum increment of loss in the vicinity of each sample, defined as:
+
+$$
+\displaystyle \Delta L _ { \mathrm { m a x } } ( \boldsymbol { X } , \epsilon ) = \operatorname* { m a x } _ { \| \delta \| \leq \epsilon } L ( f _ { \boldsymbol { \theta } } ( \boldsymbol { X } + \delta ) , \boldsymbol { y } ) - L ( f _ { \boldsymbol { \theta } } ( \boldsymbol { X } ) , \boldsymbol { y } ) ,
+$$
+
+which reflects the robustness and invariance of the model in the embedding space. In practice, we use PGD steps as in Eq. 2 to find the value of ${ \Delta } L _ { \mathrm { m a x } } ( \boldsymbol { X } , \boldsymbol { \epsilon } )$ . We found that when using a step size of $5 { \cdot } 1 0 ^ { - 3 }$ and $\epsilon = 0 . 0 1 \| X \| _ { F }$ , the PGD iterations converge to almost the same value, starting from 100 different random initializations of $\pmb { \delta }$ for the RoBERTa models, trained with or without FreeLB. This indicates that PGD reliably finds $\Delta L _ { \mathrm { m a x } }$ for these models. Therefore, we compute ${ \Delta } L _ { \mathrm { m a x } } ( X , \epsilon )$ for each $\boldsymbol { X }$ via a 2000-step PGD.
+
+Samples with small margins exist even for models with perfect accuracy, which could give a false sense of vulnerability of the model. To rule out the outlier effect and make ${ \Delta } L _ { \mathrm { m a x } } ( \boldsymbol { X } , \epsilon )$ comparable across different samples, we only consider samples that all the evaluated models can correctly classify, and search for an $\epsilon$ for each sample such that the reference model can correctly classify all samples within the $\epsilon$ ball.12 However, such choice of per-sample $\epsilon$ favors the reference model by design. To make fair comparisons, Table 5 provides the median of ${ \Delta } L _ { \mathrm { m a x } } ( \boldsymbol { X } , \epsilon )$ with per-sample $\epsilon$ from models trained by FreeLB (Max Inc) and PGD (Mac Inc (R)), respectively.
+
+Across all three datasets and different reference models, FreeLB has the smallest median increment even when starting from a larger natural loss than vanilla models. This demonstrates that FreeLB is more robust and invariant in most cases. Such results are also consistent with the models’ dev set performance (the performances for Vanilla/PGD/FreeLB models on RTE, CoLA and MRPC are 86.69/87.41/89.21, 69.91/70.84/71.40, 91.67/91.17/91.17, respectively).
+
+Comparing with YOPO The original implementation of YOPO (Zhang et al., 2019) chooses the first convolutional layer of the ResNets as $f _ { 0 }$ for updating the adversary in the “s-loop”. As a result, each step of the “s-loop” should be using exactly the same value to update the adversary,and YOPO$m { - } n$ degenerates into FreeLB with a $n$ -times large step size. To avoid that, we choose the layers up to the output of the first Transformer block as $f _ { 0 }$ when implementing YOPO. To make the total amount of update on the adversary equal, we take the hyper-parameters for FreeLB- $m$ and only change the step size $\alpha$ into $\alpha / n$ for YOPO- $m { \cdot } n$ . Table 4 shows that FreeLB performs consistently better than YOPO on all three datasets. Accidentally, we also give the results comparing with YOPO- $\mathbf { \nabla } m - n$ without changing the step size $\alpha$ for YOPO in Table 8. The gap between two approaches seem to shrink, which may be caused by using a larger total step size for the YOPO adversaries. We leave exhaustive hyperparameter search for both models as our future work.
+
+# 5 CONCLUSION
+
+In this work, we have developed an adversarial training approach, FreeLB, to improve natural language understanding. The proposed approach adds perturbations to continuous word embeddings using a gradient method, and minimizes the resultant adversarial risk in an efficient way. FreeLB is able to boost Transformer-based model (BERT and RoBERTa) on several datasets and achieve new state of the art on GLUE and ARC benchmarks. Empirical study demonstrates that our method results in both higher robustness in the embedding space than natural training and better generalization ability. Such observation is also consistent with recent findings in Computer Vision. However, adversarial training still takes significant overhead compared with vanilla SGD. How to accelerate this process while improving generalization is an interesting future direction.
+
+Acknowledgements: Goldstein and Zhu were supported in part by the DARPA GARD, DARPA QED for RML, and AFOSR MURI programs.
+
+# REFERENCES
+
+Eneko Agirre, Llu’is M‘arquez, and Richard Wicentowski (eds.). Proceedings of the Fourth International Workshop on Semantic Evaluations (SemEval-2007). Association for Computational Linguistics, 2007.
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2018.
+
+Roy Bar Haim, Ido Dagan, Bill Dolan, Lisa Ferro, Danilo Giampiccolo, Bernardo Magnini, and Idan Szpektor. The second PASCAL recognising textual entailment challenge. 2006.
+
+Yonatan Belinkov and Yonatan Bisk. Synthetic and natural noise both break neural machine translation. In ICLR, 2018.
+
+Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. The fifth PASCAL recognizing textual entailment challenge. 2009.
+
+Yong Cheng, Lu Jiang, and Wolfgang Macherey. Robust neural machine translation with doubly adversarial inputs. In ACL, 2019.
+
+Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge. arXiv preprint arXiv:1803.05457, 2018.
+
+Patrick L Combettes and Jean-Christophe Pesquet. Proximal splitting methods in signal processing. In Fixed-point algorithms for inverse problems in science and engineering. 2011.
+
+Ido Dagan, Oren Glickman, and Bernardo Magnini. The PASCAL recognising textual entailment challenge. In Machine learning challenges. evaluating predictive uncertainty, visual object classification, and recognising tectual entailment. Springer, 2006.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019.
+
+William B Dolan and Chris Brockett. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the International Workshop on Paraphrasing, 2005.
+
+Sanghamitra Dutta, Gauri Joshi, Soumyadip Ghosh, Parijat Dube, and Priya Nagpurkar. Slow and stale gradients can win the race: Error-runtime trade-offs in distributed sgd. In AISTATS, pp. 803–812, 2018.
+
+Javid Ebrahimi, Anyi Rao, Daniel Lowd, and Dejing Dou. HotFlip: White-box adversarial examples for text classification. In ACL, 2018.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In NeurIPS, 2016.
+
+Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and Bill Dolan. The third PASCAL recognizing textual entailment challenge. In Proceedings of the ACL-PASCAL workshop on textual entailment and paraphrasing, 2007.
+
+Tom Goldstein, Christoph Studer, and Richard Baraniuk. A field guide to forward-backward splitting with a fasta implementation. arXiv preprint 1411.3406, 2014.
+
+Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+
+Shankar Iyer, Nikhil Dandekar, and Kornl Csernai. First quora dataset release: Question pairs, 2017. URL https://www.quora.com/q/quoradata/ First-Quora-Dataset-Release-Question-Pairs.
+
+Mohit Iyyer, John Wieting, Kevin Gimpel, and Luke Zettlemoyer. Adversarial example generation with syntactically controlled paraphrase networks. In NAACL, 2018.
+
+Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In EMNLP, 2017.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. In ICLR, 2017.
+
+Guokun Lai, Qizhe Xie, Hanxiao Liu, Yiming Yang, and Eduard Hovy. Race: Large-scale reading comprehension dataset from examinations. arXiv preprint arXiv:1704.04683, 2017.
+
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. Albert: A lite bert for self-supervised learning of language representations. ICLR, 2020.
+
+Hector J Levesque, Ernest Davis, and Leora Morgenstern. The Winograd schema challenge. In AAAI Spring Symposium: Logical Formalizations of Commonsense Reasoning, 2011.
+
+Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. Multi-task deep neural networks for natural language understanding. In ACL, 2019a.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019b.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.
+
+Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. Can a suit of armor conduct electricity? a new dataset for open book question answering. arXiv preprint arXiv:1809.02789, 2018.
+
+Takeru Miyato, Andrew M Dai, and Ian Goodfellow. Adversarial training methods for semisupervised text classification. In ICLR, 2017.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: A regularization method for supervised and semi-supervised learning. TPAMI, 2019.
+
+Chongli Qin, James Martens, Sven Gowal, Dilip Krishnan, Alhussein Fawzi, Soham De, Robert Stanforth, Pushmeet Kohli, et al. Adversarial robustness through local linearization. In NeurIPS, 2019.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint 1910.10683, 2019.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. SQuAD: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. In EMNLP, 2016.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Semantically equivalent adversarial rules for debugging NLP models. In ACL, 2018.
+
+Parsa Saadatpanah, Ali Shafahi, and Tom Goldstein. Adversarial attacks on copyright detection systems. arXiv preprint 1906.07153, 2019.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL, 2016.
+
+A. Shafahi, M. Najibi, A. Ghiasi, Z. Xu, J. Dickerson, C. Studer, L. Davis, G. Taylor, and T. Goldstein. Adversarial Training for Free! In NeurIPS, 2019.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Ng, and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In EMNLP, 2013.
+
+Jure Sokolic, Raja Giryes, Guillermo Sapiro, and Miguel Rodrigues. Generalization error of invariant classifiers. In AISTATS, 2017.
+
+Robert Speer, Joshua Chin, and Catherine Havasi. Conceptnet 5.5: An open multilingual graph of general knowledge. In AAAI, 2017.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014.
+
+Kai Sun, Dian Yu, Dong Yu, and Claire Cardie. Improving machine reading comprehension with general reading strategies. arXiv preprint arXiv:1810.13441, 2018.
+
+Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. Commonsenseqa: A question answering challenge targeting commonsense knowledge. In NAACL, 2019.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. In ICLR, 2019.
+
+Alex Warstadt, Amanpreet Singh, and Samuel R. Bowman. Neural network acceptability judgments. arXiv preprint 1805.12471, 2018.
+
+Adina Williams, Nikita Nangia, and Samuel R. Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In NAACL, 2018.
+
+Chaowei Xiao, Ruizhi Deng, Bo Li, Fisher Yu, Mingyan Liu, and Dawn Song. Characterizing adversarial examples based on spatial consistency information for semantic segmentation. In ECCV, 2018.
+
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan L. Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. In CVPR, 2019.
+
+Huan Xu and Shie Mannor. Robustness and generalization. Machine learning, 2012.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In NeurIPS, 2019.
+
+Dinghuai Zhang, Tianyuan Zhang, Yiping Lu, Zhanxing Zhu, and Bin Dong. You only propagate once: Painless adversarial training using maximal principle. In NeurIPS, 2019.
+
+Zhengli Zhao, Dheeru Dua, and Sameer Singh. Generating natural adversarial examples. In ICLR, 2018.
+
+# A ADDITIONAL EXPERIMENTAL DETAILS
+
+# A.1 PROBLEM FORMULATIONS
+
+For tasks with ranking loss like ARC, CommonsenseQA, WNLI and QNLI, add the perturbation to the concatenation of the embeddings of all question/answer pairs.
+
+Additional tricks are required to achieve high performance on WNLI and QNLI for the GLUE benchmark. We use the same tricks as Liu et al. (2019b). For WNLI, we use the same WSC data provided by Liu et al. (2019b) for training. For testing, Liu et al. (2019b) also provided the test set with span annotations, but the order is different form the GLUE dataset. We re-order their test set by matching. For the QNLI, we follow Liu et al. (2019b) and formulate the problem as pairwise ranking problem, which is the same for CommonsenseQA. We find the matching pairs for both training set and testing set by matching the queries in the dev set. We predict “entailment” if the candidate has the higher score, and “not entailment” otherwise.
+
+# A.2 HYPER-PARAMETERS
+
+Table 6: Additional hyper-parameters on GLUE tasks.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>RTE</td><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>CoLA</td><td rowspan=1 colspan=1>STS-B</td></tr><tr><td rowspan=1 colspan=1>E</td><td rowspan=1 colspan=1>2E-1</td><td rowspan=1 colspan=1>1.5E-1</td><td rowspan=1 colspan=1>4.5E-1</td><td rowspan=1 colspan=1>1.5E-1</td><td rowspan=1 colspan=1>6E-1</td><td rowspan=1 colspan=1>4E-1</td><td rowspan=1 colspan=1>2E-1</td><td rowspan=1 colspan=1>3E-1</td></tr><tr><td rowspan=1 colspan=1>a</td><td rowspan=1 colspan=1>1E-1</td><td rowspan=1 colspan=1>1E-1</td><td rowspan=1 colspan=1>1.5E-1</td><td rowspan=1 colspan=1>3E-2</td><td rowspan=1 colspan=1>1E-1</td><td rowspan=1 colspan=1>4E-2</td><td rowspan=1 colspan=1>2.5E-2</td><td rowspan=1 colspan=1>1E-1</td></tr><tr><td rowspan=1 colspan=1>m</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr></table>
+
+As other adversarial training methods, introduces three additional hyper-parameters: step size $\alpha$ , maximum perturbation $\epsilon$ , number of steps $m$ . For all other hyper-parameters such as learning rate and number of iterations, we either search in the same interval as RoBERTa (on CommonsenseQA, ARC, and WNLI), or use exactly the same setting as RoBERTa (except for MRPC, where we find using a learning rate of $5 \times 1 0 ^ { - 6 }$ gives better results).13. We list the best combinations for $\alpha , \epsilon$ and $m$ for each of the GLUE tasks in Table 6. For WSC/WNLI, the best combination is $\epsilon = 1 e - 2 , \alpha =$ $5 e - 3 , m = 2$ . Notice even when $m \alpha < \epsilon$ , the maximum perturbation could still reach $\epsilon$ due to the random initialization.
+
+# B VARIANCE OF MAXIMUM INCREMENT OF LOSS
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=3>RTE</td><td rowspan=1 colspan=3>CoLA</td><td rowspan=1 colspan=3>MRPC</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4）</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4）</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-3)</td><td rowspan=1 colspan=1>M-Inc (R)(10-3）</td><td rowspan=1 colspan=1>N-Loss(10-3)</td></tr><tr><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>5.1(15087)</td><td rowspan=1 colspan=1>5.3(14346)</td><td rowspan=1 colspan=1>4.5(920)</td><td rowspan=1 colspan=1>6.1(13118)</td><td rowspan=1 colspan=1>5.7(14122)</td><td rowspan=1 colspan=1>5.2(447)</td><td rowspan=1 colspan=1>10.2(929)</td><td rowspan=1 colspan=1>10.2(955)</td><td rowspan=1 colspan=1>1.9(76)</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>4.7(10138)</td><td rowspan=1 colspan=1>4.9(1828)</td><td rowspan=1 colspan=1>6.2(752)</td><td rowspan=1 colspan=1>128.2(1300)</td><td rowspan=1 colspan=1>130.1(893)</td><td rowspan=1 colspan=1>436.1(1276)</td><td rowspan=1 colspan=1>5.7(321)</td><td rowspan=1 colspan=1>5.7(155)</td><td rowspan=1 colspan=1>5.4(54)</td></tr><tr><td rowspan=1 colspan=1>FreeLB</td><td rowspan=1 colspan=1>3.0(1614)</td><td rowspan=1 colspan=1>2.6(11114)</td><td rowspan=1 colspan=1>4.1(595)</td><td rowspan=1 colspan=1>1.4(1392)</td><td rowspan=1 colspan=1>1.3(6231)</td><td rowspan=1 colspan=1>7.2(615)</td><td rowspan=1 colspan=1>3.6(167)</td><td rowspan=1 colspan=1>3.6(601)</td><td rowspan=1 colspan=1>2.7(54)</td></tr></table>
+
+Table 7: Median and Standard Deviation of the maximum increase in loss in the vicinity of the dev set samples for RoBERTa-Large model finetuned with different methods. Vanilla models are naturally trained RoBERTa’s. Nat Loss is the loss value on clean samples. Notice we require all clean samples here to be correctly classified by all models, which results in 227, 850 and 355 samples for RTE, CoLA and MRPC.
+
+Table 7 provides the complete results for the increment of loss in the interval, with median and standard deviation.
+
+# C ADDITIONAL RESULTS FOR ABLATION STUDIES
+
+Here we provide some additional results for comparison with YOPO as complementary results to Table 4. We will release the complete results for comparing with YOPO and without variational dropout on each of the GLUE tasks in our next revision. From the current results, there is no need
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>FreeLB-3</td><td rowspan=1 colspan=1>YOPO-3-2</td><td rowspan=1 colspan=1>YOPO-3-3</td></tr><tr><td rowspan=1 colspan=1>STS-B</td><td rowspan=1 colspan=1>92.20 (.2)</td><td rowspan=1 colspan=1>92.67 (.08)</td><td rowspan=1 colspan=1>92.60 (.17)</td><td rowspan=1 colspan=1>92.60 (0.20)</td></tr><tr><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>96.56 (.3)</td><td rowspan=1 colspan=1>96.79 (.2)</td><td rowspan=1 colspan=1>96.44 (.2)</td><td rowspan=1 colspan=1>96.33 (.1)</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>94.98 (.2)</td><td rowspan=1 colspan=1>94.96 (.1)</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>92.60 (.03)</td><td rowspan=1 colspan=1>92.55 (.05)*</td><td rowspan=1 colspan=1>92.50 (.02)*</td></tr><tr><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>90.61 (.1)</td><td rowspan=1 colspan=1>90.59 (.2)</td><td rowspan=1 colspan=1>90.45 (.2)</td></tr></table>
+
+Table 8: The median and standard deviation of the scores on the dev sets of STS-B, SST-2, QNLI, QQP and MNLI from the GLUE benchmark, each computed from 5 runs with the same hyper-parameters except for the random seeds (except for the results with YOPO on QQP, which are from 4 runs). Also note here we use a step size of $\alpha$ for the adversary of YOPO-m-n, so YOPO effectively uses a step size of $_ { n \alpha }$ . We use FreeLB- $\mathbf { \nabla } m$ to denote FreeLB with $m$ ascent steps, and YOPO-3- $\mathbf { \nabla } \cdot \mathbf { n }$ to denote YOPO with $_ n$ shallow-layer ascents.
+
+in using extra shallow-layer updates that YOPO advocates, since this consistently deteriorates the performance while introducing extra computations.

parse/train/BygzbyHFvB/BygzbyHFvB_content_list.json

@@ -0,0 +1,1710 @@
+[
+    {
+        "type": "text",
+        "text": "FREELB: ENHANCED ADVERSARIAL TRAINING FOR NATURAL LANGUAGE UNDERSTANDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chen $\\mathbf { Z } \\mathbf { h } \\mathbf { u } ^ { \\mathbf { 1 } }$ , Yu Cheng2, Zhe $\\mathbf { G a n } ^ { 2 }$ , Siqi $\\mathbf { S u n } ^ { 2 }$ , Tom Goldstein1, Jingjing Liu2 1University of Maryland, College Park 2Microsoft Dynamics 365 AI Research {chenzhu,tomg}@cs.umd.edu, {yu.cheng,zhe.gan,siqi.sun,jingjl}@microsoft.com ",
+        "bbox": [
+            184,
+            167,
+            714,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training, which minimizes the maximal risk for label-preserving input perturbations, has proved to be effective for improving the generalization of language models. In this work, we propose a novel adversarial training algorithm, FreeLB, that promotes higher invariance in the embedding space, by adding adversarial perturbations to word embeddings and minimizing the resultant adversarial risk inside different regions around input samples. To validate the effectiveness of the proposed approach, we apply it to Transformer-based models for natural language understanding and commonsense reasoning tasks. Experiments on the GLUE benchmark show that when applied only to the finetuning stage, it is able to improve the overall test scores of BERT-base model from 78.3 to 79.4, and RoBERTa-large model from 88.5 to 88.8. In addition, the proposed approach achieves state-of-the-art single-model test accuracies of $8 5 . 4 4 \\%$ and $6 7 . 7 5 \\%$ on ARC-Easy and ARC-Challenge. Experiments on CommonsenseQA benchmark further demonstrate that FreeLB can be generalized and boost the performance of RoBERTa-large model on other tasks as well. 1 ",
+        "bbox": [
+            233,
+            282,
+            764,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            334,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training is a method for creating robust neural networks. During adversarial training, mini-batches of training samples are contaminated with adversarial perturbations (alterations that are small and yet cause misclassification), and then used to update network parameters until the resulting model learns to resist such attacks. Adversarial training was originally proposed as a means to enhance the security of machine learning systems (Goodfellow et al., 2015), especially for safety-critical systems like self-driving cars (Xiao et al., 2018) and copyright detection (Saadatpanah et al., 2019). ",
+        "bbox": [
+            174,
+            550,
+            825,
+            647
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we turn our focus away from the security benefits of adversarial training, and instead study its effects on generalization. While adversarial training boosts the robustness, it is widely accepted by computer vision researchers that it is at odds with generalization, with classification accuracy on non-corrupted images dropping as much as $1 0 \\%$ on CIFAR-10, and $1 5 \\%$ on Imagenet (Madry et al., 2018; Xie et al., 2019). Surprisingly, people observe the opposite result for language models (Miyato et al., 2017; Cheng et al., 2019), showing that adversarial training can improve both generalization and robustness. ",
+        "bbox": [
+            174,
+            655,
+            823,
+            752
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We will show that adversarial training significantly improves performance of state-of-the-art models for many language understanding tasks. In particular, we propose a novel adversarial training algorithm, called FreeLB (Free Large-Batch), which adds adversarial perturbations to word embeddings and minimizes the resultant adversarial loss around input samples. The method leverages recently proposed “free” training strategies (Shafahi et al., 2019; Zhang et al., 2019) to enrich the training data with diversified adversarial samples under different norm constraints at no extra cost than PGD-based (Projected Gradient Descent) adversarial training (Madry et al., 2018), which enables us to perform such diversified adversarial training on large-scale state-of-the-art models. We observe improved invariance in the embedding space for models trained with FreeLB, which is positively correlated with generalization. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We perform comprehensive experiments to evaluate the performance of a variety of adversarial training algorithms on state-of-the-art language understanding models and tasks. In the comparisons with standard PGD (Madry et al., 2018), FreeAT (Shafahi et al., 2019) and YOPO (Zhang et al., 2019), FreeLB stands out to be the best for the datasets and models we evaluated. With FreeLB, we achieve state-of-the-art results on several important language understanding benchmarks. On the GLUE benchmark, FreeLB pushes the performance of the BERT-base model from 78.3 to 79.4. The overall score of the RoBERTa-large models on the GLUE benchmark is also lifted from 88.5 to 88.8, achieving best results on most of its sub-tasks. Experiments also show that FreeLB can boost the performance of RoBERTa-large on question answering tasks, such as the ARC and CommonsenseQA benchmarks. We also provide a comprehensive ablation study and analysis to demonstrate the effectiveness of our training process. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            291,
+            343,
+            308
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            328,
+            393,
+            342
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To improve the robustness of neural networks against adversarial examples, many defense strategies and models have been proposed, in which PGD-based adversarial training (Madry et al., 2018) is widely considered to be the most effective, since it largely avoids the the obfuscated gradient problem (Athalye et al., 2018). It formulates a class of adversarial training algorithms (Kurakin et al., 2017) into solving a minimax problem on the cross-entropy loss, which can be achieved reliably through multiple projected gradient ascent steps followed by a SGD (Stochastic Gradient Descent) step. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite being verified by Athalye et al. (2018) to avoid obfuscated gradients, Qin et al. (2019) shows that PGD-based adversarial training still leads to highly convolved and non-linear loss surfaces when $K$ is small, which could be readily broken under stronger adversaries. Thus, to be effective, the cost of PGD-based adversarial training is much higher than conventional training. To mitigate this cost, Shafahi et al. (2019) proposed a “free” adversarial training algorithm that simultaneously updates both model parameters and adversarial perturbations on a single backward pass. Using a similar formulation, Zhang et al. (2019) effectively reduce the total number of full forward and backward propagations for obtaining adversarial examples by restricting most of its adversarial updates in the first layer. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 ADVERSARIAL EXAMPLES IN NATURAL LANGUAGES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            581,
+            628
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial examples have been explored primarily in the image domain, and received many attention in text domain recently. Previous works on text adversaries have focused on heuristics for creating adversarial examples in the black-box setting, or on specific tasks. Jia & Liang (2017) propose to add distracting sentences to the input document in order to induce mis-classification. Zhao et al. (2018) generate text adversaries by projecting the input data to a latent space using GANs, and searching for adversaries close to the original instance. Belinkov & Bisk (2018) manipulate every word in a sentence with synthetic or natural noise in machine translation systems. Iyyer et al. (2018) propose a neural paraphrase model based on back-translated data to produce paraphrases that have different sentence structures. Different from previous work, ours is not to produce actual adversarial examples, but only take the benefit of adversarial training for natural language understanding. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We are not the first to observe that robust language models may perform better on clean test data. Miyato et al. (2017) extend adversarial and virtual adversarial training (Miyato et al., 2019) to the text domain to improve the performance on semi-supervised classification tasks. Ebrahimi et al. (2018) propose a character/word replacement for crafting attacks, and show employing adversarial examples in training renders the models more robust. Ribeiro et al. (2018) show that adversarial attacks can be used as a valuable tool for debugging NLP models. Cheng et al. (2019) also find that crafting adversarial examples can help neural machine translation significantly. Notably, these studies have focused on simple models or text generation tasks. Our work explores how to efficiently use the gradients obtained in adversarial training to boost the performance of state-of-the-art transformer-based models. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 ADVERSARIAL TRAINING FOR LANGUAGE UNDERSTANDING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            709,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pre-trained large-scale language models, such as BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019b), ALBERT (Lan et al., 2020) and T5 (Raffel et al., 2019), have proven to be highly effective for downstream tasks. We aim to further improve the generalization of these pre-trained language models on the downstream language understanding tasks by enhancing their robustness in the embedding space during finetuning on these tasks. We achieve this goal by creating “virtual” adversarial examples in the embedding space, and then perform parameter updates on these adversarial embeddings. Creating actual adversarial examples for language is difficult; even with state-of-theart language models as guidance (e.g., (Cheng et al., 2019)), it remains unclear how to construct label-preserving adversarial examples via word/character replacement without human evaluations, because the meaning of each word/character depends on the context (Ribeiro et al., 2018). Since we are only interested in the effects of adversarial training, rather than producing actual adversarial examples, we add norm-bounded adversarial perturbations to the embeddings of the input sentences using a gradient-based method. Note that our embedding-based adversary is strictly stronger than a more conventional text-based adversary, as our adversary can make manipulations on word embeddings that are not possible in the text domain. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            342
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For models that incorporate various input representations, including word or subword embeddings, segment embeddings and position embeddings, our adversaries only modify the concatenated word or sub-word embeddings, leaving other components of the sentence representation unchanged. 2 Denote the sequence of one-hot representations of the input subwords as $\\pmb { Z } = [ z _ { 1 } , z _ { 2 } , . . . , z _ { n } ]$ , the embedding matrix as $V$ , and the language model (encoder) as a function ${ \\pmb y } = f _ { \\pmb \\theta } ( { \\pmb X } )$ , where $\\dot { \\boldsymbol { X } } = \\boldsymbol { V } \\boldsymbol { Z }$ is the subword embeddings, $\\textbf {  { y } }$ is the output of the model (e.g., class probabilities for classification models), and $\\pmb \\theta$ denotes all the learnable parameters including the embedding matrix $V$ . We add adversarial perturbations $\\delta$ to the embeddings such that the prediction becomes $\\pmb { y } ^ { \\prime } = f _ { \\pmb { \\theta } } ( \\pmb { X } + \\pmb { \\delta } )$ . To preserve the semantics, we constrain the norm of $\\pmb { \\delta }$ to be small, and assume the model’s prediction should not change after the perturbation. This formulation is analogous to Miyato et al. (2017), with the difference that we do not require $\\boldsymbol { X }$ to be normalized. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PGD FOR ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            464,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Standard adversarial training seeks to find optimal parameters $\\pmb { \\theta } ^ { * }$ to minimize the maximum risk for any $\\pmb { \\delta }$ within a norm ball as: ",
+        "bbox": [
+            176,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17c85187abb9a6ea71a8c3e97ea4dd66fd478797846cf419f4a2d777a9491c4c.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { ( Z , y ) \\sim \\mathcal { D } } \\left[ \\operatorname* { m a x } _ { \\| \\delta \\| \\leq \\epsilon } L ( f _ { \\theta } ( X + \\delta ) , y ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            573,
+            638,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { D }$ is the data distribution, $y$ is the label, and $L$ is some loss function. We use the Frobenius norm to constrain $\\delta$ . For neural networks, the outer “min” is non-convex, and the inner “max” is non-concave. Nonetheless, Madry et al. (2018) demonstrated that this saddle-point problem can be solved reliably with SGD for the outer minimization and PGD (a standard method for large-scale constrained optimization, see (Combettes & Pesquet, 2011) and (Goldstein et al., 2014)), for the inner maximization. In particular, for the constraint $\\| \\delta \\| _ { F } \\le \\epsilon$ , with an additional assumption that the loss function is locally linear, PGD takes the following step (with step size $\\alpha$ ) in each iteration: ",
+        "bbox": [
+            174,
+            611,
+            825,
+            709
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be4aa28dea2f09e48329453f621909356a76b82a9114c7d9674cce7e2f1707f6.jpg",
+        "text": "$$\n\\delta _ { t + 1 } = \\Pi _ { \\| \\pmb { \\delta } \\| _ { F } \\leq \\epsilon } \\left( \\pmb { \\delta } _ { t } + \\alpha g ( \\pmb { \\delta } _ { t } ) / \\| g ( \\pmb { \\delta } _ { t } ) \\| _ { F } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            713,
+            642,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $g ( \\delta _ { t } ) = \\nabla _ { \\delta } L ( f _ { \\theta } ( X + \\delta _ { t } ) , y )$ is the gradient of the loss with respect to $\\delta$ , and $\\Pi _ { \\| \\delta \\| _ { F } \\leq \\epsilon }$ performs a projection onto the $\\epsilon$ -ball. To achieve high-level robustness, multi-step adversarial examples are needed during training, which is computationally expensive. The $K$ -step PGD ( $K$ -PGD) requires $K$ forward-backward passes through the network, while the standard SGD update requires only one. As a result, the adversary generation step in adversarial training increases run-time by an order of magnitude—a catastrophic amount when training large state-of-the-art language models. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 LARGE-BATCH ADVERSARIAL TRAINING FOR FREE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            837,
+            575,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the inner ascent steps of PGD, the gradients of the parameters can be obtained with almost no overhead when computing the gradients of the inputs. From this observation, FreeAT (Shafahi et al., ",
+        "bbox": [
+            176,
+            859,
+            821,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 “Free” Large-Batch Adversarial Training (FreeLB- $K$ ) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            619,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/faa4884339b2dc56b051cb475bba7c56913f2fcee10d81fc04db122bc7add815.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>ascent step size α</td><td>Require: Training samples X = {(Z,y)}, perturbation bound ε, learning rate T, ascent steps K,</td></tr><tr><td>1:Initialize 0</td><td></td></tr><tr><td>2: for epoch =1... Nep do</td><td></td></tr><tr><td>3:</td><td>for minibatchB ℃Xdo</td></tr><tr><td>4:</td><td>U(-∈,∈)</td></tr><tr><td>5:</td><td>90↑0</td></tr><tr><td>6:</td><td></td></tr><tr><td>7:</td><td>fort=1...K do</td></tr><tr><td>8:</td><td>Accumulate gradient of parameters θ</td></tr><tr><td>9:</td><td>gt←gt-1+kE(z,y)∈B[VθL(fe(X+δt-1),y)]</td></tr><tr><td>10:</td><td>Update the perturbation δ via gradient ascend</td></tr><tr><td>11:</td><td>gadu ←VsL(fθ(X+δt-1),y) δt ←II|δ|lr≤e(δt-1+α:gadu/llgadullF)</td></tr><tr><td>12:</td><td></td></tr><tr><td>13:</td><td>end for</td></tr><tr><td>14:</td><td>0←0-TgK</td></tr><tr><td>end for 15: end for</td><td></td></tr></table>",
+        "bbox": [
+            174,
+            123,
+            823,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2019) and YOPO (Zhang et al., 2019) have been proposed to accelerate adversarial training. They achieve comparable robustness and generalization as standard PGD-trained models using only the same or a slightly larger number of forward-backward passes as natural training (i.e., SGD on clean samples). FreeAT takes one descent step on the parameters together with each of the $K$ ascent steps on the perturbation. As a result, FreeAT may suffer from the “stale gradient” problem (Dutta et al., 2018), where in every step $t$ , $\\delta _ { t }$ does not necessarily maximize the model with parameter $\\theta _ { t }$ since its update is based on $\\nabla _ { \\delta } L \\big ( f _ { \\pmb { \\theta } _ { t - 1 } } ( \\pmb { X } + \\delta _ { t - 1 } ) , y \\big )$ , and vice versa, $\\theta _ { t }$ does not necessarily minimize the adversarial risk with adversary $\\delta _ { t }$ since its update is based on $\\nabla _ { \\pmb { \\theta } } L \\big ( f _ { \\pmb { \\theta } _ { t - 1 } } ( \\pmb { X } + \\delta _ { t - 1 } ) , y \\big )$ . Such a problem may be more significant when the step size is large. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Different from FreeAT, YOPO accumulates the gradient of the parameters from each of the ascent steps, and updates the parameters only once after the $K$ inner ascent steps. YOPO also advocates that after each back-propagation, one should take the gradient of the first hidden layer as a constant and perform several additional updates on the adversary using the product of this constant and the Jacobian of the first layer of the network to obtain strong adversaries. However, when the first hidden layer is a linear layer as in their implementation, such an operation is equivalent to taking a larger step size on the adversary. The analysis backing the extra update steps also assumes a twice continuously differentiable loss, which does not hold for ReLU-based neural networks they experimented with, and thus the reasons for the success of such an algorithm remains obscure. We give empirical comparisons between YOPO and our approach in Sec. 4.3. ",
+        "bbox": [
+            173,
+            521,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To obtain better solutions for the inner max and avoid fundamental limitations on the function class, we propose FreeLB, which performs multiple PGD iterations to craft adversarial examples, and simultaneously accumulates the “free” parameter gradients $\\nabla _ { \\boldsymbol { \\theta } } L$ in each iteration. After that, it updates the model parameter $\\pmb \\theta$ all at once with the accumulated gradients. The overall procedure is shown in Algorithm 1, in which $X + \\delta _ { t }$ is an approximation to the local maximum within the intersection of two balls $\\mathcal { T } _ { t } = \\mathcal { B } _ { X + \\delta _ { 0 } } ( \\alpha t ) \\cap \\mathcal { B } _ { X } ( \\epsilon )$ . By taking a descent step along the averaged gradients at $X + \\delta _ { 0 } , . . . , X + \\delta _ { K - 1 }$ , we approximately optimize the following objective: ",
+        "bbox": [
+            174,
+            666,
+            825,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ccae4d8ef9e13199ab20f9f8a5afaca5aac1d2c3bfff645daf32d9544c002c1d.jpg",
+        "text": "$$\n\\underset { \\pmb { \\theta } } { \\operatorname* { m i n } } \\mathbb { E } _ { ( Z , y ) \\sim \\mathcal { D } } \\left[ \\frac { 1 } { K } \\sum _ { t = 0 } ^ { K - 1 } \\underset { \\delta _ { t } \\in \\mathcal { Z } _ { t } } { \\operatorname* { m a x } } L \\big ( f _ { \\pmb { \\theta } } \\big ( \\pmb { X } + \\delta _ { t } \\big ) , y \\big ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            770,
+            666,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which is equivalent to replacing the original batch $\\boldsymbol { X }$ with a $K$ -times larger virtual batch, consisting of samples whose embeddings are $X + \\delta _ { 0 } , . . . , X + \\delta _ { K - 1 }$ . Compared with PGD-based adversarial training (Eq. 1), which minimizes the maximum risk at a single estimated point in the vicinity of each training sample, FreeLB minimizes the maximum risk at each ascent step at almost no overhead. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, FreeLB could be a learning method with lower generalization error than PGD. Sokolic et al. (2017) have proved that the generalization error of a learning method invariant to a set of√ $T$ transformations may be up to $\\sqrt { T }$ smaller than a non-invariant learning method. According to their theory, FreeLB could have a more significant improvement over natural training, since FreeLB enforces the invariance to $K$ adversaries from a set of up to $K$ different norm constraints,3 while PGD only enforces invariance to a single norm constraint $\\epsilon$ . ",
+        "bbox": [
+            174,
+            880,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Empirically, FreeLB does lead to higher robustness and invariance than PGD in the embedding space, in the sense that the maximum increase of loss in the vicinity of $\\boldsymbol { X }$ for models trained with FreeLB is smaller than that with PGD. See Sec. 4.3 for details. In theory, such improved robustness can lead to better generalization (Xu & Mannor, 2012), which is consistent with our experiments. Qin et al. (2019) also demonstrated that PGD-based method leads to highly convolved and non-linear loss surfaces in the vicinity of input samples when $K$ is small, indicating a lack of robustness. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 WHEN ADVERSARIAL TRAINING MEETS DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            255,
+            570,
+            270
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Usually, adversarial training is not used together with dropout (Srivastava et al., 2014). However, for some language models like RoBERTa (Liu et al., 2019b), dropout is used during the finetuning stage. In practice, when dropout is turned on, each ascent step of Algorithm 1 is optimizing $\\delta$ for a different network. Specifically, denote the dropout mask as $_ { m }$ with each entry $m _ { i } \\sim \\mathrm { B e r n o u l l i } ( p )$ . Similar to our analysis for FreeAT, the ascent step from $\\delta _ { t - 1 }$ to $\\delta _ { t }$ is based on $\\nabla _ { \\delta } L \\big ( f _ { \\theta ( m _ { t - 1 } ) } \\big ( \\boldsymbol { X } + \\delta _ { t - 1 } \\big ) , \\boldsymbol { y } \\big )$ , so $\\delta _ { t }$ is sub-optimal for $L ( f _ { \\theta ( m _ { t } ) } ( \\boldsymbol { X } + \\delta ) , y )$ . Here $\\theta ( m )$ is the effective parameters under dropout mask $_ { m }$ . ",
+        "bbox": [
+            174,
+            277,
+            825,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The more plausible solution is to use the same $_ { \\mathbf { \\nabla } } \\mathbf { m }$ in each step. When applying dropout to any network, the objective for $\\pmb \\theta$ is to minimize the expectation of loss under different networks determined by the dropout masks, which is achieved by minimizing the Monte Carlo estimation of the expected loss. In our case, the objective becomes: ",
+        "bbox": [
+            176,
+            383,
+            825,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e662cc84309c58d4d57852d609bdc508f80860aaba1115045b618ae79744dc0a.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { ( Z , y ) \\sim \\mathcal { D } , m \\sim \\mathcal { M } } \\left[ \\frac { 1 } { K } \\sum _ { t = 0 } ^ { K - 1 } \\operatorname* { m a x } _ { \\delta _ { t } \\in \\mathcal { T } _ { t } } L \\big ( f _ { \\theta ( m ) } ( X + \\delta _ { t } ) , y \\big ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            448,
+            700,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the 1-sample Monte Carlo estimation should be $\\begin{array} { r } { \\frac { 1 } { K } \\sum _ { t = 0 } ^ { K - 1 } \\operatorname* { m a x } _ { \\delta _ { t } \\in \\mathcal { T } _ { t } } L ( f _ { \\theta ( m _ { 0 } ) } ( X + \\delta _ { t } ) , y ) } \\end{array}$ and can be minimized by using FreeLB with dropout mask $m _ { 0 }$ in each ascent step. This is similar to applying Variational Dropout to RNNs as used in Gal & Ghahramani (2016). ",
+        "bbox": [
+            174,
+            501,
+            825,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            326,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide comprehensive analysis on FreeLB through extensive experiments on three Natural Language Understanding benchmarks: GLUE (Wang et al., 2019), ARC (Clark et al., 2018) and CommonsenseQA (Talmor et al., 2019). We also compare the robustness and generalization of FreeLB with other adversarial training algorithms to demonstrate its strength. Additional experimental details are provided in the Appendix. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            688,
+            287,
+            703
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GLUE Benchmark. The GLUE benchmark is a collection of 9 natural language understanding tasks, namely Corpus of Linguistic Acceptability (CoLA; Warstadt et al. (2018)), Stanford Sentiment Treebank (SST; Socher et al. (2013)), Microsoft Research Paraphrase Corpus (MRPC; Dolan & Brockett (2005)), Semantic Textual Similarity Benchmark (STS; Agirre et al. (2007)), Quora Question Pairs (QQP; Iyer et al. (2017)), Multi-Genre NLI (MNLI; Williams et al. (2018)), Question NLI (QNLI; Rajpurkar et al. (2016)), Recognizing Textual Entailment (RTE; Dagan et al. (2006); Bar Haim et al. (2006); Giampiccolo et al. (2007); Bentivogli et al. (2009)) and Winograd NLI (WNLI; Levesque et al. (2011)). 8 of the tasks are formulated as classification problems and only STS-B is formulated as regression, but FreeLB applies to all of them. For BERT-base, we use the HuggingFace implementation4, and follow the single-task finetuning procedure as in Devlin et al. (2019). For RoBERTa, we use the fairseq implementation5. Same as Liu et al. (2019b), we also use single-task finetuning for all dev set results, and start with MNLI-finetuned models on RTE, MRPC and STS-B for the test submissions. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            868
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e1f0b3873d4f551620e6abc0f84fd1bd6b832d5a4995eee5316a5213471483a2.jpg",
+        "table_caption": [
+            "Table 1: Results (median and variance) on the dev sets of GLUE based on the RoBERTa-large model, from 5 runs with the same hyperparameter but different random seeds. ReImp is our reimplementation of RoBERTalarge. The training process can be very unstable even with the vanilla version. Here, both PGD on STS-B and FreeAT on RTE demonstrates such instability, with one unconverged instance out of five. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>MNLI(Acc)</td><td rowspan=1 colspan=1>QNLI(Acc)</td><td rowspan=1 colspan=1>QQP(Acc)</td><td rowspan=1 colspan=1>RTE(Acc)</td><td rowspan=1 colspan=1>SST-2(Acc)</td><td rowspan=1 colspan=1>MRPC(Acc)</td><td rowspan=1 colspan=1>CoLA(Mcc)</td><td rowspan=1 colspan=1>STS-B(Pearson)</td></tr><tr><td rowspan=1 colspan=1>Reported</td><td rowspan=1 colspan=1>90.2</td><td rowspan=1 colspan=1>94.7</td><td rowspan=1 colspan=1>92.2</td><td rowspan=1 colspan=1>86.6</td><td rowspan=1 colspan=1>96.4</td><td rowspan=1 colspan=1>90.9</td><td rowspan=1 colspan=1>68.0</td><td rowspan=1 colspan=1>92.4</td></tr><tr><td rowspan=1 colspan=1>ReImp</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>85.61 (1.7)</td><td rowspan=1 colspan=1>96.56 (.3)</td><td rowspan=1 colspan=1>90.69(.5)</td><td rowspan=1 colspan=1>67.57 (1.3)</td><td rowspan=1 colspan=1>92.20 (.2)</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>90.53 (.2)</td><td rowspan=1 colspan=1>94.87 (.2)</td><td rowspan=1 colspan=1>92.49 (.07)</td><td rowspan=1 colspan=1>87.41 (.9)</td><td rowspan=1 colspan=1>96.44 (.1)</td><td rowspan=1 colspan=1>90.93 (.2)</td><td rowspan=1 colspan=1>69.67 (1.2)</td><td rowspan=1 colspan=1>92.43 (7.)</td></tr><tr><td rowspan=1 colspan=1>FreeAT</td><td rowspan=1 colspan=1>90.02 (.2)</td><td rowspan=1 colspan=1>94.66 (.2)</td><td rowspan=1 colspan=1>92.48(.08)</td><td rowspan=1 colspan=1>86.69 (15.)</td><td rowspan=1 colspan=1>96.10 (.2)</td><td rowspan=1 colspan=1>90.69 (.4)</td><td rowspan=1 colspan=1>68.80 (1.3)</td><td rowspan=1 colspan=1>92.40 (.3)</td></tr><tr><td rowspan=1 colspan=1>FreeLB</td><td rowspan=1 colspan=1>90.61 (.1)</td><td rowspan=1 colspan=1>94.98 (.2)</td><td rowspan=1 colspan=1>92.60 (.03)</td><td rowspan=1 colspan=1>88.13 (1.2)</td><td rowspan=1 colspan=1>96.79 (.2)</td><td rowspan=1 colspan=1>91.42 (.7)</td><td rowspan=1 colspan=1>71.12 (.9)</td><td rowspan=1 colspan=1>92.67 (.08)</td></tr></table>",
+        "bbox": [
+            192,
+            101,
+            800,
+            198
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ffd483862d6f9e2fd41f54a7e4c5ac87fd33bba048718a29e5bb6a776b93922.jpg",
+        "table_caption": [
+            "Table 2: Results on GLUE from the evaluation server, as of Sep 25, 2019. Metrics are the same as the leaderboard. Number under each task’s name is the size of the training set. FreeLB-BERT is the single-model results of BERT-base finetuned with FreeLB, and FreeLB-RoB is the ensemble of 7 RoBERTa-Large models for each task. References: 1: (Devlin et al., 2019); 2: (Liu et al., 2019a); 3: (Yang et al., 2019); 4: (Liu et al., 2019b). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Score</td><td rowspan=1 colspan=1>CoLA8.5k</td><td rowspan=1 colspan=1>SST-267k</td><td rowspan=1 colspan=1>MRPC3.7k</td><td rowspan=1 colspan=1>STS-B7k</td><td rowspan=1 colspan=1>QQP364k</td><td rowspan=1 colspan=1>MNLI-m/mm393k</td><td rowspan=1 colspan=1>QNLI108k</td><td rowspan=1 colspan=1>RTE2.5k</td><td rowspan=1 colspan=1>WNLI634</td><td rowspan=1 colspan=1>AX</td></tr><tr><td rowspan=1 colspan=1>BERT-base1</td><td rowspan=1 colspan=1>78.3</td><td rowspan=1 colspan=1>52.1</td><td rowspan=1 colspan=1>93.5</td><td rowspan=1 colspan=1>88.9/84.8</td><td rowspan=1 colspan=1>87.1/85.8</td><td rowspan=1 colspan=1>71.2/89.2</td><td rowspan=1 colspan=1>84.6/83.4</td><td rowspan=1 colspan=1>90.5</td><td rowspan=1 colspan=1>66.4</td><td rowspan=1 colspan=1>65.1</td><td rowspan=1 colspan=1>34.2</td></tr><tr><td rowspan=1 colspan=1>FreeLB-BERT</td><td rowspan=1 colspan=1>79.4</td><td rowspan=1 colspan=1>54.5</td><td rowspan=1 colspan=1>93.6</td><td rowspan=1 colspan=1>88.1/83.5</td><td rowspan=1 colspan=1>87.7/86.7</td><td rowspan=1 colspan=1>72.7/89.6</td><td rowspan=1 colspan=1>85.7/84.6</td><td rowspan=1 colspan=1>91.8</td><td rowspan=1 colspan=1>70.1</td><td rowspan=1 colspan=1>65.1</td><td rowspan=1 colspan=1>36.9</td></tr><tr><td rowspan=1 colspan=1>MT-DNN2</td><td rowspan=1 colspan=1>87.6</td><td rowspan=1 colspan=1>68.4</td><td rowspan=1 colspan=1>96.5</td><td rowspan=1 colspan=1>92.7/90.3</td><td rowspan=1 colspan=1>91.1/90.7</td><td rowspan=1 colspan=1>73.7789.9</td><td rowspan=1 colspan=1>87.9/87.4</td><td rowspan=1 colspan=1>96.0</td><td rowspan=1 colspan=1>86.3</td><td rowspan=1 colspan=1>89.0</td><td rowspan=1 colspan=1>42.8</td></tr><tr><td rowspan=1 colspan=1>XLNet-Large</td><td rowspan=1 colspan=1>88.4</td><td rowspan=1 colspan=1>67.8</td><td rowspan=1 colspan=1>96.8</td><td rowspan=1 colspan=1>93.0/90.7</td><td rowspan=1 colspan=1>91.6/91.1</td><td rowspan=1 colspan=1>74.2/90.3</td><td rowspan=1 colspan=1>90.2/89.8</td><td rowspan=1 colspan=1>98.6</td><td rowspan=1 colspan=1>86.3</td><td rowspan=1 colspan=1>90.4</td><td rowspan=1 colspan=1>47.5</td></tr><tr><td rowspan=1 colspan=1>RoBERTa4</td><td rowspan=1 colspan=1>88.5</td><td rowspan=1 colspan=1>67.8</td><td rowspan=1 colspan=1>96.7</td><td rowspan=1 colspan=1>92.3/89.8</td><td rowspan=1 colspan=1>92.2/91.9</td><td rowspan=1 colspan=1>74.3/90.2</td><td rowspan=1 colspan=1>90.8/90.2</td><td rowspan=1 colspan=1>98.9</td><td rowspan=1 colspan=1>88.2</td><td rowspan=1 colspan=1>89.0</td><td rowspan=1 colspan=1>48.7</td></tr><tr><td rowspan=1 colspan=1>FreeLB-RoB</td><td rowspan=1 colspan=1>88.8</td><td rowspan=1 colspan=1>68.0</td><td rowspan=1 colspan=1>96.8</td><td rowspan=1 colspan=1>93.1/90.8</td><td rowspan=1 colspan=1>92.4/92.2</td><td rowspan=1 colspan=1>74.8/90.3</td><td rowspan=1 colspan=1>91.1/90.7</td><td rowspan=1 colspan=1>98.8</td><td rowspan=1 colspan=1>88.7</td><td rowspan=1 colspan=1>89.0</td><td rowspan=1 colspan=1>50.1</td></tr><tr><td rowspan=1 colspan=1>Human</td><td rowspan=1 colspan=1>87.1</td><td rowspan=1 colspan=1>66.4</td><td rowspan=1 colspan=1>97.8</td><td rowspan=1 colspan=1>86.3/80.8</td><td rowspan=1 colspan=1>92.7/92.6</td><td rowspan=1 colspan=1>59.5/80.4</td><td rowspan=1 colspan=1>92.0/92.8</td><td rowspan=1 colspan=1>91.2</td><td rowspan=1 colspan=1>93.6</td><td rowspan=1 colspan=1>95.9</td><td rowspan=1 colspan=1>1</td></tr></table>",
+        "bbox": [
+            176,
+            263,
+            825,
+            392
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            484,
+            821,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ARC Benchmark. The ARC dataset (Clark et al., 2018) is a collection of multi-choice science questions from grade-school level exams. It is further divided into ARC-Challenge set with 2,590 question answer (QA) pairs and ARC-Easy set with 5,197 QA pairs. Questions in ARC-Challenge are more difficult and cannot be handled by simply using a retrieval and co-occurence based algorithm (Clark et al., 2018). A typical question is: ",
+        "bbox": [
+            174,
+            518,
+            825,
+            589
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Which property of a mineral can be determined just by looking at it? ",
+        "bbox": [
+            176,
+            597,
+            624,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(A) luster [correct] $( B )$ mass $( C )$ weight $( D )$ hardness. ",
+        "bbox": [
+            174,
+            617,
+            531,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CommonsenseQA Benchmark. The CommonsenseQA dataset (Talmor et al., 2019) consists of 12,102 natural language questions that require human commonsense reasoning ability to answer. A typical question is : ",
+        "bbox": [
+            178,
+            638,
+            826,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Where can I stand on a river to see water falling without getting wet? ",
+        "bbox": [
+            178,
+            688,
+            633,
+            703
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(A) waterfall, (B) bridge [correct], (C) valley, $( D )$ stream, (E) bottom. ",
+        "bbox": [
+            176,
+            709,
+            629,
+            724
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Each question has five candidate answers from ConceptNet (Speer et al., 2017). To make the question more difficult to solve, most answers have the same relation in ConceptNet to the key concept in the question. As shown in the above example, most answers can be connected to “river” by “AtLocation” relation in ConceptNet. For a fair comparison with the reported results in papers and leaderboard6, we use the official random split 1.11. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            818,
+            392,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "GLUE We summarize results on the dev sets of GLUE in Table 1, comparing the proposed FreeLB against other adversatial training algorithms (PGD (Madry et al., 2018) and FreeAT (Shafahi et al., 2019)). We use the same step size $\\alpha$ and number of steps $m$ for PGD, FreeAT and FreeLB. FreeLB is consistently better than the two baselines. Comparisons and detailed discussions about ",
+        "bbox": [
+            174,
+            843,
+            823,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0294ede408252845a3f452283bba1eeb68e7d5fc0d948c4421b775c75aff2ef.jpg",
+        "table_caption": [
+            "Table 3: Results on ARC and CommonsenseQA (CQA). ARC-Merge is the combination of ARC-Easy and ARC-Challenge, “MTL” stands for multi-task learning and “Ens” stands for ensemble. Results of XLNet $^ +$ RoBERTa $\\left( \\mathbf { M } \\mathbf { T } \\mathbf { L } { + } \\mathbf { E } \\mathbf { n } \\mathbf { s } \\right)$ and AristoRoBERTaV7 (MTL) are from the ARC leaderboards. Test (E) denotes the test set results with ensembles. For CQA, we report the highest dev and test accuracies among all models. The models with 78.81/72.19 dev/test accuracy (as in the table) have 71.84/78.64 test/dev accuracies respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1></td><td rowspan=2 colspan=9>ARC-Easy    ARC-Challenge   ARC-Merge            CQADev   Test   Dev    Test    Dev   Test   Dev  Test Test (E)</td></tr><tr><td rowspan=1 colspan=1>Test</td><td rowspan=1 colspan=1>Dev</td><td rowspan=1 colspan=1>Test</td><td rowspan=1 colspan=1>Dev</td><td rowspan=1 colspan=2>Test   Dev</td><td rowspan=1 colspan=1>Test</td></tr><tr><td rowspan=1 colspan=1>RoBERTa(Reported)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>78.43</td><td rowspan=1 colspan=1>72.1</td><td rowspan=1 colspan=1>72.5</td></tr><tr><td rowspan=1 colspan=1>RoBERTa (ReImp)</td><td rowspan=1 colspan=1>84.39</td><td rowspan=1 colspan=1>84.13</td><td rowspan=1 colspan=1>64.54</td><td rowspan=1 colspan=1>64.44</td><td rowspan=1 colspan=1>77.83</td><td rowspan=1 colspan=1>77.62</td><td rowspan=1 colspan=1>77.56</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>FreeLB-RoBERTa</td><td rowspan=1 colspan=1>84.91</td><td rowspan=1 colspan=1>84.81</td><td rowspan=1 colspan=1>65.89</td><td rowspan=1 colspan=1>65.36</td><td rowspan=1 colspan=1>78.37</td><td rowspan=1 colspan=1>78.39</td><td rowspan=1 colspan=1>78.81</td><td rowspan=1 colspan=1>72.2</td><td rowspan=1 colspan=1>73.1</td></tr><tr><td rowspan=1 colspan=1>AristoRoBERTaV7(MTL)</td><td rowspan=1 colspan=1>:</td><td rowspan=1 colspan=1>85.02</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>66.47</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>78.89</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>:</td></tr><tr><td rowspan=1 colspan=1>XLNet +RoBERTa (MTL+Ens)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>67.06</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>二</td></tr><tr><td rowspan=1 colspan=1>FreeLB-RoBERTa(MTL)</td><td rowspan=1 colspan=1>84.91</td><td rowspan=1 colspan=1>85.44</td><td rowspan=1 colspan=1>70.23</td><td rowspan=1 colspan=1>67.75</td><td rowspan=1 colspan=1>79.86</td><td rowspan=1 colspan=1>79.60</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            825,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "YOPO (Zhang et al., 2019) are provided in Sec. 4.3. We have also submitted our results to the evaluation server, results provided in Table 2. FreeLB lifts the performance of the BERT-base model from 78.3 to 79.4, and RoBERTa-large model from 88.5 to 88.8 on overall scores. ",
+        "bbox": [
+            176,
+            301,
+            820,
+            343
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ARC For ARC, a corpus of 14 million related science documents (from ARC Corpus, Wikipedia and other sources) is provided. For each QA pair, we first use a retrieval model to select top 10 related documents. Then, given these retrieved documents7, we use RoBERTa-large model to encode $\\langle s \\rangle$ Retrieved Documents $\\langle / s \\rangle$ Question $^ +$ Answer $\\langle / s \\rangle$ , where $\\langle \\mathbf { s } \\rangle$ and $\\langle / \\mathrm { s } \\rangle$ are special tokens for RoBERTa model8. We then apply a fully-connected layer to the representation of the [CLS] token to compute the final logit, and use standard cross-entropy loss for model training. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results are summarized in Table 3. Following Sun et al. (2018), we first finetune the RoBERTa model on the RACE dataset (Lai et al., 2017). The finetuned RoBERTa model achieves $8 5 . 7 0 \\%$ and $8 5 . 2 4 \\%$ accuracy on the development and test set of RACE, respectively. Based on this, we further finetune the model on both ARC-Easy and ARC-Challenge datasets with the same hyper-parameter searching strategy (for 5 epochs), which achieves $8 4 . 1 3 \\% / 6 4 . 4 4 \\%$ test accuracy on ARC-Easy/ARCChallenge. And by adding FreeLB finetuning, we can reach $8 4 . 8 1 \\% / 6 5 . 3 6 \\%$ , a significant boost on ARC benchmark, demonstrating the effectiveness of FreeLB. ",
+        "bbox": [
+            173,
+            441,
+            825,
+            539
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further improve the results, we apply a multi-task learning (MTL) strategy using additional datasets. We first finetune the model on RACE (Lai et al., 2017), and then finetune on a joint dataset of ARC-Easy, ARC-Challenge, OpenbookQA (Mihaylov et al., 2018) and Regents Living Environment9. Based on this, we further finetune our model on ARC-Easy and ARC-Challenge with FreeLB. After finetuning, our single model achieves $6 7 . 7 5 \\%$ test accuracy on ARC-Challenge and $8 5 . 4 4 \\%$ on ARC-Easy, both outperforming the best submission on the official leaderboard10. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            628
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CommonsenseQA Similar to the training strategy in Liu et al. (2019b), we construct five inputs for each question by concatenating the question and each answer separately, then encode each input with the representation of the [CLS] token. A final score is calculated by applying the representation of [CLS] to a fully-connected layer. Following the fairseq repository11, the input is formatted as: ${ \\mathfrak { n } } ( s ) Q$ : Where can I stand on a river to see water falling without getting wet? $\\langle / s \\rangle A$ : waterfall $\\langle \\langle s \\rangle ^ { \\ast } \\cdot \\mathbf { \\vec { \\mathbf { \\mu } } }$ , where $\\cdot _ { Q }$ :’ and $^ { , } A$ :’ are the prefix for question and answer, respectively. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results are summarized in Table 3. We obtained a dev-set accuracy of $7 7 . 5 6 \\%$ with the RoBERTalarge model. When using FreeLB finetuning, we achieved $7 8 . 8 1 \\%$ , a $1 . 2 5 \\%$ absolute gain. Compared with the results reported from fairseq repository, which obtains $7 8 . 4 3 \\%$ accuracy on the devset, FreeLB still achieves better performance. Our submission to the CommonsenseQA leaderboard achieves $7 2 . 2 \\%$ single-model test set accuracy, and the result of a 20-model ensemble is $7 3 . 1 \\%$ , which achieves No.1 among all the submissions without making use of ConceptNet. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/22299a0200d7157b9946af1d49851cd5bfb444546715f02cc8dfdb5fe86e9613.jpg",
+        "table_caption": [
+            "Table 4: The median and standard deviation of the scores on the dev sets of RTE, CoLA and MRPC from the GLUE benchmark, computed from 5 runs with the same hyper-parameters except for the random seeds. We use FreeLB- $\\mathbf { \\nabla } m$ to denote FreeLB with $m$ ascent steps, and FreeLB- ${ . 3 ^ { * } }$ to denote the version without reusing the dropout mask. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>FreeLB-3*</td><td rowspan=1 colspan=1>FreeLB-3</td><td rowspan=1 colspan=1>YOPO-3-2</td><td rowspan=1 colspan=1>YOPO-3-3</td></tr><tr><td rowspan=1 colspan=1>RTE</td><td rowspan=1 colspan=1>85.61 (1.67)</td><td rowspan=1 colspan=1>87.14 (1.29)</td><td rowspan=1 colspan=1>88.13 (1.21)</td><td rowspan=1 colspan=1>87.05 (1.36)</td><td rowspan=1 colspan=1>87.05 (0.20)</td></tr><tr><td rowspan=1 colspan=1>CoLA</td><td rowspan=1 colspan=1>67.57 (1.30)</td><td rowspan=1 colspan=1>69.31 (1.16)</td><td rowspan=1 colspan=1>71.12 (0.90)</td><td rowspan=1 colspan=1>70.40 (0.91)</td><td rowspan=1 colspan=1>69.91 (1.16)</td></tr><tr><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>90.69 (0.54)</td><td rowspan=1 colspan=1>90.93 (0.66)</td><td rowspan=1 colspan=1>91.42 (0.72)</td><td rowspan=1 colspan=1>90.44 (0.62)</td><td rowspan=1 colspan=1>90.69 (0.37)</td></tr></table>",
+        "bbox": [
+            230,
+            101,
+            763,
+            159
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/123f8ec948de592b6c31088d940779fcf701f6d633979bb44b4a997bb3feb667.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=3>RTE</td><td rowspan=1 colspan=3>CoLA</td><td rowspan=1 colspan=3>MRPC</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4)</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4)</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-3)</td><td rowspan=1 colspan=1>M-Inc (R)(10-3)</td><td rowspan=1 colspan=1>N-Loss(10-3)</td></tr><tr><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>5.1</td><td rowspan=1 colspan=1>5.3</td><td rowspan=1 colspan=1>4.5</td><td rowspan=1 colspan=1>6.1</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>5.2</td><td rowspan=1 colspan=1>10.2</td><td rowspan=1 colspan=1>10.2</td><td rowspan=1 colspan=1>1.9</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>4.7</td><td rowspan=1 colspan=1>4.9</td><td rowspan=1 colspan=1>6.2</td><td rowspan=1 colspan=1>128.2</td><td rowspan=1 colspan=1>130.1</td><td rowspan=1 colspan=1>436.1</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>5.4</td></tr><tr><td rowspan=1 colspan=1>FreeLB</td><td rowspan=1 colspan=1>3.0</td><td rowspan=1 colspan=1>2.6</td><td rowspan=1 colspan=1>4.1</td><td rowspan=1 colspan=1>1.4</td><td rowspan=1 colspan=1>1.3</td><td rowspan=1 colspan=1>7.2</td><td rowspan=1 colspan=1>3.6</td><td rowspan=1 colspan=1>3.6</td><td rowspan=1 colspan=1>2.7</td></tr></table>",
+        "bbox": [
+            173,
+            219,
+            825,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Median of the maximum increase in loss in the vicinity of the dev set samples for RoBERTa-Large model finetuned with different methods. Vanilla models are naturally trained RoBERTa’s. M-Inc: Max Inc, MInc (R): Max Inc (R). Nat Loss (N-Loss) is the loss value on clean samples. Notice we require all clean samples here to be correctly classified by all models, which results in 227, 850 and 355 samples for RTE, CoLA and MRPC, respectively. We also give the variance in the Appendix. ",
+        "bbox": [
+            173,
+            304,
+            825,
+            368
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 ABLATION STUDY AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            386,
+            450,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this sub-section, we first show the importance of reusing dropout mask, then conduct a thorough ablation study on FreeLB over the GLUE benchmark to analyze the robustness and generalization strength of different approaches. We observe that it is unnecessary to perform shallow-layer updates on the adversary as YOPO for our case, and FreeLB results in improved robustness and generalization compared with PGD. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            481
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Importance of Reusing Mask Table 4 (columns 2 to 4) compares the results of FreeLB with and without reusing the same dropout mask in each ascent step, as proposed in Sec. 3.3. With reusing, FreeLB can achieve a larger improvement over the naturally trained models. Thus, we enable mask reusing for all experiments involving RoBERTa. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            545
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparing the Robustness Table 5 provides the comparisons of the maximum increment of loss in the vicinity of each sample, defined as: ",
+        "bbox": [
+            173,
+            551,
+            823,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf1340b64e7dea43e7ba8813f0bad358c01a42d13b806c2cf4c77f077ec893d9.jpg",
+        "text": "$$\n\\displaystyle \\Delta L _ { \\mathrm { m a x } } ( \\boldsymbol { X } , \\epsilon ) = \\operatorname* { m a x } _ { \\| \\delta \\| \\leq \\epsilon } L ( f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { X } + \\delta ) , \\boldsymbol { y } ) - L ( f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { X } ) , \\boldsymbol { y } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            582,
+            689,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "which reflects the robustness and invariance of the model in the embedding space. In practice, we use PGD steps as in Eq. 2 to find the value of ${ \\Delta } L _ { \\mathrm { m a x } } ( \\boldsymbol { X } , \\boldsymbol { \\epsilon } )$ . We found that when using a step size of $5 { \\cdot } 1 0 ^ { - 3 }$ and $\\epsilon = 0 . 0 1 \\| X \\| _ { F }$ , the PGD iterations converge to almost the same value, starting from 100 different random initializations of $\\pmb { \\delta }$ for the RoBERTa models, trained with or without FreeLB. This indicates that PGD reliably finds $\\Delta L _ { \\mathrm { m a x } }$ for these models. Therefore, we compute ${ \\Delta } L _ { \\mathrm { m a x } } ( X , \\epsilon )$ for each $\\boldsymbol { X }$ via a 2000-step PGD. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Samples with small margins exist even for models with perfect accuracy, which could give a false sense of vulnerability of the model. To rule out the outlier effect and make ${ \\Delta } L _ { \\mathrm { m a x } } ( \\boldsymbol { X } , \\epsilon )$ comparable across different samples, we only consider samples that all the evaluated models can correctly classify, and search for an $\\epsilon$ for each sample such that the reference model can correctly classify all samples within the $\\epsilon$ ball.12 However, such choice of per-sample $\\epsilon$ favors the reference model by design. To make fair comparisons, Table 5 provides the median of ${ \\Delta } L _ { \\mathrm { m a x } } ( \\boldsymbol { X } , \\epsilon )$ with per-sample $\\epsilon$ from models trained by FreeLB (Max Inc) and PGD (Mac Inc (R)), respectively. ",
+        "bbox": [
+            173,
+            702,
+            825,
+            800
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Across all three datasets and different reference models, FreeLB has the smallest median increment even when starting from a larger natural loss than vanilla models. This demonstrates that FreeLB is more robust and invariant in most cases. Such results are also consistent with the models’ dev set performance (the performances for Vanilla/PGD/FreeLB models on RTE, CoLA and MRPC are 86.69/87.41/89.21, 69.91/70.84/71.40, 91.67/91.17/91.17, respectively). ",
+        "bbox": [
+            174,
+            806,
+            825,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparing with YOPO The original implementation of YOPO (Zhang et al., 2019) chooses the first convolutional layer of the ResNets as $f _ { 0 }$ for updating the adversary in the “s-loop”. As a result, each step of the “s-loop” should be using exactly the same value to update the adversary,and YOPO$m { - } n$ degenerates into FreeLB with a $n$ -times large step size. To avoid that, we choose the layers up to the output of the first Transformer block as $f _ { 0 }$ when implementing YOPO. To make the total amount of update on the adversary equal, we take the hyper-parameters for FreeLB- $m$ and only change the step size $\\alpha$ into $\\alpha / n$ for YOPO- $m { \\cdot } n$ . Table 4 shows that FreeLB performs consistently better than YOPO on all three datasets. Accidentally, we also give the results comparing with YOPO- $\\mathbf { \\nabla } m - n$ without changing the step size $\\alpha$ for YOPO in Table 8. The gap between two approaches seem to shrink, which may be caused by using a larger total step size for the YOPO adversaries. We leave exhaustive hyperparameter search for both models as our future work. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            276,
+            318,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have developed an adversarial training approach, FreeLB, to improve natural language understanding. The proposed approach adds perturbations to continuous word embeddings using a gradient method, and minimizes the resultant adversarial risk in an efficient way. FreeLB is able to boost Transformer-based model (BERT and RoBERTa) on several datasets and achieve new state of the art on GLUE and ARC benchmarks. Empirical study demonstrates that our method results in both higher robustness in the embedding space than natural training and better generalization ability. Such observation is also consistent with recent findings in Computer Vision. However, adversarial training still takes significant overhead compared with vanilla SGD. How to accelerate this process while improving generalization is an interesting future direction. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: Goldstein and Zhu were supported in part by the DARPA GARD, DARPA QED for RML, and AFOSR MURI programs. ",
+        "bbox": [
+            176,
+            448,
+            821,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            285,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eneko Agirre, Llu’is M‘arquez, and Richard Wicentowski (eds.). Proceedings of the Fourth International Workshop on Semantic Evaluations (SemEval-2007). Association for Computational Linguistics, 2007. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2018. ",
+        "bbox": [
+            174,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Roy Bar Haim, Ido Dagan, Bill Dolan, Lisa Ferro, Danilo Giampiccolo, Bernardo Magnini, and Idan Szpektor. The second PASCAL recognising textual entailment challenge. 2006. ",
+        "bbox": [
+            173,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yonatan Belinkov and Yonatan Bisk. Synthetic and natural noise both break neural machine translation. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            645,
+            821,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. The fifth PASCAL recognizing textual entailment challenge. 2009. ",
+        "bbox": [
+            174,
+            681,
+            820,
+            712
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yong Cheng, Lu Jiang, and Wolfgang Macherey. Robust neural machine translation with doubly adversarial inputs. In ACL, 2019. ",
+        "bbox": [
+            169,
+            719,
+            821,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge. arXiv preprint arXiv:1803.05457, 2018. ",
+        "bbox": [
+            173,
+            756,
+            823,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Patrick L Combettes and Jean-Christophe Pesquet. Proximal splitting methods in signal processing. In Fixed-point algorithms for inverse problems in science and engineering. 2011. ",
+        "bbox": [
+            173,
+            806,
+            820,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ido Dagan, Oren Glickman, and Bernardo Magnini. The PASCAL recognising textual entailment challenge. In Machine learning challenges. evaluating predictive uncertainty, visual object classification, and recognising tectual entailment. Springer, 2006. ",
+        "bbox": [
+            174,
+            844,
+            820,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "William B Dolan and Chris Brockett. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the International Workshop on Paraphrasing, 2005. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sanghamitra Dutta, Gauri Joshi, Soumyadip Ghosh, Parijat Dube, and Priya Nagpurkar. Slow and stale gradients can win the race: Error-runtime trade-offs in distributed sgd. In AISTATS, pp. 803–812, 2018. ",
+        "bbox": [
+            174,
+            141,
+            821,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Javid Ebrahimi, Anyi Rao, Daniel Lowd, and Dejing Dou. HotFlip: White-box adversarial examples for text classification. In ACL, 2018. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In NeurIPS, 2016. ",
+        "bbox": [
+            171,
+            231,
+            823,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and Bill Dolan. The third PASCAL recognizing textual entailment challenge. In Proceedings of the ACL-PASCAL workshop on textual entailment and paraphrasing, 2007. ",
+        "bbox": [
+            173,
+            268,
+            826,
+            313
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom Goldstein, Christoph Studer, and Richard Baraniuk. A field guide to forward-backward splitting with a fasta implementation. arXiv preprint 1411.3406, 2014. ",
+        "bbox": [
+            174,
+            320,
+            823,
+            351
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shankar Iyer, Nikhil Dandekar, and Kornl Csernai. First quora dataset release: Question pairs, 2017. URL https://www.quora.com/q/quoradata/ First-Quora-Dataset-Release-Question-Pairs. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohit Iyyer, John Wieting, Kevin Gimpel, and Luke Zettlemoyer. Adversarial example generation with syntactically controlled paraphrase networks. In NAACL, 2018. ",
+        "bbox": [
+            174,
+            449,
+            823,
+            478
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In EMNLP, 2017. ",
+        "bbox": [
+            173,
+            487,
+            823,
+            516
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            525,
+            823,
+            554
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guokun Lai, Qizhe Xie, Hanxiao Liu, Yiming Yang, and Eduard Hovy. Race: Large-scale reading comprehension dataset from examinations. arXiv preprint arXiv:1704.04683, 2017. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. Albert: A lite bert for self-supervised learning of language representations. ICLR, 2020. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hector J Levesque, Ernest Davis, and Leora Morgenstern. The Winograd schema challenge. In AAAI Spring Symposium: Logical Formalizations of Commonsense Reasoning, 2011. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            669
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. Multi-task deep neural networks for natural language understanding. In ACL, 2019a. ",
+        "bbox": [
+            173,
+            676,
+            823,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019b. ",
+        "bbox": [
+            178,
+            714,
+            823,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            767,
+            821,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. Can a suit of armor conduct electricity? a new dataset for open book question answering. arXiv preprint arXiv:1809.02789, 2018. ",
+        "bbox": [
+            176,
+            805,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Andrew M Dai, and Ian Goodfellow. Adversarial training methods for semisupervised text classification. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            857,
+            820,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: A regularization method for supervised and semi-supervised learning. TPAMI, 2019. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chongli Qin, James Martens, Sven Gowal, Dilip Krishnan, Alhussein Fawzi, Soham De, Robert Stanforth, Pushmeet Kohli, et al. Adversarial robustness through local linearization. In NeurIPS, 2019. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint 1910.10683, 2019. ",
+        "bbox": [
+            176,
+            156,
+            821,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. SQuAD: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. In EMNLP, 2016. ",
+        "bbox": [
+            173,
+            208,
+            821,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Semantically equivalent adversarial rules for debugging NLP models. In ACL, 2018. ",
+        "bbox": [
+            173,
+            247,
+            823,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Parsa Saadatpanah, Ali Shafahi, and Tom Goldstein. Adversarial attacks on copyright detection systems. arXiv preprint 1906.07153, 2019. ",
+        "bbox": [
+            173,
+            286,
+            823,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL, 2016. ",
+        "bbox": [
+            173,
+            324,
+            823,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A. Shafahi, M. Najibi, A. Ghiasi, Z. Xu, J. Dickerson, C. Studer, L. Davis, G. Taylor, and T. Goldstein. Adversarial Training for Free! In NeurIPS, 2019. ",
+        "bbox": [
+            168,
+            363,
+            823,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Ng, and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In EMNLP, 2013. ",
+        "bbox": [
+            173,
+            401,
+            821,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jure Sokolic, Raja Giryes, Guillermo Sapiro, and Miguel Rodrigues. Generalization error of invariant classifiers. In AISTATS, 2017. ",
+        "bbox": [
+            169,
+            454,
+            823,
+            484
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert Speer, Joshua Chin, and Catherine Havasi. Conceptnet 5.5: An open multilingual graph of general knowledge. In AAAI, 2017. ",
+        "bbox": [
+            169,
+            493,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014. ",
+        "bbox": [
+            174,
+            531,
+            821,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kai Sun, Dian Yu, Dong Yu, and Claire Cardie. Improving machine reading comprehension with general reading strategies. arXiv preprint arXiv:1810.13441, 2018. ",
+        "bbox": [
+            173,
+            570,
+            821,
+            601
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. Commonsenseqa: A question answering challenge targeting commonsense knowledge. In NAACL, 2019. ",
+        "bbox": [
+            173,
+            609,
+            823,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            691
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Warstadt, Amanpreet Singh, and Samuel R. Bowman. Neural network acceptability judgments. arXiv preprint 1805.12471, 2018. ",
+        "bbox": [
+            171,
+            702,
+            823,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Nikita Nangia, and Samuel R. Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In NAACL, 2018. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chaowei Xiao, Ruizhi Deng, Bo Li, Fisher Yu, Mingyan Liu, and Dawn Song. Characterizing adversarial examples based on spatial consistency information for semantic segmentation. In ECCV, 2018. ",
+        "bbox": [
+            176,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan L. Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. In CVPR, 2019. ",
+        "bbox": [
+            173,
+            832,
+            823,
+            859
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Huan Xu and Shie Mannor. Robustness and generalization. Machine learning, 2012. ",
+        "bbox": [
+            173,
+            869,
+            728,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In NeurIPS, 2019. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dinghuai Zhang, Tianyuan Zhang, Yiping Lu, Zhanxing Zhu, and Bin Dong. You only propagate once: Painless adversarial training using maximal principle. In NeurIPS, 2019. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhengli Zhao, Dheeru Dua, and Sameer Singh. Generating natural adversarial examples. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            534,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 PROBLEM FORMULATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            403,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For tasks with ranking loss like ARC, CommonsenseQA, WNLI and QNLI, add the perturbation to the concatenation of the embeddings of all question/answer pairs. ",
+        "bbox": [
+            174,
+            160,
+            823,
+            188
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Additional tricks are required to achieve high performance on WNLI and QNLI for the GLUE benchmark. We use the same tricks as Liu et al. (2019b). For WNLI, we use the same WSC data provided by Liu et al. (2019b) for training. For testing, Liu et al. (2019b) also provided the test set with span annotations, but the order is different form the GLUE dataset. We re-order their test set by matching. For the QNLI, we follow Liu et al. (2019b) and formulate the problem as pairwise ranking problem, which is the same for CommonsenseQA. We find the matching pairs for both training set and testing set by matching the queries in the dev set. We predict “entailment” if the candidate has the higher score, and “not entailment” otherwise. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            306
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            324,
+            367,
+            338
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/4a6af4a2ca697bb9e27081b61d517c61fbe771acb7ab6a114f22e5ee01062b9f.jpg",
+        "table_caption": [
+            "Table 6: Additional hyper-parameters on GLUE tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>RTE</td><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>CoLA</td><td rowspan=1 colspan=1>STS-B</td></tr><tr><td rowspan=1 colspan=1>E</td><td rowspan=1 colspan=1>2E-1</td><td rowspan=1 colspan=1>1.5E-1</td><td rowspan=1 colspan=1>4.5E-1</td><td rowspan=1 colspan=1>1.5E-1</td><td rowspan=1 colspan=1>6E-1</td><td rowspan=1 colspan=1>4E-1</td><td rowspan=1 colspan=1>2E-1</td><td rowspan=1 colspan=1>3E-1</td></tr><tr><td rowspan=1 colspan=1>a</td><td rowspan=1 colspan=1>1E-1</td><td rowspan=1 colspan=1>1E-1</td><td rowspan=1 colspan=1>1.5E-1</td><td rowspan=1 colspan=1>3E-2</td><td rowspan=1 colspan=1>1E-1</td><td rowspan=1 colspan=1>4E-2</td><td rowspan=1 colspan=1>2.5E-2</td><td rowspan=1 colspan=1>1E-1</td></tr><tr><td rowspan=1 colspan=1>m</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr></table>",
+        "bbox": [
+            223,
+            354,
+            774,
+            416
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As other adversarial training methods, introduces three additional hyper-parameters: step size $\\alpha$ , maximum perturbation $\\epsilon$ , number of steps $m$ . For all other hyper-parameters such as learning rate and number of iterations, we either search in the same interval as RoBERTa (on CommonsenseQA, ARC, and WNLI), or use exactly the same setting as RoBERTa (except for MRPC, where we find using a learning rate of $5 \\times 1 0 ^ { - 6 }$ gives better results).13. We list the best combinations for $\\alpha , \\epsilon$ and $m$ for each of the GLUE tasks in Table 6. For WSC/WNLI, the best combination is $\\epsilon = 1 e - 2 , \\alpha =$ $5 e - 3 , m = 2$ . Notice even when $m \\alpha < \\epsilon$ , the maximum perturbation could still reach $\\epsilon$ due to the random initialization. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            571
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B VARIANCE OF MAXIMUM INCREMENT OF LOSS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            592,
+            604,
+            608
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc24cb509b23de841340a676916c10c0a5f0d23eba704bba7d0ecdae595f6dc7.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=3>RTE</td><td rowspan=1 colspan=3>CoLA</td><td rowspan=1 colspan=3>MRPC</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4）</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-4)</td><td rowspan=1 colspan=1>M-Inc (R)(10-4）</td><td rowspan=1 colspan=1>N-Loss(10-4)</td><td rowspan=1 colspan=1>M-Inc(10-3)</td><td rowspan=1 colspan=1>M-Inc (R)(10-3）</td><td rowspan=1 colspan=1>N-Loss(10-3)</td></tr><tr><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>5.1(15087)</td><td rowspan=1 colspan=1>5.3(14346)</td><td rowspan=1 colspan=1>4.5(920)</td><td rowspan=1 colspan=1>6.1(13118)</td><td rowspan=1 colspan=1>5.7(14122)</td><td rowspan=1 colspan=1>5.2(447)</td><td rowspan=1 colspan=1>10.2(929)</td><td rowspan=1 colspan=1>10.2(955)</td><td rowspan=1 colspan=1>1.9(76)</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>4.7(10138)</td><td rowspan=1 colspan=1>4.9(1828)</td><td rowspan=1 colspan=1>6.2(752)</td><td rowspan=1 colspan=1>128.2(1300)</td><td rowspan=1 colspan=1>130.1(893)</td><td rowspan=1 colspan=1>436.1(1276)</td><td rowspan=1 colspan=1>5.7(321)</td><td rowspan=1 colspan=1>5.7(155)</td><td rowspan=1 colspan=1>5.4(54)</td></tr><tr><td rowspan=1 colspan=1>FreeLB</td><td rowspan=1 colspan=1>3.0(1614)</td><td rowspan=1 colspan=1>2.6(11114)</td><td rowspan=1 colspan=1>4.1(595)</td><td rowspan=1 colspan=1>1.4(1392)</td><td rowspan=1 colspan=1>1.3(6231)</td><td rowspan=1 colspan=1>7.2(615)</td><td rowspan=1 colspan=1>3.6(167)</td><td rowspan=1 colspan=1>3.6(601)</td><td rowspan=1 colspan=1>2.7(54)</td></tr></table>",
+        "bbox": [
+            173,
+            627,
+            825,
+            695
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Median and Standard Deviation of the maximum increase in loss in the vicinity of the dev set samples for RoBERTa-Large model finetuned with different methods. Vanilla models are naturally trained RoBERTa’s. Nat Loss is the loss value on clean samples. Notice we require all clean samples here to be correctly classified by all models, which results in 227, 850 and 355 samples for RTE, CoLA and MRPC. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            757
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 7 provides the complete results for the increment of loss in the interval, with median and standard deviation. ",
+        "bbox": [
+            176,
+            776,
+            823,
+            804
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL RESULTS FOR ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            825,
+            609,
+            842
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Here we provide some additional results for comparison with YOPO as complementary results to Table 4. We will release the complete results for comparing with YOPO and without variational dropout on each of the GLUE tasks in our next revision. From the current results, there is no need ",
+        "bbox": [
+            176,
+            857,
+            825,
+            898
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/8c04a7228cc8d5061e850a97d495da84f386812487797d0894db7899fc19501f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Vanilla</td><td rowspan=1 colspan=1>FreeLB-3</td><td rowspan=1 colspan=1>YOPO-3-2</td><td rowspan=1 colspan=1>YOPO-3-3</td></tr><tr><td rowspan=1 colspan=1>STS-B</td><td rowspan=1 colspan=1>92.20 (.2)</td><td rowspan=1 colspan=1>92.67 (.08)</td><td rowspan=1 colspan=1>92.60 (.17)</td><td rowspan=1 colspan=1>92.60 (0.20)</td></tr><tr><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>96.56 (.3)</td><td rowspan=1 colspan=1>96.79 (.2)</td><td rowspan=1 colspan=1>96.44 (.2)</td><td rowspan=1 colspan=1>96.33 (.1)</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>94.98 (.2)</td><td rowspan=1 colspan=1>94.96 (.1)</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>92.60 (.03)</td><td rowspan=1 colspan=1>92.55 (.05)*</td><td rowspan=1 colspan=1>92.50 (.02)*</td></tr><tr><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>90.61 (.1)</td><td rowspan=1 colspan=1>90.59 (.2)</td><td rowspan=1 colspan=1>90.45 (.2)</td></tr></table>",
+        "bbox": [
+            285,
+            101,
+            709,
+            185
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 8: The median and standard deviation of the scores on the dev sets of STS-B, SST-2, QNLI, QQP and MNLI from the GLUE benchmark, each computed from 5 runs with the same hyper-parameters except for the random seeds (except for the results with YOPO on QQP, which are from 4 runs). Also note here we use a step size of $\\alpha$ for the adversary of YOPO-m-n, so YOPO effectively uses a step size of $_ { n \\alpha }$ . We use FreeLB- $\\mathbf { \\nabla } m$ to denote FreeLB with $m$ ascent steps, and YOPO-3- $\\mathbf { \\nabla } \\cdot \\mathbf { n }$ to denote YOPO with $_ n$ shallow-layer ascents. ",
+        "bbox": [
+            173,
+            189,
+            826,
+            252
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "in using extra shallow-layer updates that YOPO advocates, since this consistently deteriorates the performance while introducing extra computations. ",
+        "bbox": [
+            173,
+            272,
+            823,
+            301
+        ],
+        "page_idx": 13
+    }
+]

parse/train/ByldLrqlx/ByldLrqlx.md

@@ -0,0 +1,496 @@
+# DEEPCODER: LEARNING TO WRITE PROGRAMS
+
+Matej Balog∗ Department of Engineering University of Cambridge
+
+Alexander L. Gaunt, Marc Brockschmidt, Sebastian Nowozin, Daniel Tarlow Microsoft Research
+
+# ABSTRACT
+
+We develop a first line of attack for solving programming competition-style problems from input-output examples using deep learning. The approach is to train a neural network to predict properties of the program that generated the outputs from the inputs. We use the neural network’s predictions to augment search techniques from the programming languages community, including enumerative search and an SMT-based solver. Empirically, we show that our approach leads to an order of magnitude speedup over the strong non-augmented baselines and a Recurrent Neural Network approach, and that we are able to solve problems of difficulty comparable to the simplest problems on programming competition websites.
+
+# 1 INTRODUCTION
+
+A dream of artificial intelligence is to build systems that can write computer programs. Recently, there has been much interest in program-like neural network models (Graves et al., 2014; Weston et al., 2015; Kurach et al., 2015; Joulin & Mikolov, 2015; Grefenstette et al., 2015; Sukhbaatar et al., 2015; Neelakantan et al., 2016; Kaiser & Sutskever, 2016; Reed & de Freitas, 2016; Zaremba et al., 2016; Graves et al., 2016), but none of these can write programs; that is, they do not generate human-readable source code. Only very recently, Riedel et al. (2016); Bunel et al. (2016); Gaunt et al. (2016) explored the use of gradient descent to induce source code from input-output examples via differentiable interpreters, and Ling et al. (2016) explored the generation of source code from unstructured text descriptions. However, Gaunt et al. (2016) showed that differentiable interpreterbased program induction is inferior to discrete search-based techniques used by the programming languages community. We are then left with the question of how to make progress on program induction using machine learning techniques.
+
+In this work, we propose two main ideas: (1) learn to induce programs; that is, use a corpus of program induction problems to learn strategies that generalize across problems, and (2) integrate neural network architectures with search-based techniques rather than replace them.
+
+In more detail, we can contrast our approach to existing work on differentiable interpreters. In differentiable interpreters, the idea is to define a differentiable mapping from source code and inputs to outputs. After observing inputs and outputs, gradient descent can be used to search for a program that matches the input-output examples. This approach leverages gradient-based optimization, which has proven powerful for training neural networks, but each synthesis problem is still solved independently—solving many synthesis problems does not help to solve the next problem.
+
+We argue that machine learning can provide significant value towards solving Inductive Program Synthesis (IPS) by re-casting the problem as a big data problem. We show that training a neural network on a large number of generated IPS problems to predict cues from the problem description can help a search-based technique. In this work, we focus on predicting an order on the program space and show how to use it to guide search-based techniques that are common in the programming languages community. This approach has three desirable properties: first, we transform a difficult search problem into a supervised learning problem; second, we soften the effect of failures of the neural network by searching over program space rather than relying on a single prediction; and third, the neural network’s predictions are used to guide existing program synthesis systems, allowing us to use and improve on the best solvers from the programming languages community. Empirically, we show orders-of-magnitude improvements over optimized standard search techniques and a Recurrent Neural Network-based approach to the problem.
+
+In summary, we define and instantiate a framework for using deep learning for program synthesis problems like ones appearing on programming competition websites. Our concrete contributions are:
+
+1. defining a programming language that is expressive enough to include real-world programming problems while being high-level enough to be predictable from input-output examples; 2. models for mapping sets of input-output examples to program properties; and 3. experiments that show an order of magnitude speedup over standard program synthesis techniques, which makes this approach feasible for solving problems of similar difficulty as the simplest problems that appear on programming competition websites.
+
+# 2 BACKGROUND ON INDUCTIVE PROGRAM SYNTHESIS
+
+We begin by providing background on Inductive Program Synthesis, including a brief overview of how it is typically formulated and solved in the programming languages community.
+
+The Inductive Program Synthesis (IPS) problem is the following: given input-output examples, produce a program that has behavior consistent with the examples.
+
+Building an IPS system requires solving two problems. First, the search problem: to find consistent programs we need to search over a suitable set of possible programs. We need to define the set (i.e., the program space) and search procedure. Second, the ranking problem: if there are multiple programs consistent with the input-output examples, which one do we return? Both of these problems are dependent on the specifics of the problem formulation. Thus, the first important decision in formulating an approach to program synthesis is the choice of a Domain Specific Language.
+
+Domain Specific Languages (DSLs). DSLs are programming languages that are suitable for a specialized domain but are more restrictive than full-featured programming languages. For example, one might disallow loops or other control flow, and only allow string data types and a small number of primitive operations like concatenation. Most of program synthesis research focuses on synthesizing programs in DSLs, because full-featured languages like $\mathrm { C } { + + }$ enlarge the search space and complicate synthesis. Restricted DSLs can also enable more efficient special-purpose search algorithms. For example, if a DSL only allows concatenations of substrings of an input string, a dynamic programming algorithm can efficiently search over all possible programs (Polozov & Gulwani, 2015). The choice of DSL also affects the difficulty of the ranking problem. For example, in a DSL without if statements, the same algorithm is applied to all inputs, reducing the number of programs consistent with any set of input-output examples, and thus the ranking problem becomes easier. Of course, the restrictiveness of the chosen DSL also determines which problems the system can solve at all.
+
+Search Techniques. There are many techniques for searching for programs consistent with inputoutput examples. Perhaps the simplest approach is to define a grammar and then enumerate all derivations of the grammar, checking each one for consistency with the examples. This approach can be combined with pruning based on types and other logical reasoning (Feser et al., 2015). While simple, these approaches can be implemented efficiently, and they can be surprisingly effective.
+
+In restricted domains such as the concatenation example discussed above, special-purpose algorithms can be used. FlashMeta (Polozov & Gulwani, 2015) describes a framework for DSLs which allow decomposition of the search problem, e.g., where the production of an output string from an input string can be reduced to finding a program for producing the first part of the output and concatenating it with a program for producing the latter part of the output string.
+
+Another class of systems is based on Satisfiability Modulo Theories (SMT) solving. SMT combines SAT-style search with theories like arithmetic and inequalities, with the benefit that theory-dependent subproblems can be handled by special-purpose solvers. For example, a special-purpose solver can easily find integers $x , y$ such that $x < y$ and $y < - 1 0 0$ hold, whereas an enumeration strategy may need to consider many values before satisfying the constraints. Many program synthesis engines based on SMT solvers exist, e.g., Sketch (Solar-Lezama, 2008) and Brahma (Gulwani et al., 2011). They convert the semantics of a DSL into a set of constraints between variables representing the program and the input-output values, and then call an SMT solver to find a satisfying setting of the program variables. This approach shines when special-purpose reasoning can be leveraged, but complex DSLs can lead to very large constraint problems where constructing and manipulating the constraints can be a lot slower than an enumerative approach.
+
+Finally, stochastic local search can be employed to search over program space, and there is a long history of applying genetic algorithms to this problem. One of the most successful recent examples is the STOKE super-optimization system (Schkufza et al., 2016), which uses stochastic local search to find assembly programs that have the same semantics as an input program but execute faster.
+
+Ranking. While we focus on the search problem in this work, we briefly mention the ranking problem here. A popular choice for ranking is to choose the shortest program consistent with inputoutput examples (Gulwani, 2016). A more sophisticated approach is employed by FlashFill (Singh & Gulwani, 2015). It works in a manner similar to max-margin structured prediction, where known ground truth programs are given, and the learning task is to assign scores to programs such that the ground truth programs score higher than other programs that satisfy the input-output specification.
+
+# 3 LEARNING INDUCTIVE PROGRAM SYNTHESIS (LIPS)
+
+In this section we outline the general approach that we follow in this work, which we call Learning Inductive Program Synthesis (LIPS). The details of our instantiation of LIPS appear in Sect. 4. The components of LIPS are (1) a DSL specification, (2) a data-generation procedure, (3) a machine learning model that maps from input-output examples to program attributes, and (4) a search procedure that searches program space in an order guided by the model from (3). The framework is related to the formulation of Menon et al. (2013); the relationship and key differences are discussed in Sect. 6.
+
+(1) DSL and Attributes. The choice of DSL is important in LIPS, just as it is in any program synthesis system. It should be expressive enough to capture the problems that we wish to solve, but restricted as much as possible to limit the difficulty of the search. In LIPS we additionally specify an attribute function $\mathcal { A }$ that maps programs $P$ of the DSL to finite attribute vectors $\mathbf { \boldsymbol { a } } \overset { \cdot } { = } \mathbf { \bar { A } } ( \mathbf { \boldsymbol { P } } )$ . (Attribute vectors of different programs need not have equal length.) Attributes serve as the link between the machine learning and the search component of LIPS: the machine learning model predicts a distribution $q ( \pmb { a } \mid \mathcal { E } )$ , where $\mathcal { E }$ is the set of input-output examples, and the search procedure aims to search over programs $P$ as ordered by $q ( { \bar { \mathcal { A } } } ( { \bar { P } } ) \mid \varepsilon )$ . Thus an attribute is useful if it is both predictable from input-output examples, and if conditioning on its value significantly reduces the effective size of the search space.
+
+Possible attributes are the (perhaps position-dependent) presence or absence of high-level functions (e.g., does the program contain or end in a call to SORT). Other possible attributes include control flow templates (e.g., the number of loops and conditionals). In the extreme case, one may set $\mathcal { A }$ to the identity function, in which case the attribute is equivalent to the program; however, in our experiments we find that performance is improved by choosing a more abstract attribute function.
+
+(2) Data Generation. Step 2 is to generate a dataset $( ( P ^ { ( n ) } , \pmb { a } ^ { ( n ) } , \pmb { \mathcal { E } } ^ { ( n ) } ) ) _ { n = 1 } ^ { N }$ of programs $P ^ { ( n ) }$ in the chosen DSL, their attributes $\mathbf { \pmb { a } } ^ { ( n ) }$ , and accompanying input-output examples ${ \mathcal { E } } ^ { ( n ) }$ . Different approaches are possible, ranging from enumerating valid programs in the DSL and pruning, to training a more sophisticated generative model of programs in the DSL. The key in the LIPS formulation is to ensure that it is feasible to generate a large dataset (ideally millions of programs).
+
+(3) Machine Learning Model. The machine learning problem is to learn a distribution of attributes given input-output examples, $q ( \pmb { a } \mid \mathcal { E } )$ . There is freedom to explore a large space of models, so long as the input component can encode $\mathcal { E }$ , and the output is a proper distribution over attributes (e.g., if attributes are a fixed-size binary vector, then a neural network with independent sigmoid outputs is appropriate; if attributes are variable size, then a recurrent neural network output could be used). Attributes are observed at training time, so training can use a maximum likelihood objective.
+
+(4) Search. The aim of the search component is to interface with an existing solver, using the predicted $q ( \pmb { a } \mid \mathcal { E } )$ to guide the search. We describe specific approaches in the next section.
+
+# 4 DEEPCODER
+
+Here we describe DeepCoder, our instantiation of LIPS including a choice of DSL, a data generation strategy, models for encoding input-output sets, and algorithms for searching over program space.
+
+# 4.1 DOMAIN SPECIFIC LANGUAGE AND ATTRIBUTES
+
+We consider binary attributes indicating the presence or absence of high-level functions in the target program. To make this effective, the chosen DSL needs to contain constructs that are not so low-level that they all appear in the vast majority of programs, but at the same time should be common enough so that predicting their occurrence from input-output examples can be learned successfully.
+
+Following this observation, our DSL is loosely inspired by query languages such as SQL or LINQ, where high-level functions are used in sequence to manipulate data. A program in our DSL is a sequence of function calls, where the result of each call initializes a fresh variable that is either a singleton integer or an integer array. Functions can be applied to any of the inputs or previously computed (intermediate) variables. The output of the program is the return value of the last function call, i.e., the last variable. See Fig. 1 for an example program of length $T = 4$ in our DSL.
+
+![](images/95255e32da9df33db9a517e94978033a462b93ebbbe24b571c4b80d5e2c7f8e6.jpg)  
+Figure 1: An example program in our DSL that takes a single integer array as its input.
+
+Overall, our DSL contains the first-order functions HEAD, LAST, TAKE, DROP, ACCESS, MINIMUM, MAXIMUM, REVERSE, SORT, SUM, and the higher-order functions MAP, FILTER, COUNT, ZIPWITH, SCANL1. Higher-order functions require suitable lambda functions for their behavior to be fully specified: for MAP our DSL provides lambdas $( + 1 )$ , $( - 1 )$ , $( \star 2 )$ , $( / 2 )$ ), $( \star \ ( - 1 ) \ )$ ), $( \star \star 2 )$ , $( \star 3 )$ , $( / 3 )$ , $( \star 4 )$ , $( / 4 )$ ; for FILTER and COUNT there are predicates $( > 0 )$ ), $( < 0 )$ , ( $\scriptstyle { \frac { 0 } { 0 } } 2 = = 0$ ), ( $\scriptstyle { \frac { 0 } { 0 } } 2 = = 1$ ) and for ZIPWITH and SCANL1 the DSL provides lambdas $( + ) , ( - ) , ( \star ) ,$ MIN, MAX. A description of the semantics of all functions is provided in Appendix F.
+
+Note that while the language only allows linear control flow, many of its functions do perform branching and looping internally (e.g., SORT, COUNT, ...). Examples of more sophisticated programs expressible in our DSL, which were inspired by the simplest problems appearing on programming competition websites, are shown in Appendix A.
+
+# 4.2 DATA GENERATION
+
+To generate a dataset, we enumerate programs in the DSL, heuristically pruning away those with easily detectable issues such as a redundant variable whose value does not affect the program output, or, more generally, existence of a shorter equivalent program (equivalence can be overapproximated by identical behavior on randomly or carefully chosen inputs). To generate valid inputs for a program, we enforce a constraint on the output value bounding integers to some predetermined range, and then propagate these constraints backward through the program to obtain a range of valid values for each input. If one of these ranges is empty, we discard the program. Otherwise, input-output pairs can be generated by picking inputs from the pre-computed valid ranges and executing the program to obtain the output values. The binary attribute vectors are easily computed from the program source codes.
+
+# 4.3 MACHINE LEARNING MODEL
+
+Observe how the input-output data in Fig. 1 is informative of the functions appearing in the program: the values in the output are all negative, divisible by 4, they are sorted in decreasing order, and they happen to be multiples of numbers appearing in the input. Our aim is to learn to recognize such patterns in the input-output examples, and to leverage them to predict the presence or absence of individual functions. We employ neural networks to model and learn the mapping from input-output examples to attributes. We can think of these networks as consisting of two parts:
+
+1. an encoder: a differentiable mapping from a set of $M$ input-output examples generated by a single program to a latent real-valued vector, and 2. a decoder: a differentiable mapping from the latent vector representing a set of $M$ inputoutput examples to predictions of the ground truth program’s attributes.
+
+For the encoder we use a simple feed-forward architecture. First, we represent the input and output types (singleton or array) by a one-hot-encoding, and we pad the inputs and outputs to a maximum length $L$ with a special NULL value. Second, each integer in the inputs and in the output is mapped to a learned embedding vector of size $E = 2 0$ . (The range of integers is restricted to a finite range and each embedding is parametrized individually.) Third, for each input-output example separately, we concatenate the embeddings of the input types, the inputs, the output type, and the output into a single (fixed-length) vector, and pass this vector through $H = 3$ hidden layers containing $K = 2 5 6$ sigmoid units each. The third hidden layer thus provides an encoding of each individual input-output example. Finally, for input-output examples in a set generated from the same program, we pool these representations together by simple arithmetic averaging. See Appendix C for more details.
+
+The advantage of this encoder lies in its simplicity, and we found it reasonably easy to train. A disadvantage is that it requires an upper bound $L$ on the length of arrays appearing in the input and output. We confirmed that the chosen encoder architecture is sensible in that it performs empirically at least as well as an RNN encoder, a natural baseline, which may however be more difficult to train.
+
+DeepCoder learns to predict presence or absence of individual functions of the DSL. We shall see this can already be exploited by various search techniques to large computational gains. We use a decoder that pre-multiplies the encoding of input-output examples by a learned $C \times K$ matrix, where $C = 3 4$ is the number of functions in our DSL (higher-order functions and lambdas are predicted independently), and treats the resulting $C$ numbers as log-unnormalized probabilities (logits) of each function appearing in the source code. Fig. 2 shows the predictions a trained neural network made from 5 input-output examples for the program shown in Fig. 1.
+
+![](images/c3c080b2a8813d24f061fe69fe44372e58ba574c230d52185f026a848a7215ca.jpg)  
+Figure 2: Neural network predicts the probability of each function appearing in the source code.
+
+# 4.4 SEARCH
+
+One of the central ideas of this work is to use a neural network to guide the search for a program consistent with a set of input-output examples instead of directly predicting the entire source code. This section briefly describes the search techniques and how they integrate the predicted attributes.
+
+Depth-first search (DFS). We use an optimized version of DFS to search over programs with a given maximum length $T$ (see Appendix D for details). When the search procedure extends a partial program by a new function, it has to try the functions in the DSL in some order. At this point DFS can opt to consider the functions as ordered by their predicted probabilities from the neural network.
+
+“Sort and add” enumeration. A stronger way of utilizing the predicted probabilities of functions in an enumerative search procedure is to use a Sort and add scheme, which maintains a set of active functions and performs DFS with the active function set only. Whenever the search fails, the next most probable function (or several) are added to the active set and the search restarts with this larger active set. Note that this scheme has the deficiency of potentially re-exploring some parts of the search space several times, which could be avoided by a more sophisticated search procedure.
+
+Sketch. Sketch (Solar-Lezama, 2008) is a successful SMT-based program synthesis tool from the programming languages research community. While its main use case is to synthesize programs by filling in “holes” in incomplete source code so as to match specified requirements, it is flexible enough for our use case as well. The function in each step and its arguments can be treated as the “holes”, and the requirement to be satisfied is consistency with the provided set of input-output examples. Sketch can utilize the neural network predictions in a Sort and add scheme as described above, as the possibilities for each function hole can be restricted to the current active set.
+
+$\lambda ^ { 2 }$ . $\lambda ^ { 2 }$ (Feser et al., 2015) is a program synthesis tool from the programming languages community that combines enumerative search with deduction to prune the search space. It is designed to infer small functional programs for data structure manipulation from input-output examples, by combining functions from a provided library. $\lambda ^ { 2 }$ can be used in our framework using a Sort and add scheme as described above by choosing the library of functions according to the neural network predictions.
+
+# 4.5 TRAINING LOSS FUNCTION
+
+We use the negative cross entropy loss to train the neural network described in Sect. 4.3, so that its predictions about each function can be interpreted as marginal probabilities. The LIPS framework dictates learning $q ( \pmb { a } \mid \mathcal { E } )$ , the joint distribution of all attributes $\textbf { \em a }$ given the input-output examples, and it is not clear a priori how much DeepCoder loses by ignoring correlations between functions. However, under the simplifying assumption that the runtime of searching for a program of length $T$ with $C$ functions made available to a search routine is proportional to $\check { C } ^ { T }$ , the following result for Sort and add procedures shows that their runtime can be optimized using marginal probabilities.
+
+Lemma 1. For any fixed program length $T$ , the expected total runtime of a Sort and add search scheme can be upper bounded by a quantity that is minimized by adding the functions in the order of decreasing true marginal probabilities.
+
+Proof. Predicting source code functions from input-output examples can be seen as a multi-label classification problem, where each set of input-output examples is associated with a set of relevant labels (functions appearing in the ground truth source code). Dembczynski et al. (2010) showed that in multi-label classification under a so-called Rank loss, it is Bayes optimal to rank the labels according to their marginal probabilities. If the runtime of search with $C$ functions is proportional to $C ^ { T }$ , the total runtime of a Sort and add procedure can be monotonically transformed so that it is upper bounded by this Rank loss. See Appendix E for more details. □
+
+# 5 EXPERIMENTS
+
+In this section we report results from two categories of experiments. Our main experiments (Sect. 5.1) show that the LIPS framework can lead to significant performance gains in solving IPS by demonstrating such gains with DeepCoder. In Sect. 5.2 we illustrate the robustness of the method by demonstrating a strong kind of generalization ability across programs of different lengths.
+
+# 5.1 DEEPCODER COMPARED TO BASELINES
+
+We trained a neural network as described in Sect. 4.3 to predict used functions from input-output examples and constructed a test set of $P = 5 0 0$ programs, guaranteed to be semantically disjoint from all programs on which the neural network was trained (similarly to the equivalence check described in Sect. 4.2, we have ensured that all test programs behave differently from all programs used during training on at least one input). For each test program we generated $M = 5$ input-output examples involving integers of magnitudes up to 256, passed the examples to the trained neural network, and fed the obtained predictions to the search procedures from Sect. 4.4. We also considered a RNN-based decoder generating programs using beam search (see Sect. 5.3 for details). To evaluate DeepCoder, we then recorded the time the search procedures needed to find a program consistent with the $M$ input-output examples. As a baseline, we also ran all search procedures using a simple prior as function probabilities, computed from their global incidence in the program corpus.
+
+In the first, smaller-scale experiment (program search space size $\sim 2 \times 1 0 ^ { 6 }$ ) we trained the neural network on programs of length $T = 3$ , and the test programs were of the same length. Table 1 shows the per-task timeout required such that a solution could be found for given proportions of the test tasks (in time less than or equal to the timeout). For example, in a hypothetical test set with 4 tasks and runtimes of 3s, 2s, 1s, 4s, the timeout required to solve $50 \%$ of tasks would be 2s. More detailed experimental results are discussed in Appendix B.
+
+Table 1: Search speedups on programs of length $T = 3$ due to using neural network predictions.   
+
+<table><tr><td rowspan="2">Timeout needed to solve</td><td colspan="3">DFS</td><td colspan="3">Enumeration</td><td colspan="3">12</td><td colspan="2">Sketch</td><td>Beam</td></tr><tr><td>20%</td><td>40%</td><td>60%</td><td>20%</td><td>40%</td><td>60%</td><td>20%</td><td>40%</td><td>60%</td><td>20%</td><td>40%</td><td>20%</td></tr><tr><td>Baseline</td><td>41ms</td><td>126ms</td><td>314ms</td><td>80ms</td><td>：335ms861ms</td><td></td><td>18.9s</td><td>49.6s 84.2s</td><td></td><td>&gt;103s</td><td>&gt;103s</td><td>&gt;103s</td></tr><tr><td>DeepCoder</td><td>2.7ms</td><td>33ms</td><td>110ms</td><td>1.3ms</td><td>6.1ms</td><td>27ms</td><td>0.23s</td><td>0.52s 13.5s</td><td></td><td>2.13s</td><td>455s</td><td>292s</td></tr><tr><td>Speedup</td><td>15.2×</td><td>3.9×</td><td>2.9×</td><td>62.2×</td><td>54.6×</td><td>31.5×</td><td>80.4×</td><td>94.6×</td><td>6.2×</td><td>&gt;467×</td><td>&gt;2.2×</td><td>&gt;3.4×</td></tr></table>
+
+In the main experiment, we tackled a large-scale problem of searching for programs consistent with input-output examples generated from programs of length $T = 5$ (search space size on the order of $1 0 ^ { \overline { { 1 0 } } }$ ), supported by a neural network trained with programs of shorter length $T = 4$ . Here, we only consider $P = 1 0 0$ programs for reasons of computational efficiency, after having verified that this does not significantly affect the results in Table 1. The table in Fig. 3a shows significant speedups for DFS, Sort and add enumeration, and $\lambda ^ { 2 }$ with Sort and add enumeration, the search techniques capable of solving the search problem in reasonable time frames. Note that Sort and add enumeration without the neural network (using prior probabilities of functions) exceeded the $1 0 ^ { 4 }$ second timeout in two cases, so the relative speedups shown are crude lower bounds.
+
+![](images/a7cd9438bdca3d6b3e822af385015998ac105636d940628b2f68f443f81b05e3.jpg)  
+Figure 3: Search speedups on programs of length $T = 5$ and influence of length of training programs.
+
+We hypothesize that the substantially larger performance gains on Sort and add schemes as compared to gains on DFS can be explained by the fact that the choice of attribute function (predicting presence of functions anywhere in the program) and learning objective of the neural network are better matched to the Sort and add schemes. Indeed, a more appropriate attribute function for DFS would be one that is more informative of the functions appearing early in the program, since exploring an incorrect first function is costly with DFS. On the other hand, the discussion in Sect. 4.5 provides theoretical indication that ignoring the correlations between functions is not cataclysmic for Sort and add enumeration, since a Rank loss that upper bounds the Sort and add runtime can still be minimized.
+
+In Appendix G we analyse the performance of the neural networks used in these experiments, by investigating which attributes (program instructions) tend to be difficult to distinguish from each other.
+
+# 5.2 GENERALIZATION ACROSS PROGRAM LENGTHS
+
+To investigate the encoder’s generalization ability across programs of different lengths, we trained a network to predict used functions from input-output examples that were generated from programs of length $T _ { \mathrm { t r a i n } } \in \{ 1 , . . . , 4 \}$ . We then used each of these networks to predict functions on 5 test sets containing input-output examples generated from programs of lengths $T _ { \mathrm { t e s t } } \in \{ 1 , . . . , 5 \}$ , respectively. The test programs of a given length $T$ were semantically disjoint from all training programs of the same length $T$ and also from all training and test programs of shorter lengths $T ^ { \prime } < T$ .
+
+For each of the combinations of $T _ { \mathrm { t r a i n } }$ and $T _ { \mathrm { t e s t } }$ , Sort and add enumerative search was run both with and without using the neural network’s predictions (in the latter case using prior probabilities) until it solved $2 0 \%$ of the test set tasks. Fig. 3b shows the relative speedup of the solver having access to predictions from the trained neural networks. These results indicate that the neural networks are able to generalize beyond programs of the same length that they were trained on. This is partly due to the search procedure on top of their predictions, which has the opportunity to correct for the presence of functions that the neural network failed to predict. Note that a sequence-to-sequence model trained on programs of a fixed length could not be expected to exhibit this kind of generalization ability.
+
+# 5.3 ALTERNATIVE MODELS
+
+Encoder We evaluated replacing the feed-forward architecture encoder (Sect. 4.3) with an RNN, a natural baseline. Using a GRU-based RNN we were able to achieve results almost as good as using the feed-forward architecture, but found the RNN encoder more difficult to train.
+
+Decoder We also considered a purely neural network-based approach, where an RNN decoder is trained to predict the entire program token-by-token. We combined this with our feed-forward encoder by initializing the RNN using the pooled final layer of the encoder. We found it substantially more difficult to train an RNN decoder as compared to the independent binary classifiers employed above. Beam search was used to explore likely programs predicted by the RNN, but it only lead to a solution comparable with the other techniques when searching for programs of lengths $T \le 2$ , where the search space size is very small (on the order of $1 0 ^ { 3 }$ ). Note that using an RNN for both the encoder and decoder corresponds to a standard sequence-to-sequence model. However, we do do not rule out that a more sophisticated RNN decoder or training procedure could be possibly more successful.
+
+# 6 RELATED WORK
+
+Machine Learning for Inductive Program Synthesis. There is relatively little work on using machine learning for programming by example. The most closely related work is that of Menon et al. (2013), in which a hand-coded set of features of input-output examples are used as “clues.” When a clue appears in the input-output examples (e.g., the output is a permutation of the input), it reweights the probabilities of productions in a probabilistic context free grammar by a learned amount. This work shares the idea of learning to guide the search over program space conditional on input-output examples. One difference is in the domains. Menon et al. (2013) operate on short string manipulation programs, where it is arguably easier to hand-code features to recognize patterns in the input-output examples (e.g., if the outputs are always permutations or substrings of the input). Our work shows that there are strong cues in patterns in input-output examples in the domain of numbers and lists. However, the main difference is the scale. Menon et al. (2013) learns from a small (280 examples), manually-constructed dataset, which limits the capacity of the machine learning model that can be trained. Thus, it forces the machine learning component to be relatively simple. Indeed, Menon et al. (2013) use a log-linear model and rely on hand-constructed features. LIPS automatically generates training data, which yields datasets with millions of programs and enables high-capacity deep learning models to be brought to bear on the problem.
+
+Learning Representations of Program State. Piech et al. (2015) propose to learn joint embeddings of program states and programs to automatically extend teacher feedback to many similar programs in the MOOC setting. This work is similar in that it considers embedding program states, but the domain is different, and it otherwise specifically focuses on syntactic differences between semantically equivalent programs to provide stylistic feedback. Li et al. (2016) use graph neural networks (GNNs) to predict logical descriptions from program states, focusing on data structure shapes instead of numerical and list data. Such GNNs may be a suitable architecture to encode states appearing when extending our DSL to handle more complex data structures.
+
+Learning to Infer. Very recently, Alemi et al. (2016) used neural sequence models in tandem with an automated theorem prover. Similar to our Sort and Add strategy, a neural network component is trained to select premises that the theorem prover can use to prove a theorem. A recent extension (Loos et al., 2017) is similar to our DFS enumeration strategy and uses a neural network to guide the proof search at intermediate steps. The main differences are in the domains, and that they train on an existing corpus of theorems. More broadly, if we view a DSL as defining a model and search as a form of inference algorithm, then there is a large body of work on using discriminatively-trained models to aid inference in generative models. Examples include Dayan et al. (1995); Kingma & Welling (2014); Shotton et al. (2013); Stuhlmuller et al. (2013); Heess et al. (2013); Jampani et al. ¨ (2015).
+
+# 7 DISCUSSION AND FUTURE WORK
+
+We have presented a framework for improving IPS systems by using neural networks to translate cues in input-output examples to guidance over where to search in program space. Our empirical results show that for many programs, this technique improves the runtime of a wide range of IPS baselines by 1-3 orders. We have found several problems in real online programming challenges that can be solved with a program in our language, which validates the relevance of the class of problems that we have studied in this work. In sum, this suggests that we have made significant progress towards being able to solve programming competition problems, and the machine learning component plays an important role in making it tractable.
+
+There remain some limitations, however. First, the programs we can synthesize are only the simplest problems on programming competition websites and are simpler than most competition problems. Many problems require more complex algorithmic solutions like dynamic programming and search, which are currently beyond our reach. Our chosen DSL currently cannot express solutions to many problems. To do so, it would need to be extended by adding more primitives and allow for more flexibility in program constructs (such as allowing loops). Second, we currently use five input-output examples with relatively large integer values (up to 256 in magnitude), which are probably more informative than typical (smaller) examples. While we remain optimistic about LIPS’s applicability as the DSL becomes more complex and the input-output examples become less informative, it remains to be seen what the magnitude of these effects are as we move towards solving large subsets of programming competition problems.
+
+We foresee many extensions of DeepCoder. We are most interested in better data generation procedures by using generative models of source code, and to incorporate natural language problem descriptions to lessen the information burden required from input-output examples. In sum, DeepCoder represents a promising direction forward, and we are optimistic about the future prospects of using machine learning to synthesize programs.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to express their gratitude to Rishabh Singh and Jack Feser for their valuable guidance and help on using the Sketch and $\lambda ^ { 2 }$ program synthesis systems.
+
+# REFERENCES
+
+Alex A. Alemi, Franc¸ois Chollet, Geoffrey Irving, Christian Szegedy, and Josef Urban. DeepMath - deep sequence models for premise selection. In Proocedings of the 29th Conference on Advances in Neural Information Processing Systems (NIPS), 2016.   
+Rudy R Bunel, Alban Desmaison, Pawan K Mudigonda, Pushmeet Kohli, and Philip Torr. Adaptive neural compilation. In Proceedings of the 29th Conference on Advances in Neural Information Processing Systems (NIPS), 2016.   
+Peter Dayan, Geoffrey E Hinton, Radford M Neal, and Richard S Zemel. The Helmholtz machine. Neural computation, 7(5):889–904, 1995.   
+Krzysztof Dembczynski, Willem Waegeman, Weiwei Cheng, and Eyke H ´ ullermeier. On label de- ¨ pendence and loss minimization in multi-label classification. Machine Learning, 88(1):5–45, 2012.   
+Krzysztof J. Dembczynski, Weiwei Cheng, and Eyke Hllermeier. Bayes optimal multilabel classification via probabilistic classifier chains. In Proceedings of the 27th International Conference on Machine Learning (ICML), 2010.   
+John K. Feser, Swarat Chaudhuri, and Isil Dillig. Synthesizing data structure transformations from input-output examples. In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), 2015.   
+Alexander L. Gaunt, Marc Brockschmidt, Rishabh Singh, Nate Kushman, Pushmeet Kohli, Jonathan Taylor, and Daniel Tarlow. Terpret: A probabilistic programming language for program induction. CoRR, abs/1608.04428, 2016. URL http://arxiv.org/abs/1608.04428.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural Turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio G ´ omez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´ et al. Hybrid computing using a neural network with dynamic external memory. Nature, 2016.
+
+Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In Proceedings of the 28th Conference on Advances in Neural Information Processing Systems (NIPS), 2015.
+
+Sumit Gulwani. Programming by examples: Applications, algorithms, and ambiguity resolution. In Proceedings of the 8th International Joint Conference on Automated Reasoning (IJCAR), 2016.
+
+Sumit Gulwani, Susmit Jha, Ashish Tiwari, and Ramarathnam Venkatesan. Synthesis of loop-free programs. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), 2011.
+
+Nicolas Heess, Daniel Tarlow, and John Winn. Learning to pass expectation propagation messages. In Proceedings of the 26th Conference on Advances in Neural Information Processing Systems (NIPS), 2013.
+
+Varun Jampani, Sebastian Nowozin, Matthew Loper, and Peter V Gehler. The informed sampler: A discriminative approach to Bayesian inference in generative computer vision models. Computer Vision and Image Understanding, 136:32–44, 2015.
+
+Armand Joulin and Tomas Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. In Proceedings of the 28th Conference on Advances in Neural Information Processing Systems (NIPS), 2015.
+
+Łukasz Kaiser and Ilya Sutskever. Neural GPUs learn algorithms. In Proceedings of the 4th International Conference on Learning Representations, 2016.
+
+Diederik P Kingma and Max Welling. Stochastic gradient VB and the variational auto-encoder. In Proceedings of the 2nd International Conference on Learning Representations (ICLR), 2014.
+
+Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random-access machines. In Proceedings of the 4th International Conference on Learning Representations 2016, 2015.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard S. Zemel. Gated graph sequence neural networks. In Proceedings of the 4th International Conference on Learning Representations (ICLR), 2016.
+
+Wang Ling, Edward Grefenstette, Karl Moritz Hermann, Toma´s Ko ˇ cisk ˇ y, Andrew Senior, Fumin ´ Wang, and Phil Blunsom. Latent predictor networks for code generation. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, 2016.
+
+Sarah M. Loos, Geoffrey Irving, Christian Szegedy, and Cezary Kaliszyk. Deep network guided proof search. CoRR, abs/1701.06972, 2017. URL http://arxiv.org/abs/1701.06972.
+
+Aditya Krishna Menon, Omer Tamuz, Sumit Gulwani, Butler W Lampson, and Adam Kalai. A machine learning framework for programming by example. In Proceedings of the International Conference on Machine Learning (ICML), 2013.
+
+Arvind Neelakantan, Quoc V. Le, and Ilya Sutskever. Neural programmer: Inducing latent programs with gradient descent. In Proceedings of the 4th International Conference on Learning Representations (ICLR), 2016.
+
+Chris Piech, Jonathan Huang, Andy Nguyen, Mike Phulsuksombati, Mehran Sahami, and Leonidas J. Guibas. Learning program embeddings to propagate feedback on student code. In Proceedings of the 32nd International Conference on Machine Learning (ICML), 2015.
+
+Oleksandr Polozov and Sumit Gulwani. FlashMeta: a framework for inductive program synthesis. In Proceedings of the International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), 2015.
+
+Scott E. Reed and Nando de Freitas. Neural programmer-interpreters. In Proceedings of the 4th International Conference on Learning Representations (ICLR), 2016.
+
+Sebastian Riedel, Matko Bosnjak, and Tim Rocktaschel. Programming with a differentiable forth ¨ interpreter. CoRR, abs/1605.06640, 2016. URL http://arxiv.org/abs/1605.06640.
+
+Eric Schkufza, Rahul Sharma, and Alex Aiken. Stochastic program optimization. Commununications of the ACM, 59(2):114–122, 2016.
+
+Jamie Shotton, Toby Sharp, Alex Kipman, Andrew Fitzgibbon, Mark Finocchio, Andrew Blake, Mat Cook, and Richard Moore. Real-time human pose recognition in parts from single depth images. Communications of the ACM, 56(1):116–124, 2013.
+
+Rishabh Singh and Sumit Gulwani. Predicting a correct program in programming by example. In Proceedings of the 27th Conference on Computer Aided Verification (CAV), 2015.
+
+Armando Solar-Lezama. Program Synthesis By Sketching. PhD thesis, EECS Dept., UC Berkeley, 2008.
+
+Andreas Stuhlmuller, Jessica Taylor, and Noah D. Goodman. Learning stochastic inverses. In ¨ Proceedings of the 26th Conference on Advances in Neural Information Processing Systems (NIPS), 2013.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In Proceedings of the 28th Conference on Advances in Neural Information Processing Systems (NIPS), 2015.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. In Proceedings of the 3rd International Conference on Learning Representations (ICLR), 2015.
+
+Wojciech Zaremba, Tomas Mikolov, Armand Joulin, and Rob Fergus. Learning simple algorithms from examples. In Proceedings of the 33nd International Conference on Machine Learning (ICML), 2016.
+
+# A EXAMPLE PROGRAMS
+
+This section shows example programs in our Domain Specific Language (DSL), together with inputoutput examples and short descriptions. These programs have been inspired by simple tasks appearing on real programming competition websites, and are meant to illustrate the expressive power of our DSL.
+
+# Program 0:
+
+$\mathrm { k } $ int b ← [int] c ← SORT b d ← TAKE k c e ← SUM d
+
+Input-output example:   
+Input:   
+2, [3 5 4 7 5]   
+Output:   
+[7]
+
+Description:
+
+A new shop near you is selling $n$ paintings. You have $k \ < \ n$ friends and you would like to buy each of your friends a painting from the shop. Return the minimal amount of money you will need to spend.
+
+# Program 1:
+
+$\bar { w } $ [int]   
+t ← [int]   
+c ← MAP (\*3) w   
+d ← ZIPWITH (+) c t   
+e ← MAXIMUM d   
+Input-output example:   
+Input:   
+[6 2 4 7 9],   
+[5 3 6 1 0]   
+Output:   
+27
+
+Description:
+
+In soccer leagues, match winners are awarded 3 points, losers 0 points, and both teams get 1 point in the case of a tie. Compute the number of points awarded to the winner of a league given two arrays $w , t$ of the same length, where $w [ i ]$ (resp. $t [ i ] ,$ ) is the number of times team $i$ won (resp. tied).
+
+# Program 2:
+
+a ← [int]   
+b ← [int]   
+c ← ZIPWITH (-) b a $\mathsf { d } \gets \mathbf { C o u v r } \mathsf { T }$ $( > 0 )$ ) c
+
+# Input-output example:
+
+Input:   
+[6 2 4 7 9],   
+[5 3 2 1 0]   
+Output:   
+4
+
+Description:
+
+Alice and Bob are comparing their results in a recent exam. Given their marks per question as two arrays $a$ and $b$ , count on how many questions Alice got more points than Bob.
+
+# Program 3:
+
+h ← [int]   
+b ← SCANL1 MIN h   
+c ← ZIPWITH (-) h b $\mathrm { ~ d ~ } $ FILTER $( > 0 )$ ) c   
+$\mathrm { ~ e ~ } { \gets } \mathbf { S } \mathbf { U } \mathbf { M } \mathrm { ~ d ~ }$   
+Input-output example:   
+Input:   
+[8 5 7 2 5]   
+Output:   
+5
+
+Description:
+
+Perditia is very peculiar about her garden and wants that the trees standing in a row are all of non-increasing heights. Given the tree heights in centimeters in order of the row as an array h, compute how many centimeters she needs to trim the trees in total.
+
+# Program 4:
+
+x ← [int]   
+y ← [int]   
+$\mathbf { \boldsymbol { \mathrm { c } } } \gets \mathbf { \boldsymbol { S } } \mathbf { \boldsymbol { O } } \mathbf { R } \mathbf { \boldsymbol { T } } \ \mathbf { \boldsymbol { x } }$   
+d ← SORT y   
+e ← REVERSE d   
+f ← ZIPWITH (\*) d e   
+$\mathsf { g } \gets \mathsf { S U M } \mathrm { ~ f ~ }$   
+Input-output example:   
+Input:   
+[7 3 8 2 5],   
+[2 8 9 1 3]   
+Output:   
+79
+
+Description:
+
+Xavier and Yasmine are laying sticks to form non-overlapping rectangles on the ground. They both have fixed sets of pairs of sticks of certain lengths (represented as arrays x and y of numbers). Xavier only lays sticks parallel to the x axis, and Yasmine lays sticks only parallel to y axis. Compute the area their rectangles will cover at least.
+
+Program 5:   
+$\ a \gets$ [int]   
+$\ u \text b \gets$ REVERSE a   
+$\subset $ ZIPWITH MIN a b   
+Input-output example:   
+Input:   
+[3 7 5 2 8]   
+Output:   
+[3 2 5 2 3]
+
+# Description:
+
+A sequence called Billy is looking into the mirror, wondering how much weight it could lose by replacing any of its elements by their mirror images. Given a description of Billy as an array $b$ of length $n$ , return an array $c$ of minimal sum where each element $c [ i ]$ is either $b [ i ]$ or its mirror image $b [ n - i - 1 ]$ .
+
+<table><tr><td colspan="2"></td></tr><tr><td>Program 6: IO example: t←[int] Input: p←[int] [4 8 11 2], C←MAP（-1）t [2341] d←MAP（-1）p Output: e ←ZIPWITH（+）c d 1 f←MINIMUMe</td><td>Description: Umberto has a large collection of ties and match- ing pocket squares—too large, his wife says—and he needs to sell one pair. Given their values as arrays t and p,assuming that he sells the cheapest pair, and selling costs 2,how much will he lose from the sale?</td></tr><tr><td>Program 7: IO example: s←[int] Input: p←[int] [4723], C ← SCANL1（+）p [2131] d ←ZIPWITH（*）S C Output: e←SUMd 62</td><td>Description: Zack always promised his n friends to buy them candy, but never did. Now he won the lottery and counts how often and how much candy he promised to his friends,obtaining arrays p (num- ber of promises) and s (number of promised sweets). He announces that to repay them,he will buy s[1]+s[2]+...+s[n] pieces of candy for the firstp[1]days,thens[2]+s[3]+...+s[n]for p[2] days,and so on,until he has fulfilled all promises. How much candy will he buy in total?</td></tr><tr><td>Program 8: IO example: s←[int] Input: b ←REVERSE S [12457] C ←ZIPWITH（-）b s Output: d ←FILTER（&gt;O）C 9 e←SuMd</td><td>Description: Vivian loves rearranging things.Most of all,when she sees a row of heaps, she wants to make sure that each heap has more items than the one to its left. She is also obsessed with efficiency, so always moves the least possible number of items.Her dad really dislikes if she changes the size of heaps,so she only moves single items between them,making sure that the set of sizes of the heaps is the same as at the start; they are only in a different order. When you come in, you see heaps of sizes (of course,sizes strictly monotonically increasing）s[O]，s[1]，... s[n].What is the maximal number of items that Vivian could have moved?</td></tr></table>
+
+![](images/6d29878119ef08e20bad2e228bb9a4b1140e7a88251e4c13cbe46fb4f2478484.jpg)  
+Fig. 4 shows the predictions made by a neural network trained on programs of length $T = 4$ that were ensured to be semantically disjoint from all 9 example programs shown in this section. For each task, the neural network was provided with 5 input-output examples.   
+Figure 4: Predictions of a neural network on the 9 example programs described in this section. Numbers in squares would ideally be close to 1 (function is present in the ground truth source code), whereas all other numbers should ideally be close to 0 (function is not needed).
+
+# B EXPERIMENTAL RESULTS
+
+Results presented in Sect. 5.1 showcased the computational speedups obtained from the LIPS framework (using DeepCoder), as opposed to solving each program synthesis problem with only the information about global incidence of functions in source code available. For completeness, here we show plots of raw computation times of each search procedure to solve a given number of problems.
+
+Fig. 5 shows the computation times of DFS, of Enumerative search with a Sort and add scheme, of the $\lambda ^ { 2 }$ and Sketch solvers with a Sort and add scheme, and of Beam search, when searching for a program consistent with input-output examples generated from $P = 5 0 0$ different test programs of length $T = 3$ . As discussed in Sect. 5.1, these test programs were ensured to be semantically disjoint from all programs used to train the neural networks, as well as from all programs of shorter length (as discussed in Sect. 4.2).
+
+![](images/69617f5d9c5e8b7b5a7be3c5b88b0456a2865590e84e41413e9067abe2f41f17.jpg)  
+Figure 5: Number of test problems solved versus computation time.
+
+The “steps” in the results for Beam search are due to our search strategy, which doubles the size of the considered beam until reaching the timeout (of 1000 seconds) and thus steps occur whenever the search for a beam of size $2 ^ { k }$ is finished. For $\dot { \lambda ^ { 2 } }$ , we observed that no solution for a given set of allowed functions was ever found after about 5 seconds (on the benchmark machines), but that $\lambda ^ { 2 }$ continued to search. Hence, we introduced a hard timeout after 6 seconds for all but the last iterations of our Sort and add scheme.
+
+Fig. 6 shows the computation times of DFS, Enumerative search with a Sort and add scheme, and $\lambda ^ { 2 }$ with a Sort and add scheme when searching for programs consistent with input-output examples generated from $P = 1 0 0$ different test programs of length $T = 5$ . The neural network was trained on programs of length $T = 4$ .
+
+![](images/8d83b6177f99db604465ccbe078168c96645752256eb9f14da14c4754aa158fd.jpg)  
+Figure 6: Number of test problems solved versus computation time.
+
+# C THE NEURAL NETWORK
+
+As briefly described in Sect. 4.3, we used the following simple feed-forward architecture encoder:
+
+• For each input-output example in the set generated from a single ground truth program:
+
+– Pad arrays appearing in the inputs and in the output to a maximum length $L = 2 0$ with a special NULL value.   
+– Represent the type (singleton integer or integer array) of each input and of the output using a one-hot-encoding vector. Embed each integer in the valid integer range $( - 2 5 6$ to 255) using a learned embedding into $E = 2 0$ dimensional space. Also learn an embedding for the padding NULL value.
+
+– Concatenate the representations of the input types, the embeddings of integers in the inputs, the representation of the output type, and the embeddings of integers in the output into a single (fixed-length) vector. – Pass this vector through $H = 3$ hidden layers containing $K = 2 5 6$ sigmoid units each.
+
+• Pool the last hidden layer encodings of each input-output example together by simple arithmetic averaging.
+
+Fig. 7 shows a schematic drawing of this encoder architecture, together with the decoder that performs independent binary classification for each function in the DSL, indicating whether or not it appears in the ground truth source code.
+
+![](images/1b4ae4043ae84d4ac119b02713a27cb85173d4a2d0a85116dc32199039ab2623.jpg)  
+Figure 7: Schematic representation of our feed-forward encoder, and the decoder.
+
+While DeepCoder learns to embed integers into a $E = 2 0$ dimensional space, we built the system up gradually, starting with a $E = 2$ dimensional space and only training on programs of length $T = 1$ . Such a small scale setting allowed easier investigation of the workings of the neural network, and indeed Fig. 8 below shows a learned embedding of integers in $\mathbb { R } ^ { 2 }$ . The figure demonstrates that the network has learnt the concepts of number magnitude, sign (positive or negative) and evenness, presumably due to FILTER $( > 0 )$ , FILTER $( < 0 )$ , FILTER ( $\scriptstyle { \frac { 0 } { 0 } } 2 = = 0$ ) and FILTER ( $\scriptstyle { \frac { 0 } { 0 } } 2 = = 1$ ) all being among the programs on which the network was trained.
+
+# D DEPTH-FIRST SEARCH
+
+We use an optimized $\mathrm { C } { + } { + }$ implementation of depth-first search (DFS) to search over programs with a given maximum length $T$ . In depth-first search, we start by choosing the first function (and its arguments) of a potential solution program, and then recursively consider all ways of filling in the rest of the program (up to length $T$ ), before moving on to a next choice of first instruction (if a solution has not yet been found).
+
+A program is considered a solution if it is consistent with all $M = 5$ provided input-output examples. Note that this requires evaluating all candidate programs on the $M$ inputs and checking the results for equality with the provided $M$ respective outputs. Our implementation of DFS exploits the sequential structure of programs in our DSL by caching the results of evaluating all prefixes of the currently considered program on the example inputs, thus allowing efficient reuse of computation between candidate programs with common prefixes.
+
+This allows us to explore the search space at roughly the speed of $\sim 3 \times 1 0 ^ { 6 }$ programs per second.
+
+![](images/94148f752106bd924a4f80c9c825128a3efe588caf08184e8765377bb5e169db.jpg)  
+Figure 8: A learned embedding of integers $\{ - 2 5 6 , - 2 5 5 , \ldots , - 1 , 0 , 1 , \ldots , 2 5 5 \}$ in $\mathbb { R } ^ { 2 }$ . The color intensity corresponds to the magnitude of the embedded integer.
+
+When the search procedure extends a partial program by a new function, it has to try the functions in the DSL in some order. At this point DFS can opt to consider the functions as ordered by their predicted probabilities from the neural network. The probability of a function consisting of a higherorder function and a lambda is taken to be the minimum of the probabilities of the two constituent functions.
+
+# E TRAINING LOSS FUNCTION
+
+In Sect. 4.5 we outlined a justification for using marginal probabilities of individual functions as a sensible intermediate representation to provide a solver employing a Sort and add scheme (we considered Enumerative search and the Sketch solver with this scheme). Here we provide a more detailed discussion.
+
+Predicting program components from input-output examples can be cast as a multilabel classification problem, where each instance (set of input-output examples) is associated with a set of relevant labels (functions appearing in the code that generated the examples). We denote the number of labels (functions) by $C$ , and note that throughout this work $C = 3 4$ .
+
+When the task is to predict a subset of labels $\mathbf { y } \in \{ 0 , 1 \} ^ { C }$ , different loss functions can be employed to measure the prediction error of a classifier $\mathbf { h } ( \mathbf { x } )$ or ranking function $\mathbf { f } \left( \mathbf { x } \right)$ . Dembczynski et al. (2010) discuss the following three loss functions:
+
+• Hamming loss counts the number of labels that are predicted incorrectly by a classifier h:
+
+$$
+L _ { H } ( \mathbf { y } , \mathbf { h } ( \mathbf { x } ) ) = \sum _ { c = 1 } ^ { C } \mathbb { 1 } _ { \{ y _ { c } \neq h _ { c } ( \mathbf { x } ) \} }
+$$
+
+• Rank loss counts the number of label pairs violating the condition that relevant labels are ranked higher than irrelevant ones by a scoring function f:
+
+$$
+L _ { r } ( \mathbf { y } , \mathbf { f } ( \mathbf { x } ) ) = \sum _ { ( i , j ) : y _ { i } = 1 , y _ { j } = 0 } ^ { C } \mathbb { 1 } _ { \{ f _ { i } < f _ { j } \} }
+$$
+
+• Subset Zero-One loss indicates whether all labels have been correctly predicted by $\mathbf { h }$ :
+
+$$
+L _ { s } ( \mathbf { y } , \mathbf { h } ( \mathbf { x } ) ) = \mathbb { 1 } _ { \{ \mathbf { y } \neq \mathbf { h } ( \mathbf { x } ) \} }
+$$
+
+Dembczynski et al. (2010) proved that Bayes optimal decisions under the Hamming and Rank loss functions, i.e., decisions minimizing the expected loss under these loss functions, can be computed from marginal probabilities $p _ { c } ( y _ { c } | \mathbf { x } )$ . This suggests that:
+
+• Multilabel classification under these two loss functions may not benefit from considering dependencies between the labels.   
+• ”Instead of minimizing the Rank loss directly, one can simply use any approach for single label prediction that properly estimates the marginal probabilities.” (Dembczynski et al., ´ 2012)
+
+Training the neural network with the negative cross entropy loss function as the training objective is precisely a method for properly estimating the marginal probabilities of labels (functions appearing in source code). It is thus a sensible step in preparation for making predictions under a Rank loss.
+
+It remains to discuss the relationship between the Rank loss and the actual quantity we care about, which is the total runtime of a Sort and add search procedure. Recall the simplifying assumption that the runtime of searching for a program of length $T$ with $C$ functions made available to the search is proportional to $C ^ { T }$ , and consider a Sort and add search for a program of length $T$ , where the size of the active set is increased by 1 whenever the search fails. Starting with an active set of size 1, the total time until a solution is found can be upper bounded by
+
+$$
+1 ^ { T } + 2 ^ { T } + \cdot \cdot \cdot + C _ { A } ^ { T } \leq C _ { A } ^ { T + 1 } \leq C C _ { A } ^ { T }
+$$
+
+where $C _ { A }$ is the size of the active set when the search finally succeeds (i.e., when the active set finally contains all necessary functions for a solution to exist). Hence the total runtime of a Sort and add search can be upper bounded by a quantity that is proportional to $C _ { A } ^ { T }$ .
+
+Now fix a valid program solution $P$ that requires $C _ { P }$ functions, and let $\mathbf { y } _ { P } \in \{ 0 , 1 \} ^ { C }$ be the indicator vector of functions used by $P$ . Let $D : = C _ { A } - C _ { P }$ be the number of redundant operations added into the active set until all operations from $P$ have been added.
+
+Example 1. Suppose the labels, as sorted by decreasing predicted marginal probabilities $\mathbf { f } \left( \mathbf { x } \right)$ , are as follows:
+
+$$
+\begin{array} { r l r l r } { 1 \mathrm { ~ 1 ~ 1 ~ 1 ~ } } & { { } } & { 1 } &  \qquad 1 \mathrm  ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 ~ 0 0 ~ 0 ~ 0 ~ 0 ~ 0 0  \end{array}
+$$
+
+Then the solution $P$ contains $C _ { P } = 6$ functions, but the active set needs to grow to size $C _ { A } = 1 1$ to include all of them, adding $D = 5$ redundant functions along the way. Note that the rank loss of the predictions $\mathbf { f } \left( \mathbf { x } \right)$ is $L _ { r } ( \mathbf { y } _ { P } , \mathbf { f } ( \mathbf { x } ) ) = 2 + 5 = 7$ , as it double counts the two redundant functions which are scored higher than two relevant labels.
+
+Noting that in general $L _ { r } ( \mathbf { y } _ { P } , \mathbf { f } ( \mathbf { x } ) ) \ge D$ , the previous upper bound on the runtime of Sort and add can be further upper bounded as follows:
+
+$$
+C _ { A } ^ { T } = ( C _ { P } + D ) ^ { T } \leq \mathrm { c o n s t } + \mathrm { c o n s t } \times D ^ { T } \leq \mathrm { c o n s t } + \mathrm { c o n s t } \times L _ { r } ( \mathbf { y } _ { P } , \mathbf { f } ( \mathbf { x } ) ) ^ { T }
+$$
+
+Hence we see that for a constant value of $T$ , this upper bound can be minimized by optimizing the Rank loss of the predictions $\mathbf { f } \left( \mathbf { x } \right)$ . Note also that $\bar { L _ { r } } ( { \bf y } _ { P } , { \bf f } ( { \bf x } ) ) = 0$ would imply $D = 0$ , in which case $C _ { A } = C _ { P }$ .
+
+# F DOMAIN SPECIFIC LANGUAGE OF DEEPCODER
+
+Here we provide a description of the semantics of our DSL from Sect. 4.1, both in English and as a Python implementation. Throughout, NULL is a special value that can be set e.g. to an integer outside the working integer range.
+
+First-order functions:
+
+• HEAD :: [int] -> int lambda xs: xs[0] if len $( \mathbf { \nabla } _ { \mathbf { X } } \mathbf { S } \mathbf { \nabla } ) > 0$ else Null Given an array, returns its first element (or NULL if the array is empty).   
+• LAST :: [int] $- >$ int lambda xs: xs[-1] if len $( \mathbf { \nabla } _ { \mathbf { X } } \mathbf { s } ) > 0$ else Null Given an array, returns its last element (or NULL if the array is empty).   
+• TAKE :: int $- >$ [int] -> int lambda n, xs: xs[:n] Given an integer n and array xs, returns the array truncated after the $\boldsymbol { \mathrm { n } }$ -th element. (If the length of xs was no larger than n in the first place, it is returned without modification.)   
+• DROP :: int $- >$ [int] $- >$ int lambda n, xs: xs[n:] Given an integer n and array $_ { \textrm { x S } }$ , returns the array with the first n elements dropped. (If the length of xs was no larger than n in the first place, an empty array is returned.)   
+• ACCESS :: int $- >$ [int] $- >$ int lambda n, xs: xs[n] if $\mathrm { n } > = 0$ and len $( \mathsf { x s } ) > \mathsf { n }$ else Null Given an integer n and array $_ { \textrm { x S } }$ , returns the $( \mathrm { n } { + } 1 )$ -st element of $_ { \textrm { x S } }$ . (If the length of xs was less than or equal to $\boldsymbol { \mathrm { n } }$ , the value NULL is returned instead.)   
+• MINIMUM :: [int] $- >$ int lambda xs: min(xs) if len $( \mathbf { \nabla } _ { \mathbf { X } } \mathbf { S } ) > 0$ else Null Given an array, returns its minimum (or NULL if the array is empty).   
+• MAXIMUM :: [int] $- >$ int lambda xs: max(xs) if len $( \mathbf { \nabla } _ { \mathbf { X } } \mathbf { S } ) > 0$ else Null Given an array, returns its maximum (or NULL if the array is empty). REVERSE :: [int] $- >$ [int] lambda xs: list(reversed(xs)) Given an array, returns its elements in reversed order.   
+• SORT :: [int] -> [int] lambda xs: sorted(xs) Given an array, return its elements in non-decreasing order. SUM :: [int] $- >$ int lambda xs: sum(xs) Given an array, returns the sum of its elements. (The sum of an empty array is 0.)
+
+Higher-order functions:
+
+• MAP :: (int -> int) -> [int] -> [int] lambda f, xs: [f(x) for x in xs] Given a lambda function f mapping from integers to integers, and an array xs, returns the array resulting from applying f to each element of xs.   
+• FILTER :: (int $- >$ bool) $- >$ [int] -> [int] lambda f, xs: [x for x in xs if f(x)] Given a predicate f mapping from integers to truth values, and an array xs, returns the elements of xs satisfying the predicate in their original order.   
+• COUNT :: (int $- >$ bool) $- >$ [int] $- >$ int lambda f, xs: len([x for x in xs if f(x)]) Given a predicate f mapping from integers to truth values, and an array xs, returns the number of elements in xs satisfying the predicate.   
+• ZIPWITH :: (int $- >$ int $- >$ int) $- >$ [int] -> [int] -> [int] lambda f, xs, ys: [f(x, y) for (x, y) in zip(xs, ys)] Given a lambda function f mapping integer pairs to integers, and two arrays xs and ys, returns the array resulting from applying f to corresponding elements of xs and ys. The length of the returned array is the minimum of the lengths of $_ { \textrm { x S } }$ and ys. SCANL1 :: (int $- >$ int $- >$ int) $- >$ [int] -> [int] Given a lambda function f mapping integer pairs to integers, and an array $_ { \textrm { x S } }$ , returns an array ys of the same length as xs and with its content defined by the recurrence $\begin{array} { r l } { \mathrm { y s } \left[ 0 \right] } & { { } = } \end{array}$ $\mathbf { x } \mathbf { s } \left[ 0 \right] , \mathbf { y } \mathbf { s } \left[ \mathrm { n } \right] \mathbf { \Psi } = \mathbf { \Psi } \mathbf { f } \left( \mathbf { y } \mathbf { s } \left[ \mathrm { n - 1 } \right] \right.$ , $\mathtt { x s } [ \mathtt { n } ]$ ) for $n \geq 1$ .
+
+The INT INT lambdas $\left( + 1 \right) , \left( - 1 \right) , \left( \star 2 \right) , \left( / 2 \right) , \left( \star \left( - 1 \right) \right) , \left( \star \star 2 \right) , \left( \star 3 \right) , \left( / 3 \right) , \left( \star 4 \right) , \left( / 4 \right) , \left( \star 3 \right) , \left( \star 4 \right) .$ ) provided by our DSL map integers to integers in a self-explanatory manner. The $\mathrm { I N T } {  } \mathrm { B O O L }$ lambdas $( > 0 )$ , $( < 0 )$ , ( $\scriptstyle { \frac { 0 } { 0 } } 2 = = 0$ ), ( $\scriptstyle { \frac { 0 } { 0 } } 2 = = 1$ ) respectively test positivity, negativity, evenness and oddness of the input integer value. Finally, the $\mathrm { I N T } {  } \mathrm { I N T } {  } \mathrm { I N T }$ lambdas $( + ) , ( - ) , ( \star )$ , MIN, MAX apply a function to a pair of integers and produce a single integer.
+
+As an example, consider the function SCANL1 MAX, consisting of the higher-order function SCANL1 and the $\mathrm { I N T } {  } \mathrm { I N T } {  } \mathrm { I N T }$ lambda MAX. Given an integer array a of length $L$ , this function computes the running maximum of the array a. Specifically, it returns an array $\mathrm { b }$ of the same length $L$ whose $i$ -th element is the maximum of the first $i$ elements in $\exists$ .
+
+![](images/da5620eb6e4f0a76e4439147498cbeb617797fc9a1d092bb07c51b51e15fdcb8.jpg)  
+Figure 9: Conditional confusion matrix for the neural network and test set of $P = 5 0 0$ programs of length $T = 3$ that were used to obtain the results presented in Table 1. Each cell contains the average false positive probability (in larger font) and the number of test programs from which this average was computed (smaller font, in brackets). The color intensity of each cell’s shading coresponds to the magnitude of the average false positive probability.
+
+# G ANALYSIS OF TRAINED NEURAL NETWORKS
+
+We analyzed the performance of trained neural networks by investigating which program instructions tend to get confused by the networks. To this end, we looked at a generalization of confusion matrices to the multilabel classification setting: for each attribute in a ground truth program (rows) measure how likely each other attribute (columns) is predicted as a false positive. More formally, in this matrix the $( i , j )$ -entry is the average predicted probability of attribute $j$ among test programs that do possess attribute $i$ and do not possess attribute $j$ . Intuitively, the $i$ -th row of this matrix shows how the presence of attribute $i$ confuses the network into incorrectly predicting each other attribute $j$ .
+
+Figure 9 shows this conditional confusion matrix for the neural network and $P = 5 0 0$ program test set configuration used to obtain Table 1. We re-ordered the confusion matrix to try to expose block structure in the false positive probabilities, revealing groups of instructions that tend to be difficult to distinguish. Figure 10 show the conditional confusion matrix for the neural network used to obtain the table in Fig. 3a. While the results are somewhat noisy, we observe a few general tendencies:
+
+• There is increased confusion amongst instructions that select out a single element from an array: HEAD, LAST, ACCESS, MINIMUM, MAXIMUM.   
+• Some common attributes get predicted more often regardless of the ground truth program: FILTER, $( > 0 )$ ), $( < 0 )$ , ( $\scriptstyle { \frac { \circ } { \circ } } 2 = = 1$ ), ( $\scriptstyle { \frac { 0 } { \circ } } 2 = = 0$ ), MIN, MAX, (+), (-), ZIPWITH.   
+There are some groups of lambdas that are more difficult for the network to distinguish within: $( + )$ vs $( - ) ~ ; ~ ( + 1 )$ vs $( - 1 ) \ ; \ ( \ / 2 )$ vs (/3) vs (/4).   
+• When a program uses $( \star \star 2 )$ , the network often thinks it’s using $( \star )$ , presumably because both can lead to large values in the output.
+
+![](images/a2f6e1ddd3c6cc3aed7aca84775a0568e1abe730347297f96f96da4cfd262c8d.jpg)
+
+Figure 10: Conditional confusion matrix for the neural network and test set of $P = 5 0 0$ programs of length $T = 5$ . The presentation is the same as in Figure 9.

parse/train/ByxXZpVtPB/ByxXZpVtPB.md

@@ -0,0 +1,204 @@
+# HOMOGENEOUS LINEAR INEQUALITY CONSTRAINTS FOR NEURAL NETWORK ACTIVATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a method to impose homogeneous linear inequality constraints of the form $A x \le 0$ on neural network activations. The proposed method allows a datadriven training approach to be combined with modeling prior knowledge about the task. One way to achieve this task is by means of a projection step at test time after unconstrained training. However, this is an expensive operation. By directly incorporating the constraints into the architecture, we can significantly speed-up inference at test time; for instance, our experiments show a speed-up of up to two orders of magnitude over a projection method. Our algorithm computes a suitable parameterization of the feasible set at initialization and uses standard variants of stochastic gradient descent to find solutions to the constrained network. Thus, the modeling constraints are always satisfied during training. Crucially, our approach avoids to solve an optimization problem at each training step or to manually trade-off data and constraint fidelity with additional hyperparameters. We consider constrained generative modeling as an important application domain and experimentally demonstrate the proposed method by constraining a variational autoencoder.
+
+# 1 INTRODUCTION
+
+Deep learning models (LeCun et al., 2015) have demonstrated remarkable success in tasks that require exploitation of subtle correlations, such as computer vision (Krizhevsky et al., 2012) and sequence learning (Sutskever et al., 2014). Typically, humans have strong prior knowledge about a task, e.g., based on symmetry, geometry, or physics. Learning such a priori assumptions in a purely data-driven manner is inefficient and, in some situations, may not be feasible at all. While certain prior knowledge was successfully imposed – for example translational symmetry through convolutional architectures (LeCun et al., 1998) – incorporating more general modeling assumptions in the training of deep networks remains an open challenge. Recently, generative neural networks have advanced significantly (Goodfellow et al., 2014; Kingma & Welling, 2014). With such models, controlling the generative process beyond a data-driven, black-box approach is particularly important.
+
+In this paper, we present a method to impose prior knowledge through homogeneous linear inequality constraints of the form $A x \le 0$ on the activations of deep learning models. We directly impose these constraints through a suitable parameterization of the feasible set. This has several advantages:
+
+• The constraints are hard-constraints in the sense that they are satisfied at any point during training and inference.   
+• Inference on the constrained network incurs no overhead compared to unconstrained inference.   
+• There is no manual trade-off between constraint satisfaction and data representation.
+
+In summary, the main contribution of our method is a reparameterization that incorporates homogeneous linear inequality hard-constraints on neural network activations and allows for efficient test time predictions, i.e., our method is faster up to two orders of magnitude. The model can be optimized by standard variants of stochastic gradient descent. As an application in generative modeling, we demonstrate that our method is able to produce authentic samples from a variational autoencoder while satisfying the imposed constraints.
+
+![](images/6ff2de8059afd1546259716b3fa3bcc6f284f19dca82e98544dec5426da694f1.jpg)  
+Figure 1: Samples drawn from a variational autoencoder trained on MNIST without constraints (left) and with a checkerboard constraint on the output domain (right). For a pixel intensity domain $[ - 1 , 1 ]$ , the checkerboard constraint forces the image tiles to have average positive or negative brightness.
+
+# 2 RELATED WORK
+
+Various works have introduced methods to impose some type of hard constraint on neural network activations. This differs from a classical constrained optimization problem (Nocedal & Wright, 2006) in that the constraints are on the image of a parameterized function rather than on the neural network parameters.
+
+Marquez-Neila et al. (2017) formulated generic differentiable equality constraints as soft constraints ´ and employed a Lagrangian approach to train their model. While this is a principled approach to constrained optimization, it does not scale well to practical deep neural network models with their vast number of parameters. To make their method computationally tractable, a subset of the constraints is selected at each training step. In addition, these constraints are locally linearized; thus, there is no guarantee that this subset will be satisfied after a parameter update.
+
+For the specific problem of weakly supervised segmentation, Pathak et al. (2015) proposed an optimization scheme that alternates between optimizing the deep learning model and fitting a constrained distribution to these intermediate models. However, this method involves solving a (convex) optimization problem at each training step. Furthermore, the overall convergence path depends on how the alternating optimization steps are combined, which introduces an additional hyperparameter that must be tuned. Briq et al. (2018) approached the weakly supervised segmentation problem with a layer that implements the orthogonal projection onto a simplex, thereby directly constraining the activations to a probability distribution. This optimization problem can be solved efficiently, but does not generalize to other types of inequality constraints.
+
+OptNet, an approach to solve a generic quadratic program as a differentiable network layer, was proposed by Amos & Kolter (2017). OptNet backpropagates through the first-order optimality conditions of the quadratic program, and linear inequality constraints can be enforced as a special case. The formulation is flexible; however, it scales cubically with the number of variables and constraints. Thus, it becomes prohibitively expensive to train large-scale deep learning models.
+
+Finally, several works have proposed handcrafted solutions for specific applications, such as skeleton prediction (Zhou et al., 2016) and prediction of rigid body motion (Byravan & Fox, 2017). In contrast, to avoid laborious architecture design, we argue for the value of generically modeling constraint classes. In practice, this makes constraint methods more accessible for a broader class of problems.
+
+Contribution In this work, we tackle the problem of imposing homogeneous linear inequality constraints on neural network activations. Rather than solving an optimization problem during training, we split this task into a feasibility step at initialization and an optimality step during training. At initialization, we compute a suitable parameterization of the constraint set (a polyhedral cone) and use the neural network training algorithm to find a good solution within this feasible set. Conceptually, we are trading-off computational cost during initialization to obtain a model that has no overhead at test time. The proposed method is implemented as a neural network layer that is specified by a set of homogeneous linear inequalities and whose output parameterizes the feasible set.
+
+We consider a generic $L$ layer neural network $F _ { \theta }$ with model parameters $\theta$ for inputs $x$ as follows:
+
+$$
+F _ { \theta } ( x ) = f _ { \theta _ { L } } ^ { ( L ) } ( \sigma ( f _ { \theta _ { L - 1 } } ^ { ( L - 1 ) } ( \sigma ( \dots f _ { \theta _ { 1 } } ^ { ( 1 ) } ( x ) \dots ) ) ) ) ,
+$$
+
+where $f _ { \theta _ { l } } ^ { ( l ) }$ are affine functions, e.g., a fully-connected or convolutional layer, and $\sigma$ is an elementwise non-linearity1, e.g., a sigmoid or rectified linear unit (ReLU). In supervised learning, training targets $y$ are known and a loss $\mathcal { L } _ { y } ( F _ { \theta } ( x ) )$ is minimized as a function of the network parameters $\theta$ . A typical loss for a classification task is the cross entropy between the network output and the empirical target distribution, while the mean-squared error is commonly used for a regression task. The proposed method can be applied to constrain any linear activations $z ^ { ( l ) } = f _ { \theta _ { l } } ^ { ( l ) } ( a ^ { ( l - 1 ) } )$ or non-linear activations $a ^ { ( l ) } = \sigma ( z ^ { ( l ) } )$ . In most cases, one would like to constrain the output $F _ { \theta } ( x )$ .
+
+The feasible set for $m$ linear inequality constraints in $d$ dimensions is the convex polyhedron
+
+$$
+\mathcal { C } : = \left\{ z \bigg | A z \leq b , A \in \mathbb { R } ^ { m \times d } , b \in \mathbb { R } ^ { m } \right\} \subseteq \mathbb { R } ^ { d } .
+$$
+
+A suitable description of the convex polyhedron $\mathcal { C }$ is obtained by the decomposition theorem for polyhedra.
+
+Theorem 1 (Decomposition of polyhedra, Minkowski-Weyl). $A$ set $\mathcal { C } \subset \mathbb { R } ^ { d }$ is a convex polyhedron of the form (2) if and only $i f$
+
+$$
+\begin{array} { l } { { \displaystyle { \mathcal C } = \mathrm { c o n v } \big ( \upsilon _ { 1 } , \ldots , \upsilon _ { n } \big ) + \mathrm { c o n e } \big ( r _ { 1 } , \ldots , r _ { s } \big ) } \ ~ } \\ { { \displaystyle ~ = \left\{ \sum _ { i = 1 } ^ { n } \lambda _ { i } \upsilon _ { i } + \sum _ { j = 1 } ^ { s } \mu _ { j } r _ { j } \bigg | \lambda _ { i } , \mu _ { j } \geq 0 , \sum _ { i = 1 } ^ { n } \lambda _ { i } = 1 \right\} } \ } \end{array}
+$$
+
+for finitely many vertices $\{ v _ { 1 } , \ldots , v _ { n } \}$ and rays $\{ r _ { 1 } , \ldots , r _ { s } \}$
+
+Furthermore, $\mathcal { C } = \left\{ z | A z \leq 0 , A \in \mathbb { R } ^ { m \times d } \right\}$ if and only if
+
+$$
+\mathcal { C } = \mathrm { c o n e } ( r _ { 1 } , . . . , r _ { s } )
+$$
+
+for finitely many rays $\{ r _ { 1 } , \ldots , r _ { s } \}$
+
+The theorem states that an intersection of half-spaces (half-space or $\mathrm { H } \cdot$ -representation) can be written as the Minkowski sum of a convex combination of the polyhedron’s vertices and a conical combination of some rays (vertex or $\mathrm { V } .$ -representation). One can switch algorithmically between these two viewpoints via the double description method (Motzkin et al., 1953; Fukuda & Prodon, 1996), which we discuss in the following. Thus, the $\mathrm { H }$ -representation, which is natural when modeling inequality constraints, can be transformed into the V-representation, which can be incorporated into gradient-based neural network training.
+
+In this paper, we focus on homogeneous constraints of the form (4), for which the feasible set is a polyhedral cone. Due to the special structure of this set, we can avoid to work with the convex combination parameters in (3), which is numerically advantageous (Section 3.5), and we can efficiently combine modeling constraints and domain constraints, such as a $[ - 1 , 1 ]$ -pixel domain for images (Section 3.3). Such a polyhedral cone is shown in Figure 2.
+
+# 3.1 DOUBLE DESCRIPTION METHOD
+
+The double description method converts between the half-space and vertex representation of a system of linear inequalities. It was originally proposed by Motzkin et al. (1953) and further refined by Fukuda & Prodon (1996).2 Here, we are only interested in the conversion from $\mathrm { H } \cdot$ -representation to V-representation for homogeneous constraints (4),
+
+$$
+\mathcal { H } \to \mathrm { c o n e } ( r _ { 1 } , \dots , r _ { s } ) \ .
+$$
+
+![](images/e34f7d5efaaf63be07414ce913edd9a6616ef7e1dcd0ac505ab2653737bf016f.jpg)  
+Figure 2: Diagram illustrating an iteration of the double description method. Adding a constraint to the $k$ -constraint set $A ^ { k }$ at iteration $k + 1$ introduces a hyperplane $H$ . The intersection points of $H$ with the boundary of the current polyhedron $R ^ { k }$ (marked by $\circ ^ { \prime }$ ) are added as rays $r _ { 6 }$ and $r _ { 7 }$ to the polyhedral cone. The ray $r _ { 2 }$ is cut-off by the hyperplane $H$ and is removed from $R ^ { k }$ . The result is the next iterate Rk+1.
+
+The core algorithm proceeds as follows. Let the rows of $A$ define a set of homogeneous inequalities and let $R = [ r _ { 1 } , \ldots , r _ { s } ]$ be the matrix whose columns are the rays of the corresponding cone. Here, $( A , R )$ form a double description pair. The algorithm iteratively builds a double description pair $( A ^ { k + 1 } , R ^ { k + 1 } )$ from $( A ^ { k } , R ^ { k } )$ in the following manner. The rows in $A ^ { k }$ represent a $k$ -subset of the rows of $A$ and thus define a convex polyhedron associated with $R ^ { k }$ . Adding a single row to $A ^ { k }$ introduces an additional half-space constraint, which corresponds to a hyperplane. If the vector $r _ { i } - r _ { j }$ for two columns $r _ { i } , r _ { j }$ of $\bar { \boldsymbol { R } } ^ { k }$ intersects with this hyperplane then this intersection point is added to $R ^ { k }$ . Existing rays that are cut-off by the additional hyperplane are removed from $R ^ { k }$ . The result is the double description pair $( A ^ { k + 1 } , \dot { R } ^ { k + 1 } )$ . This procedure is shown in Figure 2.
+
+Adding a hyperplane might drastically increase the number of rays in intermediate representations, which, in turn, contribute combinatorically in the subsequent iteration. In fact, there exist worst case polyhedra for which the algorithm has exponential run time as a function of the number of inequalities and the input dimension, as well as the number of rays (Dyer, 1983; Bremner, 1999). Overall, one can expect the algorithm to be efficient only for problems with a reasonably small number $m$ of inequalities and dimension $d$ .
+
+# 3.2 INTEGRATION IN NEURAL NETWORK ARCHITECTURES
+
+We parameterize the homogeneous form (4) via a neural network layer. This layer takes as input some (latent) representation of the data, which is mapped to activations satisfying the desired hard constraints. The algorithm is provided with the $_ \mathrm { H }$ -representation of linear inequality constraints, i.e., a matrix $A \in \breve { \mathbb { R } } ^ { m \times d }$ for $m$ constraints in $d$ dimensions to specify the feasible set (4). At initialization, we convert this to the $\mathrm { V } .$ -representation via the double description method (Section 3.1). This corresponds to computing the set of rays $\{ r _ { 1 } , \ldots , r _ { s } \}$ to represent the polyhedral cone. During training, the neural network training algorithm is used to optimize within in the feasible set. There are two critical aspects in this procedure. First, as outlined in Section 3.1, the run-time complexity of the double description method may be prohibitive. Conceptually, the proposed approach allows for significant compute time at initialization to obtain an algorithm that is very efficient at training and test time. Second, we must ensure that the mapping from the latent representation to the parameters integrates well with the training algorithm. We assume that the model is trained with gradient-based backpropagation, as is common for current deep learning applications. The constraint layer comprises a batch normalization layer and an affine mapping (fully-connected layer with biases) followed by the element-wise absolute value function that ensures the non-negativity required by the conical combination parameters. In theory, any function $f : \mathbb { R } \to \mathbb { R } _ { \geq 0 }$ would fulfill this requirement; however, care must be taken to not interfere with backpropagated gradients.
+
+# 3.3 COMBINING MODELING AND DOMAIN CONSTRAINTS
+
+Domain constraints are often formulated as unit box constraints, $B : = \{ x \in \mathbb { R } ^ { d } | - 1 \leq x _ { i } \leq 1 \}$ , such as a pixel domain for images. Box constraints are particularly unfit to be converted using the double description method because the number of vertices is exponential in the dimension. Therefore, we distinguish modeling constraints and domain constraints and only convert the former into $\mathrm { V } .$ - representation. Based on this representation, we obtain a point in the modeling constraint set, $x \in { \mathcal { C } }$ . However, this point may not be in the unit box $\boldsymbol { B }$ . To arrive at a point in the intersection $\mathcal { C } \cap \mathcal { B }$ , we normalize $x$ by its infinity norm if $x \notin B$ , $\hat { x } = x / \operatorname* { m a x } \{ \| x \| _ { \infty } , 1 \bar  \}$ . Indeed, $\hat { x } \in \mathcal { C } \cap B$ since scaling by a positive constant remains in the cone, i.e., if $x \in { \mathcal { C } }$ , then $\alpha x \in \mathcal { C } \forall \alpha \geq 0$ .
+
+# 3.4 APPLICATIONS OF HOMOGENEOUS LINEAR INEQUALITY CONSTRAINTS
+
+A natural application of constraints of the form $A x \le 0$ is a parameterization of a set of binary classifiers. If each row $a _ { i }$ of $A$ is such a binary classifier, then the method presented in this paper parameterizes the set $\{ x | a _ { i } ^ { T } x \le 0 \ \forall i \}$ . Consequently, it can be guaranteed that neural network activations satisfy a set of binary criteria. Another domain is to express certain direct relations between neural network activations. Notably, one can guarantee mathematical properties such as monotonicity via $x _ { i + 1 } \geq x _ { i }$ and convexity via $x _ { i + 1 } - 2 x _ { i } + x _ { i - 1 } \geq 0$ .
+
+# 3.5 EXTENSION TO GENERAL LINEAR INEQUALITY CONSTRAINTS
+
+The proposed method takes advantage of the special structure of a polyhedral cone to efficiently combine modeling and domain constraints (Section 3.3). General linear inequality constraints of the form $A x \leq b$ without restrictions on $A$ and $b$ possibly require the conic and convex component of (3) for their $\mathrm { v } .$ -representation. The main approach of this paper may be used in this case, i.e., our layer additionally needs to predict convex combination parameters. However, we observed slow convergence, which we ascribe to the simplex parameterization for the convex combination parameters. We used a softmax function $f ( x ) _ { i } = { \mathrm { { \bar { e x p } } } ( x _ { i } ) } / { \sum _ { j = 1 } ^ { m } \exp ( x _ { j } ) }$ to enforce the constraints $\begin{array} { r } { \lambda _ { i } \ge 0 , \sum _ { i = 1 } ^ { m } \lambda _ { i } = 1 } \end{array}$ of the convex combination parameters in (3). This function has vanishing gradients when one $x _ { i }$ is significantly greater than the other vector entries. Furthermore, this most general setting does not allow for efficient incorporation of domain constraints, as this would require an efficient parameterization of the intersection of a general convex polyhedron and the unit box.
+
+# 4 NUMERICAL RESULTS
+
+We compare the proposed constraint parameterization algorithm with an algorithm that trains without constraints, but requires a projection step at test time. We call this latter algorithm test time projection. We analyze these algorithms in two different settings. In an initial experiment, we learn the orthogonal projection onto a constraint set to demonstrate properties of these algorithms. Here, the result can be compared to the optimal solution of the convex optimization problem. In a second experiment, consistent with our motivation to constrain the output of generative models, we apply these algorithms to a variational autoencoder. Finally, we evaluate the running time of inference for these problems and show that the proposed algorithm is significantly more efficient compared to the test time projection method.
+
+We used the MNIST dataset (LeCun et al.) for both experiments (59000 training, 1000 validation, and 10000 test samples). We chose PyTorch (Paszke et al., 2017) for our implementation3 and all experiments were performed on a single Nvidia Titan X GPU. All networks were optimized with the Adam optimizer and we evaluated learning rates in the range $[ 1 0 ^ { - 5 } , 1 0 ^ { - 3 } ]$ . The initial learning rate was annealed by a factor of $1 / 2$ if progress on the validation loss stagnated for more than 5 epochs. We used OSQP (Stellato et al., 2017) as an efficient solver to compute orthogonal projections.
+
+Both experiments were performed with a checkerboard constraint with 16 tiles, where neighboring tiles are constrained to be on average either below or above pixel domain midpoint. For a $[ - 1 , 1 ]$ -pixel domain, the tiles’ average intensity is positive or negative, respectively. The initial computational cost of converting these constraints into $\mathrm { v } .$ -representation via the double description method is negligible (less than 1s). We observed that it is numerically advantageous to activate unit box scaling after the constraint parameterization model was initially optimized only with modeling constraints for a specified number of epochs.
+
+One might consider OptNet (Amos & Kolter, 2017) and an analogous version of the method introduced by Pathak et al. (2015) as baselines. However, these approaches incur a significant drawback for the setup presented in this paper as they are are computationally expensive at training time. An OptNet layer solves a generic quadratic program as a differentiable network layer, which scales cubically with the number of variables and constraints. The method by Pathak et al. (2015) for the regression problems in this paper alternates between optimization steps in the network parameters via a variant of stochastic gradient descent and projecting the network output onto the constraints, which is computationally expensive.
+
+# 4.1 ORTHOGONAL PROJECTION ONTO A CONSTRAINT SET
+
+We learn an orthogonal projection to demonstrate general properties of both algorithms. For given linear inequalities specified in H-representation, we solve the following problem:
+
+$$
+\operatorname* { m i n } _ { z \in \mathbb { R } ^ { d } } \left\| z - y \right\| _ { 2 } \quad \mathrm { s . t . } A z \leq 0 \qquad ,
+$$
+
+where $y$ is an MNIST image. Here, the problem is convex; therefore, the global optimum can be readily computed and compared to the performance of the learning algorithms. In this setting, we can expect that training an unconstrained network with subsequent projection onto the constraint set at test time yields good results, which can be seen as follows. Let $\begin{array} { r } { \mathcal { P } c ( y ) : = \arg \operatorname* { m i n } _ { z \in \mathcal { C } } \| z - y \| _ { 2 } } \end{array}$ be the orthogonal projection onto the constraint set $\mathcal { C }$ and denote the mean-squared error as $\mathcal { L } _ { y } ( x ) : =$ $\| x - y \| _ { 2 }$ . Both mappings are Lipschitz continuous with Lipschitz constant $L = 1$ . Consequently, for an output $\hat { y }$ of an unconstrained model,
+
+$$
+\begin{array} { r } { \displaystyle \Big | \mathcal { L } _ { y } ( \mathcal { P } _ { \mathcal { C } } ( \hat { y } ) ) - \mathcal { L } _ { y } ( \mathcal { P } _ { \mathcal { C } } ( y ) ) \Big | \le \left\| \mathcal { P } _ { \mathcal { C } } ( \hat { y } ) - \mathcal { P } _ { \mathcal { C } } ( y ) \right\| _ { 2 } \le \left\| \hat { y } - y \right\| _ { 2 } , } \end{array}
+$$
+
+where, by definition, the term $\mathcal { L } _ { y } ( \mathcal { P } c ( y ) )$ is the optimal value of problem (6). The training algorithm fits $\hat { y }$ to $y$ ; therefore, projecting the unconstrained output $\hat { y }$ onto the constraint set will yield an objective value that is close to the optimal value of the constrained optimization problem.
+
+To have a comparable number of parameters for both methods, we use a single fully-connected layer in both cases. For the unconstrained model, we employ an $F C ( 7 8 4 , 7 8 4 )$ layer, and for the constrained model we employ an $F C ( 7 8 4 , n _ { r } )$ layer with $n _ { r } = 1 5 5 2$ many rays to represent the constraint set in V-representation. Additionally, the constraint layer first applies a batch normalization operation (Ioffe & Szegedy, 2015). Both models were optimized with an initial learning rate of $1 0 ^ { - 4 }$ , which was annealed by a factor of 0.1 if progress on the validation loss stagnated for more than 5 epochs. The batch size was chosen to be 256. The unit box constraints were activated after 25 epochs. Additionally, the data for training the model with all constraints being active is shown. This mode eventually results in worse generalization. Figure 3 shows that the mean-squared validation objective for both algorithms converges close to the average optimum. The constraint parameterization method has a larger variance and optimality gap, which hints at the numerical difficulty of training the constrained network. To be precise, the best average validation error during training is within $9 \%$ of the optimum for the constraint parameterization method and within $1 \%$ of the optimum for the test time projection method. Figure 4 shows a test set sample and the respective output of the learned models.
+
+![](images/ccb26edf90e7c914ec8c93ff4de1521e67d3e69261ccf2961a943d7f3e77649f.jpg)  
+Figure 3: Mean-squared validation loss averaged over all pixels for 10 runs; shaded area denotes standard deviation. The objective function (6) is computed on a held-out validation set for the proposed constraint parameterization method and unconstrained optimization with subsequent test time projection. The average optimum over the validation set is obtained as a solution to a convex optimization problem. For the box delay curve, the box constraints are activated after 25 epochs (after $\sim \mathrm { 3 0 s }$ ), which results in better generalization. The best average validation error during training is within $9 \%$ of the optimum for the constraint parameterization method with box constraint delay and within $1 \%$ of the optimum for the test time projection method.
+
+![](images/49fc0106d7c90222b808e52dcf5a411c2b40977fc67fcc1408d6bbddb9492dbf.jpg)  
+Figure 4: Learning to solve the orthogonal projection onto a constraint set as defined in (6). From left to right: MNIST sample from a test set, optimal projection by solving a quadratic program, constraint parameterization model inference, and test time projection model inference.
+
+# 4.2 CONSTRAINED GENERATIVE MODELING WITH VARIATIONAL AUTOENCODERS
+
+Variational autoencoders (VAE) are a class of generative models that are jointly trained to encode observations into latent variables via an encoder or inference network and decode observations from latent variables using a decoder or generative network (Kingma & Welling, 2014). We base our implementation on (Baumgartner, 2018). The model has a fully-connected architecture: ¨
+
+Here, $\mathrm { R e L U } ( x ) = \operatorname* { m a x } ( 0 , x )$ and the sigmoid non-linearity takes the form $\sigma ( x ) = 1 / ( 1 { + } \mathrm { e x p } ( - x ) )$ . In contrast to a standard VAE, we constrain the samples generated by the model to obey a checkerboard constraint. The model was optimized with an initial learning rate of $1 0 ^ { - 4 }$ , which was annealed by a factor of 0.1 if progress on the validation loss stagnated for more than 5 epochs. The batch size was chosen to be 64. The model was trained for 200 epochs while the unit box constraints were activated after 100 epochs. To generate images, we sample the latent space prior $z \sim \mathcal { N } ( 0 , I )$ and evaluate the decoding neural network (Figure 5). The model is able to sample authentic digits while obeying the checkerboard constraint.
+
+# 4.3 FAST INFERENCE WITH CONSTRAINED NEURAL NETWORKS
+
+The main advantage of the proposed method over a simple projection method is a vast speed-up at test time. Since the constraint is incorporated into the neural network architecture, a forward pass has almost no overhead compared to an unconstrained network. On the other hand, for a network that was trained without constraints, a final projection step is necessary; this requires solving a convex optimization problem, which is relatively costly. Table 1 shows inference times for both models for the above numerical experiments. The constraint parameterization approach is up to two orders of magnitude faster at test time compared to the test time projection algorithm.
+
+![](images/02f0cfe4745a3f1d0401396a1e80304dc0a37a9588d7f9d2d50cf658cde58b72.jpg)  
+Figure 5: Samples from a constrained variational autoencoder trained with the test time projection method and our constraint parameterization method. The images represent authentic digits while satisfying the imposed checkerboard constraint. Inference is significantly faster using our method.
+
+Table 1: Inference time for test time projection and constraint parameterization methods. Mean and standard deviation of running times are computed over 100 runs of 59000 samples with a batch size of 256.   
+
+<table><tr><td>METHOD</td><td>PROJECTION</td><td>VAE</td></tr><tr><td>Test time projection</td><td>82±1 s</td><td>40±1s</td></tr><tr><td>Constraint parameterization (ours)</td><td>0.46 ± 0.02 s</td><td>0.75 ± 0.04 s</td></tr></table>
+
+# 5 CONCLUSION
+
+To combine a data-driven task with modeling constraints, we have developed a method to impose homogeneous linear inequality constraints on neural network activations. At initialization, a suitable parameterization is computed and subsequently a standard variant of stochastic gradient descent is used to train the reparameterized network. In this way, we can efficiently guarantee that network activations – in the final or any intermediate layer – satisfy the constraints at any point during training. The main advantage of our method over simply projecting onto the feasible set after unconstrained training is a significant speed-up at test time of up to two orders of magnitude. An important application of the proposed method is generative modeling with prior assumptions. Therefore, we demonstrated experimentally that the proposed method can be used successfully to constrain the output of a variational autoencoder. Our method is implemented as a layer, which is simple to combine with existing and novel neural network architectures in modern deep learning frameworks and is therefore readily available in practice.
+
+# REFERENCES
+
+Brandon Amos and J. Zico Kolter. OptNet: Differentiable optimization as a layer in neural networks. In Proceedings of the 34th International Conference on Machine Learning (ICML 2017), pp. 136– 145, 2017.
+
+Tim Baumgartner.¨ VAE-CVAE-MNIST. https://github.com/timbmg/ VAE-CVAE-MNIST, 2018. commit: e4ba231.
+
+David Bremner. Incremental convex hull algorithms are not output sensitive. Discrete & Computational Geometry, 21(1):57–68, 1999.
+
+Rania Briq, Michael Moeller, and Juergen Gall. Convolutional Simplex Projection Network (CSPN) for Weakly Supervised Semantic Segmentation. BMVC 2018, 2018.
+
+Arunkumar Byravan and Dieter Fox. SE3-nets: Learning rigid body motion using deep neural networks. In 2017 IEEE International Conference on Robotics and Automation (ICRA), 2017.
+
+Martin E. Dyer. The complexity of vertex enumeration methods. Mathematics of Operations Research, 8(3):381–402, 1983.
+
+Komei Fukuda and Alain Prodon. Double description method revisited, pp. 91–111. Combinatorics and Computer Science: 8th Franco-Japanese and 4th Franco-Chinese Conference Brest, France, July 3–5, 1995 Selected Papers. Springer Berlin Heidelberg, 1996.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems 27 (NIPS 2014), pp. 2672–2680. 2014.
+
+Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In Proceedings of the 32nd International Conference on Machine Learning, volume 37, pp. 448–456. PMLR, 07–09 Jul 2015.
+
+Diederik Kingma and Max Welling. Auto-encoding variational bayes. In International Conference on Learning Representations (ICLR 2014), 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. ImageNet classification with deep convolutional neural networks. In Proceedings of the 25th International Conference of Neural Information Processing Systems (NIPS 2012), 2012.
+
+Yann LeCun, Corinna Cortes, and Christopher Burges. The MNIST database of handwritten digits. URL http://yann.lecun.com/exdb/mnist/.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.
+
+Pablo Marquez-Neila, Mathieu Salzmann, and Pascal Fua. Imposing hard constraints on deep net- ´ works: Promises and limitations. First Workshop on Negative Results in Computer Vision, CVPR 2017, 2017.
+
+T. S. Motzkin, H. Raiffa, G. L. Thompson, and R. M. Thrall. The double description method. In Contributions to the Theory of Games II, volume 8 of Ann. of Math. Stud., pp. 51–73. Princeton University Press, 1953.
+
+Jorge Nocedal and Stephen Wright. Numerical Optimization. Springer Series in Operations Research and Financial Engineering. Springer, 2006.
+
+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. Autodiff Workshop, NIPS 2017, 2017.
+
+Deepak Pathak, Philipp Krahenb ¨ uhl, and Trevor Darrell. Constrained Convolutional Neural Net- ¨ works for Weakly Supervised Segmentation. In International Conference on Computer Vision (ICCV 2015), 2015.
+
+Bartolomeo Stellato, Goran Banjac, Paul Goulart, Alberto Bemporad, and Stephen Boyd. OSQP: An Operator Splitting Solver for Quadratic Programs. ArXiv e-prints, 2017.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to Sequence Learning with Neural Networks. In Proceedings of the 27th International Conference of Neural Information Processing Systems (NIPS 2014), 2014.
+
+Xingyi Zhou, Xiao Sun, Wei Zhang, Shuang Liang, and Yichen Wei. Deep Kinematic Pose Regression. Workshop on Geometry Meets Deep Learning, ECCV 2016, 2016.

parse/train/ByxXZpVtPB/ByxXZpVtPB_content_list.json

@@ -0,0 +1,1079 @@
+[
+    {
+        "type": "text",
+        "text": "HOMOGENEOUS LINEAR INEQUALITY CONSTRAINTS FOR NEURAL NETWORK ACTIVATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a method to impose homogeneous linear inequality constraints of the form $A x \\le 0$ on neural network activations. The proposed method allows a datadriven training approach to be combined with modeling prior knowledge about the task. One way to achieve this task is by means of a projection step at test time after unconstrained training. However, this is an expensive operation. By directly incorporating the constraints into the architecture, we can significantly speed-up inference at test time; for instance, our experiments show a speed-up of up to two orders of magnitude over a projection method. Our algorithm computes a suitable parameterization of the feasible set at initialization and uses standard variants of stochastic gradient descent to find solutions to the constrained network. Thus, the modeling constraints are always satisfied during training. Crucially, our approach avoids to solve an optimization problem at each training step or to manually trade-off data and constraint fidelity with additional hyperparameters. We consider constrained generative modeling as an important application domain and experimentally demonstrate the proposed method by constraining a variational autoencoder. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            336,
+            531
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning models (LeCun et al., 2015) have demonstrated remarkable success in tasks that require exploitation of subtle correlations, such as computer vision (Krizhevsky et al., 2012) and sequence learning (Sutskever et al., 2014). Typically, humans have strong prior knowledge about a task, e.g., based on symmetry, geometry, or physics. Learning such a priori assumptions in a purely data-driven manner is inefficient and, in some situations, may not be feasible at all. While certain prior knowledge was successfully imposed – for example translational symmetry through convolutional architectures (LeCun et al., 1998) – incorporating more general modeling assumptions in the training of deep networks remains an open challenge. Recently, generative neural networks have advanced significantly (Goodfellow et al., 2014; Kingma & Welling, 2014). With such models, controlling the generative process beyond a data-driven, black-box approach is particularly important. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a method to impose prior knowledge through homogeneous linear inequality constraints of the form $A x \\le 0$ on the activations of deep learning models. We directly impose these constraints through a suitable parameterization of the feasible set. This has several advantages: ",
+        "bbox": [
+            176,
+            694,
+            825,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• The constraints are hard-constraints in the sense that they are satisfied at any point during training and inference.   \n• Inference on the constrained network incurs no overhead compared to unconstrained inference.   \n• There is no manual trade-off between constraint satisfaction and data representation. ",
+        "bbox": [
+            215,
+            747,
+            825,
+            828
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In summary, the main contribution of our method is a reparameterization that incorporates homogeneous linear inequality hard-constraints on neural network activations and allows for efficient test time predictions, i.e., our method is faster up to two orders of magnitude. The model can be optimized by standard variants of stochastic gradient descent. As an application in generative modeling, we demonstrate that our method is able to produce authentic samples from a variational autoencoder while satisfying the imposed constraints. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ff2de8059afd1546259716b3fa3bcc6f284f19dca82e98544dec5426da694f1.jpg",
+        "image_caption": [
+            "Figure 1: Samples drawn from a variational autoencoder trained on MNIST without constraints (left) and with a checkerboard constraint on the output domain (right). For a pixel intensity domain $[ - 1 , 1 ]$ , the checkerboard constraint forces the image tiles to have average positive or negative brightness. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            356,
+            101,
+            637,
+            203
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            310,
+            341,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Various works have introduced methods to impose some type of hard constraint on neural network activations. This differs from a classical constrained optimization problem (Nocedal & Wright, 2006) in that the constraints are on the image of a parameterized function rather than on the neural network parameters. ",
+        "bbox": [
+            174,
+            349,
+            823,
+            406
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Marquez-Neila et al. (2017) formulated generic differentiable equality constraints as soft constraints ´ and employed a Lagrangian approach to train their model. While this is a principled approach to constrained optimization, it does not scale well to practical deep neural network models with their vast number of parameters. To make their method computationally tractable, a subset of the constraints is selected at each training step. In addition, these constraints are locally linearized; thus, there is no guarantee that this subset will be satisfied after a parameter update. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            497
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the specific problem of weakly supervised segmentation, Pathak et al. (2015) proposed an optimization scheme that alternates between optimizing the deep learning model and fitting a constrained distribution to these intermediate models. However, this method involves solving a (convex) optimization problem at each training step. Furthermore, the overall convergence path depends on how the alternating optimization steps are combined, which introduces an additional hyperparameter that must be tuned. Briq et al. (2018) approached the weakly supervised segmentation problem with a layer that implements the orthogonal projection onto a simplex, thereby directly constraining the activations to a probability distribution. This optimization problem can be solved efficiently, but does not generalize to other types of inequality constraints. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            630
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "OptNet, an approach to solve a generic quadratic program as a differentiable network layer, was proposed by Amos & Kolter (2017). OptNet backpropagates through the first-order optimality conditions of the quadratic program, and linear inequality constraints can be enforced as a special case. The formulation is flexible; however, it scales cubically with the number of variables and constraints. Thus, it becomes prohibitively expensive to train large-scale deep learning models. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            705
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, several works have proposed handcrafted solutions for specific applications, such as skeleton prediction (Zhou et al., 2016) and prediction of rigid body motion (Byravan & Fox, 2017). In contrast, to avoid laborious architecture design, we argue for the value of generically modeling constraint classes. In practice, this makes constraint methods more accessible for a broader class of problems. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contribution In this work, we tackle the problem of imposing homogeneous linear inequality constraints on neural network activations. Rather than solving an optimization problem during training, we split this task into a feasibility step at initialization and an optimality step during training. At initialization, we compute a suitable parameterization of the constraint set (a polyhedral cone) and use the neural network training algorithm to find a good solution within this feasible set. Conceptually, we are trading-off computational cost during initialization to obtain a model that has no overhead at test time. The proposed method is implemented as a neural network layer that is specified by a set of homogeneous linear inequalities and whose output parameterizes the feasible set. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider a generic $L$ layer neural network $F _ { \\theta }$ with model parameters $\\theta$ for inputs $x$ as follows: ",
+        "bbox": [
+            171,
+            132,
+            816,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ea9f946da75e03aa20d0e9e0bf4f7ce7c4abdbc95f203880c817c6911ffa619.jpg",
+        "text": "$$\nF _ { \\theta } ( x ) = f _ { \\theta _ { L } } ^ { ( L ) } ( \\sigma ( f _ { \\theta _ { L - 1 } } ^ { ( L - 1 ) } ( \\sigma ( \\dots f _ { \\theta _ { 1 } } ^ { ( 1 ) } ( x ) \\dots ) ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            151,
+            653,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { \\theta _ { l } } ^ { ( l ) }$ are affine functions, e.g., a fully-connected or convolutional layer, and $\\sigma$ is an elementwise non-linearity1, e.g., a sigmoid or rectified linear unit (ReLU). In supervised learning, training targets $y$ are known and a loss $\\mathcal { L } _ { y } ( F _ { \\theta } ( x ) )$ is minimized as a function of the network parameters $\\theta$ . A typical loss for a classification task is the cross entropy between the network output and the empirical target distribution, while the mean-squared error is commonly used for a regression task. The proposed method can be applied to constrain any linear activations $z ^ { ( l ) } = f _ { \\theta _ { l } } ^ { ( l ) } ( a ^ { ( l - 1 ) } )$ or non-linear activations $a ^ { ( l ) } = \\sigma ( z ^ { ( l ) } )$ . In most cases, one would like to constrain the output $F _ { \\theta } ( x )$ . ",
+        "bbox": [
+            173,
+            179,
+            825,
+            290
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The feasible set for $m$ linear inequality constraints in $d$ dimensions is the convex polyhedron ",
+        "bbox": [
+            174,
+            295,
+            781,
+            310
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/948dee054635b23f991212ed43f04568c86d4c01a4fc9f9e26ec04531537dd24.jpg",
+        "text": "$$\n\\mathcal { C } : = \\left\\{ z \\bigg | A z \\leq b , A \\in \\mathbb { R } ^ { m \\times d } , b \\in \\mathbb { R } ^ { m } \\right\\} \\subseteq \\mathbb { R } ^ { d } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            314,
+            656,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A suitable description of the convex polyhedron $\\mathcal { C }$ is obtained by the decomposition theorem for polyhedra. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            387
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Decomposition of polyhedra, Minkowski-Weyl). $A$ set $\\mathcal { C } \\subset \\mathbb { R } ^ { d }$ is a convex polyhedron of the form (2) if and only $i f$ ",
+        "bbox": [
+            174,
+            388,
+            823,
+            419
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ed8d31f28a2dfeb5fbe089d56a5410cabba0f133327c41c7397573ce679b99d.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { \\mathcal C } = \\mathrm { c o n v } \\big ( \\upsilon _ { 1 } , \\ldots , \\upsilon _ { n } \\big ) + \\mathrm { c o n e } \\big ( r _ { 1 } , \\ldots , r _ { s } \\big ) } \\ ~ } \\\\ { { \\displaystyle ~ = \\left\\{ \\sum _ { i = 1 } ^ { n } \\lambda _ { i } \\upsilon _ { i } + \\sum _ { j = 1 } ^ { s } \\mu _ { j } r _ { j } \\bigg | \\lambda _ { i } , \\mu _ { j } \\geq 0 , \\sum _ { i = 1 } ^ { n } \\lambda _ { i } = 1 \\right\\} } \\ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            421,
+            673,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for finitely many vertices $\\{ v _ { 1 } , \\ldots , v _ { n } \\}$ and rays $\\{ r _ { 1 } , \\ldots , r _ { s } \\}$ ",
+        "bbox": [
+            171,
+            493,
+            575,
+            510
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, $\\mathcal { C } = \\left\\{ z | A z \\leq 0 , A \\in \\mathbb { R } ^ { m \\times d } \\right\\}$ if and only if ",
+        "bbox": [
+            173,
+            515,
+            553,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/141c5be6d1de4af0a7e4ef915e90293fa419f7830888a5d6491eb626c5e933aa.jpg",
+        "text": "$$\n\\mathcal { C } = \\mathrm { c o n e } ( r _ { 1 } , . . . , r _ { s } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            536,
+            571,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for finitely many rays $\\{ r _ { 1 } , \\ldots , r _ { s } \\}$ ",
+        "bbox": [
+            173,
+            556,
+            403,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The theorem states that an intersection of half-spaces (half-space or $\\mathrm { H } \\cdot$ -representation) can be written as the Minkowski sum of a convex combination of the polyhedron’s vertices and a conical combination of some rays (vertex or $\\mathrm { V } .$ -representation). One can switch algorithmically between these two viewpoints via the double description method (Motzkin et al., 1953; Fukuda & Prodon, 1996), which we discuss in the following. Thus, the $\\mathrm { H }$ -representation, which is natural when modeling inequality constraints, can be transformed into the V-representation, which can be incorporated into gradient-based neural network training. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on homogeneous constraints of the form (4), for which the feasible set is a polyhedral cone. Due to the special structure of this set, we can avoid to work with the convex combination parameters in (3), which is numerically advantageous (Section 3.5), and we can efficiently combine modeling constraints and domain constraints, such as a $[ - 1 , 1 ]$ -pixel domain for images (Section 3.3). Such a polyhedral cone is shown in Figure 2. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DOUBLE DESCRIPTION METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            437,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The double description method converts between the half-space and vertex representation of a system of linear inequalities. It was originally proposed by Motzkin et al. (1953) and further refined by Fukuda & Prodon (1996).2 Here, we are only interested in the conversion from $\\mathrm { H } \\cdot$ -representation to V-representation for homogeneous constraints (4), ",
+        "bbox": [
+            173,
+            797,
+            825,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07953e3b7708217b360452246e0af32fd666d060d8d31f24becee732886e0ca0.jpg",
+        "text": "$$\n\\mathcal { H } \\to \\mathrm { c o n e } ( r _ { 1 } , \\dots , r _ { s } ) \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            858,
+            580,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e34f7d5efaaf63be07414ce913edd9a6616ef7e1dcd0ac505ab2653737bf016f.jpg",
+        "image_caption": [
+            "Figure 2: Diagram illustrating an iteration of the double description method. Adding a constraint to the $k$ -constraint set $A ^ { k }$ at iteration $k + 1$ introduces a hyperplane $H$ . The intersection points of $H$ with the boundary of the current polyhedron $R ^ { k }$ (marked by $\\circ ^ { \\prime }$ ) are added as rays $r _ { 6 }$ and $r _ { 7 }$ to the polyhedral cone. The ray $r _ { 2 }$ is cut-off by the hyperplane $H$ and is removed from $R ^ { k }$ . The result is the next iterate Rk+1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            277,
+            103,
+            710,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The core algorithm proceeds as follows. Let the rows of $A$ define a set of homogeneous inequalities and let $R = [ r _ { 1 } , \\ldots , r _ { s } ]$ be the matrix whose columns are the rays of the corresponding cone. Here, $( A , R )$ form a double description pair. The algorithm iteratively builds a double description pair $( A ^ { k + 1 } , R ^ { k + 1 } )$ from $( A ^ { k } , R ^ { k } )$ in the following manner. The rows in $A ^ { k }$ represent a $k$ -subset of the rows of $A$ and thus define a convex polyhedron associated with $R ^ { k }$ . Adding a single row to $A ^ { k }$ introduces an additional half-space constraint, which corresponds to a hyperplane. If the vector $r _ { i } - r _ { j }$ for two columns $r _ { i } , r _ { j }$ of $\\bar { \\boldsymbol { R } } ^ { k }$ intersects with this hyperplane then this intersection point is added to $R ^ { k }$ . Existing rays that are cut-off by the additional hyperplane are removed from $R ^ { k }$ . The result is the double description pair $( A ^ { k + 1 } , \\dot { R } ^ { k + 1 } )$ . This procedure is shown in Figure 2. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adding a hyperplane might drastically increase the number of rays in intermediate representations, which, in turn, contribute combinatorically in the subsequent iteration. In fact, there exist worst case polyhedra for which the algorithm has exponential run time as a function of the number of inequalities and the input dimension, as well as the number of rays (Dyer, 1983; Bremner, 1999). Overall, one can expect the algorithm to be efficient only for problems with a reasonably small number $m$ of inequalities and dimension $d$ . ",
+        "bbox": [
+            174,
+            550,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 INTEGRATION IN NEURAL NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            660,
+            588,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We parameterize the homogeneous form (4) via a neural network layer. This layer takes as input some (latent) representation of the data, which is mapped to activations satisfying the desired hard constraints. The algorithm is provided with the $_ \\mathrm { H }$ -representation of linear inequality constraints, i.e., a matrix $A \\in \\breve { \\mathbb { R } } ^ { m \\times d }$ for $m$ constraints in $d$ dimensions to specify the feasible set (4). At initialization, we convert this to the $\\mathrm { V } .$ -representation via the double description method (Section 3.1). This corresponds to computing the set of rays $\\{ r _ { 1 } , \\ldots , r _ { s } \\}$ to represent the polyhedral cone. During training, the neural network training algorithm is used to optimize within in the feasible set. There are two critical aspects in this procedure. First, as outlined in Section 3.1, the run-time complexity of the double description method may be prohibitive. Conceptually, the proposed approach allows for significant compute time at initialization to obtain an algorithm that is very efficient at training and test time. Second, we must ensure that the mapping from the latent representation to the parameters integrates well with the training algorithm. We assume that the model is trained with gradient-based backpropagation, as is common for current deep learning applications. The constraint layer comprises a batch normalization layer and an affine mapping (fully-connected layer with biases) followed by the element-wise absolute value function that ensures the non-negativity required by the conical combination parameters. In theory, any function $f : \\mathbb { R } \\to \\mathbb { R } _ { \\geq 0 }$ would fulfill this requirement; however, care must be taken to not interfere with backpropagated gradients. ",
+        "bbox": [
+            173,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 COMBINING MODELING AND DOMAIN CONSTRAINTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            104,
+            575,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Domain constraints are often formulated as unit box constraints, $B : = \\{ x \\in \\mathbb { R } ^ { d } | - 1 \\leq x _ { i } \\leq 1 \\}$ , such as a pixel domain for images. Box constraints are particularly unfit to be converted using the double description method because the number of vertices is exponential in the dimension. Therefore, we distinguish modeling constraints and domain constraints and only convert the former into $\\mathrm { V } .$ - representation. Based on this representation, we obtain a point in the modeling constraint set, $x \\in { \\mathcal { C } }$ . However, this point may not be in the unit box $\\boldsymbol { B }$ . To arrive at a point in the intersection $\\mathcal { C } \\cap \\mathcal { B }$ , we normalize $x$ by its infinity norm if $x \\notin B$ , $\\hat { x } = x / \\operatorname* { m a x } \\{ \\| x \\| _ { \\infty } , 1 \\bar  \\}$ . Indeed, $\\hat { x } \\in \\mathcal { C } \\cap B$ since scaling by a positive constant remains in the cone, i.e., if $x \\in { \\mathcal { C } }$ , then $\\alpha x \\in \\mathcal { C } \\forall \\alpha \\geq 0$ . ",
+        "bbox": [
+            173,
+            128,
+            825,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 APPLICATIONS OF HOMOGENEOUS LINEAR INEQUALITY CONSTRAINTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            260,
+            704,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A natural application of constraints of the form $A x \\le 0$ is a parameterization of a set of binary classifiers. If each row $a _ { i }$ of $A$ is such a binary classifier, then the method presented in this paper parameterizes the set $\\{ x | a _ { i } ^ { T } x \\le 0 \\ \\forall i \\}$ . Consequently, it can be guaranteed that neural network activations satisfy a set of binary criteria. Another domain is to express certain direct relations between neural network activations. Notably, one can guarantee mathematical properties such as monotonicity via $x _ { i + 1 } \\geq x _ { i }$ and convexity via $x _ { i + 1 } - 2 x _ { i } + x _ { i - 1 } \\geq 0$ . ",
+        "bbox": [
+            174,
+            284,
+            825,
+            368
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 EXTENSION TO GENERAL LINEAR INEQUALITY CONSTRAINTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            387,
+            640,
+            400
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proposed method takes advantage of the special structure of a polyhedral cone to efficiently combine modeling and domain constraints (Section 3.3). General linear inequality constraints of the form $A x \\leq b$ without restrictions on $A$ and $b$ possibly require the conic and convex component of (3) for their $\\mathrm { v } .$ -representation. The main approach of this paper may be used in this case, i.e., our layer additionally needs to predict convex combination parameters. However, we observed slow convergence, which we ascribe to the simplex parameterization for the convex combination parameters. We used a softmax function $f ( x ) _ { i } = { \\mathrm { { \\bar { e x p } } } ( x _ { i } ) } / { \\sum _ { j = 1 } ^ { m } \\exp ( x _ { j } ) }$ to enforce the constraints $\\begin{array} { r } { \\lambda _ { i } \\ge 0 , \\sum _ { i = 1 } ^ { m } \\lambda _ { i } = 1 } \\end{array}$ of the convex combination parameters in (3). This function has vanishing gradients when one $x _ { i }$ is significantly greater than the other vector entries. Furthermore, this most general setting does not allow for efficient incorporation of domain constraints, as this would require an efficient parameterization of the intersection of a general convex polyhedron and the unit box. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 NUMERICAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            390,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare the proposed constraint parameterization algorithm with an algorithm that trains without constraints, but requires a projection step at test time. We call this latter algorithm test time projection. We analyze these algorithms in two different settings. In an initial experiment, we learn the orthogonal projection onto a constraint set to demonstrate properties of these algorithms. Here, the result can be compared to the optimal solution of the convex optimization problem. In a second experiment, consistent with our motivation to constrain the output of generative models, we apply these algorithms to a variational autoencoder. Finally, we evaluate the running time of inference for these problems and show that the proposed algorithm is significantly more efficient compared to the test time projection method. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            744
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used the MNIST dataset (LeCun et al.) for both experiments (59000 training, 1000 validation, and 10000 test samples). We chose PyTorch (Paszke et al., 2017) for our implementation3 and all experiments were performed on a single Nvidia Titan X GPU. All networks were optimized with the Adam optimizer and we evaluated learning rates in the range $[ 1 0 ^ { - 5 } , 1 0 ^ { - 3 } ]$ . The initial learning rate was annealed by a factor of $1 / 2$ if progress on the validation loss stagnated for more than 5 epochs. We used OSQP (Stellato et al., 2017) as an efficient solver to compute orthogonal projections. ",
+        "bbox": [
+            174,
+            752,
+            823,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Both experiments were performed with a checkerboard constraint with 16 tiles, where neighboring tiles are constrained to be on average either below or above pixel domain midpoint. For a $[ - 1 , 1 ]$ -pixel domain, the tiles’ average intensity is positive or negative, respectively. The initial computational cost of converting these constraints into $\\mathrm { v } .$ -representation via the double description method is negligible (less than 1s). We observed that it is numerically advantageous to activate unit box scaling after the constraint parameterization model was initially optimized only with modeling constraints for a specified number of epochs. ",
+        "bbox": [
+            176,
+            843,
+            823,
+            898
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One might consider OptNet (Amos & Kolter, 2017) and an analogous version of the method introduced by Pathak et al. (2015) as baselines. However, these approaches incur a significant drawback for the setup presented in this paper as they are are computationally expensive at training time. An OptNet layer solves a generic quadratic program as a differentiable network layer, which scales cubically with the number of variables and constraints. The method by Pathak et al. (2015) for the regression problems in this paper alternates between optimization steps in the network parameters via a variant of stochastic gradient descent and projecting the network output onto the constraints, which is computationally expensive. ",
+        "bbox": [
+            174,
+            151,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 ORTHOGONAL PROJECTION ONTO A CONSTRAINT SET ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            311,
+            586,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We learn an orthogonal projection to demonstrate general properties of both algorithms. For given linear inequalities specified in H-representation, we solve the following problem: ",
+        "bbox": [
+            174,
+            348,
+            825,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74fc678c3f170e82d36e5079493783b48948763b7547bae099077e8fe93f45c2.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { z \\in \\mathbb { R } ^ { d } } \\left\\| z - y \\right\\| _ { 2 } \\quad \\mathrm { s . t . } A z \\leq 0 \\qquad ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            410,
+            612,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $y$ is an MNIST image. Here, the problem is convex; therefore, the global optimum can be readily computed and compared to the performance of the learning algorithms. In this setting, we can expect that training an unconstrained network with subsequent projection onto the constraint set at test time yields good results, which can be seen as follows. Let $\\begin{array} { r } { \\mathcal { P } c ( y ) : = \\arg \\operatorname* { m i n } _ { z \\in \\mathcal { C } } \\| z - y \\| _ { 2 } } \\end{array}$ be the orthogonal projection onto the constraint set $\\mathcal { C }$ and denote the mean-squared error as $\\mathcal { L } _ { y } ( x ) : =$ $\\| x - y \\| _ { 2 }$ . Both mappings are Lipschitz continuous with Lipschitz constant $L = 1$ . Consequently, for an output $\\hat { y }$ of an unconstrained model, ",
+        "bbox": [
+            173,
+            467,
+            825,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/920f3f8c46ba6ecacc05ead4128f3ba6ca78c605e3362ed6634c6044f0a99b5d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\displaystyle \\Big | \\mathcal { L } _ { y } ( \\mathcal { P } _ { \\mathcal { C } } ( \\hat { y } ) ) - \\mathcal { L } _ { y } ( \\mathcal { P } _ { \\mathcal { C } } ( y ) ) \\Big | \\le \\left\\| \\mathcal { P } _ { \\mathcal { C } } ( \\hat { y } ) - \\mathcal { P } _ { \\mathcal { C } } ( y ) \\right\\| _ { 2 } \\le \\left\\| \\hat { y } - y \\right\\| _ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            598,
+            707,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where, by definition, the term $\\mathcal { L } _ { y } ( \\mathcal { P } c ( y ) )$ is the optimal value of problem (6). The training algorithm fits $\\hat { y }$ to $y$ ; therefore, projecting the unconstrained output $\\hat { y }$ onto the constraint set will yield an objective value that is close to the optimal value of the constrained optimization problem. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To have a comparable number of parameters for both methods, we use a single fully-connected layer in both cases. For the unconstrained model, we employ an $F C ( 7 8 4 , 7 8 4 )$ layer, and for the constrained model we employ an $F C ( 7 8 4 , n _ { r } )$ layer with $n _ { r } = 1 5 5 2$ many rays to represent the constraint set in V-representation. Additionally, the constraint layer first applies a batch normalization operation (Ioffe & Szegedy, 2015). Both models were optimized with an initial learning rate of $1 0 ^ { - 4 }$ , which was annealed by a factor of 0.1 if progress on the validation loss stagnated for more than 5 epochs. The batch size was chosen to be 256. The unit box constraints were activated after 25 epochs. Additionally, the data for training the model with all constraints being active is shown. This mode eventually results in worse generalization. Figure 3 shows that the mean-squared validation objective for both algorithms converges close to the average optimum. The constraint parameterization method has a larger variance and optimality gap, which hints at the numerical difficulty of training the constrained network. To be precise, the best average validation error during training is within $9 \\%$ of the optimum for the constraint parameterization method and within $1 \\%$ of the optimum for the test time projection method. Figure 4 shows a test set sample and the respective output of the learned models. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ccb26edf90e7c914ec8c93ff4de1521e67d3e69261ccf2961a943d7f3e77649f.jpg",
+        "image_caption": [
+            "Figure 3: Mean-squared validation loss averaged over all pixels for 10 runs; shaded area denotes standard deviation. The objective function (6) is computed on a held-out validation set for the proposed constraint parameterization method and unconstrained optimization with subsequent test time projection. The average optimum over the validation set is obtained as a solution to a convex optimization problem. For the box delay curve, the box constraints are activated after 25 epochs (after $\\sim \\mathrm { 3 0 s }$ ), which results in better generalization. The best average validation error during training is within $9 \\%$ of the optimum for the constraint parameterization method with box constraint delay and within $1 \\%$ of the optimum for the test time projection method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            103,
+            684,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/49fc0106d7c90222b808e52dcf5a411c2b40977fc67fcc1408d6bbddb9492dbf.jpg",
+        "image_caption": [
+            "Figure 4: Learning to solve the orthogonal projection onto a constraint set as defined in (6). From left to right: MNIST sample from a test set, optimal projection by solving a quadratic program, constraint parameterization model inference, and test time projection model inference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            395,
+            787,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 CONSTRAINED GENERATIVE MODELING WITH VARIATIONAL AUTOENCODERS",
+        "text_level": 1,
+        "bbox": [
+            173,
+            582,
+            750,
+            594
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Variational autoencoders (VAE) are a class of generative models that are jointly trained to encode observations into latent variables via an encoder or inference network and decode observations from latent variables using a decoder or generative network (Kingma & Welling, 2014). We base our implementation on (Baumgartner, 2018). The model has a fully-connected architecture: ¨ ",
+        "bbox": [
+            174,
+            606,
+            825,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\mathrm { R e L U } ( x ) = \\operatorname* { m a x } ( 0 , x )$ and the sigmoid non-linearity takes the form $\\sigma ( x ) = 1 / ( 1 { + } \\mathrm { e x p } ( - x ) )$ . In contrast to a standard VAE, we constrain the samples generated by the model to obey a checkerboard constraint. The model was optimized with an initial learning rate of $1 0 ^ { - 4 }$ , which was annealed by a factor of 0.1 if progress on the validation loss stagnated for more than 5 epochs. The batch size was chosen to be 64. The model was trained for 200 epochs while the unit box constraints were activated after 100 epochs. To generate images, we sample the latent space prior $z \\sim \\mathcal { N } ( 0 , I )$ and evaluate the decoding neural network (Figure 5). The model is able to sample authentic digits while obeying the checkerboard constraint. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 FAST INFERENCE WITH CONSTRAINED NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            842,
+            625,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The main advantage of the proposed method over a simple projection method is a vast speed-up at test time. Since the constraint is incorporated into the neural network architecture, a forward pass has almost no overhead compared to an unconstrained network. On the other hand, for a network that was trained without constraints, a final projection step is necessary; this requires solving a convex optimization problem, which is relatively costly. Table 1 shows inference times for both models for the above numerical experiments. The constraint parameterization approach is up to two orders of magnitude faster at test time compared to the test time projection algorithm. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/02f0cfe4745a3f1d0401396a1e80304dc0a37a9588d7f9d2d50cf658cde58b72.jpg",
+        "image_caption": [
+            "Figure 5: Samples from a constrained variational autoencoder trained with the test time projection method and our constraint parameterization method. The images represent authentic digits while satisfying the imposed checkerboard constraint. Inference is significantly faster using our method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            99,
+            803,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bdbfdf545c0c3896e0aaa1f7c2727179f15affae2568d69cb68ede176ba81380.jpg",
+        "table_caption": [
+            "Table 1: Inference time for test time projection and constraint parameterization methods. Mean and standard deviation of running times are computed over 100 runs of 59000 samples with a batch size of 256. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>METHOD</td><td>PROJECTION</td><td>VAE</td></tr><tr><td>Test time projection</td><td>82±1 s</td><td>40±1s</td></tr><tr><td>Constraint parameterization (ours)</td><td>0.46 ± 0.02 s</td><td>0.75 ± 0.04 s</td></tr></table>",
+        "bbox": [
+            250,
+            434,
+            746,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            503,
+            826,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            566,
+            318,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To combine a data-driven task with modeling constraints, we have developed a method to impose homogeneous linear inequality constraints on neural network activations. At initialization, a suitable parameterization is computed and subsequently a standard variant of stochastic gradient descent is used to train the reparameterized network. In this way, we can efficiently guarantee that network activations – in the final or any intermediate layer – satisfy the constraints at any point during training. The main advantage of our method over simply projecting onto the feasible set after unconstrained training is a significant speed-up at test time of up to two orders of magnitude. An important application of the proposed method is generative modeling with prior assumptions. Therefore, we demonstrated experimentally that the proposed method can be used successfully to constrain the output of a variational autoencoder. Our method is implemented as a layer, which is simple to combine with existing and novel neural network architectures in modern deep learning frameworks and is therefore readily available in practice. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Brandon Amos and J. Zico Kolter. OptNet: Differentiable optimization as a layer in neural networks. In Proceedings of the 34th International Conference on Machine Learning (ICML 2017), pp. 136– 145, 2017. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tim Baumgartner.¨ VAE-CVAE-MNIST. https://github.com/timbmg/ VAE-CVAE-MNIST, 2018. commit: e4ba231. ",
+        "bbox": [
+            168,
+            178,
+            821,
+            208
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Bremner. Incremental convex hull algorithms are not output sensitive. Discrete & Computational Geometry, 21(1):57–68, 1999. ",
+        "bbox": [
+            171,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rania Briq, Michael Moeller, and Juergen Gall. Convolutional Simplex Projection Network (CSPN) for Weakly Supervised Semantic Segmentation. BMVC 2018, 2018. ",
+        "bbox": [
+            169,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Arunkumar Byravan and Dieter Fox. SE3-nets: Learning rigid body motion using deep neural networks. In 2017 IEEE International Conference on Robotics and Automation (ICRA), 2017. ",
+        "bbox": [
+            173,
+            294,
+            823,
+            324
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin E. Dyer. The complexity of vertex enumeration methods. Mathematics of Operations Research, 8(3):381–402, 1983. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Komei Fukuda and Alain Prodon. Double description method revisited, pp. 91–111. Combinatorics and Computer Science: 8th Franco-Japanese and 4th Franco-Chinese Conference Brest, France, July 3–5, 1995 Selected Papers. Springer Berlin Heidelberg, 1996. ",
+        "bbox": [
+            173,
+            372,
+            825,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems 27 (NIPS 2014), pp. 2672–2680. 2014. ",
+        "bbox": [
+            173,
+            424,
+            823,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In Proceedings of the 32nd International Conference on Machine Learning, volume 37, pp. 448–456. PMLR, 07–09 Jul 2015. ",
+        "bbox": [
+            174,
+            477,
+            823,
+            521
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Max Welling. Auto-encoding variational bayes. In International Conference on Learning Representations (ICLR 2014), 2014. ",
+        "bbox": [
+            169,
+            530,
+            823,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. ImageNet classification with deep convolutional neural networks. In Proceedings of the 25th International Conference of Neural Information Processing Systems (NIPS 2012), 2012. ",
+        "bbox": [
+            174,
+            568,
+            823,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Corinna Cortes, and Christopher Burges. The MNIST database of handwritten digits. URL http://yann.lecun.com/exdb/mnist/. ",
+        "bbox": [
+            174,
+            621,
+            821,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            174,
+            660,
+            823,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            173,
+            698,
+            823,
+            727
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pablo Marquez-Neila, Mathieu Salzmann, and Pascal Fua. Imposing hard constraints on deep net- ´ works: Promises and limitations. First Workshop on Negative Results in Computer Vision, CVPR 2017, 2017. ",
+        "bbox": [
+            173,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "T. S. Motzkin, H. Raiffa, G. L. Thompson, and R. M. Thrall. The double description method. In Contributions to the Theory of Games II, volume 8 of Ann. of Math. Stud., pp. 51–73. Princeton University Press, 1953. ",
+        "bbox": [
+            173,
+            789,
+            823,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jorge Nocedal and Stephen Wright. Numerical Optimization. Springer Series in Operations Research and Financial Engineering. Springer, 2006. ",
+        "bbox": [
+            169,
+            842,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in PyTorch. Autodiff Workshop, NIPS 2017, 2017. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Philipp Krahenb ¨ uhl, and Trevor Darrell. Constrained Convolutional Neural Net- ¨ works for Weakly Supervised Segmentation. In International Conference on Computer Vision (ICCV 2015), 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bartolomeo Stellato, Goran Banjac, Paul Goulart, Alberto Bemporad, and Stephen Boyd. OSQP: An Operator Splitting Solver for Quadratic Programs. ArXiv e-prints, 2017. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to Sequence Learning with Neural Networks. In Proceedings of the 27th International Conference of Neural Information Processing Systems (NIPS 2014), 2014. ",
+        "bbox": [
+            174,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xingyi Zhou, Xiao Sun, Wei Zhang, Shuang Liang, and Yichen Wei. Deep Kinematic Pose Regression. Workshop on Geometry Meets Deep Learning, ECCV 2016, 2016. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            272
+        ],
+        "page_idx": 9
+    }
+]