Add files using upload-large-folder tool

parse/dev/0Q6BzWbvg0P/0Q6BzWbvg0P.md

@@ -0,0 +1,482 @@
+# LESS IS MORE: DIMENSION REDUCTION FINDS ON-MANIFOLD ADVERSARIAL EXAMPLES IN HARDLABEL ATTACKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Designing deep networks robust to adversarial examples remains an open problem. Likewise, recent zeroth-order hard-label attacks on image classification models have shown comparable performance to their first-order, gradient-level alternatives. It was recently shown in the gradient-level setting that regular adversarial examples leave the data manifold, while their on-manifold counterparts are in fact generalization errors. In this paper, we argue that query efficiency in the zeroth-order setting is connected to an adversary’s traversal through the data manifold. To explain this behavior, we propose an information-theoretic argument based on a noisy manifold distance oracle, which leaks manifold information through the adversary’s gradient estimate. Through numerical experiments of manifold-gradient mutual information, we show this behavior acts as a function of the effective problem dimensionality. On high-dimensional real-world datasets and multiple zeroth-order attacks using dimension reduction, we observe the same behavior to produce samples closer to the data manifold. This can result in up to $4 \mathbf { x }$ decrease in the manifold distance measure, regardless of the model robustness. Our results suggest that taking the manifold-gradient mutual information into account can thus inform better robust model design in the future, and avoid leakage of the sensitive data manifold information.
+
+# 1 INTRODUCTION
+
+Adversarial examples against deep learning models were originally investigated as blind spots in classification (Szegedy et al., 2013; Goodfellow et al., 2014). Formal methods for discovering these blind spots emerged, which we denote as gradient-level attacks, and became the first techniques to reach widespread attention within the deep learning community (Papernot et al., 2016; MoosaviDezfooli et al., 2015; Carlini & Wagner, 2016; 2017; Chen et al., 2018). In order to compute the necessary gradient information, such techniques required access to the model parameters and a sizeable query budget. These shortcomings were addressed by the creation of score-level attacks, which only require the confidence values output by the deep learning models (Fredrikson et al., 2015; Tramer et al., 2016; Chen et al., 2017; Ilyas et al., 2018). However, these attacks still rely on \` models to divulge information that would be impractical to receive in real-world systems. By contrast, hard-label attacks make no assumptions about receiving side information, and only the predicted class is observable, thus providing the weakest, yet most realistic adversarial threat model. These methods, which originated from a random-walk on the decision boundary (Brendel et al., 2017), have been carefully refined to offer convergence guarantees (Cheng et al., 2019), query efficiency (Chen et al., 2019; Cheng et al., 2020), and capability in the physical world Feng et al. (2020).
+
+Despite the steady improvements of hard-label attacks, open questions persist about their behavior, and adversarial machine learning (AML) attacks at large. Adversarial examples were originally assumed to lie in rare pockets of the input space (Goodfellow et al., 2014), but this conventional wisdom was later challenged by the boundary tilting assumption (Tanay & Griffin, 2016; Gilmer et al., 2018), which adopts a “data-geometric” view of the input space living on a lower-dimensional manifold. This is supported by Stutz et al. (2019), who suggest that regular adversarial examples leave the data manifold, while on-manifold adversarial examples are generalization errors. From a data-geometric perspective, an adversarial example’s distance to the manifold primarily describes the amount of semantic features preserved during the attack process. This makes it advantageous to produce on-manifold adversarial examples, since the adversary can exploit the inherent generalization error of the model while producing samples that are semantically similar for humans. However, the true data manifold is either difficult or impossible to describe, and relying solely on approximations of the manifold can lead to the creation of crude adversarial examples (Stutz et al., 2019).
+
+In this paper, we adopt the boundary-tilting assumption and demonstrate an unexpected benefit of query-efficient zeroth-order attacks, i.e., attacks enabled by the use of dimensionality reduction techniques. These attacks are more likely to discover on-manifold examples, which we theoretically demonstrate is the result of manifold-gradient mutual information. Our results suggest that this quantity can increase as a function of the data dimensionality. This information leakage leads to adversarial examples that are on-manifold generalization errors. With this knowledge, we empirically demonstrate how to improve hard-label attacks in a generic yet principled way, and potentially re-think their interaction with model robustness and public-facing systems in the near future.
+
+For clarity, we provide a block diagram of our claims and experiments in the Appendix (Section A.3). Our specific contributions are as follows:
+
+• Introduction of manifold distance oracle. To create on-manifold examples, the adversary must (implicitly) leverage manifold information during the attack phase. We thus propose an informationtheoretic formulation of the noisy manifold distance (NMD) oracle, which can explain how zerothorder attacks craft on-manifold examples. We theoretically demonstrate on a Gaussian data model that manifold-gradient mutual information can increase as a function of data dimensionality. We empirically show this is true even on large-scale image datasets such as CIFAR-10 and ImageNet. This finding relates to known behavior in the gradient-level setting, where semantic manifold priors (e.g., shapes and textures) can be leaked from robust models (Engstrom et al., 2019).
+
+• Reveal new insights of manifold feedback during query-efficient zeroth-order search. In practice, the data manifold is difficult to characterize. We propose the use of three proxies for manifold distance, which all show consistent results in terms of an adversary’s ability to search near the manifold. This methodology allows us to empirically demonstrate the connection between dimension reduction, model robustness, and manifold feedback from the model, beyond the known convergence rates tied to dimensionality (Nesterov & Spokoiny, 2017). Our findings inform how to search closer to the manifold (Table 1), reduce gradient deviation (Table 2), and improve query efficiency (Figure 2) in a simple and generic way for hard-label attacks.
+
+• Attack-agnostic method for super-pixel grouping. We show that spatial dimension reduction of a decision-based gradient estimate acts as an attack- and knowledge-agnostic method for searching over super-pixels of an image. More importantly, this helps an attacker exploit a model’s reaction to salient input changes, leading to samples closer to the manifold compared to the attack on full dimension. As a result, we demonstrate up to $200 \%$ and $340 \%$ success rate improvement for state-of-the-art hard-label attacks HSJA (Chen et al., 2019) and Sign-OPT attack (Cheng et al., 2020), respectively.
+
+# 2 RELATED WORK
+
+Since the original discovery of adversarial samples against deep models (Szegedy et al., 2013; Goodfellow et al., 2014), the prevailing question was why such examples existed. The original assumption was that adversarial examples lived in low-probability pockets of the input space, and were never encountered during parameter optimization (Szegedy et al., 2013). This effect was believed to be amplified by the linearity of weight activations in the presence of small perturbations (Goodfellow et al., 2014). These assumptions were later challenged by the boundary tilting assumption, which in summary 1) asserts that the train and test sets of a model only occupy a sub-manifold of the true data, while the decision boundary lies close to samples on and beyond the sub-manifold (Tanay & Griffin, 2016), and 2) supports the “data geometric“ view, where high-dimensional geometry of the true data manifold enables a low-probability error set to exist (Gilmer et al., 2018). Likewise the boundary tilting assumption describes adversarial samples as leaving the manifold, which has inspired defenses based on projecting such samples back to the data manifold (Jalal et al., 2019; Samangouei et al., 2018). However, these approaches were later defeated by adaptive attacks (Carlini et al., 2019; Carlini & Wagner, 2017; Tramer et al., 2020).
+
+We investigate the scenario where an adversary uses zeroth-order information (i.e., top-1 label feedback) to estimate the desired gradient direction (Cheng et al., 2020; Chen et al., 2019). Contemporary attacks in this setting are variants of random gradient-free method (RGF) (Nesterov & Spokoiny, 2017), and rely on formulations which convert the top-1 (hard) label, which is a step function, into a continuous real-valued function $\cdot$ , which takes search direction $\cdot$ and outputs the distance to the nearest adversarial example (Cheng et al., 2018). The gradient estimate is conceived as a function of the gradient $\cdot$ and can be estimated with either two samples of information (SignOPT) (Cheng et al., 2020), or a single point (HopSkipJumpAttack) (Chen et al., 2019). Details of specific formulations for each attack are provided in Section A.2 of the Appendix.
+
+Query efficiency is a persistent desire in the study of hard-label attacks. One clue for achieving efficiency comes from the theory of gradient estimation error and convergence, which shows that the estimation cost is polynomial in $d$ , the dimension of the optimized variable, thus motivating the use of standard dimension-reduction techniques (Tu et al., 2019). However, to date it is not completely understood how this relates to traversal through the data manifold. We leverage previous results of the gradient-level setting (Stutz et al., 2019; Engstrom et al., 2019) to formulate an explanation of manifold leakage during hard-label adversarial attacks.
+
+# 3 NOISY MANIFOLD DISTANCE ORACLE
+
+Santurkar et al. (2019) demonstrate that the gradients of robust models have higher visual semantic alignment with the data compared to gradients of standard models. We build on this finding by first assuming that the benign observable data generates from a true lower-dimension distribution. Under the boundary-tilting assumption, this lower-dimension distribution forms a manifold onto which new observations, either benign or adversarial, can be encoded (Tanay & Griffin, 2016). Likewise, we assume that deep learning models will learn a lower-dimension representation of the observable data, e.g., feature layers of convolutional neural networks learn to encode training observations onto a low dimension approximate manifold (Zhang et al., 2018). When an adversary creates adversarial samples, they are leveraging a pathway that shadows the model gradient, not the true manifold. Thus there is the possibility that adversarial samples are considered “off-manifold”, e.g., cannot be expected to generate naturally from the true manifold. However, it is critical for adversarial samples to be as close to the manifold as possible, since on-manifold adversarial examples can exploit the fundamental generalization error of the model (Stutz et al., 2019). More formally, we define the notion of manifold distance as follows.
+
+Definition 3.1 (Manifold Distance). Consider the benign sample $\mathbf { x } _ { \mathrm { 0 } }$ and adversarial counterpart $\mathbf { x }$ . Assuming a perfect encoding back to the true manifold $\phi$ , the manifold distance is defined as $\mathrm { d } ( \phi ( \mathbf { x } _ { 0 } ) , \phi ( \mathbf { x } ) )$ , where d is a distance function with the domain of the true manifold.
+
+Unfortunately, unless the true manifold for a dataset is known, it is impossible to define $\phi$ . Instead, a proxy $\mathrm { d } ^ { \prime }$ can be used such that $\mathrm { d } ^ { \prime } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) \sim \mathrm { d } ( \phi ( \mathbf { x } ) , \phi ( \mathbf { x } ^ { \prime } ) )$ . In practice, one can implement $\mathrm { d } ^ { \prime }$ with any perceptual distance score, such as Learned Perceptual Image Patch Similarity (Zhang et al., 2018). If relying on a distance measure $\mathrm { d }$ , such as the $L _ { p }$ -norm, an approximate encoder $\phi ^ { \prime } ( \cdot ) \^ { - } \phi ( \cdot )$ can be learned using reconstruction-based training of autoencoders (Stutz et al., 2019), or leveraging feature layers of convolutional neural networks (Zhang et al., 2018). We are interested in the class of hard-label adversaries that implicitly minimize some proxy of the manifold distance. Given the result of Santurkar et al. (2019), the robust model’s gradient could be treated as a manifold distance oracle, because it leaks the direction towards its approximate manifold. As a result, the model acts as an oracle responding to queries about manifold distance, or in other words, an implicit proxy for manifold distance, $\mathrm { d } ^ { \prime }$ . In the hard-label setting, the data manifold, true gradient, and model parameters are not accessible. Thus we are interested in a decision-based version of the manifold distance oracle, defined as follows.
+
+Definition 3.2 (Noisy Manifold Distance Oracle). Consider a manifold distance oracle instantiating $\mathrm { d } ^ { \prime }$ , benign sample $\mathbf { x } _ { \mathrm { 0 } }$ , and pair of adversarial samples $( \mathbf { x } ^ { \prime } , \mathbf { x } ^ { \prime \prime } )$ such that $\mathrm { d } ^ { \prime } ( \mathbf { x } _ { 0 } , \mathbf { x } ^ { \prime } ) < \mathrm { d } ^ { \prime } ( \mathbf { x } _ { 0 } , \mathbf { x } ^ { \prime \prime } ) $ , e.g., $\mathbf { x } ^ { \prime }$ is considered on-manifold while $\mathbf { x } ^ { \prime \prime }$ is not. In the hard-label setting, the noisy manifold distance (NMD) oracle instantiates $\mathrm { d } ^ { \prime \prime }$ such that $\mathrm { d } ^ { \prime \prime } ( \mathbf { x } _ { 0 } , \mathbf { x } ^ { \prime } ) = 0$ and $\mathrm { d } ^ { \prime \prime } ( \mathbf { x } _ { 0 } , \mathbf { x } ^ { \bar { \prime } \prime } ) = 1$ .
+
+During a hard-label attack, the adversary searches in a direction that minimizes perceptual distance to the original sample. Concurrently, the adversary can be said to implicitly minimize the expected output of the NMD oracle, which is a binary indicator that a sample is on-manifold or not. Without knowledge of the true (or approximate) manifold, this requires careful selection of the search direction from the current sample. Since the search direction of contemporary hard-label attacks is synthesized over expectation of a ball around the adversarial sample, we are interested in search directions such as $\mathbf { x } _ { 0 } - \mathbf { x } ^ { \prime }$ which minimize the expected distance to the manifold.
+
+To formalize the entailed information in the NMD oracle, we turn to a standard result in data processing, which states the following:
+
+Definition 3.3 (Data Processing Inequality (DPI) (Beaudry & Renner, 2012)). If three random variables form the Markov chain $X  Y  Z$ , then their mutual information (MI) has the relation $I ( X ; Y ) \geqslant I ( X ; Z )$ .
+
+We assume the data manifold $\mathcal { M }$ , the input gradient $\mathcal { G }$ , and the hard-label gradient estimate $\ddot { \mathcal { G } }$ will form the Markov chain $\mathcal { M } \to \mathcal { G } \to \ddot { \mathcal { G } }$ . This assumption is reasonable due to the observations by Santurkar et al. (2019); modifying the sampled data manifold (e.g., by adding adversarial samples through saddle-point optimization) causally induces a smoother loss surface, which imposes its own gradient distribution. Likewise, the true gradient and gradient estimate of hard-label attack are causally linked due to the estimate’s bounded variance (Cheng et al., 2020).
+
+If $I ( { \mathcal { M } } , { \mathcal { G } } )$ is larger for adversarially robust models, by Definition 3.3 the upper bound on $I ( { \mathcal { M } } , { \ddot { \mathcal { G } } } )$ is larger, which means more manifold information could be leaked in the noisy gradient. This information could be used to search in the direction where $\mathrm { d } ^ { \prime \prime }$ is minimized in expectation, leading towards on-manifold examples. However, DPI only offers an upper bound, thus the distance decrease is not guaranteed, only suggested. In the information theoretic sense, does this mean the gradients of models robust in an $\epsilon$ -ball around each sample can reveal more information about the distance to training data than standard models? An immediate follow-up concern is whether other factors can influence the model to reveal this information, such as the problem dimensionality. As a first step we posit the following hypothesis:
+
+Hypothesis 1. Consider the manifold distribution $\mathcal { M }$ which can generate data to train a natural model with gradient distribution $\mathcal { G }$ , and train robust model with smoothed gradient distribution $\mathcal { G } ^ { \prime }$ . We posit that their manifold-gradient mutual information $I$ has the relation $\bar { I } ( \mathcal { M } , \mathcal { G } ^ { \prime } ) \geq I ( \mathcal { M } , \mathcal { G } )$ .
+
+In order to empirically verify Hypothesis 1, we must parameterize the notion of model robustness while solving for $I ( { \mathcal { M } } , { \mathcal { G } } )$ , given an arbitrary gradient distribution $\mathcal { G }$ and manifold distribution $\mathcal { M }$ Schmidt et al. (2018) have shown that robust training requires additional data as a function of the data dimensionality. We leverage the data model and results from Schmidt et al. (2018) to derive an analytical solution for $I ( \mathcal { M } , \bar { \mathcal { G } } )$ , since we can parameterize model robustness as a function of data size and dimensionality. Consequently, the remainder of our theoretical analysis assumes a Gaussian mixture data model.
+
+Definition 3.4 (Data model and optimal weights (Schmidt et al., 2018)). Let $\pmb { \mu } \in \mathbb { R } ^ { d }$ be the per-class centers (means) and let $\sigma > 0$ be the variance parameter. Then the $( \mu , \sigma I )$ -Gaussian model is defined by the following distribution over $( \mathbf { x } , y ) \in \bar { \mathbb { R } ^ { d } } \times \{ \pm 1 \}$ : First, draw a label $y \in \{ \pm 1 \}$ uniformly at random. Then sample the data point $\mathbf { x } \in \mathbb { R } ^ { d }$ from $\mathcal { N } ( \boldsymbol { y } \cdot \boldsymbol { \mu } , \sigma \boldsymbol { I } )$ .
+
+Definition 3.5 (Optimal classification weight (Schmidt et al., 2018)). Fix $\sigma \leq c _ { 1 } d ^ { \frac { 1 } { 4 } }$ for the universal constant $c _ { 1 }$ , and samples $( \mathbf { x } _ { 1 } , y _ { 1 } ) , \cdot \cdot \cdot , ( \mathbf { x } _ { n } , y _ { n } )$ drawn $i . i . d$ from the $( \mu , \sigma I )$ -Gaussian model with $| | { \boldsymbol { \mu } } | | = { \sqrt { d } }$ (i.e., $\mu _ { k } = 1$ for all dimensions $k \in \{ 0 , \ldots , d \} )$ . Schmidt et al. (2018) prove that the weight setting $\begin{array} { r } { \widehat { \mathbf { w } } = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } y _ { i } \mathbf { x } _ { i } } \end{array}$ yields an $l _ { \infty } ^ { \epsilon }$ -robust classification error of at most $1 \%$ for the linear classifier $f _ { \widehat { \mathbf { w } } } : \mathbb { R } ^ { d }  \{ \pm 1 \}$ instantiated as $f _ { \widehat { \mathbf { w } } } ( x ) = \mathrm { s i g n } ( \widehat { \mathbf { w } } ^ { T } \mathbf { x } )$ if
+
+$$
+n \geq \left\{ \begin{array} { l l } { { 1 , } } & { { \mathrm { f o r } ~ \epsilon \leq \frac 1 4 d ^ { - \frac 1 4 } } } \\ { { c _ { 2 } \epsilon ^ { 2 } \sqrt { d } , } } & { { \mathrm { f o r } ~ \frac 1 4 d ^ { - \frac 1 4 } \leq \epsilon \leq \frac 1 4 } } \end{array} , \right.
+$$
+
+for a universal constant $c _ { 2 }$
+
+Note that the instantiation of $\widehat { \bf w }$ must change with choice of $\epsilon$ and $d$ . We can leverage the weight settings as a function of $n$ and $d$ to give a definition of manifold-gradient mutual information.
+
+![](images/9298751749e2f7005a373cca6de066290617a0be2d685819c61603b29325bba5.jpg)  
+Figure 1: a) Average per-dimension mutual information $\cdot$ over dimension $d$ for values of $c _ { 2 }$ and $\epsilon$ in Equation 13, log-scale $\cdot$ -axis with $\cdot$ , average over ten seeds. The approximate mutual information is higher for robust and standard models at lower $d$ regardless of $\cdot$ and choice of $\cdot$ .
+
+# 3.1 MANIFOLD-GRADIENT MUTUAL INFORMATION
+
+Notice the classifier $\operatorname { s g n } ( { \mathord { \cdot } } )$ in Definition 3.5 is discontinuous at ${ \bf x } _ { k } = 0$ for any dimension $k$ . Instead we consider the sub-gradient of the classifier at $\mathbf { x } _ { k } < 0$ and $\mathbf { x } _ { k } > 0$ . In either case (non-robust or robust), the input sub-gradient for $f _ { \widehat { w } } ( \mathbf { x } _ { k } ^ { \prime } )$ is defined dimension-wise for our isotropic Gaussian as $\nabla _ { \mathbf x _ { k } ^ { \prime } } f _ { \widehat { \mathbf w _ { k } } } = \mathrm { s i g n } \mathbf w _ { k }$ b. Since the weight of each dimension is Gaussian distributed with $\widehat { \mathbf { w } _ { k } } \sim$ $\mathcal { N } ( \mu _ { k } , \sigma ^ { 2 } )$ , we can define the distribution of gradients as $\mathcal { G } \sim$ Rademacher $\left( \mathbb { P } _ { \widehat { \mathbf { w } _ { k } } \sim \mathcal { N } } \left[ \widehat { \mathbf { w } _ { k } } \geq 0 \right] \right) ,$ ). c cUsing this fact, we define manifold-gradient mutual information in three parts: 1) defining the manifold-gradient point-wise joint probabilities between $\mathbf { g } _ { k }$ and $\mathbf { x } _ { k }$ at each dimension $k$ for the sub-gradient cases where $\mathbf { x } _ { k } > 0$ and $\mathbf { x } _ { k } < 0 , 2$ ) defining the manifold-gradient marginal probability under the gradient, and 3) the marginal probability under the manifold. The complete derivation of the joint and marginal probabilities can be found in Section A.1 of the Appendix. The three parts are used in the standard definition of mutual information (Cover & Thomas, 2006).
+
+Notation. Fix $\sigma = c _ { 1 } d ^ { \frac { 1 } { 4 } }$ for both cases. We denote the sub-manifold sampled from the positive $( y = 1 )$ ) and negative $( y = - 1$ ) classes as $\mathcal { M } ^ { + }$ and $\mathcal { M } ^ { - }$ , respectively. For brevity we label $\mathbf { x } _ { k } > 0$ as $\mathbf { x } ^ { + }$ and $\mathbf { x } _ { k } < 0$ as $\mathbf { x } ^ { - }$ .
+
+Definition 3.6 (Manifold-Gradient Mutual Information). We define the manifold-gradient mutual information, based on the standard definition of mutual information from information theory (Cover & Thomas, 2006), as
+
+$$
+I ( \mathcal M , \mathcal G ) _ { \epsilon , k } = 2 \int _ { \mathcal M ^ { + } } p ( 1 , \mathbf x ^ { + } ) \log ( \frac { p ( 1 , \mathbf x ^ { + } ) } { p _ { \mathcal G } ( 1 ) p _ { \mathcal M } ( \mathbf x ^ { + } ) } ) d \mathbf x ^ { + } + 2 \int _ { \mathcal M ^ { + } } p ( - 1 , x ^ { + } ) \log ( \frac { p ( - 1 , x ^ { + } ) } { p _ { \mathcal G } ( - 1 ) p _ { \mathcal M } ( x ^ { + } ) } ) d x ^ { + } .
+$$
+
+with the total unnormalized mutual information defined as the summation over dimensions (due to dimension co-independence) $\begin{array} { r } { I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon } = \sum _ { k = 1 } ^ { d } I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon , k } } \end{array}$ .
+
+# 3.2 MUTUAL INFORMATION AS A FUNCTION OF DIMENSIONALITY
+
+To provide numerical support for Hypothesis 1, we run experiments using the Riemann approximation of Equation 13, provided in the Appendix as Equation 15. We estimate the average per-dimension mutual information, $\begin{array} { r } { I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon , \overline { { k } } } = \frac { I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon } } { d } } \end{array}$ I(M,G)d , for the case where x ∈ Rd while varying the dimensionality term $\cdot$ against values of $c _ { 2 } \in \{ 1 , 1 0 0 \}$ and $-$ . The values of $c _ { 2 }$ represent two multiplicative factors for number of samples in robust models (Equation 1). In our experiments, we target an error within $1 0 ^ { - 1 }$ (e.g., $-$ . Thus we multiply each branch of Equation 1 by a large constant $( 1 0 ^ { 4 } )$ . We run the approximation over ten different random seeds and show the average with standard error shaded.
+
+The estimation result is shown in Figure 1 with log-scale $\mathbf { X }$ -axis. Regardless of $c _ { 2 }$ and $\epsilon$ , lower values of the dimensionality evidence a higher mutual information. We minimize variance of the estimate when $\cdot$ (right plot shaded area), which follows intuition due to the higher sample count in the estimate.
+
+Observation 1. Given reduced data dimensionality, a robust model could increase $I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon , \overline { { k } } }$ and lead to leaking better search direction through the gradient (e.g., act as manifold distance oracle). This supports Hypothesis 1.
+
+This can theoretically explain the high visual alignment observed empirically by Engstrom et al. (2019) and Santurkar et al. (2019) on robust models. From the security perspective, the NMD oracle acts as a side channel leaking sensitive information as a factor of the model robustness and data dimensionality.
+
+# 4 ZEROTH-ORDER SEARCH THROUGH THE MANIFOLD DISTANCE ORACLE
+
+According to Observation 1, the true gradient and manifold of a robust model have higher mutual information, and this is exacerbated by reducing the data dimensionality. Under our Markov chain assumption, this means an attack algorithm can act as a noisy manifold distance oracle, and this oracle could be upper bounded by the true gradient-manifold mutual information. Although the data dimensionality and robustness are controlled by the model designer, an attacker can search in arbitrarily lower dimensionality through dimension-reduction techniques, such as autoencoder-based attacks (Tu et al., 2019). In fact, in the image domain the intrinsic dimensionality of data can be lower than the true dimension (Amsaleg et al., 2017). In order to connect the notion of manifold-gradient mutual information with on-manifold adversarial samples of real datasets, we posit the following.
+
+Hypothesis 2. Consider Observation 1 and Definition 3.3 (DPI), then due to the higher upper bound on $I ( { \mathcal { M } } , { \ddot { \mathcal { G } } } )$ and leaking better search directions, a hard-label adversary can minimize $d ^ { \prime \prime }$ in expectation on robust models when the gradient estimate dimensionality is reduced.
+
+In the most common problem setting, the adversary is interested in attacking a $K$ -way multiclass classification model $f : \mathbb { R } ^ { d }  \mathbf { \bar { \{ 1 , \dots , K \} } }$ . Given an original example $\mathbf { x } _ { \mathrm { 0 } }$ , the goal is to generate adversarial example $\mathbf { x }$ such that $\mathbf { x }$ is close to $\mathbf { x } _ { \mathrm { 0 } }$ and $f ( \mathbf { \bar { x } } ) \neq f ( \mathbf { x } _ { 0 } )$ , where closeness is often approximated by the $L _ { p }$ -norm of ${ \bf x } - { \bf x } _ { 0 }$ . In the gradient-level setting, we require the gradient $\nabla f ( \cdot )$ . However, in the hard-label setting we are forced to estimate $\frac { \partial f ( \mathbf { x } ) } { \partial \mathbf { x } }$ without access to $\nabla f ( \cdot )$ , only decision evaluations of $f$ . Rather than optimizing the step function $\boldsymbol { \mathscr { f } }$ , hard-label attacks minimize the continuous function $g ( \pmb \theta )$ , which is an estimate of the distance to the nearest decision boundary in the direction $\pmb \theta$ . We evaluate the effect of dimension reduction on Sign-OPT attack (Cheng et al., 2020) and HopSkipJumpAttack (HSJA) (Chen et al., 2019), as both are considered state-of-the-art in the literature, and rely on minimization of $g ( \cdot )$ . We provide a brief overview of their formulation in Section A.2 of the Appendix, and leave details to the respective authors’ work. Alternative hard-label attacks, such as RayS by Chen & Gu (2020), do not rely on the explicit zeroth-order gradient estimate from the model. This style of attack behaves differently since it can adapt to the problem dimension independent of the true gradient, which we demonstrate in Section A.5.6 of the Appendix.
+
+# 4.1 DIMENSION-REDUCED ZEROTH-ORDER SEARCH
+
+To test Hypothesis 2, we modify existing hard-label attacks to produce dimension-reduced variants. This scheme enables dynamic scaling of the effective dimensionality regardless of specific attack formulation. In practice we implement the reduction through an encoding map $\mathcal { E } : \mathbb { R } ^ { d }  \mathbb { R } ^ { d ^ { \prime } }$ for reduced dimension $d ^ { \prime }$ and decoding map $\mathcal { D } : \mathbb { R } ^ { d ^ { \prime } }  \mathbb { R } ^ { d }$ . In general the adversarial sample is created by $\begin{array} { r } { \mathbf { x } = \mathbf { x } _ { 0 } + g \left( { \cal D } ( \pmb { \theta } ^ { \prime } ) \right) \frac { \pmb { \mathcal { D } } ( \pmb { \theta } ^ { \prime } ) } { | | \pmb { \mathcal { D } } ( \pmb { \theta } ^ { \prime } ) | | } } \end{array}$ , where $\pmb { \theta } ^ { \prime } \in \mathbb { R } ^ { d ^ { \prime } }$ and is optimized depending on the respective attack (e.g., Sign-OPT and HSJA), and as before, $g$ is a measure of distance to the decision boundary in direction ${ \mathcal { D } } ( \theta ^ { \prime } )$ . The mapping functions can be initialized with either an autoencoder (AE), or a pair of channel-wise bilinear transform functions (henceforth referred to as BiLN) which simply scales the spatial dimension of the input up or down. This represents two distinct methods to search over super-pixels of the image, which either rely on an approximate description of the manifold (AE), or instead exploit the known spatial co-dependence of images (BiLN). The implementation and training details of the AE variant can be found in Section A.4.2 of the Appendix. To study the effect of dimension-reduction without semantic information, we implement a random variant of BiLN (Rand) which samples a subset of coordinates uniform-randomly from the source image as the dimension-reduced version, then replaces the pixels at these coordinates with those from the gradient estimate. This is meant to show the effect of discarding some semantic information (e.g., spatial correlation) in the update.
+
+# 4.2 ESTIMATING MANIFOLD DISTANCE
+
+We leverage three proxies of manifold distance in order to test Hypothesis 2. The Learned Perceptual Image Patch Similarity (LPIPS) acts as a proxy for manifold distance, $\mathrm { d } ^ { \prime }$ , and computes a distance that correlated well with human perception in human studies (Zhang et al., 2018; Laidlaw et al., 2021). We use the same LPIPS code and checkpoint provided by the authors. Frechet Inception ´ Distance (FID) (Heusel et al., 2018) is similar to LPIPS, and leverages the internal representations of deep networks as an approximate encoding onto the manifold. Although FID lacks human studies, Heusel et al. (2018) show it is viable for scoring the visual quality of synthetically generated images, which offers us a comparison against LPIPS. In addition to LPIPS and FID, we create an approximate encoding $\phi ^ { \prime }$ by taking the encoder of trained autoencoders for each dataset, which can be used to compute $L _ { \infty }$ distance between encoded samples. In other words, this lets us compute $| | \phi ^ { \prime } ( \mathbf { x } _ { 0 } ) - \phi ^ { \prime } ( \bar { \mathbf { x } } ) | | _ { \infty }$ for benign sample $\mathbf { x } _ { \mathrm { 0 } }$ and adversarial sample x. The results on FID and our trained autoencoder were consistent with LPIPS, so they are described in Section A.5.9 of the Appendix.
+
+Finally, if hard-label gradient estimates on real-world data resulted in a sample close to the approximate manifold, we could say the gradient estimates leveraged noisy mutual information, which may be upper bounded by the clean mutual information (Hypothesis 1). This would manifest in a lower gradient deviation, or in other words, the distance between the true gradient and gradient estimate at the first attack step. We can further infer that the adversarial training effectively smooths the sampled data manifold (which generates from true manifold) by augmenting perturbed data samples during training. The smoothing yields a well-defined boundary that aligns with salient input changes (Santurkar et al., 2019), and should further lower variance of the gradient estimate compared to natural models, which improves the baseline performance of an attack. We test this by calculating per-pixel gradient deviation $\frac { | | \mathbf { g } - \hat { \mathbf { g } } | | _ { 2 } } { H \times W }$ for true gradient $\mathbf { g }$ (in the direction of the adversarial label), first gradient estimate $\hat { \bf g }$ , estimate height $H$ , and estimate width $W$ . When taking the true input gradient in the direction of the adversarial label, we use the victim model’s original criterion to calculate the gradient, which was cross-entropy for all models in our evaluation.
+
+# 5 RESULTS & DISCUSSION
+
+We test Hypothesis 2 by comparing two SotA hard-label attacks with their compatible dimensionreduced variants, against both natural and robust models. First we show empirical evidence of the relationship between manifold distance and dimension-reduced attacks in Section 5.1. Next in Section 5.2, we investigate the result of Section 5.1 from the perspective of reducing error in the gradient estimate. Finally in Section 5.3, we show how these observations inform better attack design.
+
+Setup. We perform experiments using CIFAR-10 (Krizhevsky, 2009) and ImageNet (Krizhevsky et al., 2012) for RGB image data. The natural CIFAR-10 network is the same implementation opensourced by Cheng et al. (2020). The architecture for ImageNet is the Resnet50 network taken from the PyTorch Torchvision library, and the accompanying pre-trained weights act as the natural model.1 In addition, we leverage the representative adversarial training technique proposed by Madry et al. (2017) (and their  = 8255 $\epsilon = \overline { { \frac { 8 } { 2 5 5 } } } = 0 . \dot { 0 3 } 1$ checkpoints for $L _ { \infty }$ setting) as the robust models for CIFAR-10 and ImageNet. The BiLN variants downscale to $1 6 \times 1 6$ for CIFAR-10, and $3 2 \times 3 2$ for ImageNet. We use $L _ { \infty }$ -norm versions of attacks for all experiments, and the same $\epsilon$ values for natural models as the robust CIFAR-10 and robust ImageNet (hereafter referred to as Madry CIFAR-10 and Madry ImageNet). All attacks run for $2 5 \mathrm { k }$ queries without early stopping on correctly classified samples. For brevity, we only show results for the untargeted case. Additional implementation details, such as hyperparameters and hardware used, can be found in the Appendices (Section A.4). Code for experiments is provided in the supplementary materials.
+
+Table 1: Average LPIPS scores for each attack’s set of 200 adversarial samples on CIFAR-10 and ImageNet (lower is better). Arrows denote higher or lower score compared to baseline variant, and starred items indicate highest success rate.   
+
+<table><tr><td>Attack Variant</td><td>Natural CIFAR-10</td><td>Madry CIFAR-10</td><td>Natural ImageNet</td><td>Madry ImageNet</td></tr><tr><td>HSJA</td><td>0.132 ± 0.098*</td><td>1.335 ± 0.611</td><td>0.257 ± 0.378</td><td>1.249 ± 0.652</td></tr><tr><td>HSJA+BiLN</td><td>0.252 ±0.165个</td><td>1.147 ± 0.535↓*</td><td>0.170 ± 0.143↓*</td><td>1.205± 0.711↓*</td></tr><tr><td>HSJA+Rand</td><td>1.433 ± 0.747个</td><td>2.384± 0.503个</td><td>1.276 ± 0.649个</td><td>1.183 ± 0.596↓</td></tr><tr><td>Sign-OPT</td><td>0.105 ± 0.081</td><td>0.768 ±0.408</td><td>0.768± 0.872</td><td>1.229 ± 0.771</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.225 ± 0.146个</td><td>0.849 ± 0.397个</td><td>0.176 ± 0.204↓</td><td>0.708 ±0.461↓</td></tr><tr><td>Sign-OPT+Rand</td><td>0.440 ± 0.464个</td><td>1.021 ± 0.593个</td><td>0.356 ± 0.385↓</td><td>0.367 ± 0.361↓</td></tr><tr><td>Sign-OPT+AE</td><td>0.331 ± 0.389↑</td><td>0.660 ± 0.302↓</td><td>1.034 ± 0.571个</td><td>1.658 ± 0.638个</td></tr></table>
+
+<table><tr><td>Med. Benign Local ID</td><td>0.469</td><td>0.224</td><td>1.039</td><td>2.013</td></tr><tr><td>Attack Variant</td><td>Natural CIFAR-10</td><td>Madry CIFAR-10</td><td>Natural ImageNet</td><td>Madry ImageNet</td></tr><tr><td>HSJA</td><td>6.65 ± 0.61*</td><td>5.46 ±0.06</td><td>77.35 ± 0.04</td><td>77.32 ± 0.00</td></tr><tr><td>HSJA+BiLN</td><td>5.37 ± 0.69↓</td><td>3.86 ±0.10↓*</td><td>55.12 ± 1.37↓*</td><td>56.14±0.12↓</td></tr><tr><td>HSJA+Rand</td><td>11.33 ± 7.41个</td><td>2.01 ±1.65↓</td><td>72.19 ± 59.98↓</td><td>3.22 ±2.73</td></tr><tr><td>Sign-OPT</td><td>3.72 ± 0.99</td><td>0.71 ±0.38</td><td>1.70 ± 1.01</td><td>0.55 ± 0.18</td></tr><tr><td>Sign-OPT+BiLN</td><td>3.71 ± 1.02↓</td><td>0.78 ± 0.35个</td><td>1.83 ± 0.97个</td><td>1.74 ± 0.56个</td></tr><tr><td>Sign-OPT+Rand</td><td>8.21 ± 6.67个</td><td>2.32 ± 2.07个</td><td>37.54± 46.20个</td><td>6.72 ± 1.54个</td></tr><tr><td>Sign-OPT+AE</td><td>4.66 ± 0.86↑</td><td>2.48 ± 0.32↑</td><td>36.83 ± 0.15个</td><td>36.87 ± 0.31↑</td></tr></table>
+
+Table 2: Average per-pixel gradient deviation on natural and robust CIFAR-10 (unit of $1 0 ^ { - 2 }$ ) and ImageNet (unit of $\mathrm { { \bar { 1 0 } ^ { - 4 } } }$ ) over 200 samples. Top row lists the median Local Intrinsic Dimensionality (LID) of benign samples from the dataset. Arrows denote higher or lower deviation compared to baseline variant, and starred items indicate highest success rate.
+
+# 5.1 MANIFOLD DISTANCE
+
+LPIPS results are shown in Table 1, with colored arrows denoting either lower distance than baseline variant (green arrow), or a higher distance (red arrow). Generally, the dimension-reduced variants lower the proxy of manifold distance on ImageNet more often than on CIFAR-10 (green arrows). The random sampling variant $\times$ -Rand) discards the semantic priors of the estimate, and in fact it achieved the lowest SR AUC scores, despite having lower scores. Our results using LPIPS are consistent with $L _ { \infty }$ distance of the manifold approximation (Section A.5.9), and Frechet Inception Distance ´ (Section A.5.8), which all demonstrate a tendency to be lower with dimension-reduced attacks.
+
+Observation 2. Dimension-reduced hard-label attacks can have lower LPIPS score, $L _ { \infty }$ approximated distance, and Frechet Inception Distance (and thus lower manifold distance) on robust models ´ if they preserve semantic priors in the update, which supports Hypothesis 2.
+
+# 5.2 GRADIENT DEVIATION
+
+The results for gradient deviation are shown in Table 2. Notably, an attack can have high gradient deviation despite low LPIPS score (AE case, bottom row). Likewise, low deviation does not imply successful attack, as we show later with the Rand variant (rows three and six). We investigated why Madry ImageNet did not always have lower gradient deviation, which we posit is due to having a higher true dimensionality. For the benign samples of each dataset we estimated the Local Intrinsic Dimensionality (LID), which was proposed to estimate true data dimensionality in a region around samples (Amsaleg et al., 2017). In the top row of Table 2 we find the median LID is similar between natural and robust CIFAR-10, but much higher on robust ImageNet than natural. Since our results of Section 3 suggested that higher problem dimension reduced mutual information, we suspect the Madry ImageNet model reduces the leakage through the NMD oracle through higher true data dimensionality. We leave a deeper analysis of this direction for future work. Results on additional robust CIFAR-10 models are provided in Section A.5.2 of the Appendix, which exhibited a similar trend of lower gradient deviation. Sign-OPT has a universally lower gradient deviation than HSJA, which aligns with findings of Liu et al. (2020).
+
+![](images/971f85b87184092256aa2eb10969112b19791694002b8015fda63e6d1ce816e1.jpg)  
+Figure 2: Success rates across attacks over 200 samples on CIFAR-10 (a) and ImageNet (b).
+
+Observation 3. The gradient deviation is universally lower on the robust CIFAR-10 model for BiLN attacks (rows two and five). For ImageNet, deviation on robust models is either lower or similar (rows one, two, four, and seven).
+
+# 5.3 INFORMING PRACTICE
+
+We have shown that dimension reduction has unexpected consequences in terms of manifold distance, and on CIFAR-10 and some ImageNet cases, leads to a lower gradient deviation on the robust model. We finalize our contribution by providing a comprehensive evaluation of the attack success rates in Figure 2 against number of queries. The plots are quantified by taking their max-normalized Trapezoid rule area-under-curve (AUC).2 For comparison, the highest AUC scores are starred in the previous tables. Our dimension-reduced HSJA $+$ BiLN variant (yellow line) surpasses the previous SotA hard-label attack for ImageNet, HSJA, on both natural and robust models. This variant also exhibited the lowest LPIPS score across attack variants. However, lowest LPIPS score does not imply highest SR, evidenced with HSJA $^ +$ Rand on natural ImageNet (brown line, $\mathrm { A U C } = 0 . 0 7 7 $ and SignOPT variants on either dataset (e.g., yellow line in Madry ImageNet, $\mathbf { A U C } = 0 . 2 1 5 ,$ . Low gradient deviation does not imply higher attack success, evidenced by Sign-OPT $+$ BiLN in Table 2 for Madry CIFAR-10 $( \mathrm { A U C } = 0 . 1 5 6 )$ or HSJA $^ { + }$ Rand and Sign-OPT $^ { + }$ Rand $( \mathrm { A U C } = 0 . 0 8 8$ and $\mathrm { { A U C } = 0 . 0 9 2 }$ , respectively). The Rand variants, combined with our findings so far, allow us to say the following.
+
+Observation 4. Successful attacks exhibit preservation of leaked semantic priors. Measures of manifold distance such as LPIPS tend to be lower on dimension-reduced attacks, independent of variance in the gradient estimate.
+
+We posit that minimizing gradient deviation through correction of estimator bias alone could be misleading, since the semantic information provided by a better NMD oracle (due to dimension reduction) can potentially improve the gradient deviation. Although our theoretical analysis focuses on robust models, we suspect future hard-label attacks may treat $\epsilon$ as a useful prior, which carries with it implications about when to deploy robust models in society. On the contrary, natural models will respond to any input changes, even if they are semantically meaningless (Santurkar et al., 2019), so depending on the adversary’s goal (e.g., evasion or information leakage), they could be less useful in the hard-label setting.
+
+# 6 CONCLUSION
+
+Despite the recent progress in zeroth-order attack methods, open questions remain about their precise behavior. We develop an information-theoretic analysis that sheds light on their ability to produce on-manifold adversarial examples. Through experiments on real-world datasets, we show an over two-fold increase in attack success rates by leveraging new findings about manifold distance and gradient deviation. With knowledge of the manifold-gradient relationship, it is possible to further refine hard-label attacks, and inform a better evaluation of model robustness. Given the availability of larger datasets in the future, our method may turn the strength of deep learning, which is efficiently extracting patterns in large-scale data, into a weakness.
+
+# REFERENCES
+
+L. Amsaleg, J. Bailey, D. Barbe, S. Erfani, M. E. Houle, V. Nguyen, and M. Radovanovic. The ´ vulnerability of learning to adversarial perturbation increases with intrinsic dimensionality. In 2017 IEEE Workshop on Information Forensics and Security (WIFS), pp. 1–6, December 2017. doi: 10.1109/WIFS.2017.8267651.   
+Normand J. Beaudry and Renato Renner. An intuitive proof of the data processing inequality. arXiv:1107.0740 [quant-ph], September 2012. URL http://arxiv.org/abs/1107.0740. arXiv: 1107.0740.   
+Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-Based Adversarial Attacks: Reliable Attacks Against Black-Box Machine Learning Models. arXiv:1712.04248 [cs, stat], December 2017. URL http://arxiv.org/abs/1712.04248. arXiv: 1712.04248.   
+Nicholas Carlini and David Wagner. Towards Evaluating the Robustness of Neural Networks. In Security and Privacy (SP), pp. 582–597, 2016. ISBN 978-1-5090-5533-3. doi: 10.1109/SP.2017.49. arXiv: 1608.04644 ISSN: 10816011.   
+Nicholas Carlini and David Wagner. Adversarial Examples Are Not Easily Detected: Bypassing Ten Detection Methods. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security - AISec ’17, pp. 3–14, Dallas, Texas, USA, 2017. ACM Press. ISBN 978-1-4503-5202- 4. doi: 10.1145/3128572.3140444. URL http://dl.acm.org/citation.cfm?doid= 3128572.3140444.   
+Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, Aleksander Madry, and Alexey Kurakin. On Evaluating Adversarial Robustness. arXiv:1902.06705 [cs, stat], February 2019. URL http://arxiv.org/abs/1902.06705. arXiv: 1902.06705.   
+Jianbo Chen, Michael I. Jordan, and Martin J. Wainwright. HopSkipJumpAttack: A Query-Efficient Decision-Based Attack. arXiv:1904.02144 [cs, math, stat], April 2019. URL http://arxiv. org/abs/1904.02144. arXiv: 1904.02144.   
+Jinghui Chen and Quanquan Gu. RayS: A Ray Searching Method for Hard-label Adversarial Attack. arXiv:2006.12792 [cs, stat], June 2020. URL http://arxiv.org/abs/2006.12792. arXiv: 2006.12792.   
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. ZOO: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In ACM Workshop on Artificial Intelligence and Security, pp. 15–26, 2017.   
+Pin-Yu Chen, Yash Sharma, Huan Zhang, Jinfeng Yi, and Cho-Jui Hsieh. Ead: elastic-net attacks to deep neural networks via adversarial examples. In Thirty-second AAAI conference on artificial intelligence, 2018.   
+Minhao Cheng, Thong Le, Pin-Yu Chen, Jinfeng Yi, Huan Zhang, and Cho-Jui Hsieh. Query-Efficient Hard-label Black-box Attack:An Optimization-based Approach. arXiv:1807.04457 [cs, stat], July 2018. URL http://arxiv.org/abs/1807.04457. arXiv: 1807.04457.
+
+Minhao Cheng, Thong Le, Pin-Yu Chen, Jinfeng Yi, Huan Zhang, and Cho-Jui Hsieh. Queryefficient hard-label black-box attack: An optimization-based approach. International Conference on Learning Representations, 2019.
+
+Minhao Cheng, Simranjit Singh, Patrick Chen, Pin-Yu Chen, Sijia Liu, and Cho-Jui Hsieh. SIGNOPT: A QUERY-EFFICIENT HARD-LABEL ADVERSARIAL ATTACK. The International Conference on Learning Representations (ICLR), pp. 16, 2020. URL https://openreview. net/forum?id ${ . } = { }$ SklTQCNtvS.
+
+Jeremy M. Cohen, Elan Rosenfeld, and J. Zico Kolter. Certified Adversarial Robustness via Randomized Smoothing. arXiv:1902.02918 [cs, stat], February 2019. URL http://arxiv.org/ abs/1902.02918. arXiv: 1902.02918.
+
+Thomas M Cover and Joy A Thomas. Elements of Information Theory. Wiley-Interscience. John Wiley & Sons, 2nd edition, 2006.
+
+Logan Engstrom, Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Brandon Tran, and Aleksander Madry. Learning Perceptually-Aligned Representations via Adversarial Robustness. arXiv:1906.00945 [cs, stat], June 2019. URL http://arxiv.org/abs/1906.00945. arXiv: 1906.00945.
+
+Ryan Feng, Jiefeng Chen, Nelson Manohar, Earlence Fernandes, Somesh Jha, and Atul Prakash. Query-Efficient Physical Hard-Label Attacks on Deep Learning Visual Classification. arXiv:2002.07088 [cs], February 2020. URL http://arxiv.org/abs/2002.07088. arXiv: 2002.07088.
+
+Matt Fredrikson, Somesh Jha, and Thomas Ristenpart. Model Inversion Attacks that Exploit Confidence Information and Basic Countermeasures. Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security - CCS ’15, pp. 1322–1333, 2015. ISSN 15437221. doi: 10.1145/2810103.2813677. URL http://dl.acm.org/citation.cfm? doid ${ . } =$ 2810103.2813677. ISBN: 9781450338325.
+
+Justin Gilmer, Luke Metz, Fartash Faghri, Samuel S. Schoenholz, Maithra Raghu, Martin Wattenberg, and Ian Goodfellow. The Relationship Between High-Dimensional Geometry and Adversarial Examples. arXiv:1801.02774 [cs], September 2018. URL http://arxiv.org/abs/1801. 02774. arXiv: 1801.02774.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and Harnessing Adversarial Examples. 2014. ISSN 0012-7183. URL http://arxiv.org/abs/1412.6572. arXiv: 1412.6572 ISBN: 1412.6572.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium. arXiv:1706.08500 [cs, stat], January 2018. URL http://arxiv.org/abs/1706.08500. arXiv: 1706.08500.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box Adversarial Attacks with Limited Queries and Information. arXiv:1804.08598 [cs, stat], July 2018. URL http: //arxiv.org/abs/1804.08598. arXiv: 1804.08598.
+
+Ajil Jalal, Andrew Ilyas, Constantinos Daskalakis, and Alexandros G. Dimakis. The Robust Manifold Defense: Adversarial Training using Generative Models. arXiv:1712.09196 [cs, stat], July 2019. URL http://arxiv.org/abs/1712.09196. arXiv: 1712.09196.
+
+Kim Jungeum and Xiao Wang. Sensible Adversarial Learning. 2020. URL https:// openreview.net/pdf?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rJlf_RVKwr.
+
+Alex Krizhevsky. Learning Multiple Layers of Features from Tiny Images. pp. 60, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet Classification with Deep Convolutional Neural Networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 25, pp. 1097–1105. Curran Associates, Inc., 2012. URL http://papers.nips.cc/paper/ 4824-imagenet-classification-with-deep-convolutional-neural-networks. pdf.
+
+Cassidy Laidlaw, Sahil Singla, and Soheil Feizi. Perceptual Adversarial Robustness: Defense Against Unseen Threat Models. arXiv:2006.12655 [cs, stat], July 2021. URL http://arxiv.org/ abs/2006.12655. arXiv: 2006.12655.
+
+Sijia Liu, Pin-Yu Chen, Bhavya Kailkhura, Gaoyuan Zhang, Alfred Hero, and Pramod K. Varshney. A Primer on Zeroth-Order Optimization in Signal Processing and Machine Learning. arXiv:2006.06224 [cs, eess, stat], June 2020. URL http://arxiv.org/abs/2006.06224. arXiv: 2006.06224.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards Deep Learning Models Resistant to Adversarial Attacks. arXiv:1706.06083 [cs, stat], June 2017. URL http://arxiv.org/abs/1706.06083. arXiv: 1706.06083.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. DeepFool: a simple and accurate method to fool deep neural networks. 2015. ISSN 10636919. doi: 10.1109/ CVPR.2016.282. URL http://arxiv.org/abs/1511.04599. arXiv: 1511.04599 ISBN: 9781467388511.
+
+Yurii Nesterov and Vladimir Spokoiny. Random Gradient-Free Minimization of Convex Functions. Foundations of Computational Mathematics, 17(2):527–566, April 2017. ISSN 1615-3375, 1615- 3383. doi: 10.1007/s10208-015-9296-2. URL http://link.springer.com/10.1007/ s10208-015-9296-2.
+
+Nicolas Papernot, Patrick Mcdaniel, Somesh Jha, Matt Fredrikson, Z. Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. Proceedings - 2016 IEEE European Symposium on Security and Privacy, EURO S and P 2016, pp. 372–387, 2016. doi: 10.1109/ EuroSP.2016.36. URL http://arxiv.org/abs/1511.07528. arXiv: 1511.07528 ISBN: 9781509017515.
+
+Pouya Samangouei, Maya Kabkab, and Rama Chellappa. Defense-gan: Protecting classifiers against adversarial attacks using generative models. In International Conference on Learning Representations, 2018.
+
+Shibani Santurkar, Dimitris Tsipras, Brandon Tran, Andrew Ilyas, Logan Engstrom, and Aleksander Madry. Image Synthesis with a Single (Robust) Classifier. arXiv:1906.09453 [cs, stat], June 2019. URL http://arxiv.org/abs/1906.09453. arXiv: 1906.09453.
+
+Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander Madry. Adversarially Robust Generalization Requires More Data. arXiv:1804.11285 [cs, stat], May 2018. URL http://arxiv.org/abs/1804.11285. arXiv: 1804.11285.
+
+David Stutz, Matthias Hein, and Bernt Schiele. Disentangling Adversarial Robustness and Generalization. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 12. IEEE Computer Society, 2019.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. pp. 1–10, 2013. ISSN 15499618. doi: 10.1021/ct2009208. URL http://arxiv.org/abs/1312.6199. arXiv: 1312.6199 ISBN: 1549-9618.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.
+
+Thomas Tanay and Lewis Griffin. A Boundary Tilting Persepective on the Phenomenon of Adversarial Examples. arXiv:1608.07690 [cs, stat], August 2016. URL http://arxiv.org/abs/1608. 07690. arXiv: 1608.07690.
+
+Florian Tramer, Nicholas Carlini, Wieland Brendel, and Aleksander Madry. On Adaptive Attacks to Adversarial Example Defenses. arXiv:2002.08347 [cs, stat], February 2020. URL http: //arxiv.org/abs/2002.08347. arXiv: 2002.08347.
+
+Florian Tramer, Fan Zhang, Floriantra Er Epfl, Ari Juels, Michael K Reiter, and Thomas \` Ristenpart. Stealing Machine Learning Models via Prediction APIs. 2016. URL https: //www.usenix.org/conference/usenixsecurity16/technical-sessions/ presentation/tramer. ISBN: 978-1-931971-32-4.
+
+Chun-Chen Tu, Paishun Ting, Pin-Yu Chen, Sijia Liu, Huan Zhang, Jinfeng Yi, Cho-Jui Hsieh, and Shin-Ming Cheng. AutoZOOM: Autoencoder-Based Zeroth Order Optimization Method for Attacking Black-Box Neural Networks. Proceedings of the AAAI Conference on Artificial Intelligence, 33:742–749, July 2019. ISSN 2374-3468, 2159-5399. doi: 10.1609/aaai.v33i01. 3301742. URL https://aaai.org/ojs/index.php/AAAI/article/view/3852.
+
+Haichao Zhang and Jianyu Wang. Defense Against Adversarial Attacks Using Feature Scatteringbased Adversarial Training. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d\textquotesingle Alche-Buc, E. Fox, and R. Garnett (eds.), ´ Advances in Neural Information Processing Systems 32, pp. 1831–1841. Curran Associates, Inc., 2019.
+
+Haichao Zhang and Wei Xu. Adversarial Interpolation Training: A simple approach for improving model robustness. 2020. URL https://openreview.net/pdf?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ Syejj0NYvr.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically Principled Trade-off between Robustness and Accuracy. PMLR, pp. 11, 2019.
+
+Richard Zhang, Phillip Isola, Alexei A. Efros, Eli Shechtman, and Oliver Wang. The Unreasonable Effectiveness of Deep Features as a Perceptual Metric. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 586–595, Salt Lake City, UT, June 2018. IEEE. ISBN 978-1- 5386-6420-9. doi: 10.1109/CVPR.2018.00068. URL https://ieeexplore.ieee.org/ document/8578166/.
+
+Xiao Zhang, Jinghui Chen, Quanquan Gu, and David Evans. Understanding the Intrinsic Robustness of Image Distributions using Conditional Generative Models. arXiv:2003.00378 [cs, stat], February 2020. URL http://arxiv.org/abs/2003.00378. arXiv: 2003.00378.
+
+# A APPENDIX
+
+# A.1 DERIVATION OF MANIFOLD-GRADIENT MUTUAL INFORMATION (MI)
+
+We define the manifold-gradient point-wise joint probability in a case-wise manner, for the respective values under $\mathbf { g } \in \{ - 1 , \bar { 1 } \} ^ { d }$ and $\bar { \mathbf { x } } \in \mathbb { R } ^ { d }$ . We are concerned with the sub-gradient cases where $\mathbf { x } > 0$ (denoted $\mathbf { x } ^ { + }$ ) and $\mathbf { x } < 0$ (denoted $\mathbf { x } ^ { - }$ ) which correspond to fixed values of $\mathbf { g }$ based on class means $y \cdot \pmb { \mu }$ with $y \in \{ - 1 , 1 \}$ . This gives for each dimension $k$ ,
+
+$$
+\begin{array} { l } { { \displaystyle p ( { \bf g } _ { k } = 1 , { \bf x } _ { k } ^ { + } ) = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \mathrm { e x p } \left( - \frac { 1 } { 2 } \left( \frac { { \bf x } _ { k } ^ { + } - \mu _ { k } } { \sigma } \right) ^ { 2 } \right) } } \\ { { \displaystyle p ( { \bf g } _ { k } = 1 , { \bf x } _ { k } ^ { - } ) = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \mathrm { e x p } \left( - \frac { 1 } { 2 } \left( \frac { { \bf x } _ { k } ^ { + } + \mu _ { k } } { \sigma } \right) ^ { 2 } \right) } } \end{array}
+$$
+
+$$
+\begin{array} { l } { { \displaystyle p ( { \bf g } _ { k } = - 1 , { \bf x } _ { k } ^ { + } ) = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \mathrm { e x p } \left( - \frac { 1 } { 2 } \left( \frac { { \bf x } _ { k } ^ { + } + \mu _ { k } } { \sigma } \right) ^ { 2 } \right) } } \\ { { \displaystyle p ( { \bf g } _ { k } = - 1 , { \bf x } _ { k } ^ { - } ) = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \mathrm { e x p } \left( - \frac { 1 } { 2 } \left( \frac { { \bf x } _ { k } ^ { + } - \mu _ { k } } { \sigma } \right) ^ { 2 } \right) . } } \end{array}
+$$
+
+Since the Schmidt et al. Gaussian mixture is created symmetrically (the probability mass is evenly split between the two classes i.e., the mixture comprises one Gaussian offset by $\pmb { \mu _ { k } }$ and mirrored at $\mathbf { x } _ { k } = 0 .$ ) we can simplify to
+
+$$
+p ( \mathbf { g } _ { k } = 1 , \mathbf { x } _ { k } ^ { + } ) = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \mathrm { e x p } \left( - \frac { 1 } { 2 } \left( \frac { \mathbf { x } _ { k } ^ { + } - \pmb { \mu } _ { k } } { \sigma } \right) ^ { 2 } \right) ,
+$$
+
+$$
+p ( \mathbf { g } _ { k } = - 1 , \mathbf { x } _ { k } ^ { + } ) = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \mathrm { e x p } \left( - \frac { 1 } { 2 } \left( \frac { \mathbf { x } _ { k } ^ { + } + \pmb { \mu } _ { k } } { \sigma } \right) ^ { 2 } \right) ,
+$$
+
+where $\mathbf { x } \sim { \mathcal { N } } ( y \cdot \mu , \sigma I )$ . In words, Equation 6 is the symmetrical tail of the Gaussian mixture marginal while Equation 5 is the remainder of the mixture.
+
+Similarly, a point-wise gradient is given as the Rademacher outcome $\mathbf { g } _ { k } \in \{ \pm 1 \}$ . The choice of $\epsilon$ directly influences the marginal probability over the manifold. The marginal probability over the manifold can be given as the Riemann approximations
+
+$$
+p _ { \mathcal { G } } ( \mathbf { g } _ { k } = 1 ) _ { \epsilon } = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \sum _ { i = 1 } ^ { n } \exp \left( - \frac { 1 } { 2 } \left( \frac { \mathbf { x } _ { i , k } ^ { * } - \pmb { \mu } _ { k } } { \sigma } \right) ^ { 2 } \right) \Delta _ { i }
+$$
+
+and
+
+$$
+p _ { \mathcal { G } } ( \mathbf { g } _ { k } = - 1 ) _ { \epsilon } = \frac { 1 } { 2 \sigma \sqrt { 2 \pi } } \sum _ { i = 1 } ^ { n } \exp \left( - \frac { 1 } { 2 } \left( \frac { \mathbf { x } _ { i , k } ^ { * } + \mu _ { k } } { \sigma } \right) ^ { 2 } \right) \Delta _ { i } ,
+$$
+
+with $\Delta _ { i } = \mathbf { x } _ { i , k } ^ { + } - \mathbf { x } _ { i - 1 , k } ^ { + }$ for arbitrary $\mathbf { x } _ { i , k } ^ { * } \in [ \mathbf { x } _ { i - 1 , k } ^ { + } , \mathbf { x } _ { i , k } ^ { + } ]$ , and $n$ is controlled by the hyper-parameter $\epsilon$ .
+
+The marginal for the manifold under the gradient is given similarly as
+
+$$
+{ \begin{array} { r l } & { p _ { \mathcal { M } } ( \mathbf { x } _ { k } ) = p ( \mathbf { g } _ { k } = 1 , \mathbf { x } _ { k } ^ { + } ) + p ( \mathbf { g } _ { k } = - 1 , \mathbf { x } _ { k } ^ { + } ) } \\ & { \qquad = { \frac { 1 } { \sigma { \sqrt { 2 \pi } } } } \exp \left( - { \frac { 1 } { 2 } } \left( { \frac { \mathbf { x } _ { k } ^ { + } - { \boldsymbol { \mu } } _ { k } } { \sigma } } \right) ^ { 2 } \right) + { \frac { 1 } { \sigma { \sqrt { 2 \pi } } } } \exp \left( - { \frac { 1 } { 2 } } \left( { \frac { \mathbf { x } _ { k } ^ { + } + { \boldsymbol { \mu } } _ { k } } { \sigma } } \right) ^ { 2 } \right) , } \end{array} }
+$$
+
+where $\mathbf { x } _ { k } ^ { + } > 0$ for all dimensions $k$ . Denote the sub-manifold sampled from the positive $( y = 1 )$ ) and negative $y = - 1 ,$ ) classes as $\mathcal { M } ^ { + }$ and $\mathcal { M } ^ { - }$ , respectively. Our definition for manifold-gradient mutual information is based on the standard definition of mutual information from information theory (Cover & Thomas, 2006),
+
+$$
+I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon , k } = \int _ { \mathcal { M } } \int _ { \mathcal { G } } p ( \mathbf { g } _ { k } , \mathbf { x } _ { k } ) \log \bigr ( \frac { p ( \mathbf { g } _ { k } , \mathbf { x } _ { k } ) } { p _ { \mathcal { G } } ( \mathbf { g } _ { k } ) p _ { \mathcal { M } } ( \mathbf { x } _ { k } ) } \bigr ) d \mathbf { g } _ { k } d \mathbf { x } _ { k } ,
+$$
+
+where $\epsilon$ is treated as a hyper-parameter controlling the value of $n$ in $p _ { \mathcal { G } } ( \mathbf { g } _ { k } )$ . By substitution into Equation 10 we have
+
+$$
+\begin{array} { l } { { \displaystyle I ( { \mathcal { M } } , { \mathcal { G } } ) _ { \epsilon , k } = \int _ { { \mathcal { M } } } p ( 1 , { \mathbf { x } } _ { k } ) \log ( \frac { p ( 1 , { \mathbf { x } } _ { k } ) } { p _ { \mathcal { G } } ( 1 ) p _ { \mathcal { M } } ( { \mathbf { x } } _ { k } ) } ) d { \mathbf { x } } _ { k } } } \\ { { \displaystyle ~ + \int _ { { \mathcal { M } } } p ( - 1 , { \mathbf { x } } _ { k } ) \log ( \frac { p ( - 1 , { \mathbf { x } } _ { k } ) } { p _ { \mathcal { G } } ( - 1 ) p _ { \mathcal { M } } ( { \mathbf { x } } _ { k } ) } ) d { \mathbf { x } } _ { k } } . } \end{array}
+$$
+
+This is split further similar to true positive, true negative, false positive, and false negative, as
+
+$$
+\begin{array} { l } { { \displaystyle I ( { \mathcal M } , { \mathcal G } ) _ { \epsilon , k } = \int _ { { \mathcal M } + } p ( 1 , { \mathbf x } _ { k } ^ { + } ) \log ( \frac { p ( 1 , { \mathbf x } _ { k } ^ { + } ) } { p _ { \mathcal G } ( 1 ) p _ { { \mathcal M } } ( { \mathbf x } _ { k } ^ { + } ) } ) d { \mathbf x } _ { k } ^ { + } } } \\ { ~ + \int _ { { \mathcal M } ^ { - } } p ( 1 , { \mathbf x } _ { k } ^ { - } ) \log ( \frac { p ( 1 , { \mathbf x } _ { k } ^ { - } ) } { p _ { \mathcal G } ( 1 ) p _ { { \mathcal M } } ( { \mathbf x } _ { k } ^ { - } ) } ) d { \mathbf x } _ { k } ^ { - } }  \\ { { + \int _ { { \mathcal M } ^ { + } } p ( - 1 , { \mathbf x } _ { k } ^ { + } ) \log ( \frac { p ( - 1 , { \mathbf x } _ { k } ^ { + } ) } { p _ { \mathcal G } ( - 1 ) p _ { { \mathcal M } } ( { \mathbf x } _ { k } ^ { + } ) } ) d { \mathbf x } _ { k } ^ { + } } } \\ { { + \int _ { { \mathcal M } ^ { - } } p ( - 1 , { \mathbf x } _ { k } ^ { - } ) \log ( \frac { p ( - 1 , { \mathbf x } _ { k } ^ { - } ) } { p _ { \mathcal G } ( - 1 ) p _ { { \mathcal M } } ( { \mathbf x } _ { k } ^ { - } ) } ) d { \mathbf x } _ { k } ^ { - } , } } \end{array}
+$$
+
+and simplified due to symmetry at 0 as
+
+$$
+\begin{array} { l } { { \displaystyle I ( { \mathcal { M } } , { \mathcal { G } } ) _ { \epsilon , k } = 2 \int _ { { \mathcal { M } } ^ { + } } p ( 1 , { \mathbf { x } } _ { k } ^ { + } ) \log ( \frac { p ( 1 , { \mathbf { x } } _ { k } ^ { + } ) } { p _ { \mathcal { G } } ( 1 ) p _ { \mathcal { M } } ( { \mathbf { x } } _ { k } ^ { + } ) } ) d { \mathbf { x } } _ { k } ^ { + } } } \\ { { \displaystyle ~ + \ 2 \int _ { { \mathcal { M } } ^ { + } } p ( - 1 , { \mathbf { x } } _ { k } ^ { + } ) \log ( \frac { p ( - 1 , { \mathbf { x } } _ { k } ^ { + } ) } { p _ { \mathcal { G } } ( - 1 ) p _ { \mathcal { M } } ( { \mathbf { x } } _ { k } ^ { + } ) } ) d { \mathbf { x } } _ { k } ^ { + } } . } \end{array}
+$$
+
+The total un-normalized mutual information is given by the summation over dimensions $\scriptstyle \sum _ { k = 1 } ^ { d } I ( { \mathcal { M } } , { \mathcal { G } } ) _ { \epsilon , k }$ . Notably the cases for each possible scenario under detection theory are repre- is bounded by the results of Schmidt et al. (2018). By substitution from each $I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon } =$ marginal and joint probability in Equations 8, 3, and 4 respectively, we have the closed form solution for mutual information.
+
+This leads to the Riemann approximation of Equation 13,
+
+$$
+\begin{array} { r l } { \displaystyle I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon , k } = 2 \sum _ { i = 1 } ^ { n } p ( 1 , \mathbf { x } _ { i , k } ^ { * } ) \log ( \frac { p ( 1 , \mathbf { x } _ { i , k } ^ { * } ) } { p _ { \mathcal { G } } ( 1 ) p _ { \mathcal { M } } ( \mathbf { x } _ { i , k } ^ { * } ) } ) \Delta _ { i } } & { } \\ { \displaystyle + 2 \sum _ { i = 1 } ^ { n } p ( - 1 , \mathbf { x } _ { i , k } ^ { * } ) \log ( \frac { p ( - 1 , \mathbf { x } _ { i , k } ^ { * } ) } { p _ { \mathcal { G } } ( - 1 ) p _ { \mathcal { M } } ( \mathbf { x } _ { i , k } ^ { * } ) } ) \Delta _ { i } . } & { } \end{array}
+$$
+
+with $\Delta _ { i } = \mathbf { x } _ { i , k } ^ { + } - \mathbf { x } _ { i - 1 , k } ^ { + }$ for arbitrary positive $\mathbf { x } _ { i , k } ^ { * } \in [ \mathbf { x } _ { i - 1 , k } ^ { + } , \mathbf { x } _ { i , k } ^ { + } ]$ . Since $\mathbf { x } ^ { + }$ is a standard multivariate Gaussian (Cover & Thomas, 2006), the final mutual information is the summation over each dimension,
+
+$$
+\begin{array} { r l } { I ( \mathcal { M } , \mathcal { G } ) _ { \epsilon } = 2 \displaystyle \sum _ { k = 1 } ^ { d } \sum _ { i = 1 } ^ { n } p ( 1 , \mathbf { x } _ { i , k } ^ { * } ) \log ( \frac { p ( 1 , \mathbf { x } _ { i , k } ^ { * } ) } { p _ { \mathcal { G } } ( 1 ) p _ { \mathcal { M } } ( \mathbf { x } _ { i , k } ^ { * } ) } ) \Delta _ { i } } & { { } } \\ { \quad \quad \quad \quad + 2 \displaystyle \sum _ { k = 1 } ^ { d } \sum _ { i = 1 } ^ { n } p ( - 1 , \mathbf { x } _ { i , k } ^ { * } ) \log ( \frac { p ( - 1 , \mathbf { x } _ { i , k } ^ { * } ) } { p _ { \mathcal { G } } ( - 1 ) p _ { \mathcal { M } } ( \mathbf { x } _ { i , k } ^ { * } ) } ) \Delta _ { i } . } & { { } } \end{array}
+$$
+
+# A.2 HARD-LABEL ATTACK FORMULATION
+
+Contemporary hard-label attacks are variants of random gradient-free method (RGF) (Nesterov & Spokoiny, 2017), a gradient estimator which yields the estimate $\hat { \bf g }$ over $q$ random directions $\{ { \mathbf { u } } _ { i } \} _ { i = 1 } ^ { q }$
+
+OPT-Attack For benign example $\mathbf { x } _ { \mathrm { 0 } }$ , true label $y _ { 0 }$ , and hard-label black-box function $f : \mathbb { R } ^ { d } $ $\{ 1 , \ldots , K \}$ , Cheng et al. (2019) define the objective function $g : \mathbb { R } ^ { d }  \mathbb { R }$ as a function of search direction $\pmb \theta$ , where the optimal solution is $g ( \theta ^ { * } )$ , the minimum distance from $\mathbf { x } _ { \mathrm { 0 } }$ to the nearest adversarial example along the direction $\pmb { \theta } ^ { * }$ . For the untargeted attack, $g ( \pmb \theta )$ is the distance to any decision boundary along direction $\pmb \theta$ , and allows for estimating the gradient as
+
+$$
+\hat { \mathbf { g } } = \frac { 1 } { q } \sum _ { i = 0 } ^ { q } \frac { g ( \pm \beta \mathbf { u } _ { i } ) - g ( \pmb { \theta } ) } { \beta } \cdot \mathbf { u } _ { i } ,
+$$
+
+where $\beta$ is a small smoothing parameter. Notably, $g ( \pmb \theta )$ is continuous even if $f$ is a non-continuous step function.
+
+Sign-OPT Cheng et al. (2020) later improved the query efficiency by only considering the sign of the gradient estimate,
+
+$$
+\hat { \nabla } g ( \pmb \theta ) \approx \hat { \mathbf g } : = \sum _ { i = 1 } ^ { q } \mathrm { s i g n } \left( g ( \pmb \theta + \beta \mathbf { u } _ { i } ) - g ( \pmb \theta ) \right) \mathbf { u } _ { i } .
+$$
+
+We focus on the Sign-OPT variant, since the findings are more relevant to the current state-of-the-art.
+
+HopSkipJumpAttack Similar to Sign-OPT, HopSkipJumpAttack (HSJA) (Chen et al., 2019) uses a zeroth-order sign oracle to improve Boundary Attack (Brendel et al., 2017). HSJA lacks the convergence analysis of Sign-OPT and relies on one-point gradient estimate. Regardless, HSJA is competitive and can excel in the $L _ { \infty }$ setting.
+
+Dimension-reduced Sign-OPT & HSJA. In general, for attacks relying on the Cheng et al. (2019) formulation, the update in Equation 16 becomes
+
+$$
+\hat { \bf g } = \frac { 1 } { q } \sum _ { i = 0 } ^ { q } \frac { g ( \pmb { \theta } ^ { \prime } + \beta \mathbf { u } _ { i } ^ { \prime } ) - g ( \pmb { \theta } ^ { \prime } ) } { \beta } \cdot \mathbf { u } _ { i } ^ { \prime }
+$$
+
+for the reduced-dimension Gaussian vectors $\{ \mathbf { u } _ { i } ^ { \prime } \in \mathbb { R } ^ { d ^ { \prime } } \} _ { i = 0 } ^ { q }$ for integer $d ^ { \prime } < d$ and direction $\pmb { \theta } ^ { \prime } \in \mathbb { R } ^ { d ^ { \prime } }$ . The reduced-dimension direction $\pmb { \theta } ^ { \prime }$ is initialized randomly with $\pmb { \theta } ^ { \prime } \sim \mathcal { N } ( 0 , 1 )$ for the untargeted case, or for the targeted case as $\pmb { \theta } ^ { \prime } = \mathcal { E } ( \mathbf { x } _ { t } )$ , where $\mathbf { x } _ { t }$ is a test sample correctly classified as target class $t$ by the victim model. This scheme also applies to HSJA, since HSJA performs a single-point sign estimate. As in the normal variants, $\hat { \bf g }$ is used to update $\pmb { \theta } ^ { \prime }$ .
+
+# A.3 MAIN PAPER BLOCK DIAGRAM
+
+A block diagram of assumptions, claims, and observations is shown in Figure 3.
+
+![](images/979cd2f1dcb85dd68c32313ec1ca15d7b1f300f63cc80acc4c6361343a1daf23.jpg)  
+Figure 3: Block diagram summarizing the assumptions, claims, and observations of the main paper.
+
+# A.4 IMPLEMENTATION DETAILS
+
+# A.4.1 HARDWARE AND ATTACK HYPERPARAMETERS
+
+All experiments in the main paper were performed on an internal high-performance compute cluster equipped with NVIDIA Tesla V100 Tensor Core GPUs and high-speed non-volatile flash storage. In total 16 GPUs, 1TB main system memory, and 40 Intel Xeon CPU cores were used to run experiments completely.
+
+Depending on dataset dimension, HSJA requires tuning of parameter $\gamma$ for best performance. On CIFAR-10 we used $\gamma = 1 0 . 0$ . For ImageNet, it was necessary to set $\gamma \geq 1 0 0 0 . 0$ to re-create the published results of the regular variant (Chen et al., 2019). Due to similar performance we use $\gamma = 1 0 0 0 . 0$ for regular and dimension-reduced variants. We note that the dimension-reduced variants like HSJA+BiLN were less sensitive to $\gamma$ , performing similarly regardless of the setting.
+
+# A.4.2 ADVERSARY AUTOENCODER
+
+We are primarily interested in the effect of reduced search resolution on attack behavior. Thus in this work, given a candidate direction $\pmb { \theta } ^ { \prime }$ and magnitude (or radius) $r$ , the adversarial sample in the AE case is the blending $( 1 - r ) \mathbf { x } _ { 0 } + r \mathcal { D } \left( \mathcal { E } ( \mathbf { x } _ { 0 } ) \mathbf { \bar { \rho } } + \pmb { \theta } ^ { \prime } \right)$ . 3
+
+For AE attack variants, we implement the same architecture described by Tu et al. (2019). Specifically it leverages a fully convolutional network for the encoder and decoder. Every AE is trained using the held out test set, as we assume disjoint data between adversary and victim.
+
+The adversary’s AE is tuned to minimize reconstruction error of input images, so the output quality of the AE will depend on the adversary’s ability to collect data. We assume the adversary only has access to the test set, which tends to be considerably less informative than the training set. This crude manifold approximation can manifest as an additional layer of distortion on top of adversarial noise. With BiLN, no additional training is required, so it synthesizes search directions independent of the adversary’s manifold description (i.e., possible extracted knowledge about test samples).
+
+ImageNet samples are downsized to $1 2 8 \mathrm { x } 1 2 8$ before passing to the AE, and the output of the AE is scaled back to $2 2 4 \mathbf { x } 2 2 4$ , as described by Tu et al. (2019).
+
+# A.4.3 DATA SAMPLING
+
+Original samples are chosen from the test set using the technique from Chen et al. (2019): on CIFAR-10, five random samples are taken from each of ten uniform-randomly chosen classes (i.e., 50 total samples). On the ImageNet dataset, ten random classes are uniform-randomly chosen and ten random samples taken from each (100 total samples).
+
+# A.5 SUPPLEMENTAL RESULTS
+
+# A.5.1 QUERY VS. DISTORTION PLOTS
+
+We show the model queries against attack distortion measurement in Figure 4 to accompany the results in the main paper. The distortion is much higher and stays higher with Rand variants, due to discarding important semantic information. The plots evidence that BiLN variants (yellow lines) offer a simple yet effective way to improve the query efficiency of the hard-label attacks.
+
+# A.5.2 GRADIENT DEVIATION ON ROBUST CIFAR-10
+
+In Table 3 we show supplementary gradient deviation results for CIFAR-10 using different defense mechanisms or robust models. In general they exhibit the same trend as our main paper results, which is that dimension-reduced attacks manage to reduce gradient deviation across each robust model.
+
+![](images/f9c7cf7768af79749c237fe7c0baeb5938a09c506a0ac225576e1d3e8f2a4b36.jpg)  
+Figure 4: Query vs. distortion plots for a) CIFAR-10 and b) ImageNet, corresponding to the success rate plots in the main text. Dashed lines denote the value of $\epsilon$ .
+
+Table 3: Per-pixel gradient deviation measured across additional robust CIFAR-10 models   
+
+<table><tr><td>Attack Variant</td><td>TRADES (Zhang et al., 2019)</td><td>Interpolation (Zhang &amp; Xu,2020)</td><td>Feat. Scattering (Zhang &amp;Wang,2019)</td><td>SENSE (Jungeum &amp; Wang,2020)</td></tr><tr><td>HSJA</td><td>0.0542±0.0001</td><td>0.0542±0.0001</td><td>0.0541±0.0000</td><td>0.0556±0.0045</td></tr><tr><td>HSJA+BiLN</td><td>0.0395±0.0001</td><td>0.0393±0.0001</td><td>0.0401±0.0004</td><td>0.0389±0.0056</td></tr><tr><td>HSJA+Rand</td><td>0.008±0.004</td><td>0.002±0.005</td><td>0.216±0.000</td><td>0.222±0.017</td></tr><tr><td>Sign-OPT</td><td>0.0042±0.0005</td><td>0.0039±0.0007</td><td>0.0019±0.0004</td><td>0.0083±0.0104</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.0026±0.0007</td><td>0.0023±0.0009</td><td>0.0020±0.0004</td><td>0.0075±0.0110</td></tr><tr><td>Sign-OPT+Rand</td><td>0.007±0.002</td><td>0.004±0.005</td><td>0.006±0.002</td><td>0.025±0.048</td></tr><tr><td>Sign-OPT+AE</td><td>0.0257±0.0002</td><td>0.0282±0.0002</td><td>0.0259±0.0000</td><td>0.0278±0.0069</td></tr></table>
+
+# A.5.3 SUCCESS RATE NORMALIZED AUC SCORES
+
+Tables 5 and 4 show the max-normalized Trapezoid rule area-under-curve (AUC) measurements for the success rate plots of the main text. Highest scores are bolded. Notably, the HSJA $+$ BiLN variant earns the highest score in almost all cases.
+
+# A.5.4 SUCCESS RATE SCORES
+
+We provide the success rates over all samples at specific query intervals in Tables 6 and 7.
+
+# A.5.5 ATTACKING A SMOOTHED MODEL
+
+Gaussian smoothing is a technique of performing adversarial training with sampled affected by Gaussian noise. At test time, inference is achieved via a Monte Carlo search over many Gaussianperturbed versions of the sample under test. The SotA at time of writing, randomized smoothing proposed by Cohen et al. (2019), is a good candidate for hard-label attacks since the true gradient of the smoothed model is undefined. We use the checkpoint corresponding to smoothing parameter $\sigma = 0 . 5$ and $\epsilon \simeq 1 . 0$ . These results are shown in Figure 5. In general, the BiLN variant exceeds all other variants in the natural ImageNet case, with small improvement on the smoothed model. Although it can find samples closer to the smoothed $\epsilon$ , only a fraction are within the bound.
+
+Table 4: Success Rate (SR) Normalized AUC scores for CIFAR-10 SR plots of the main text. Higher is better.   
+
+<table><tr><td>Attack Variant</td><td>Natural CIFAR-10</td><td>Madry CIFAR-10</td></tr><tr><td>HSJA</td><td>1.000</td><td>0.650</td></tr><tr><td>HSJA+BiLN</td><td>0.968</td><td>1.000</td></tr><tr><td>HSJA+Rand</td><td>0.033</td><td>0.088</td></tr><tr><td>Sign-OPT</td><td>0.763</td><td>0.171</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.310</td><td>0.156</td></tr><tr><td>Sign-OPT+Rand</td><td>0.144</td><td>0.092</td></tr><tr><td>Sign-OPT+AE</td><td>0.312</td><td>0.300</td></tr></table>
+
+<table><tr><td>Attack Variant</td><td>Natural ImageNet</td><td>Madry ImageNet</td></tr><tr><td>HSJA</td><td>0.867</td><td>0.470</td></tr><tr><td>HSJA+BiLN</td><td>1.000</td><td>1.000</td></tr><tr><td>HSJA+Rand</td><td>0.077</td><td>0.211</td></tr><tr><td>Sign-OPT</td><td>0.364</td><td>0.153</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.376</td><td>0.215</td></tr><tr><td>Sign-OPT+Rand</td><td>0.070</td><td>0.033</td></tr><tr><td>Sign-OPT+AE</td><td>0.018</td><td>0.105</td></tr></table>
+
+![](images/d2bd3e352f8be4d3e881a6fdfbef44288c3999f54fb1f2b5ddff41692d502bb1.jpg)  
+Table 5: Success Rate (SR) Normalized AUC scores for ImageNet SR plots of the main text. Higher is better.   
+Figure 5: Results of attacking Smoothed ImageNet Cohen et al. (2019) in the $L _ { 2 }$ setting for a) query vs. distortion and b) query vs. success rate, Dashed lines denote the value of $\epsilon$ .
+
+# A.5.6 ATTACKING WITHOUT GRADIENT ESTIMATE
+
+We perform additional experiments with an attack that does not perform an explicit gradient estimate. Chen & Gu (2020) propose an alternative hard-label attack method which is to search for the minimum decision boundary radius $r$ from a sample $\mathbf { x } _ { \mathrm { 0 } }$ , along a ray direction $\pmb { \theta }$ . Instead of searching over $\mathbb { R } ^ { d }$ to minimize $g ( \pmb \theta )$ , Chen et al. propose to perform ray search over directions $\pmb { \theta } \in \{ - 1 , 1 \} ^ { d }$ , resulting in $2 ^ { d }$ maximum possible directions. This reduction of the search resolution enables SotA query efficiency in the $L _ { \infty }$ setting with proof of convergence. The search resolution is further reduced by the hierarchical variant of RayS, which performs on-the-fly upscaling of image super-pixels.
+
+Table 6: CIFAR-10 succcess rate values at query intervals 4k, 11k, and 25k, for setting $\cdot$   
+
+<table><tr><td>Attack Variant</td><td>Natural @4k</td><td>Madry @4k</td><td>Natural @11k</td><td>Madry @11k</td><td>Natural @25k</td><td>Madry @25k</td></tr><tr><td>HSJA</td><td>0.905</td><td>0.100</td><td>0.995</td><td>0.145</td><td>1.000</td><td>0.180</td></tr><tr><td>HSJA+BiLN</td><td>0.850</td><td>0.165</td><td>0.970</td><td>0.225</td><td>0.985</td><td>0.255</td></tr><tr><td>HSJA+Rand</td><td>0.040</td><td>0.020</td><td>0.020</td><td>0.020</td><td>0.040</td><td>0.000</td></tr><tr><td>Sign-OPT</td><td>0.515</td><td>0.030</td><td>0.795</td><td>0.040</td><td>0.890</td><td>0.040</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.235</td><td>0.035</td><td>0.310</td><td>0.035</td><td>0.355</td><td>0.035</td></tr><tr><td>Sign-OPT+Rand</td><td>0.060</td><td>0.020</td><td>0.200</td><td>0.020</td><td>0.180</td><td>0.020</td></tr><tr><td>Sign-OPT+AE</td><td>0.210</td><td>0.055</td><td>0.325</td><td>0.065</td><td>0.345</td><td>0.070</td></tr></table>
+
+Table 7: ImageNet succcess rate values at query intervals 4k, 11k, and 25k, for setting $\cdot$   
+
+<table><tr><td>Attack Variant</td><td>Natural @4k</td><td>Madry @4k</td><td>Natural @11k</td><td>Madry @11k</td><td>Natural @25k</td><td>Madry @ 25k</td></tr><tr><td>HSJA</td><td>0.550</td><td>0.105</td><td>0.850</td><td>0.130</td><td>0.965</td><td>0.165</td></tr><tr><td>HSJA+BiLN</td><td>0.835</td><td>0.240</td><td>0.965</td><td>0.290</td><td>1.000</td><td>0.335</td></tr><tr><td>HSJA+Rand</td><td>0.070</td><td>0.060</td><td>0.070</td><td>0.060</td><td>0.070</td><td>0.060</td></tr><tr><td>Sign-OPT</td><td>0.210</td><td>0.045</td><td>0.335</td><td>0.045</td><td>0.485</td><td>0.045</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.240</td><td>0.055</td><td>0.345</td><td>0.065</td><td>0.445</td><td>0.065</td></tr><tr><td>Sign-OPT+Rand</td><td>0.050</td><td>0.010</td><td>0.070</td><td>0.010</td><td>0.070</td><td>0.010</td></tr><tr><td>Sign-OPT+AE</td><td>0.015</td><td>0.030</td><td>0.015</td><td>0.030</td><td>0.020</td><td>0.040</td></tr></table>
+
+![](images/b225bb9490a9025c43fb78938b9f99c7569ae28daa56453493b3bcd2ae976406.jpg)  
+Figure 6: Results for RayS on the CIFAR-10 dataset, corresponding to distortion against query usage (dotted red line denotes the value of $\epsilon$ , shaded areas mark standard deviation).
+
+The intuition behind RayS attack is to perform a discrete search in at most $2 ^ { d }$ directions. Chen et al. also perform a hierarchical search over progressively larger super-pixels of the image. This has the effect of already upscaling on-the-fly (Chen & Gu, 2020). RayS has the unique behavior of performing a discrete search for the decision boundary, rather than an explicit gradient estimate. To achieve an appropriate reduced-dimension version of RayS, we modify the calculation of $s$ in Algorithm 3 of Chen & Gu (2020), which either speeds up upscaling by a factor $a$ (i.e., $s = s + a )$ ), or extends the search through a specific block index by a factor $b$ (increase block level at $k = 2 ^ { s } b$ instead of $k = 2 ^ { s }$ ).
+
+The result of attacking CIFAR-10 with RayS is shown in Figure 6. The BiLN variants of RayS each have minimal effect on overall query efficiency (Insets 6.i and 6.ii). This is a result of RayS not relying on explicit gradient estimation. When comparing the FID-64 score, the dimension-reduced variants of RayS do not have a large variation between them (Inset 6.i), a side-effect of the adaptive super-pixel search, which can automatically scale the super-pixel size as the search progresses.
+
+Table 8: Measurement of Local Intrinsic Dimensionality (LID) averaged over 200 samples.   
+
+<table><tr><td></td><td>Natural CIFAR-10</td><td>Madry CIFAR-10</td><td>Natural ImageNet</td><td>Madry ImageNet</td></tr><tr><td>Benign</td><td>0.787 ± 0.830</td><td>0.564± 1.724</td><td>1.206 ± 0.803</td><td>2.623 ± 2.383</td></tr><tr><td>HSJA</td><td>8.014 ± 5.829</td><td>62.709 ± 112.416</td><td>4.798 ± 2.578</td><td>3.342 ± 2.263</td></tr><tr><td>HSJA+BiLN</td><td>7.497 ± 5.811</td><td>50.467 ± 100.057</td><td>4.787 ± 2.550</td><td>4.290 ± 4.524</td></tr><tr><td>HSJA+Rand</td><td>6.156 ± 6.053</td><td>15.745 ± 24.195</td><td>5.191 ± 1.948</td><td>3.132 ± 2.489</td></tr><tr><td>Sign-OPT</td><td>7.240 ± 5.006</td><td>51.491 ± 100.080</td><td>4.747 ± 1.988</td><td>3.707 ± 3.660</td></tr><tr><td>Sign-OPT+BiLN</td><td>6.308 ± 4.079</td><td>47.355 ± 119.958</td><td>4.547 ± 2.118</td><td>4.808 ± 4.873</td></tr><tr><td>Sign-OPT+Rand</td><td>5.576 ± 4.178</td><td>12.792 ± 13.546</td><td>5.364 ± 1.757</td><td>4.867 ± 3.369</td></tr><tr><td>Sign-OPT+AE</td><td>6.700 ± 4.735</td><td>51.380 ± 103.355</td><td>4.891 ± 2.299</td><td>3.791 ± 3.598</td></tr></table>
+
+# A.5.7 LOCAL INTRINSIC DIMENSIONALITY
+
+In Table 8 we show the average Local Intrinsic Dimensionality Amsaleg et al. (2017) for each dataset and attack combination.
+
+# A.5.8 FRECHET ´ INCEPTION DISTANCE
+
+Unfortunately, the data manifold of real-world datasets is difficult to describe. This is an open problem in the study of Generative Adversarial Networks (GANs), since designers require that generator images are on-manifold (i.e., in-distribution Zhang et al. (2020)) to preserve semantic relationships between images. This has motivated the recently proposed Frechet Inception Distance (FID) that acts ´ as a surrogate measure of the manifold distance over a set of RGB image samples (Heusel et al., 2018). As an additional proxy for manifold distance, we run experiments that assume adversarial samples are synthetically generated images from the data manifold, which can later be compared to their unmodified counterparts on the true manifold using FID. As a result, this estimation process is only available from the defender’s perspective. Since FID uses an Inception-V3 coding layer (Szegedy et al., 2016) to encode images, the estimation correlates with distortion of semantic high-level features. Thus sampling closer to the data manifold will result in a lower FID score. The attacks in our experiments do not target the Inception-V3 network, so the FID metric will not rely on any internal aspects of the victim models.
+
+FID score is calculated using the 64-dimensional max pooling layer of the Inception-V3 deep network for coding (denoted as FID-64 in this supplementary material), taken from an open-source implementation.4 The choice of the 64-dimensional feature layer allows to calculate full-rank FID without the full 2,048 sample count of original FID, which is prohibitive based on the scale of our analysis. Since the coding layer differs slightly from the original FID-2048 implementation, the magnitudes will differ from those published by Heusel et al. (2018).
+
+The comparison of FID scores is shown in Table 9 for natural and robust models. The scores for ImageNet on dimension-reduced attack variants (italicized) are universally lower (as low as 0.014, bold), while on CIFAR-10 the regular variants did not exhibit the behavior. We posit that the higher dimensionality of ImageNet $( 2 2 4 \times 2 2 4 )$ enables dimension reduction to be more effective than the lower dimension CIFAR-10 $( 3 2 \times 3 2 )$ . In general, attacks have a higher FID score on robust models than natural models. This can be explained by the fact that robust models are more secure in a region around the original sample, as a result the adversarial sample discovery is further away from the true manifold. The random variant (Rand) in rows three and six evidences that the preservation of semantic priors is important during the update, otherwise samples have high manifold distance. The regular variants of HSJA and Sign-OPT are capable of high FID scores on robust models. However, dimension-reduced variants have a universal behavior to reduce the score in the robust setting, similar to the natural setting for ImageNet. AE variants exhibit higher FID score than BiLN, since BiLN can rescale invariant of the adversary’s manifold knowledge (e.g., only having knowledge of test set).
+
+Table 9: Frechet Inception Distance (FID) scores for each attack’s set of 200 adversarial samples on ´ CIFAR-10 and ImageNet (lower is better). ∗ denotes highest success rate (SR) AUC. Arrows denote higher or lower score compared to baseline variant.   
+
+<table><tr><td>Attack Variant</td><td>Natural CIFAR-10</td><td>Madry CIFAR-10</td><td>Natural ImageNet</td><td>Madry ImageNet</td></tr><tr><td>HSJA</td><td>0.005</td><td>1.622</td><td>1.026</td><td>29.756</td></tr><tr><td>HSJA+BiLN</td><td>0.006个</td><td>0.373↓</td><td>0.012↓</td><td>4.646↓</td></tr><tr><td>HSJA+Rand</td><td>2.198个</td><td>8.256个</td><td>3.404↑</td><td>2.354↓</td></tr><tr><td>Sign-OPT</td><td>0.001</td><td>0.305</td><td>20.969</td><td>38.505</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.002个</td><td>0.045↓</td><td>0.009↓</td><td>0.062↓</td></tr><tr><td>Sign-OPT+Rand</td><td>0.141个</td><td>0.210↓</td><td>0.234↓</td><td>0.156↓</td></tr><tr><td>Sign-OPT+AE</td><td>0.333个</td><td>0.008↓</td><td>1.514↓</td><td>7.869↓</td></tr></table>
+
+<table><tr><td>Attack Variant</td><td>Natural CIFAR-10</td><td>Madry CIFAR-10</td><td>Natural ImageNet</td><td>Madry ImageNet</td></tr><tr><td>HSJA</td><td>0.016 ± 0.012*</td><td>0.162 ± 0.099</td><td>0.030 ±0.046</td><td>0.170 ± 0.119</td></tr><tr><td>HSJA+BiLN</td><td>0.033 ± 0.024个</td><td>0.156 ± 0.096↓*</td><td>0.019 ± 0.017↓*</td><td>0.169 ± 0.122↓*</td></tr><tr><td>HSJA+Rand</td><td>0.334 ± 0.176个</td><td>0.457 ± 0.101↑</td><td>0.309 ± 0.136个</td><td>0.308 ± 0.141个</td></tr><tr><td>Sign-OPT</td><td>0.015 ± 0.013</td><td>0.137 ± 0.088</td><td>0.096 ±0.118</td><td>0.152 ± 0.112</td></tr><tr><td>Sign-OPT+BiLN</td><td>0.048 ± 0.039↑</td><td>0.191 ± 0.103个</td><td>0.040 ± 0.044↓</td><td>0.171 ± 0.105个</td></tr><tr><td>Sign-OPT+Rand</td><td>0.084±0.092个</td><td>0.214± 0.100↑</td><td>0.082±0.077↓</td><td>0.087± 0.059↓</td></tr><tr><td>Sign-OPT+AE</td><td>0.058 ±0.123个</td><td>0.094 ± 0.068↓</td><td>0.235 ± 0.200个</td><td>0.586 ± 0.299↑</td></tr></table>
+
+Table 10: $L _ { \infty }$ distance between adversarial and benign samples projected to approximated manifold (using autoencoder trained on training data) for each attack’s set of 200 adversarial samples on CIFAR-10 and ImageNet (lower is better). Arrows denote higher or lower distance compared to baseline variant, and starred items indicate highest success rate.
+
+# A.5.9 $L _ { \infty }$ -NORM OVER APPROXIMATE MANIFOLD
+
+We re-use the setup described in Section A.4.2, but train the autoencoders using the training data (defender’s perspective) instead of test data (attacker’s perspective). The results are shown in Table 10. The HSJA $+$ BiLN attack variants were successful in lowering distance for both natural and robust ImageNet. Generally, Sign-OPT variants were most successful for lowering distance from baseline variant for both CIFAR-10 and ImageNet. The primary factor is the dataset dimensionality, with dimension reduction having a bigger impact on ImageNet than CIFAR-10 (green arrows in ImageNet are more widespread). Likewise, robust models always exhibit a higher distance than natural. This can be explained by the fact that adversarially trained models are more robust in a region around the benign sample, thus the successful adversarial sample will be farther away.
+
+# A.5.10 VISUAL RESULTS - CIFAR-10
+
+We provide visual qualitative results for each attack on CIFAR-10 in Figure 7.
+
+# A.5.11 VISUAL RESULTS - IMAGENET
+
+We provide visual qualitative results for each attack on ImageNet in Figure 8.
+
+![](images/847dfbc02048cb61f2f67a8935acbb9521bf9688453dd5f7edf41012e3a1f85b.jpg)  
+Figure 7: Visual selection of attack trajectories on CIFAR-10.
+
+![](images/3c9a1cc18f8870c0a61ef6c65f0c3f2d8b13bb18d20e5f7887a35d1a4c12ea35.jpg)  
+Figure 8: Visual selection of attack trajectories on ImageNet.

parse/dev/FjqBs4XKe87/FjqBs4XKe87.md

@@ -0,0 +1,359 @@
+# Prompt Injection: Parameterization of Fixed Inputs
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Recent works have shown that attaching prompts to the input is effective at con  
+2 ditioning Language Models (LM) to perform specific tasks. However, prompts   
+3 are always included in the input text during inference, thus incurring substantial   
+4 computational and memory overhead. Also, there is currently no straightforward   
+5 method of utilizing prompts that are longer than the maximum input length of   
+6 the LMs without incurring additional costs during inference. We propose Prompt   
+7 Injection (PI), a novel formulation of injecting the prompt into the parameters of an   
+8 LM to be an efficient alternative to attaching fixed prompts to the input. We show   
+9 that in scenarios with long fixed prompts, PI can be up to 280 times more efficient in   
+10 terms of total FLOPs than previous approaches. We further explore methodologies   
+11 for PI and show promising results in persona-dependent conversation, semantic   
+12 parsing, and zero-shot learning with task instructions. Through these explorations,   
+13 we show that PI can be a promising direction for conditioning language models,   
+14 especially in scenarios with long and fixed prompts1.
+
+# 15 1 Introduction
+
+16 Contemporary works with large Language Models (LMs) [3, 32, 23, 5, 28] have shown that attaching   
+17 prompts (also referred to as prefixes) to the input is effective at conditioning LMs to perform specific   
+18 tasks. During training, LMs are trained to condition on the given prompts in hopes of generalizing   
+19 to unseen prompts during inference. Unseen prompts can be a persona for persona-dependent   
+20 conversation [39], database schema for semantic parsing [10], and task instruction for zero-shot   
+21 learning with task instructions [23]. In these tasks, a new prompt is fixed to the input at every   
+22 inference. For instance, in persona-dependent conversation [39, 18, 33], a persona description is   
+23 appended to the dialogue history, so that the LM can always be conditioned on the persona. For   
+24 another example, in semantic parsing, the LM is conditioned on the database schema as well as   
+25 natural language questions to generalize to a new database [37, 10, 36]. Lastly, zero-shot learning   
+26 with task instructions [32, 23] involves adding natural language instructions to the inputs for adapting   
+27 LMs to novel tasks.
+
+However, concatenating prompts to input sequences for prompt-dependent inference has two major limitations. (1) During inference, prompts are always included in the input text and thus incur computational and memory overhead [16]. (2) It is challenging to fit a long text such as the detailed description of a persona as a prompt into Transformer-based models whose input lengths are often fixed [27]. For instance, in persona-dependent conversation, the model constantly refers to the persona description along with the dialogue history [35, 22], as shown in the left side of Figure 1. Moreover, in real world scenarios, a persona may consist of a long detailed text description of a character or person, not just a few profile sentences. Naively concatenating long prompts to the input sequences is challenging due to the quadratic cost in time and memory of Transformer-based architectures with
+
+![](images/6a2f4349d134ed10b03b29bce1d472bf4919ffd26d838e57cabf6b2a1322159a.jpg)  
+Figure 1: Prompt Injection example on a persona-dependent conversation. The left side presents an inference procedure of a previous approach where the persona (prompt) is concatenated to every input. The right side describes Prompt Injection, where the persona is injected into the model in advance, so that the model is able to generate responses without constantly referring to the persona description. Thus, Prompt Injection approach takes less time to generate responses than the previous method.
+
+37 regard to the input sequence length. Other approaches specialized for long inputs [1, 13], such as   
+38 Fusion-in-Decoder [12], or those that augment the LM with a retrieval mechanism [9] may be used   
+39 but still come with increased overall memory and computations, ultimately leading to a delay in   
+40 generating responses. This problem becomes critical in situations where the LMs are deployed, and   
+41 fast inference speed is required.   
+42 In this work, we formulate a novel problem called Prompt Injection (PI), where we attempt to inject a   
+43 given prompt into the parameters of an LM to address the two limitations mentioned above. With   
+44 PI, LMs can produce prompt-dependent outputs without the computational overhead of appending   
+45 fixed prompts at inference time (the right side of Figure 1), and it also enables the injection of longer   
+46 prompts in a wholistic way. More specifically, we first show that PI is much more efficient (up to   
+47 280 times) in terms of total FLOPs compared to previous approaches that may be used for handling   
+48 long prompts such as Fusion-in-Decoder [12] or Linear Transformer [13]. Next, we explore different   
+49 methodologies as baselines for PI, including the continued pre-training approach on the prompt as   
+50 well as a novel distillation approach called Pseudo-INput Generation (PING), in order to analyze   
+51 what components are effective for successful PI. We apply these PI methods to three different tasks   
+52 with fixed prompts: persona-dependent conversation, semantic parsing, and zero-shot learning with   
+53 instructions. We compare the methods against LMs with explicit prompts as the upper bound (i.e.,   
+54 unconstrained) as well as the LM without both the prompt and PI as the lower bound. Experimental   
+55 results show meaningful improvements with respect to the lower bound, but also exhibit a non-trivial   
+56 gap with the upper bound. Despite the performance gap, we still believe that PI is a direction worth   
+57 exploring considering the computational benefit of the injection, especially since inference speed is   
+58 critical in real world applications.
+
+59 In sum, our main contributions are three folds:
+
+• We formally define the Prompt Injection (PI) formulation and demonstrate its necessity in terms of computation and memory efficiency, especially in scenarios with long prompts.   
+• We explore baseline approaches for PI, showing that performance can approach the upper bound (unconstrained) performance in some cases.   
+• We show that the injection of long prompts (e.g., detailed description of persona) can be achieved through PI and show its efficiency in comparison with previous methods, being up to 280 times more efficient during inference.
+
+67 Through this work, we hope the community explores PI as an efficient alternative for performing   
+68 prompt-dependent tasks.
+
+# 69 2 Related Work
+
+70 Prompting Prompting is an emerging paradigm for modeling LMs, especially for few-shot and   
+71 zero-shot learning [20, 3, 21, 24, 32, 23]. With the help of appropriate prompts, one can exploit   
+72 knowledge learned by a pre-trained LM and manipulate the LM’s behavior. The benefit of prompting   
+73 is that the pre-trained LM can adapt to new scenarios with few or no labeled training data. However,   
+74 for the in-context learning scenario, processing prompts that involve many training examples for each   
+75 inference incurs substantial computational and memory overhead [16]. Given training data, Liu et al.   
+76 [16] replace in-context learning with fine-tuning a small set of parameters for tackling the above   
+77 issue. Prompt Injection also tackles the same issue but assumes a stricter scenario where there are no   
+78 training data for the given prompt.   
+79 Efficient Transformers for Long Inputs One can consider using efficient Transformer-based [29]   
+80 architectures for handling long input sequences [27]. The main challenge of using a vanilla Trans  
+81 former architecture is the quadratic cost in time and memory with regard to the input sequence   
+82 length due to the self-attention operation. There has been a surge of recent works addressing this   
+83 problem [6, 38, 1, 13, 40, 8]. They are primarily dedicated to improving either the efficiency of the   
+84 self-attention mechanism or the general efficiency of the Transformer architecture through sparse mod  
+85 els. Our Prompt Injection approach tackles the efficiency problem of performing prompt-dependent   
+86 tasks by keeping the input sequences short (without prompts), bounding the time and memory   
+87 complexity to a constant invariant of the length of the prompt.   
+88 Persona-dependent Conversation Endowing a chabot with a persona [39, 18, 33] is challenging,   
+89 but it enables the chatbot to deliver more personal, specific, consistent, and engaging conversa  
+90 tions [39] and gain user trust [17, 25, 19]. To achieve this, previous works have attached a persona to   
+91 the dialog history at every inference time, so that the model can always be conditioned on the persona.   
+92 However, given a long persona description, this approach brings the critical problem of increased   
+93 overall memory and computations, resulting in delayed response generation. An LM augmented   
+94 with a retrieval mechanism [9] may be used but still comes with non-trivial computational overhead.   
+95 Prompt Injection allows a dialogue agent to generate responses without a persona description as the   
+96 explicit input once the persona is injected.   
+97 Semantic Parsing Semantic parsing is the task of mapping a natural language query into a SQL   
+98 query executable on a database. Recently, the community has focused more on cross-domain (cross  
+99 database) semantic parsing, where models are trained and tested on different domains (databases) [37].   
+100 The domain-adaptation setup introduces many generalization challenges, such as non-explicit column   
+101 names and domain-specific phrases [10], and recent works concatenate the natural language query   
+102 with the serialized database schema as the input to address the problem [26, 7, 36]. With Prompt   
+103 Injection, the model is adapted to a new database schema in advance, so that it can map natural   
+104 language queries to SQL queries on the new database without explicitly referring to the schema   
+105 during inference.   
+106 Zero-shot Learning with Task Instructions Recent works [23, 32] have addressed zero-shot   
+107 generalization to new tasks [3, 14] by multi-task prompted training. With multi-task prompted   
+108 training, the models learn to use task instructions as prompts to generalize to unseen tasks. It is   
+109 demonstrated that this approach improves generalization ability to novel tasks and offers an effective   
+110 substitute for unsupervised language model pre-training. Through Prompt Injection, the LM can be   
+111 aware of a novel task instruction before performing the task and thus does not require the instruction,   
+112 which can be lengthy, to make predictions.
+
+# 113 3 Prompt Injection
+
+114 In this section, we formally define Prompt Injection (PI) as a task and describe the benefits of the   
+115 formulation. Prompt-dependent generation is a task of generating an output sequence $\textbf {  { y } }$ that is a   
+116 proper response to the input sequence $_ { \textbf { \em x } }$ and coherent to the prompt $_ z$ . Utilizing the prompt during   
+117 inference, the generated sentence is obtained by ${ \pmb y } = f ( \tilde { z , \pmb x } )$ where $f$ denotes an LM such as   
+118 T5 and GPT-2. Prompt Injection (PI), i.e., parameterization of prompts, allows LMs to perform   
+119 prompt-dependent generation without using prompts during inference. To achieve this, we need to   
+120 design a PI method $H$ to inject a prompt $_ z$ into an LM $f$ . The process of PI can be represented as
+
+$$
+f _ { z } = H ( z , f )
+$$
+
+121 where $f _ { z }$ denotes an LM injected with the prompt. Then the prompt-dependent output sequence can   
+122 be obtained by ${ \pmb y } = f _ { z } ( { \pmb x } )$ .   
+123 PI can also be applied for long prompts whose length exceeds the LM’s input sequence length. Given   
+124 a long prompt $_ z$ , we decompose it into multiple sub-prompts $\left\{ z _ { i } \right\}$ each of which fits the LM’s input   
+125 length, i.e., $\boldsymbol { z } = \boldsymbol { z } _ { 1 : n } = [ z _ { 1 } ; z _ { 2 } ; . . . ; z _ { n } ]$ . Then the $\mathrm { P I }$ process can be executed iteratively, injecting   
+126 each sub-prompt sequentially while the LM is aware of the previous sub-prompts:
+
+$$
+\begin{array} { c } { f _ { z _ { 1 } } = H ( z _ { 1 } , f ) } \\ { f _ { z _ { 1 : 2 } } = H ( z _ { 2 } , f _ { z _ { 1 } } ) } \\ { \cdot \cdot \cdot } \\ { f _ { z _ { 1 : n } } = H ( z _ { n } , f _ { z _ { 1 : n - 1 } } ) } \end{array}
+$$
+
+127 The above formulation can be seen as a high-level abstraction of iterative PI that we aim to ap  
+128 proximate. In practice, in order to fully inject $z _ { 1 : n }$ , we repeat (2)-(4) multiple times (i.e., multiple   
+129 epochs).   
+130 Why is Prompt Injection necessary? Prompt Injection brings definite advantages when applied to   
+131 prompt-dependent tasks. The previous approach of appending prompts to the input sequences has   
+132 the drawback of the model repeatedly referring to the prompt at each inference time. This becomes   
+133 critical in scenarios requiring long prompts, as Transformer architecture has quadratic computational   
+134 and memory costs due to the limitation of the self-attention operation. We propose PI as a solution   
+135 to this computation bottleneck. Once a prompt is injected into the LM in advance, the LM no   
+136 longer needs to refer to the prompt during inference. As a result, the model’s input length remains   
+137 independent of the length of prompts and is able to utilize prompts of any length efficiently. We   
+138 discuss the efficiency gain of PI in Section 6.1.   
+139 Evaluation Metric for Prompt Injection PI can be evaluated by the evaluation metric of the   
+140 fixed prompt-dependent task at hand. We also introduce a metric called the Prompt Injection   
+141 score (PI score) to measure the degree of injection. The metric is agnostic of the target task by   
+142 comparing the results with that of an LM given actual prompts during inference. Let $X _ { w / }$ prompt   
+143 denote the LM’s task score with the prompt as an additional input (upper bound) and $X _ { w / o }$ prompt   
+144 denote the LM’s task score without the prompt (lower bound). We define PI score as the min  
+145 max scaling score of $X _ { P I }$ , where $X _ { P I }$ represents the score of the LM on the target task after PI,   
+146 $i . e . , \mathbf { P I } \ s \mathbf { c o r e } = \operatorname* { m a x } ( 0 , X _ { P I } - X _ { w / o \ p r o m p t } ) / \left( X _ { w / \ p r o m p t } - X _ { w / o \ p r o m p t } \right)$ . We limit using PI   
+147 only in situations where $X _ { w / p r o m p t } > X _ { w / c }$ prompt because there is no reason to inject a prompt   
+148 if task performance degrades when using the prompt. Even if the range of individual task scores   
+149 may vary from task to task, PI score represents the overall injection effectiveness of the PI methods,   
+150 agnostic of the individual task score range.
+
+# 151 4 Methods for Prompt Injection
+
+152 In this section, we explore methods of Prompt Injection (PI) that can address prompt-dependent tasks   
+153 without accessing the prompt during inference. To achieve this, the model should be trained to store   
+154 the prompt in its parameters. This can be seen as parameterizing the prompt into the model instead of   
+155 feeding the prompt explicitly to the model. This is challenging as the prompt is unseen to the model   
+156 and has no corresponding training data. In Section 4.1, a baseline method by continued pre-training   
+157 is introduced, followed by a method for improving the baseline with curriculum learning. Section 4.2   
+158 presents a novel distillation-based method called Pseudo-INput Generation (PING) that learns to   
+159 generate pseudo-inputs to inject novel prompts.
+
+![](images/2a93bcabfda8ff404527ba796388f2aa0bc3cf1d9bf7f3075a86368ec01cc60f.jpg)  
+Phase 2: Distillation
+
+Phase 1: Generator Training
+
+Figure 2: Illustration of the Pseudo-INput Generation (PING). During Phase 1, an input generator is trained with the task-specific training data. The inputs are prompts of a task, and the outputs are task inputs corresponding to the prompt. Input and output examples applied to semantic parsing are shown. During Phase 2, the input generator generates pseudo-inputs from the given target prompt, which are used to distill knowledge from the teacher to the student. Blue square boxes indicate frozen parameters; yellow rounded boxes indicate unfrozen parameters.
+
+# 160 4.1 Continued Pre-training
+
+161 We establish the Continued Pre-training method as a straightforward baseline for PI. This method   
+162 injects prompts into the parameters of an LM by continuing with the pre-training objective of the   
+163 LM on the target prompt. The pre-training objective is a straightforward option as it works in an   
+164 unsupervised manner. In our experiments, we leverage the pre-trained T5 model [21] and thus use   
+165 the masked language modeling objective which is the pre-training objective of T5. Following Raffel   
+166 et al. [21], we randomly replace $15 \%$ of a given prompt with special mask tokens; then, the model is   
+167 trained to predict the sequence of masked tokens. In this process, the model learns about the prompt   
+168 the same way the model learns knowledge during the pre-training stage.   
+169 Curriculum learning We further investigate the baseline method by leveraging curricula [2, 4]   
+170 during continued pre-training. We set the mask ratio as the difficulty criteria [34] and gradually   
+171 increase the ratio throughout the Continued Pre-training. As the mask ratio increases, the model   
+172 should predict more masked tokens given less context. With curriculum learning, we expect the LM to   
+173 gradually better adapt to the prompt, improving its prompt-dependent task performance. Throughout   
+174 the experiments, we increase the mask ratio linearly from $15 \%$ to $30 \%$ , $50 \%$ , and $70 \%$ and report the   
+175 best score.
+
+# 176 4.2 Pseudo-INput Generation (PING)
+
+177 The purpose of PI is to inject a prompt into the parameters of an LM which can also be done indirectly   
+178 through distillation. In this subsection, we propose a novel distillation-based method called Pseudo  
+179 INput Generation (PING) that distills a novel prompt into a student LM that does not have access   
+180 to the prompt through a teacher LM that does have access to the prompt. In order for distillation,   
+181 pseudo-inputs are needed since we assume a scenario where the prompt to be injected has never been   
+182 seen during training and does not have separate training data. An overview of PING is illustrated in   
+183 Figure 2. As shown in the figure, during Phase 1, an input generator is trained with the task-specific   
+184 training data. When given a prompt of the task as the input, the generator is expected to generate the   
+185 task inputs that correspond to the prompt. During Phase 2, the input generator is frozen and is used to   
+186 generate pseudo-inputs from the unseen prompt, which are then given to the teacher together with the   
+187 prompt, while only the pseudo-inputs are given to the student. This way, the student learns to follow   
+188 the teacher and is able to learn about the prompt indirectly. We believe that this is the first work that   
+189 aims to distill knowledge with different inputs for the teacher and the student.
+
+# 190 5 Experimental Setup
+
+In this section, we explain the experimental setups in detail. All experiments are performed with the T5-base [21] (220M parameters) model unless noted otherwise.
+
+# 5.1 Prompt-dependent tasks
+
+In order to evaluate the effectiveness of Prompt Injection (PI) methods, we select three promptdependent tasks—persona-dependent conversation, semantic parsing, and zero-shot learning with task instructions; all these tasks require fixed prompts during inference. Fixed prompts come in the form of a persona in persona-dependent conversation [39], database schema in semantic parsing [10], and task instruction in zero-shot learning with task instructions [23]. As described in the introduction and Section 3, when PI is applied for these tasks, there would be apparent benefits in real world scenarios. For instance, PI eliminates the need to repeatedly include persona descriptions in the input during inference when serving a conversational model of a specific personality. With these tasks, not only the performance of the baseline PI methods is evaluated, but also the significance of PI is emphasized by comparison with the (unconstrained) previous approaches that concatenate prompts to the input.
+
+# 5.2 Datasets
+
+Following datasets of prompt-dependent tasks mentioned in Section 5.1 are utilized to evaluate Prompt Injection (PI).
+
+PERSONA-CHAT PERSONA-CHAT [39] is a crowd-sourced dataset intended for training agents to perform engaging and personal chit-chat by comprising the dialogues to be grounded on specific personas. They crowdsourced 1,155 unique personas, each with five profile sentences and 162,064 utterances over 10,907 dialogues. For each dialogue, two speakers have a 6-8 turn conversation conditioned on a given persona. The task is measured via perplexity (PPL). We randomly select 100 dialogues from the validation set as persona-dependent conversation benchmark for testing PI. The persona descriptions are 60 tokens long on average.
+
+215 Spider Spider [37] is a large cross-domain semantic parsing and text-to-SQL dataset for developing   
+216 natural language interfaces to cross-domain databases. It includes 10,181 questions, 5,693 unique   
+217 SQL queries, and 200 database schemas covering 138 different domains. Models must generalize to   
+218 new database schemas as well as new queries to perform well on it. Evaluation metrics include Exact   
+219 Matching (EM) and Execution Accuracy (EA). We utilize the dev set containing 20 databases with   
+220 about 50 questions per database as a semantic parsing benchmark for PI. The database schemas range   
+221 in length from 55 to 430 token lengths.
+
+WSC / RTE / COPA For the task of zero-shot task generalization, Raffel et al. [21] have trained the LM on a diverse set of tasks and evaluated on a held-out group of tasks to evaluate generalization performance. We choose coreference resolution, natural language inference, and sentence completion tasks, three out of their four held-out tasks, and test PI on WSC (Winograd Schema Challenge), RTE (Recognizing Textual Entailment), and COPA (Choice of Plausible Alternatives) datasets [30]. All of these tasks are binary classification tasks. We utilize task instructions (prompts) of WSC, RTE, and COPA provided from Raffel et al. [21] and report average task scores of using task instructions. The task instructions are comprised of about 20-30 tokens.
+
+# 5.3 Implementation Details
+
+For the Continued Pre-training method (Section 4.1), we use the Adam optimizer [15] with a constant learning rate 1e-4 and batch size 8. We perform 5-20 steps of injection. For PING (Section 4.2), input generators are trained on each tasks for 1-2 epochs. We use KL-divergence for distilling the last layer’s output of the decoder and perform 10-40 steps of injection. Diverse pseudo-inputs are generated by sampling each token from the output probability distribution of the decoder. For all of the experiments except for zero-shot generalization, we use a single 16GB T4 GPU. For zero-shot generalization, we use 4 32GB V100 GPUs.
+
+Table 1: Inference efficiency of different models that can be used for performing prompt-dependent inference. We depict how many times PI is efficient in comparison with the other approaches inside the parenthesis. When there is out-of-memory (OOM) using the 16GB T4 GPU, we estimate the FLOPs in italics assuming a linear correlation between prompt length and FLOPs.   
+
+<table><tr><td>Model</td><td>Prompt Length</td><td>FLOPs (G)</td><td>Latency (s)</td></tr><tr><td>T5 W/ PI</td><td>*</td><td>0.7k</td><td>0.58</td></tr><tr><td>T5</td><td>512</td><td>7.2k (×10.3)</td><td>1.09 (x1.9)</td></tr><tr><td rowspan="6">T5 W/ FID</td><td>512 ×2</td><td>14.6k (×21.0)</td><td>2.38 (×4.1)</td></tr><tr><td>512×4</td><td>OOM</td><td>=</td></tr><tr><td>512</td><td>7.2k (×10.3)</td><td>1.09 (×1.9)</td></tr><tr><td>512×2</td><td>14.0k (×20.2)</td><td>1.54 (×2.6)</td></tr><tr><td>512 ×4</td><td>27.6k(×39.8)</td><td>2.87 (×4.9)</td></tr><tr><td>512 ×8</td><td>54.9k(×79.2)</td><td>5.87 (×10.0)</td></tr><tr><td>LINEAR-</td><td>512 ×28</td><td>00M(×280)</td><td>-</td></tr><tr><td rowspan="4">TRANSFORMER</td><td>512</td><td>9.5k (×13.8)</td><td>1.58 (×2.7)</td></tr><tr><td>512×2</td><td>16.1k(×23.2)</td><td>2.62 (x4.5)</td></tr><tr><td>512 × 4</td><td>29.2k(×42.2)</td><td>4.74 (×8.1)</td></tr><tr><td>512×8 512 × 28</td><td>55.6k(×80.1) 0OM(×280)</td><td>9.11 (×15.6) -</td></tr></table>
+
+238 In order for injection and comparison with upper-bound and lower-bound performance, we first   
+239 need two different versions of the LM adapted to the given task. For the task of persona-dependent   
+240 conversation and semantic parsing, one (upper bound) is fine-tuned together with prompts since   
+241 prompts are explicitly used during inference, while the other (lower bound) is fine-tuned on the task   
+242 without being given the prompt. We perform PI on the lower-bound LM since we also assume having   
+243 no access to prompts during inference.   
+244 For the zero-shot learning task, we modify the prompts developed by Raffel et al. [21]   
+245 in the form of a fixed prompt. Their prompts have placeholders such as Premise, and   
+246 Hypothesis. We replace the placeholders with fixed words such as "Premise" and "Hypoth  
+247 esis", then append the actual content to the prompt in a key-value format. For example,   
+248 if the original is If {Premise} is true, is it also true that {Hypothesis}?, then   
+249 the converted prompt is If "Premise" is true, is it also true that "Hypothesis"?   
+250 Premise:{Premise} Hypothesis:{Hypothesis}. This ensures that the prompt is fixed, which   
+251 can be injected with PI. We use the T0-3B LM checkpoint for the zero-shot generalization.
+
+# 252 6 Experimental Results
+
+In this section, we first explore the inference efficiency of models performing prompt-dependent tasks and show that Prompt Injection (PI) leads to meaningful computational efficiency. Then the baseline and proposed methods are tested and compared on datasets discussed in Section 5.2. The results indicate that the Pseudo-INput Generation (PING) method achieves the best performance among PI methods, sometimes even outperforming the unconstrained upper bound, which uses explicit prompts during inference. In Section 6.3, we provide a concrete instance of injecting a real persona description into a conversational model, demonstrating the feasibility of long prompt injection.
+
+# 6.1 Inference Efficiency
+
+The comparison of inference efficiency of a model with PI, a baseline model that naively concatenates prompts to the input, Fusion-in-Decoder (FiD) [12], and Linear Transformer [13] are shown in Table 1. We consider FiD as one of the options for processing long inputs because it processes long input sequences by encoding chunks of input sequences separately, reducing the quadratic complexity to linear. Linear Transformer also reduces the complexity to linear by linearizing the
+
+Table 2: Prompt Injection performance on three prompt-dependent tasks. W/ PROMPT stands for the upper bound (unconstrained) method, which uses the prompt during inference by appending it to the input. W/O PROMPT depicts the lower bound method of not utilizing the prompts at all. Lastly, we show three W/ PI methods: CP and CP W/ CURR stand for the Continued Pre-training (baseline) and the Continued Pre-training with curricular, respectively, as explained in Section 4.1; PING depicts our novel proposed method utilizing distillation.   
+
+<table><tr><td></td><td colspan="2">Dialogue</td><td colspan="3">Semantic Parsing</td><td colspan="6">Task Generalization</td></tr><tr><td></td><td colspan="2">PERSONA-CHAT</td><td colspan="2">Spider</td><td colspan="2"></td><td colspan="2">RTE</td><td colspan="2">COPA</td></tr><tr><td></td><td>PPL (↓)</td><td>PI Score</td><td>EM</td><td>EA PI Score</td><td></td><td>ACC PI Score ACC PI Score </td><td></td><td></td><td></td><td>ACC PI Score</td></tr><tr><td>W/PROMPT</td><td>8.83</td><td></td><td>57.9 61.3</td><td></td><td>=</td><td>63.6</td><td>1</td><td>67.9</td><td>、</td><td>67.3</td></tr><tr><td>W/O PROMPT</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>W/O PI</td><td>11.01</td><td></td><td>14.5 15.1</td><td></td><td>=</td><td>44.0</td><td>64.2 =</td><td></td><td>60.0</td><td></td></tr><tr><td>W/PI</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>CP</td><td>10.85</td><td>0.073</td><td>16.9 17.5</td><td></td><td>0.054</td><td>54.5</td><td>0.536 67.7</td><td>0.946</td><td>64.8</td><td>0.658</td></tr><tr><td>CP W/ CURR</td><td>10.61</td><td>0.183</td><td>17.7 18.4</td><td></td><td>0.072</td><td>50.8</td><td>0.347 68.2</td><td>1.08</td><td>64.1</td><td>0.562</td></tr><tr><td>PING</td><td>9.82</td><td>0.546</td><td>36.6 41.7</td><td></td><td>0.507</td><td>63.7</td><td>1.005</td><td>64.2 0</td><td>60.6</td><td>0.082</td></tr></table>
+
+266 attention mechanism. We measure FLOPs and forward propagation latency via DeepSpeed Flops profiler 2267 using a single 16GB T4 GPU.
+
+As shown in Table 1, T5 W/ PI is much more efficient than other models, especially as we assume a longer prompt length. This is because the efficiency of PI remains the same independent of the prompt length while the costs of others increase linearly. Specifically, when the prompt length is 8 times the model’s max input sequence length, one can achieve $8 0 \times$ computational efficiency in terms of FLOPs by applying PI. Furthermore, in a scenario where the prompt length is $2 8 \times$ the model’s max input sequence length (shown in Section 6.3 when trying to utilize a long persona that is over 13,000 token length long), previous approaches show an out-of-memory (OOM) issue using the 16GB T4 GPU, and it is impossible to utilize them. PI is estimated to be $2 8 0 \times$ more efficient in terms of total FLOPs if there is no OOM issue.
+
+# 77 6.2 Task Performance
+
+In Table 2, we report the task performance obtained by applying different PI methods on three prompt-dependent tasks. PI scores are also obtained as introduced in Section 3. For all of W/ PI methods, we observe an overall increase in performance compared to W/O PROMPT, indicating successful injection of prompts into the parameters of the model through PI methods.
+
+For the results, while CP gives modest performance improvement over W/O PROMPT, the results of CP W/ CURR show that leveraging curricula during continued pre-training is effective in some cases. CP W/ CURR performs better compared to CP in PERSONA-CHAT, Spider, and RTE; it even outperforms W/ PROMPT in RTE. On the other hand, PING significantly improves performance from CP in PERSONA-CHAT, Spider, and WSC, outperforming W/ PROMPT in WSC. This sheds light on the possibility that PI may be able to reach the upper bound (unconstrained) performance. However, the results show at the same time that there is still a gap between the performance of PI methods and the upper bound W/ PROMPT that needs to be bridged in future work.
+
+We find that the performance of different methods depends on the complexity of the input sequence structure. We believe that PING achieves a good performance in PERSONA-CHAT, Spider, and WSC because those datasets have relatively simple input sequences (short utterances; simple query; a sentence and two words, respectively). In datasets with many components or multiple complex sentences (e.g., COPA and RTE), the low quality of generated pseudo-inputs degrades the performance of PING. On the other hand, CP and CP W/ CURR perform better in datasets with complex structure. These findings encourage the community to explore a more integral PI method that can cover different datasets.
+
+![](images/23b4d0e017c66c95861ef1175ce0fa215bd10b7ad6c429df192e2d111505220a.jpg)  
+some of the most important questions humaniFigure 3: A real world example of Prompt Injection with a long prompt. (Left) The process of injecting a Wikipedia article describing a person (Elon Musk) into a model with PI. The article is more than 13,000 tokens long. (Right) Actual conversation between the persona injected model and a human that is hand-picked.
+
+# 298 6.3 Long Prompts Injection
+
+To demonstrate the effectiveness of PI on injection of long prompts into LMs, we show how the method works with a real world example. We pick a Wikipedia page (Elon Musk), considering it as a long persona description, and inject the entire article (over 13,000 tokens) into an LM trained with PERSONA-CHAT. Here, we use T5-large as a base model and apply PING.
+
+Figure 3 shows an actual instance of interactions with the LM that underwent PI through PING. The responses show the LM successfully reflecting the description of the person on the Wikipedia page without having the description appended to the input. Moreover, the inference of PI is $2 8 0 \times$ more computationally efficient in terms of FLOPs than the baseline, as shown in Section 6.1. Lastly, we provide a live demo to allow interactions with an LM injected with the persona of Elon Musk.
+
+# 308 7 Conclusion
+
+09 Limitations and Future Work While Prompt Injection (PI) enables performing prompt-dependent   
+0 tasks efficiently, there are limitations that needs to be addressed in future work. In particular, the   
+current PI methods cause task performance degradation. Moreover, the computational costs needed   
+12 for the injection of prompts into the model parameters have not been extensively considered. For   
+13 example, when considering previous conversation history as prompts to be injected in a multi-turn   
+14 conversation setting, fast injection may also be a requirement for real-world application. Updating or   
+15 adding a relatively small number of parameters [11, 31] may be a potential avenue for addressing the   
+16 problems.   
+317 In this paper, we propose Prompt Injection (PI), a novel formulation of injecting the prompt into the   
+318 parameters of an LM, as an efficient alternative to attaching fixed prompts to the inputs for prompt  
+319 dependent tasks. Through experiments, we show that PI is much more computationally efficient (up   
+320 to 280 times) in terms of total FLOPs for handling long prompts compared to the previous alternatives.   
+321 We further explore baseline methodologies for PI and find that Pseudo-INput Generation (PING), a   
+322 distillation-based approach, shows promising results in persona-dependent conversation, semantic   
+323 parsing, and zero-shot learning with task instructions. Through the explorations, we show that PI   
+324 can be a promising direction for conditioning language models with prompts, especially in scenarios   
+325 with long and fixed prompts. To this end, we hope the community explores PI for achieving both   
+326 performance and efficiency on prompt-dependent tasks.
+
+# References
+
+[1] Iz Beltagy, Matthew E. Peters, and Arman Cohan. Longformer: The long-document transformer. ArXiv, abs/2004.05150, 2020.
+
+[2] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ICML ’09, 2009. [3] Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, T. J. Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeff Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. ArXiv, abs/2005.14165, 2020. [4] Daniel Fernando Campos. Curriculum learning for language modeling. ArXiv, abs/2108.02170, 2021. [5] Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, Parker Schuh, Kensen Shi, Sasha Tsvyashchenko, Joshua Maynez, Abhishek Baindoor Rao, Parker Barnes, Yi Tay, Noam M. Shazeer, Vinodkumar Prabhakaran, Emily Reif, Nan Du, Benton C. Hutchinson, Reiner Pope, James Bradbury, Jacob Austin, Michael Isard, Guy Gur-Ari, Pengcheng Yin, Toju Duke, Anselm Levskaya, Sanjay Ghemawat, Sunipa Dev, Henryk Michalewski, Xavier García, Vedant Misra, Kevin Robinson, Liam Fedus, Denny Zhou, Daphne Ippolito, David Luan, Hyeontaek Lim, Barret Zoph, Alexander Spiridonov, Ryan Sepassi, David Dohan, Shivani Agrawal, Mark Omernick, Andrew M. Dai, Thanumalayan Sankaranarayana Pillai, Marie Pellat, Aitor Lewkowycz, Erica Oliveira Moreira, Rewon Child, Oleksandr Polozov, Katherine Lee, Zongwei Zhou, Xuezhi Wang, Brennan Saeta, Mark Diaz, Orhan Firat, Michele Catasta, Jason Wei, Kathleen S. Meier-Hellstern, Douglas Eck, Jeff Dean, Slav Petrov, and Noah Fiedel. Palm: Scaling language modeling with pathways. ArXiv, abs/2204.02311, 2022. [6] Zihang Dai, Zhilin Yang, Yiming Yang, Jaime G. Carbonell, Quoc V. Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. In ACL, 2019. [7] Xiang Deng, Ahmed Hassan Awadallah, Christopher Meek, Oleksandr Polozov, Huan Sun, and Matthew Richardson. Structure-grounded pretraining for text-to-sql. ArXiv, abs/2010.12773, 2021. [8] Mandy Guo, Joshua Ainslie, David C. Uthus, Santiago Ontañón, Jianmo Ni, Yun-Hsuan Sung, and Yinfei Yang. Longt5: Efficient text-to-text transformer for long sequences. ArXiv, abs/2112.07916, 2021. [9] Seungju Han, Beomsu Kim, Jin Yong Yoo, Seokjun Seo, Sangbum Kim, Enkhbayar Erdenee, and Buru Chang. Meet your favorite character: Open-domain chatbot mimicking fictional characters with only a few utterances. arXiv preprint arXiv:2204.10825, 2022. [10] Moshe Hazoom, Vibhor Malik, and Ben Bogin. Text-to-sql in the wild: A naturally-occurring dataset based on stack exchange data. ArXiv, abs/2106.05006, 2021. [11] Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models. ArXiv, abs/2106.09685, 2021. [12] Gautier Izacard and Edouard Grave. Leveraging passage retrieval with generative models for open domain question answering. In EACL, 2021. [13] Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and Franccois Fleuret. Transformers are rnns: Fast autoregressive transformers with linear attention. ArXiv, abs/2006.16236, 2020. [14] Boseop Kim, Hyoungseok Kim, Sang-Woo Lee, Gichang Lee, Donghyun Kwak, Dong Hyeon Jeon, Sunghyun Park, Sung ju Kim, Seonhoon Kim, Dong Hyung Seo, Heungsub Lee, Minyoung Jeong, Sungjae Lee, Minsub Kim, SukHyun Ko, Seokhun Kim, Taeyong Park, Jinuk Kim,   
+78 Soyoung Kang, Na-Hyeon Ryu, Kang Min Yoo, Minsuk Chang, Soobin Suh, Sookyo In,   
+79 Jinseong Park, Kyungduk Kim, Hiun Kim, Jisu Jeong, Yong Goo Yeo, Dong hyun Ham, Do  
+80 Hyoung Park, Min Young Lee, Jaewoo Kang, Inho Kang, Jung-Woo Ha, Woo Chul Park, and Nako Sung. What changes can large-scale language models bring? intensive study on hyperclova: Billions-scale korean generative pretrained transformers. ArXiv, abs/2109.04650, 2021.   
+[15] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2015.   
+[16] Haokun Liu, Derek Tam, Mohammed Muqeeth, Jay Mohta, Tenghao Huang, Mohit Bansal, and Colin Raffel. Few-shot parameter-efficient fine-tuning is better and cheaper than in-context learning. 2022.   
+[17] Qian Liu, Yihong Chen, B. Chen, Jian-Guang Lou, Zixuan Chen, Bin Zhou, and Dongmei Zhang. You impress me: Dialogue generation via mutual persona perception. ArXiv, abs/2004.05388, 2020.   
+[18] Pierre-Emmanuel Mazaré, Samuel Humeau, Martin Raison, and Antoine Bordes. Training millions of personalized dialogue agents. In EMNLP, 2018.   
+[19] Qiao Qian, Minlie Huang, Haizhou Zhao, Jingfang Xu, and Xiaoyan Zhu. Assigning personality/profile to a chatting machine for coherent conversation generation. In IJCAI, 2018.   
+[20] Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. 2019.   
+[21] Colin Raffel, Noam M. 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, abs/1910.10683, 2020.   
+[22] Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric Michael Smith, Y.-Lan Boureau, and Jason Weston. Recipes for building an open-domain chatbot. In EACL, 2021.   
+[23] Victor Sanh, Albert Webson, Colin Raffel, Stephen H. Bach, Lintang A. Sutawika, Zaid Alyafeai, Antoine Chaffin, Arnaud Stiegler, Teven Le Scao, Arun Raja, Manan Dey, M SAIFUL BARI, Canwen Xu, Urmish Thakker, Shanya Sharma, Eliza Szczechla, Taewoon Kim, Gunjan Chhablani, Nihal V. Nayak, Debajyoti Datta, Jonathan Chang, Mike Tian-Jian Jiang, Han Wang, Matteo Manica, Sheng Shen, Zheng Xin Yong, Harshit Pandey, Rachel Bawden, Thomas Wang, Trishala Neeraj, Jos Rozen, Abheesht Sharma, Andrea Santilli, Thibault Févry, Jason Alan Fries, Ryan Teehan, Stella Rose Biderman, Leo Gao, T. G. Owe Bers, Thomas Wolf, and Alexander M. Rush. Multitask prompted training enables zero-shot task generalization. ArXiv, abs/2110.08207, 2021.   
+[24] Timo Schick and Hinrich Schütze. It’s not just size that matters: Small language models are also few-shot learners. ArXiv, abs/2009.07118, 2021.   
+[25] Haoyu Song, Weinan Zhang, Yiming Cui, Dong Wang, and Ting Liu. Exploiting persona information for diverse generation of conversational responses. In IJCAI, 2019.   
+[26] Alane Suhr, Ming-Wei Chang, Peter Shaw, and Kenton Lee. Exploring unexplored generalization challenges for cross-database semantic parsing. In ACL, 2020.   
+[27] Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. ACM Computing Surveys (CSUR), 2022.   
+[28] Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam M. Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, Yaguang Li, Hongrae Lee, Huaixiu Zheng, Amin Ghafouri, Marcelo Menegali, Yanping Huang, Maxim Krikun, Dmitry Lepikhin, James Qin, Dehao Chen, Yuanzhong Xu, Zhifeng Chen, Adam Roberts, Maarten Bosma, Yanqi Zhou, Chung-Ching Chang, I. A. Krivokon, Willard James Rusch, Marc Pickett, Kathleen S. Meier-Hellstern, Meredith Ringel Morris, Tulsee Doshi, Renelito Delos Santos, Toju Duke, Johnny Hartz Søraker, Ben Zevenbergen, Vinodkumar Prabhakaran, Mark Diaz, Ben Hutchinson, Kristen Olson, Alejandra Molina, Erin Hoffman-John, Josh Lee, Lora Aroyo, Ravindran Rajakumar, Alena Butryna, Matthew Lamm, V. O. Kuzmina, Joseph Fenton, Aaron Cohen, Rachel Bernstein, Ray Kurzweil, Blaise Aguera-Arcas, Claire Cui, Marian Croak, Ed Chi, and Quoc Le. Lamda: Language models for dialog applications. ArXiv, abs/2201.08239, 2022.   
+[29] Ashish Vaswani, Noam M. Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. ArXiv, abs/1706.03762, 2017.   
+[30] Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. Superglue: A stickier benchmark for general-purpose language understanding systems. In NeurIPS, 2019.   
+[31] Ruize Wang, Duyu Tang, Nan Duan, Zhongyu Wei, Xuanjing Huang, Jianshu Ji, Guihong Cao, Daxin Jiang, and Ming Zhou. K-adapter: Infusing knowledge into pre-trained models with adapters. In FINDINGS, 2021.   
+[32] Jason Wei, Maarten Bosma, Vincent Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M. Dai, and Quoc V. Le. Finetuned language models are zero-shot learners. ArXiv, abs/2109.01652, 2021.   
+[33] Sean Welleck, Jason Weston, Arthur D. Szlam, and Kyunghyun Cho. Dialogue natural language inference. In ACL, 2019.   
+[34] Alexander Wettig, Tianyu Gao, Zexuan Zhong, and Danqi Chen. Should you mask $15 \%$ in masked language modeling? arXiv preprint arXiv:2202.08005, 2022.   
+[35] Thomas Wolf, Victor Sanh, Julien Chaumond, and Clement Delangue. Transfertransfo: A transfer learning approach for neural network based conversational agents. ArXiv, abs/1901.08149, 2019.   
+[36] Tianbao Xie, Chen Henry Wu, Peng Shi, Ruiqi Zhong, Torsten Scholak, Michihiro Yasunaga, Chien-Sheng Wu, Ming Zhong, Pengcheng Yin, Sida I. Wang, Victor Zhong, Bailin Wang, Chengzu Li, Connor Boyle, Ansong Ni, Ziyu Yao, Dragomir Radev, Caiming Xiong, Lingpeng Kong, Rui Zhang, Noah A. Smith, Luke Zettlemoyer, and Tao Yu. Unifiedskg: Unifying and multi-tasking structured knowledge grounding with text-to-text language models. ArXiv, abs/2201.05966, 2022.   
+[37] Tao Yu, Rui Zhang, Kai-Chou Yang, Michihiro Yasunaga, Dongxu Wang, Zifan Li, James Ma, Irene Z Li, Qingning Yao, Shanelle Roman, Zilin Zhang, and Dragomir R. Radev. Spider: A large-scale human-labeled dataset for complex and cross-domain semantic parsing and text-to-sql task. In EMNLP, 2018.   
+[38] Manzil Zaheer, Guru Guruganesh, Kumar Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontañón, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, and Amr Ahmed. Big bird: Transformers for longer sequences. ArXiv, abs/2007.14062, 2020.   
+[39] Saizheng Zhang, Emily Dinan, Jack Urbanek, Arthur D. Szlam, Douwe Kiela, and Jason Weston. Personalizing dialogue agents: I have a dog, do you have pets too? In ACL, 2018.   
+[40] Chen Zhu, Wei Ping, Chaowei Xiao, Mohammad Shoeybi, Tom Goldstein, Anima Anandkumar, and Bryan Catanzaro. Long-short transformer: Efficient transformers for language and vision. ArXiv, abs/2107.02192, 2021.

parse/dev/Q42f0dfjECO/Q42f0dfjECO.md

@@ -0,0 +1,446 @@
+# DIFFERENTIALLY PRIVATE FINE-TUNING OF LANGUAGE MODELS
+
+Da $\mathbf { Y } \mathbf { u } ^ { 1 , 2 }$ Saurabh Naik4 Arturs Backurs3,∗ Sivakanth Gopi3,∗ Huseyin A. Inan $^ { 3 , * }$ Gautam Kamath5,∗ Janardhan Kulkarni3,∗ Yin Tat Lee3,6,∗ Andre Manoel3,∗ Lukas Wutschitz4,∗ Sergey Yekhanin3,∗ Huishuai Zhang2,∗
+
+1Sun Yat-sen University† , 2Microsoft Research Asia   
+3Microsoft Research, 4Microsoft   
+5Cheriton School of Computer Science, University of Waterloo   
+6University of Washington   
+1yuda3@mail2.sysu.edu.cn, 2huzhang@microsoft.com   
+3{arturs.backurs, sigopi, huseyin.inan}@microsoft.com   
+3{jakul, amonteiroman, yekhanin}@microsoft.com   
+4{snaik, lukas.wutschitz}@microsoft.com   
+5g@csail.mit.edu, 6yintat@uw.edu
+
+# ABSTRACT
+
+We give simpler, sparser, and faster algorithms for differentially private finetuning of large-scale pre-trained language models, which achieve the state-ofthe-art privacy versus utility tradeoffs on many standard NLP tasks. We propose a meta-framework for this problem, inspired by the recent success of highly parameter-efficient methods for fine-tuning. Our experiments show that differentially private adaptations of these approaches outperform previous private algorithms in three important dimensions: utility, privacy, and the computational and memory cost of private training. On many commonly studied datasets, the utility of private models approaches that of non-private models. For example, on the MNLI dataset we achieve an accuracy of $8 7 . 8 \%$ using RoBERTa-Large and $8 3 . 5 \%$ using RoBERTa-Base with a privacy budget of $\varepsilon = 6 . 7$ . In comparison, absent privacy constraints, RoBERTa-Large achieves an accuracy of $9 0 . 2 \%$ . Our findings are similar for natural language generation when privately fine-tuning GPT-2. Our experiments also show that larger models are better suited for private fine-tuning: while they are well known to achieve superior accuracy non-privately, we find that they also better maintain their accuracy when privacy is introduced.
+
+# 1 INTRODUCTION
+
+Deep learning models are well known to leak sensitive information about the dataset when trained using conventional methods (Shokri et al., 2017; Carlini et al., 2019; 2021). To combat this issue, models can instead be trained to guarantee differential privacy (DP) (Dwork et al., 2006b), a strong notion of data privacy which limits the influence of any individual training point on the final model. While DP is one of the few approaches capable of providing machine learning models with rigorous privacy guarantees, it generally comes at a cost in terms of test accuracy. One oft-cited explanation is that the constraint of DP necessitates much more training data (Tramer & Boneh \` , 2021; Feldman, 2020; Brown et al., 2021). Unfortunately, more training data may be hard to acquire, particularly in settings where privacy is a concern.
+
+Parallel to these developments, Transformer-based (Vaswani et al., 2017) large language models (LLMs), including the BERT (Devlin et al., 2019; Liu et al., 2019) and GPT (Radford et al., 2018; 2019; Brown et al., 2020) families, have enabled significant progress in natural language processing, achieving state-of-the-art accuracy in almost every task considered. These models are first pre-trained on an extremely large and diverse public dataset. The weights are then fine-tuned for each task of interest using a much smaller task-specific dataset. For example, a single pre-trained GPT-family model may be fine-tuned for various downstream tasks, such as email reply suggestion, sentence completion in text editors, language translation, and more. This two-stage paradigm can naturally be adapted to solve tasks in private learning, automatically addressing the aforementioned data shortage issue via the massive scale of the public pre-training dataset. One may pre-train the model on public data as usual,1 but then fine-tune the model privately.
+
+![](images/b92c1127606fb21f715c9e577e9d6d34dfd4097a61bcc367c1ff4615ed74cdcd.jpg)  
+Figure 1: An illustration of our framework. First, the model is pre-trained on a large, public dataset. Next, new parameters are introduced and privately fine-tuned on a smaller, private, task-specific dataset. The original parameters are frozen during this process. Finally, the fine-tuned new parameters may be released publicly and plugged-in to the model for downstream tasks, while still preserving privacy of the private dataset.
+
+Table 1: Accuracy of fine-tuning for downstream tasks with RoBERTa-Large (in $\%$ ). Our results achieve accuracy comparable to full fine-tuning non-privately, while simultaneously guaranteeing differential privacy. We choose $\delta = 1 { \mathrm e } { - } 5$ for SST-2 and QNLI and $\delta = 1 \mathrm { e } { - } 6$ for MNLI and QQP due to their dataset sizes. Implementation details are in Section 4.1.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>Trained params</td></tr><tr><td rowspan=1 colspan=1>Non-private fine-tuning</td><td rowspan=1 colspan=1>90.2</td><td rowspan=1 colspan=1>96.4</td><td rowspan=1 colspan=1>92.2</td><td rowspan=1 colspan=1>94.7</td><td rowspan=1 colspan=1>93.4</td><td rowspan=1 colspan=1>100%</td></tr><tr><td rowspan=1 colspan=1>Our results (ε= 6.7)</td><td rowspan=1 colspan=1>87.8</td><td rowspan=1 colspan=1>95.3</td><td rowspan=1 colspan=1>87.4</td><td rowspan=1 colspan=1>90.8</td><td rowspan=1 colspan=1>90.3</td><td rowspan=1 colspan=1>0.94%</td></tr></table>
+
+Despite the success of these models, task-specific fine-tuning introduces a number of technical challenges. In the non-private setting, the immense size of LLMs makes it impractical to fine-tune the full model and store a separate copy of the parameters for hundreds of downstream tasks. Things only get worse with privacy, which leads to overheads in terms of running time, memory usage, and most importantly, accuracy. The magnitude of noise introduced to a model due to DP grows as the model size increases (Bassily et al., 2014; Abadi et al., 2016; Bun et al., 2014), which can overwhelm any signal for larger models. A recent line of work in the non-private literature has proposed parameter-efficient methods to alleviate the issues of storage and computational cost for fine-tuning (Houlsby et al., 2019; Li & Liang, 2021; Aghajanyan et al., 2020; Hu et al., 2021; Mahabadi et al., 2021). The main focus of our work is to explore parameter-efficiency in the context of private learning.
+
+# 1.1 OUR CONTRIBUTIONS
+
+Our primary contribution is to show that advanced parameter-efficient methods can lead to simpler and significantly improved algorithms for private fine-tuning. Our framework is illustrated in Figure 1. Our findings and contributions are summarized as follows:
+
+State-of-the-art utility and privacy. Empirical evaluation of our algorithms reveals that they achieve state-of-the-art accuracy versus privacy tradeoffs, improving upon the previous best (Yu et al., 2021b). More importantly, for many fine-tuning tasks, the utility of models trained with DP approaches that of non-private models. For example, privately fine-tuning RoBERTa-Large on the MNLI data set (Williams et al., 2018), we achieve an accuracy of $8 7 . 8 \%$ with a privacy budget of $( \varepsilon = 6 . 7 , \delta = 1 \mathrm { e } . 6 )$ . Without privacy guarantees, RoBERTa-Large achieves an accuracy of ${ \bar { 9 0 . 2 \% } }$ (GPT-3 is known to achieve $9 1 . 7 \%$ (Hu et al., 2021)); see Table 1 for a summary. We also explore private natural language generation tasks, fine-tuning GPT-2 models on the E2E dataset (Novikova et al., 2017). Again, the utility approaches non-private levels: we achieve a ROUGE-L score of 0.6755 with GPT-2-Large and $( \varepsilon = 5 . 4 , \delta = 1 \mathrm { e } { - } 5 )$ , compared to 0.72 without privacy.
+
+Larger models are better. Prior work has consistently shown that larger language models achieve better accuracy for downstream tasks. Our results give evidence that this phenomenon extends to the private setting. For example, on the MNLI dataset, RoBERTa-Base achieves an accuracy of $8 3 . 5 \%$ whereas RoBERTa-Large achieves an accuracy of $8 7 . 8 \%$ , both under a privacy budget of $( \varepsilon = 6 . 7 , \delta = 1 \mathrm { e } . 6 )$ . Similarly, privately fine-tuning with E2E, GPT-2-Small, GPT-2-Medium, and GPT-2-Large achieve ROUGE-L scores of 0.6219, 0.6645 and 0.6755 respectively, all under a privacy budget of $( \varepsilon = 5 . 4 , \delta = 1 { \mathrm { e } } { \cdot } 5 )$ . While established in the non-private setting, we find this phenomenon quite surprising under DP. There is often a tension when choosing private model architectures: larger models may have higher capacity, but necessitate the introduction of more noise. Consequently, smaller and simpler private models achieve the better accuracy in several settings (Papernot et al., 2019; Tramer & Boneh \` , 2021). In contrast, our experiments show that fine-tuning the biggest models achieves the best accuracy.2
+
+Simpler, sparser, and faster. Beyond accuracy concerns, DP requirements also lead to significant overheads in terms of computation and memory usage. The large number of parameters contributes to the high cost of training LLMs, and things get worse under privacy, which has been documented to increase training time by up to two orders of magnitude (Carlini et al., 2019; Subramani et al., 2021). The parameter-efficient approaches we employ partially offset this issue: as we only update a small fraction of the total number of parameters, training becomes considerably more computationally and memory efficient. Furthermore, as in the non-private setting, this framework leads to a modular design, where a single large pre-trained model can be augmented with lightweight modifications for each individual downstream task.
+
+To the best of our knowledge, we are the first to fine-tune GPT-2-Large using differential privacy, the largest model trained thus far using DP. Given our state-of-the-art results for a variety of standard NLP tasks using advanced fine-tuning techniques, we believe that our paper will serve as a benchmark for further work in this direction. For example, the best average accuracy achieved by the prior work of Yu et al. (2021b) on four standard NLP tasks in Table 1 is $8 3 . 9 \%$ using $\varepsilon = 8$ (and the same $\delta$ as in Table 1), whereas we can achieve an average accuracy of $9 0 . 3 \%$ using $\varepsilon = 6 . 7$ by a combination of better algorithms, larger models, and new privacy accounting techniques.
+
+Finally, though recently considered elsewhere (see Section 5), we put further focus on the framing of public pre-training and private fine-tuning as an important conceptual direction in DP deep learning.
+
+# 2 PRELIMINARIES AND PRIOR ALGORITHM BASELINES
+
+Recall the formal definition of differential privacy.
+
+Definition 2.1 (Differential Privacy (DP) (Dwork et al., 2006b;a)). A randomized algorithm $\mathcal { A }$ is $( \varepsilon , \delta )$ -differentially private if for any two neighboring datasets $D$ and $D ^ { \prime }$ , which differ in exactly the data pertaining to a single user, and for all sets $s$ of possible outputs: $\operatorname* { P r } [ A ( D ) \in { \mathcal { S } } ] \leq e ^ { \varepsilon } \operatorname* { P r } [ A ( D ^ { \prime } ) \in { \mathcal { S } } ] + \delta$ .
+
+We review prior techniques for private fine-tuning.
+
+# 2.1 FULL FINE-TUNING VIA DPSGD
+
+To train a machine learning model with privacy, the most popular algorithm is the celebrated DP stochastic gradient descent (DPSGD) (Song et al., 2013; Bassily et al., 2014; Abadi et al., 2016). This optimization method serves as a drop-in replacement for SGD, augmenting it with the addition of per-example gradient clipping and Gaussian noise addition steps. These two steps serve to limit and mask the contribution of a single example. Two key points to note are that a) per-example gradient clipping incurs significant computational and memory overheads in most implementations, and b) noise introduced due to privacy grows as the square-root as the number of model parameters. With this tool in place, the most basic fine-tuning strategy is to train all parameters using DPSGD.
+
+# 2.2 REPARAMETRIZED GRADIENT PERTURBATION
+
+To mitigate the limitations of DPSGD, a recent work of Yu et al. (2021b) introduced an elegant method called reparametrized gradient perturbation (RGP). RGP exploits the implicit low-rank structure in the gradient updates of SGD to substantially improve upon DPSGD. Specifically, they reparametrize each layer’s weight matrix $W$ into $L R + { \tilde { W } }$ , where $L$ and $R$ are low-rank gradientcarrier matrices and $\tilde { W }$ is the residual weight. The authors show that one can obtain a lowdimensional projection of $W$ ’s gradient by taking gradients only of the low-rank matrices $L$ and $R$ (and not the high-rank $\tilde { W }$ ). Privacy is introduced by clipping and noising these low-dimensional gradients of $L$ and $R$ . While this low-dimensional projection loses some of the signal in $W$ ’s gradient, it turns out to contain enough to still achieve high accuracy. At the same time, the low-dimensional gradients alleviate the aforementioned issues related to privatization, significantly reducing the memory consumption and noise introduced.
+
+# 3 OUR APPROACH
+
+# 3.1 A META-FRAMEWORK
+
+We introduce our approach as a meta-framework for private deep learning, which abstracts the key principles of recent fine-tuning methods.
+
+Suppose $f ( W _ { \mathrm { P T } } ; x )$ is a pre-trained model where $W _ { \mathrm { P T } }$ are the pre-trained weights and $x$ is any input. We create a new fine-tuning model
+
+$$
+f _ { \mathrm { F T } } ( W _ { \mathrm { P T } } , \theta ; x )
+$$
+
+which incorporates additional trainable parameters $\theta$ , where $\dim ( \theta ) \ll \dim ( W _ { \mathrm { P T } } )$ . That is, the number of new parameters in $\theta$ is a small fraction of the original number of parameters in the pretrained weights $W _ { \mathrm { P T } }$ . Fine-tuning is done by running DPSGD on the additional parameters $\theta$ , while freezing the weights of pre-trained model $W _ { \mathrm { P T } }$ . The new parameters are initialized to $\theta _ { 0 }$ such that
+
+$$
+\begin{array} { r } { f _ { \mathrm { F T } } ( W _ { \mathrm { P T } } , \theta _ { 0 } ; x ) = f ( W _ { \mathrm { P T } } ; x ) . } \end{array}
+$$
+
+The initialization condition (2) is very important, as it ensures that fine-tuning starts at the pre-trained model and improves it by modifying the parameters $\theta$ . Most fine-tuning methods are additive and have the following special form:
+
+$$
+\begin{array} { r } { f _ { \mathrm { F T } } ( W _ { \mathrm { P T } } , \theta ; x ) = f ( W _ { \mathrm { P T } } + \pi ( \theta ) ; x ) , } \end{array}
+$$
+
+i.e., they modify the pre-trained weights by adding a correction term $\pi ( \theta )$ parametrized by $\theta$
+
+Recent work in the non-private literature has described concrete instantiations of this framework (Houlsby et al., 2019; Mahabadi et al., 2021; Hu et al., 2021), which (crucially) are effective when $\dim ( \theta ) ^ { \cdot } \ll \dim ( W _ { \mathrm { P T } } )$ . In the non-private setting, such reparametrizations are useful for reducing the computation and memory required for fine-tuning, and enable lightweight and plug-in modifications to the base model for different downstream tasks. At the same time, they maintain (or sometimes surpass) the accuracy achieved by full fine-tuning.
+
+We give some intuition as to why parameter-efficient methods can to be more effective for private fine-tuning, especially on smaller datasets. For simplicity, we assume that the fine-tuning method is additive as in (3), such that the fine-tuned weights $\dot { W _ { \mathrm { F T } } } = W _ { \mathrm { P T } } + \pi ( \theta )$ . We can imagine that
+
+$W _ { \mathrm { F T } }$ lies on a manifold passing through $W _ { \mathrm { P T } }$ of very small dimension (equal to the dimension of $\theta$ ) compared to the dimension of $W _ { \mathrm { P T } }$ . Even if the parameters $\theta$ are very noisy due to the noise added during DPSGD, we will always stay in this manifold. In particular, we are not disturbing the pre-trained weights in most directions (those orthogonal to the manifold near $W _ { \mathrm { P T } }$ ). If we run DPSGD on all the weights instead, then we add noise in all directions, thus potentially unlearning the knowledge learned during pre-training, especially in low data regimes. However, this intuition may not always be true; see the remark at the end of our experiments on NLU tasks.
+
+Besides substantial gains in the accuracy, the above method of reparametrization has several other advantages:
+
+• A single pre-trained model such as BERT or GPT is generally applied to hundreds of downstream tasks via fine-tuning. Private fine-tuning using previous methods requires updating all parameters and storing a different copy of the fine-tuned model per task. This creates substantial overheads for storing and deploying, and can be very expensive in practice. On the other hand, the reparametrization (1) means that we only need to store a single pretrained model that can be shared across many downstream tasks. Each downstream task requires only a small number of new parameters that can be plugged in. • Differentially private training requires computing and storing per-example gradients, which increases the memory footprint. In our approach, however, learning is done in a much lower dimension, hence saving on the memory cost as compared to prior works. Finally, we expect that (1) also gives a more communication-efficient method of fine-tuning in distributed settings such as federated learning, due to the significantly smaller number of parameters learned during fine-tuning.
+
+# 3.2 INSTANTIATING THE META-FRAMEWORK
+
+In this section, we discuss a few ways to instantiate our meta-framework. This list is non-exhaustive, but covers the methods we employ in our experiments.
+
+# 3.2.1 FINE-TUNING VIA LOW-RANK ADAPTATION
+
+Low-Rank Adaptation (LoRA) (Hu et al., 2021) is an additive fine-tuning scheme as defined in (3). For each dense weight matrix $\dot { W } _ { \mathrm { P T } } ^ { i }$ of size $a \times b$ in the pre-trained network, we add a low-rank correction term $L ^ { i } R ^ { i }$ , i.e.,
+
+$$
+W ^ { i } = W _ { \mathrm { P T } } ^ { i } + L ^ { i } R ^ { i } ,
+$$
+
+where $L ^ { i } \in \mathbb { R } ^ { a \times r } , R ^ { i } \in \mathbb { R } ^ { r \times b }$ are new trainable parameters. Hu et al. (2021) apply this reparameterization only to the Transformer attention weights $( W _ { q } , W _ { v } )$ , and freeze all other weights (e.g., $W _ { k }$ and $W _ { o }$ and those in the feed-forward layers). The rank $r$ is typically chosen to be small, e.g., $r = 4 , 1 6 , 6 4$ . Since most parameters in Transformer architectures are dense weight matrices, choosing a small $r$ results in a nearly square-root reduction in the number of parameters.
+
+# 3.2.2 FINE-TUNING VIA ADAPTERS
+
+Houlsby et al. (2019) propose adapter-based fine-tuning, in which we modify the architecture of the pre-trained model by adding new “adapter” layers after each attention and feed-forward layer. Adapter layers are bottleneck layers with residual connections. Specifically, given an input $x$ , an adapter layer $A$ performs
+
+$$
+A ( x ) = U ( \tau ( D ( x ) ) ) + x ,
+$$
+
+where $U$ is an up-projection affine linear map, $D$ is a down-projection affine linear map, and $\tau$ is a non-linear activation function such as the Gaussian error Linear Unit (GeLU) (Hendrycks & Gimpel, 2016). If $x$ has dimension $d$ , then $U \in \mathbb { R } ^ { d \times r } , D \in \mathbb { R } ^ { r \times d }$ for some $r \ll d$ . Thus, the number of introduced parameters is significantly less than the number of parameters in the pre-trained model. When fine-tuning, the parameters of the original model are frozen, and only parameters of the adapter layers, as well as layer normalizations, are modified. Note that fine-tuning with adapters is not an additive fine-tuning framework as in (3), but is captured by the broader framework in (1).
+
+Table 2: Memory and speed comparison for RoBERTa-Large. The rank is chosen as $r = 1 6$ for RGP and LoRA. The speed is measured by the wall-clock time for training one epoch of the SST-2 dataset on a single Tesla V100 GPU with gradient accumulation for batch size 2000.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Memory (GB)</td><td rowspan=1 colspan=1>Speed (seconds per epoch)</td></tr><tr><td rowspan=1 colspan=1>Full fine-tuning (DPSGD)</td><td rowspan=1 colspan=1>27.9</td><td rowspan=1 colspan=1>715</td></tr><tr><td rowspan=1 colspan=1>RGP</td><td rowspan=1 colspan=1>9.1</td><td rowspan=1 colspan=1>296</td></tr><tr><td rowspan=1 colspan=1>DP LoRA</td><td rowspan=1 colspan=1>6.1</td><td rowspan=1 colspan=1>271</td></tr></table>
+
+# 3.2.3 FINE-TUNING VIA COMPACTER
+
+The recent work of Mahabadi et al. (2021) introduces Compacters (Compact adapters), a method which further improves the parameter efficiency of adapters. This is done by replacing the dense matrices in the up-projection $U$ and down-projection $D$ by tensor products of smaller matrices, thus reducing the number of trainable parameters. Specifically, they replace the dense matrix $M _ { \ell }$ in the adapter layer $\ell$ by a low-rank parameterized hypercomplex multiplication (LPHM) layer, i.e., each dense matrix $\boldsymbol { M _ { \ell } } ^ { \cdot } \in \mathbb { R } ^ { a \times b }$ is expressed as
+
+$$
+M _ { \ell } = \sum _ { i = 1 } ^ { n } A _ { i } \otimes \left( S _ { i } ^ { \ell } T _ { i } ^ { \ell } \right)
+$$
+
+where $A _ { i } \in \mathbb { R } ^ { n \times n } , S _ { i } ^ { \ell } \in \mathbb { R } ^ { a / n \times k } , T _ { i } ^ { \ell } \in \mathbb { R } ^ { k \times b / n }$ and $\otimes$ is the matrix Kronecker product. Note the matrices $A _ { i }$ are not indexed by the layer $\ell$ because these matrices are shared among all the adapter layers. Since each adapter layers has two dense matrices (one for up-projection and one for down-projection), if there are $L$ adapter layers, this reduces the number of parameters from $L ( 2 a b )$ to $L ( \bar { 2 ( a + b ) k ) } + n ^ { 3 }$ . In practice, $a$ and $b$ are chosen to be either the model dimension $d$ or the intermediate representation dimension $r$ in the adapters, $n$ is typically chosen to be a small constant such as $n = 2 , 4 , 8 , 1 2$ and $k$ is chosen to be 1.
+
+# 3.2.4 WHY DOES PARAMETER-EFFICIENT TUNING WORK?
+
+Theoretical explanation of success of parameter-efficient fine-tuning methods is active area of research in deep learning. Indeed, since trends have consistently shown that model accuracy increases with size, how can one achieve competitive accuracy while fine-tuning less than $1 \%$ of the parameters? One popular hypothesis is intrinsic dimensionality (Li et al., 2018), which posits that the minimum number of parameters needed to train a machine learning model may be much less than the total number of model parameters. Aghajanyan et al. (2020) explore this hypothesis in the context of fine-tuning LLMs, showing that one can achieve most of their accuracy by training only a very small number of parameters (chosen via a random projection). Perhaps surprisingly, they find that as the model size increases, intrinsic dimension decreases, in the limit exhibiting zero-shot learning. While we did not explore this hypothesis in the context of DP due to computational restrictions, we believe it may be an interesting lens through which one can understand the effectiveness of private parameter-efficient fine-tuning.
+
+# 3.3 COMPARISION WITH BASELINE ALGORITHMS
+
+We highlight some key algorithmic differences between our proposed methods and the baselines of full fine-tuning and RGP.
+
+• DPSGD and RGP both require updating all parameters of the pre-trained model, whereas our proposed methods update only a tiny fraction (between $0 . 0 5 \%$ and $1 \%$ ). The rightmost columns of Tables 3 and 4 list the number of parameters trained by these algorithms. • RGP performs a low-rank decomposition of weight matrices which is similar to LoRA, though there are subtle differences. Recall that in RGP, at the beginning of each iteration $t$ , the historical weight matrix $W _ { t - 1 }$ is decomposed to find a low-rank product $L R$ . The gradients on $L$ and $R$ are then projected back to the full parameter space to perform the descent step. Hence, RGP keeps modifying the pre-trained weights during learning. LoRA can be viewed as a simplification of RGP. LoRA reparametrizes $W _ { \mathrm { F T } } : = W _ { \mathrm { P T } } + L R$ , where the pre-trained weight matrix $W _ { \mathrm { P T } }$ is frozen during training. Hence, compared to
+
+Table 3: Accuracy for fine-tuning with RoBERTa-Base (in $\%$ ). The privacy parameters are $\varepsilon = 6 . 7$ , and $\delta = 1 { \mathrm e } { - } 5$ for SST-2 and QNLI and 1e-6 for MNLI and QQP. Bold indicates the best accuracy with DP. Numbers for non-private fine-tuning are from Liu et al. (2019) and Hu et al. (2021).   
+
+<table><tr><td rowspan=1 colspan=2>Method</td><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>Trained params</td></tr><tr><td rowspan=2 colspan=1>Full</td><td rowspan=1 colspan=1>w/o DP</td><td rowspan=1 colspan=1>87.6</td><td rowspan=1 colspan=1>94.8</td><td rowspan=1 colspan=1>91.9</td><td rowspan=1 colspan=1>92.8</td><td rowspan=1 colspan=1>91.8</td><td rowspan=2 colspan=1>100%</td></tr><tr><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>53.1</td><td rowspan=1 colspan=1>82.6</td><td rowspan=1 colspan=1>74.4</td><td rowspan=1 colspan=1>63.9</td><td rowspan=1 colspan=1>68.5</td></tr><tr><td rowspan=1 colspan=1>LoRA</td><td rowspan=1 colspan=1>w/o DP</td><td rowspan=1 colspan=1>87.5</td><td rowspan=1 colspan=1>95.1</td><td rowspan=1 colspan=1>90.8</td><td rowspan=1 colspan=1>93.3</td><td rowspan=1 colspan=1>91.7</td><td rowspan=1 colspan=1>0.24%</td></tr><tr><td rowspan=1 colspan=1>RGP</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>80.1</td><td rowspan=1 colspan=1>91.6</td><td rowspan=1 colspan=1>85.5</td><td rowspan=1 colspan=1>87.2</td><td rowspan=1 colspan=1>86.1</td><td rowspan=1 colspan=1>100%</td></tr><tr><td rowspan=1 colspan=1>Adapter</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>83.4</td><td rowspan=1 colspan=1>92.5</td><td rowspan=1 colspan=1>85.6</td><td rowspan=1 colspan=1>87.5</td><td rowspan=1 colspan=1>87.3</td><td rowspan=1 colspan=1>1.4% (r = 48)</td></tr><tr><td rowspan=1 colspan=1>Compacter</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>82.6</td><td rowspan=1 colspan=1>92.3</td><td rowspan=1 colspan=1>84.7</td><td rowspan=1 colspan=1>85.1</td><td rowspan=1 colspan=1>86.2</td><td rowspan=1 colspan=1>0.055% (r = 96,n = 8)</td></tr><tr><td rowspan=1 colspan=1>LoRA</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>83.5</td><td rowspan=1 colspan=1>92.2</td><td rowspan=1 colspan=1>85.7</td><td rowspan=1 colspan=1>87.3</td><td rowspan=1 colspan=1>87.2</td><td rowspan=1 colspan=1>0.94% (r = 16)</td></tr></table>
+
+RGP, LoRA eliminates the decomposition and the projection to the full parameter space at each iteration, simplifying the implementation and reducing the running time and memory cost. This is summarized in Table 2. We observe that DP LoRA reduces the memory cost by about $3 3 \%$ and the training speed by $8 \%$ . As we will see, this simplification also results in improved utility.
+
+• Neither full fine-tuning nor RGP fall into our meta-framework described by (1). Thus, if a pre-trained model is to be applied to several downstream tasks, one must store a separate set of weights for each task, incurring a significant memory cost and losing the plug-in functionality. In contrast, our methods are much more lightweight.
+
+# 4 EXPERIMENTS
+
+We experimentally evaluate our methods for DP fine-tuning to demonstrate their utility, privacy, and parameter-efficiency. We investigate both language understanding and text generation tasks to establish that our techniques are applicable to a variety of tasks and model architectures. Our code is publicly available at https://github.com/AnonymousAKES/ Differentially-Private-Fine-tuning-of-Language-Models.
+
+# 4.1 FINE-TUNING FOR LANGUAGE UNDERSTANDING TASKS
+
+We first compare our methods with state-of-the-art fine-tuning algorithms using models from the BERT family, which was used in the prior work (Yu et al., 2021b). Specifically, we use RoBERTa models (Liu et al., 2019), which are pre-trained on public data collected from the web. RoBERTaBase has 125M parameters and RoBERTa-Large has 355M parameters. We choose four downstream tasks: MNLI, QQP, QNLI, and SST-2 from GLUE (Wang et al., 2018), following Yu et al. (2021b).
+
+Implementation Details: For fine-tuning with adapters, we may choose the intermediate representation dimension $r$ , shared across all adapter layers. For fine-tuning with Compacter, we can choose both $r$ and the Kronecker product kernel dimension $n$ in (6). For LoRA fine-tuning, we add bottleneck branches for both the attention layers and the feedforward layers, which differs slightly from the addition of bottleneck branches for only the $W _ { q }$ and $W _ { v }$ matrices of the attention layers as done by Hu et al. (2021). Given the same bottleneck representation dimension $r$ in (4), our new implementation uses twice as many trainable parameters as the original paper, and achieves some improvements for learning with DP. We perform privacy accounting using the approach of Gopi et al. (2021), which currently gives the tightest bounds.
+
+Hyperparameter choice: Given the large number of hyperparameter choices, e.g., the intermediate representation dimension, learning rate, weight decay, privacy parameter $\delta$ , and model size, an exhaustive grid search over all hyperparameters is expensive. Our hyperparameter choices are informed by prior work and are as follows. For privacy parameters, we use $\delta = 1 \mathrm { e } { - } 5$ for SST-2 and QNLI and $\delta = 1 \mathrm { e } { - } 6$ for QQP and MNLI due to their dataset sizes, and use noise multipliers 0.92, 0.83, 0.66 and 0.65 for SST-2, QNLI, QQP, and MNLI, respectively, which is the same as $\mathrm { Y u }$ et al. (2021b). In Appendix B, we run experiments under different privacy parameters. The proposed framework performs well under a wide range choices of $\varepsilon$ and $\delta$ . The clipping threshold is 10 for all methods. The batch size is 2000. In Appendix D, we show the performance of the proposed algorithm is stable across a wide range of choices of clipping thresholds and batch sizes. For adapters and Compacter, we follow the original papers and choose $r$ from $\{ 1 6 , 4 8 , 9 6 \}$ and $n$ from $\{ 4 , 8 , 1 2 \}$ . For LoRA, we choose the best-performing rank $r$ from the set $\{ 4 , 1 6 , 4 8 , 6 4 \}$ . The best performing hyperparameters are noted in Tables 3 and 4. We train for 20 epochs using AdamW (Loshchilov & Hutter, 2019) with weight decay 1e-2 and search over four learning rates $\{ 5 \mathrm { e } { - } 4 , 1 \mathrm { e } { - } 3 , 2 \mathrm { e } { - } 3 , 5 \mathrm { e } { - } 3 \}$ .
+
+Table 4: Accuracy for fine-tuning with RoBERTa-Large $( \mathrm { i n } \% )$ ). The privacy parameters are $\varepsilon = 6 . 7$ , and $\delta = 1 { \mathrm e } { - } 5$ for SST-2 and QNLI and $\delta = 1 \mathrm { e } { - } 6$ for MNLI and QQP. Bold indicates the best accuracy with DP. Numbers for non-private fine-tuning are from Liu et al. (2019) and Hu et al. (2021).   
+
+<table><tr><td rowspan=1 colspan=2>Method</td><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>Avg.</td><td rowspan=1 colspan=1>Trained params</td></tr><tr><td rowspan=1 colspan=1>Full</td><td rowspan=1 colspan=1>w/o DP</td><td rowspan=1 colspan=1>90.2</td><td rowspan=1 colspan=1>96.4</td><td rowspan=1 colspan=1>92.2</td><td rowspan=1 colspan=1>94.7</td><td rowspan=1 colspan=1>93.4</td><td rowspan=1 colspan=1>100%</td></tr><tr><td rowspan=1 colspan=1>LoRA</td><td rowspan=1 colspan=1>w/o DP</td><td rowspan=1 colspan=1>90.6</td><td rowspan=1 colspan=1>96.2</td><td rowspan=1 colspan=1>91.6</td><td rowspan=1 colspan=1>94.9</td><td rowspan=1 colspan=1>93.3</td><td rowspan=1 colspan=1>0.23%</td></tr><tr><td rowspan=1 colspan=1>RGP</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>86.1</td><td rowspan=1 colspan=1>93.0</td><td rowspan=1 colspan=1>86.7</td><td rowspan=1 colspan=1>90.0</td><td rowspan=1 colspan=1>88.9</td><td rowspan=1 colspan=1>100%</td></tr><tr><td rowspan=1 colspan=1>Adapter</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>87.7</td><td rowspan=1 colspan=1>93.9</td><td rowspan=1 colspan=1>86.3</td><td rowspan=1 colspan=1>90.7</td><td rowspan=1 colspan=1>89.7</td><td rowspan=1 colspan=1>1.4% (r = 48)</td></tr><tr><td rowspan=1 colspan=1>Compacter</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>87.5</td><td rowspan=1 colspan=1>94.2</td><td rowspan=1 colspan=1>86.2</td><td rowspan=1 colspan=1>90.2</td><td rowspan=1 colspan=1>89.5</td><td rowspan=1 colspan=1>0.053% (r =96,n = 8)</td></tr><tr><td rowspan=1 colspan=1>LoRA</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>87.8</td><td rowspan=1 colspan=1>95.3</td><td rowspan=1 colspan=1>87.4</td><td rowspan=1 colspan=1>90.8</td><td rowspan=1 colspan=1>90.3</td><td rowspan=1 colspan=1>0.94% (r =16)</td></tr></table>
+
+Results: We report the prediction accuracy in Tables 3 and 4. Our experiments using RoBERTaBase serve as a direct comparison to Yu et al. (2021b) who only trained the base model, whereas RoBERTa-Large experiments demonstrate the significance of using larger models. Our key findings are: (1) On all datasets, our methods achieve the best accuracy while training a tiny fraction of parameters; larger models give significant improvements. (2) Noticeable improvements in $\varepsilon$ versus Yu et al. (2021b) are primarily due to new privacy accountants based on Fourier-based numerical composition (Koskela et al., 2020; 2021; Gopi et al., 2021); we use the accountant in Gopi et al. (2021) since it is the most efficient. (3) Private adapters provide the best average performance for RoBERTa-Base, whereas LoRA outperforms all other methods for RoBERTa-Large.
+
+Remark: While our experiments indicate that full fine-tuning does not achieve competitive performance, there could be a choice of hyperparameters that improves upon the reported numbers, e.g., “mega” batch sizes (in the millions) in Anil et al. (2021). We note that our main message is that one does not need to fine-tune all parameters to achieve the best accuracy. Nevertheless, it is interesting to wonder if full fine-tuning with DPSGD can match the accuracy of parameter-efficient methods. A positive answer would imply that private and non-private fine-tuning conceptually mirror each other.
+
+Update: A concurrent work by Li et al (Li et al., 2022) show that using a larger batch size and training with full-precision improves the performance of full fine-tuning via DPSGD, and obtains similar performance as our algorithms. Thus, poor performance of DPSGD in our experiments is due to the suboptimal choice of hyperparameters and also due to precision issues, although we use same hyperparameters for all the algorithms. We run new experiments with hyperparameters of (Li et al., 2022) in full precision mode, and get improvements around $1 \%$ even for our algorithms. We report these findings in Appendix C.
+
+# 4.2 FINE-TUNING FOR NATURAL LANGUAGE GENERATION (NLG)
+
+Next, we study private fine-tuning for text generation problems using the GPT-2 series of models on the End-2-End (E2E) NLG challenge (Novikova et al., 2017), one of the primary benchmarks used in recent works on non-private fine-tuning (Hu et al., 2021; Li & Liang, 2021). We use GPT-2-Small (117M parameters), GPT-2-Medium (345M parameters), and GPT-2-Large (774M parameters).4 To the best of our knowledge, we are the first to privately fine-tune for E2E or fine-tune GPT-2-Large. The purpose of this section is not to evaluate various fine-tuning algorithms, but to show that private fine-tuning is competitive with non-private fine-tuning for text generation problems. Due to the high cost of training, we report experimental results only for fine-tuning with LoRA.
+
+In Appendix F, we present additional experiments on NLG that include private fine-tuning of the GPT-2-XL model with 1.5 billion parameters. Other noticeable points in the additional experiments include 1) we show improved performance using better hyperparameters; 2) we test different privacy parameters; 3) we consider a new dataset DART (Nan et al., 2021).
+
+Table 5: Metrics on the E2E NLG task $\mathit { \check { \Psi } } \varepsilon = 5 . 4 , \delta = 1 { \mathrm { e } } . 5 )$ . Non-DP results from Hu et al. (2021).   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>BLEU</td><td rowspan=1 colspan=1>NIST</td><td rowspan=1 colspan=1>MET</td><td rowspan=1 colspan=1>ROUGE-L</td><td rowspan=1 colspan=1>CIDEr</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Small +DP</td><td rowspan=1 colspan=1>59.26</td><td rowspan=1 colspan=1>6.13</td><td rowspan=1 colspan=1>36.6</td><td rowspan=1 colspan=1>64.1</td><td rowspan=1 colspan=1>1.63</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium+DP</td><td rowspan=1 colspan=1>64.2</td><td rowspan=1 colspan=1>7.77</td><td rowspan=1 colspan=1>40.02</td><td rowspan=1 colspan=1>66.45</td><td rowspan=1 colspan=1>2.00</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large + DP</td><td rowspan=1 colspan=1>64.51</td><td rowspan=1 colspan=1>8.22</td><td rowspan=1 colspan=1>41.5</td><td rowspan=1 colspan=1>67.55</td><td rowspan=1 colspan=1>2.13</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium</td><td rowspan=1 colspan=1>70.4</td><td rowspan=1 colspan=1>8.85</td><td rowspan=1 colspan=1>46.8</td><td rowspan=1 colspan=1>71.8</td><td rowspan=1 colspan=1>2.53</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large</td><td rowspan=1 colspan=1>70.4</td><td rowspan=1 colspan=1>8.89</td><td rowspan=1 colspan=1>46.8</td><td rowspan=1 colspan=1>72.0</td><td rowspan=1 colspan=1>2.47</td></tr></table>
+
+E2E NLG challenge: The E2E dataset in Novikova et al. (2017) contains template-like information in the restaurant domain to be mapped to natural language with end-to-end training. The dataset consists of 42K training samples, 4.6K validation samples, and 4.6K test samples. We use standard metrics such as BLUE, ROUGE-L, etc., used in (Hu et al., 2021) for evaluation.
+
+Hyperparameter choice: For LoRA, we choose the bottleneck rank $r = 4$ in (4) and fine-tune $W _ { q }$ and $W _ { v }$ matrices of the attention layers as in the original paper. We optimize using AdamW with learning rate 2e-4, weight decay 1e-2 and train our models for 5 epochs using batch size 64. We take the gradient clipping parameter to be 1.0 and set the noise multiplier as 0.5.
+
+Results: The results of our experiments are summarized in the Table 5, which reiterate the main themes of this paper: private fine-tuning with a parameter-efficient approach performs close to their non-private counterparts and show consistent improvement in the utility as the model size increases.
+
+# 5 RELATED WORK
+
+Some work studies private language models on more traditional architectures such as LSTMs (Hochreiter & Schmidhuber, 1997), either training with DPSGD (McMahan et al., 2018; Carlini et al., 2019) or related heuristics (Ramaswamy et al., 2020). Though pre-training on public data is suggested (McMahan et al., 2018), public data appears to only be used in one of these works for honest hyperparameter selection (Ramaswamy et al., 2020). A few more recent works consider training LLMs with DP. Anil et al. (2021) privately train BERT-Large from scratch, compared to our work which focuses on private fine-tuning. (Hoory et al., 2021; Basu et al., 2021) perform private full fine-tuning of BERT models. Hoory et al. (2021) achieve accuracy which is comparable to the non-private model, but additionally supplement the public pre-training data with additional domain-relevant material, while we use off-the-shelf pre-trained models. Basu et al. (2021) observe significant drops in utility, compared to our parameter-efficient methods which do not. While Kerrigan et al. (2020) consider public pre-training and private fine-tuning, their experiments are on much smaller architectures (i.e., feedforward networks with three hidden layers). A simultaneous work of Ginart et al. (2022) investigates private prediction (rather than learning) for next-token prediction. A subsequent work by Senge et al. (2021) also investigates the effect of private fine-tuning on various NLP tasks.
+
+In a concurrent work, Li et al. (2022) also investigate DP fine-tuning of LLMs. In several cases, their results demonstrate qualitatively similar findings as ours. While our experiments focus primarily on parameter-efficient fine-tuning methods, interestingly, they show that private full fine-tuning can also achieve comparable utility if the experimental setup is configured properly, e.g., using suitable hyperparameters. In Appendix C, we run experiments under the setup in Li et al. (2022). We show their setup can also improve the performance of our methods.
+
+# 6 CONCLUSION
+
+So far, DP deep learning has focused on training models from scratch. The spectacular success of transfer learning in real-world applications, however, shows that private fine-tuning is an equally pertinent problem to study and deserves more attention. We show that by combining recent advances in NLP, parameter-efficiency, privacy accounting, and using larger models, one can privately fine-tune models whose utility approaches that of non-private models. We hope our work inspires more study on the core problem of private fine-tuning, which we believe to be a central direction for research in private machine learning, leading to more interaction between the LLM and DP communities.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank Rabeeh Karimi Mahabadi for sharing hyperparameters based on experiments in Mahabadi et al. (2021). Janardhan Kulkarni would like to thank Edward Hu for sharing many ideas on fine-tuning. Gautam Kamath is supported by an NSERC Discovery Grant.
+
+# REFERENCES
+
+Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM Conference on Computer and Communications Security, CCS ’16, pp. 308–318, New York, NY, USA, 2016. ACM.
+
+Armen Aghajanyan, Luke Zettlemoyer, and Sonal Gupta. Intrinsic dimensionality explains the effectiveness of language model fine-tuning. arXiv preprint arXiv:2012.13255, 2020.
+
+Noga Alon, Raef Bassily, and Shay Moran. Limits of private learning with access to public data. In Advances in Neural Information Processing Systems 32, NeurIPS ’19, pp. 10342–10352. Curran Associates, Inc., 2019.
+
+Ehsan Amid, Arun Ganesh, Rajiv Mathews, Swaroop Ramaswamy, Shuang Song, Thomas Steinke, Vinith M Suriyakumar, Om Thakkar, and Abhradeep Thakurta. Public data-assisted mirror descent for private model training. arXiv preprint arXiv:2112.00193, 2021.
+
+Rohan Anil, Badih Ghazi, Vineet Gupta, Ravi Kumar, and Pasin Manurangsi. Large-scale differentially private BERT. arXiv preprint arXiv:2108.01624, 2021.
+
+Raef Bassily, Adam Smith, and Abhradeep Thakurta. Private empirical risk minimization: Efficient algorithms and tight error bounds. In Proceedings of the 55th Annual IEEE Symposium on Foundations of Computer Science, FOCS ’14, pp. 464–473, Washington, DC, USA, 2014. IEEE Computer Society.
+
+Raef Bassily, Om Thakkar, and Abhradeep Guha Thakurta. Model-agnostic private learning. In Advances in Neural Information Processing Systems 31, NeurIPS ’18, pp. 7102–7112. Curran Associates, Inc., 2018.
+
+Raef Bassily, Albert Cheu, Shay Moran, Aleksandar Nikolov, Jonathan Ullman, and Steven Wu. Private query release assisted by public data. In Proceedings of the 37th International Conference on Machine Learning, ICML ’20, pp. 695–703. JMLR, Inc., 2020a.
+
+Raef Bassily, Shay Moran, and Anupama Nandi. Learning from mixtures of private and public populations. In Advances in Neural Information Processing Systems 33, NeurIPS ’20, pp. 2947– 2957. Curran Associates, Inc., 2020b.
+
+Priyam Basu, Tiasa Singha Roy, Rakshit Naidu, Zumrut Muftuoglu, Sahib Singh, and Fatemehsadat Mireshghallah. Benchmarking differential privacy and federated learning for BERT models. arXiv preprint arXiv:2106.13973, 2021.
+
+Amos Beimel, Kobbi Nissim, and Uri Stemmer. Private learning and sanitization: Pure vs. approximate differential privacy. Theory of Computing, 12(1):1–61, 2016.
+
+Elad Ben Zaken, Shauli Ravfogel, and Yoav Goldberg. Bitfit: Simple parameter-efficient fine-tuning for transformer-based masked language-models. arXiv preprint arXiv:, 2021.
+
+Gavin Brown, Mark Bun, Vitaly Feldman, Adam Smith, and Kunal Talwar. When is memorization of irrelevant training data necessary for high-accuracy learning? In Proceedings of the 53nd Annual ACM Symposium on the Theory of Computing, STOC ’21, pp. 123–132, New York, NY, USA, 2021. ACM.
+
+Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M.
+
+Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In Advances in Neural Information Processing Systems 33, NeurIPS ’20. Curran Associates, Inc., 2020.
+
+Mark Bun, Jonathan Ullman, and Salil Vadhan. Fingerprinting codes and the price of approximate differential privacy. In Proceedings of the 46th Annual ACM Symposium on the Theory of Computing, STOC ’14, pp. 1–10, New York, NY, USA, 2014. ACM.
+
+Han Cai, Chuang Gan, Ligeng Zhu, and Song Han. TinyTL: Reduce memory, not parameters for efficient on-device learning. In Advances in Neural Information Processing Systems 33, NeurIPS ’20, pp. 11285–11297. Curran Associates, Inc., 2020.
+
+Nicholas Carlini, Chang Liu, Ulfar Erlingsson, Jernej Kos, and Dawn Song. The secret sharer: ´ Evaluating and testing unintended memorization in neural networks. In 28th USENIX Security Symposium, USENIX Security ’19, pp. 267–284. USENIX Association, 2019.
+
+Nicholas Carlini, Florian Tramer, Eric Wallace, Matthew Jagielski, Ariel Herbert-Voss, Katherine \` Lee, Adam Roberts, Tom Brown, Dawn Song, Ulfar Erlingsson, Alina Oprea, and Colin Raffel. Extracting training data from large language models. In 30th USENIX Security Symposium, USENIX Security ’21, pp. 2633–2650. USENIX Association, 2021.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), NAACL-HLT ’19, pp. 4171–4186, 2019.
+
+Cynthia Dwork, Krishnaram Kenthapadi, Frank McSherry, Ilya Mironov, and Moni Naor. Our data, ourselves: Privacy via distributed noise generation. In Proceedings of the 24th Annual International Conference on the Theory and Applications of Cryptographic Techniques, EUROCRYPT ’06, pp. 486–503, Berlin, Heidelberg, 2006a. Springer.
+
+Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. Calibrating noise to sensitivity in private data analysis. In Proceedings of the 3rd Conference on Theory of Cryptography, TCC ’06, pp. 265–284, Berlin, Heidelberg, 2006b. Springer.
+
+Vitaly Feldman. Does learning require memorization? a short tale about a long tail. In Proceedings of the 52nd Annual ACM Symposium on the Theory of Computing, STOC ’20, pp. 954–959, New York, NY, USA, 2020. ACM.
+
+Antonio Ginart, Laurens van der Maaten, James Zou, and Chuan Guo. Submix: Practical private prediction for large-scale language models. arXiv preprint arXiv:2201.00971, 2022.
+
+Sivakanth Gopi, Yin Tat Lee, and Lukas Wutschitz. Numerical composition of differential privacy. arXiv preprint arXiv:2106.02848, 2021.
+
+Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8): 1735–1780, 1997.
+
+Shlomo Hoory, Amir Feder, Avichai Tendler, Alon Cohen, Sofia Erell, Itay Laish, Hootan Nakhost, Uri Stemmer, Ayelet Benjamini, Avinatan Hassidim, and Yossi Matias. Learning and evaluating a differentially private pre-trained language model. In Proceedings of the Third Workshop on Privacy in Natural Language Processing, PrivateNLP ’21, pp. 21–29, 2021.
+
+Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin De Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. Parameter-efficient transfer learning for nlp. In International Conference on Machine Learning, pp. 2790–2799. PMLR, 2019.
+
+Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685, 2021.
+
+Zhanglong Ji and Charles Elkan. Differential privacy based on importance weighting. Machine Learning, 93(1):163–183, 2013.
+
+Peter Kairouz, Monica Ribero, Keith Rush, and Abhradeep Thakurta. (nearly) dimension indepen- ´ dent private ERM with adagrad rates via publicly estimated subspaces. In Proceedings of the 34th Annual Conference on Learning Theory, COLT ’21, pp. 2717–2746, 2021.
+
+Gavin Kerrigan, Dylan Slack, and Jens Tuyls. Differentially private language models benefit from public pre-training. arXiv preprint arXiv:2009.05886, 2020.
+
+Antti Koskela, Joonas Jalk ¨ o, and Antti Honkela. Computing tight differential privacy guarantees ¨ using fft. In International Conference on Artificial Intelligence and Statistics, pp. 2560–2569. PMLR, 2020.
+
+Antti Koskela, Joonas Jalk ¨ o, Lukas Prediger, and Antti Honkela. Tight differential privacy for ¨ discrete-valued mechanisms and for the subsampled gaussian mechanism using fft. In International Conference on Artificial Intelligence and Statistics, pp. 3358–3366. PMLR, 2021.
+
+Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP), EMNLP ’21. Association for Computational Linguistics, 2021.
+
+Chunyuan Li, Heerad Farkhoor, Rosanne Liu, and Jason Yosinski. Measuring the intrinsic dimension of objective landscapes. In Proceedings of the 6th International Conference on Learning Representations, ICLR ’18, 2018.
+
+Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), ACL-IJCNLP ’21, pp. 4582–4597, 2021.
+
+Xuechen Li, Florian Tramer, Percy Liang, and Tatsunori Hashimoto. Large language models can \` be strong differentially private learners. In Proceedings of the 10th International Conference on Learning Representations, ICLR ’22, 2022.
+
+Terrance Liu, Giuseppe Vietri, Thomas Steinke, Jonathan Ullman, and Steven Wu. Leveraging public data for practical private query release. In Proceedings of the 38th International Conference on Machine Learning, ICML ’21, pp. 6968–6977. JMLR, Inc., 2021.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.
+
+Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In Proceedings of the 7th International Conference on Learning Representations, ICLR ’19, 2019.
+
+Zelun Luo, Daniel J Wu, Ehsan Adeli, and Li Fei-Fei. Scalable differential privacy with sparse network finetuning. In Proceedings of the 2021 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, CVPR ’21, pp. 5059–5068, Washington, DC, USA, 2021. IEEE Computer Society.
+
+Rabeeh Karimi Mahabadi, James Henderson, and Sebastian Ruder. Compacter: Efficient low-rank hypercomplex adapter layers. arXiv preprint arXiv:2106.04647, 2021.
+
+H Brendan McMahan, Daniel Ramage, Kunal Talwar, and Li Zhang. Learning differentially private recurrent language models. In Proceedings of the 6th International Conference on Learning Representations, ICLR ’18, 2018.
+
+Paulius Micikevicius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich Elsen, David Garcia, Boris Ginsburg, Michael Houston, Oleksii Kuchaiev, Ganesh Venkatesh, et al. Mixed precision training. arXiv preprint arXiv:1710.03740, 2017.
+
+Linyong Nan, Dragomir Radev, Rui Zhang, Amrit Rau, Abhinand Sivaprasad, Chiachun Hsieh, Xiangru Tang, Aadit Vyas, Neha Verma, Pranav Krishna, Yangxiaokang Liu, Nadia Irwanto, Jessica Pan, Faiaz Rahman, Ahmad Zaidi, Mutethia Mutuma, Yasin Tarabar, Ankit Gupta, Tao Yu, Yi Chern Tan, Xi Victoria Lin, Caiming Xiong, Richard Socher, and Nazneen Fatema Rajani. DART: open-domain structured data record to text generation. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT ’21, pp. 432–447. Association for Computational Linguistics, 2021.
+
+Anupama Nandi and Raef Bassily. Privately answering classification queries in the agnostic PAC model. In Proceedings of the 31st International Conference on Algorithmic Learning Theory, ALT ’20, pp. 687–703. JMLR, Inc., 2020.
+
+Jekaterina Novikova, Ondˇrej Dusek, and Verena Rieser. The E2E dataset: New challenges for ˇ end-to-end generation. In Proceedings of the 18th Annual SIGdial Meeting on Discourse and Dialogue, SIGDIAL ’17, pp. 201–206. Association for Computational Linguistics, 2017.
+
+Myle Ott, Sergey Edunov, David Grangier, and Michael Auli. Scaling neural machine translation. In Proceedings of the Third Conference on Machine Translation (WMT), 2018.
+
+Nicolas Papernot, Mart´ın Abadi, Ulfar Erlingsson, Ian Goodfellow, and Kunal Talwar. Semisupervised knowledge transfer for deep learning from private training data. In Proceedings of the 5th International Conference on Learning Representations, ICLR ’17, 2017.
+
+Nicolas Papernot, Shuang Song, Ilya Mironov, Ananth Raghunathan, Kunal Talwar, and Ulfar Er- ´ lingsson. Scalable private learning with PATE. In Proceedings of the 6th International Conference on Learning Representations, ICLR ’18, 2018.
+
+Nicolas Papernot, Steve Chien, Shuang Song, Abhradeep Thakurta, and Ulfar Erlingsson. Making the shoe fit: Architectures, initializations, and tuning for learning with privacy. https:// openreview.net/forum?id $=$ rJg851rYwH, 2019.
+
+Jonas Pfeiffer, Aishwarya Kamath, Andreas Ruckl ¨ e, Kyunghyun Cho, and Iryna Gurevych. Adapter- ´ fusion: Non-destructive task composition for transfer learning. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, EACL ’21, pp. 487–503. Association for Computational Linguistics, 2021.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training, 2018.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners, 2019.
+
+Swaroop Ramaswamy, Om Thakkar, Rajiv Mathews, Galen Andrew, H Brendan McMahan, and Franc¸oise Beaufays. Training production language models without memorizing user data. arXiv preprint arXiv:2009.10031, 2020.
+
+Andreas Ruckl ¨ e, Gregor Geigle, Max Glockner, Tilman Beck, Jonas Pfeiffer, Nils Reimers, and ´ Iryna Gurevych. Adapterdrop: On the efficiency of adapters in transformers. arXiv preprint arXiv:2010.11918, 2020.
+
+Manuel Senge, Timour Igamberdiev, and Ivan Habernal. One size does not fit all: Investigating strategies for differentially-private learning across nlp tasks. arXiv preprint arXiv:2112.08159, 2021.
+
+Reza Shokri, Marco Stronati, Congzheng Song, and Vitaly Shmatikov. Membership inference attacks against machine learning models. In Proceedings of the 38th IEEE Symposium on Security and Privacy, SP ’17, pp. 3–18, Washington, DC, USA, 2017. IEEE Computer Society.
+
+Shuang Song, Kamalika Chaudhuri, and Anand D Sarwate. Stochastic gradient descent with differentially private updates. In Proceedings of the 2013 IEEE Global Conference on Signal and Information Processing, GlobalSIP ’13, pp. 245–248, Washington, DC, USA, 2013. IEEE Computer Society.
+
+Pranav Subramani, Nicholas Vadivelu, and Gautam Kamath. Enabling fast differentially private sgd via just-in-time compilation and vectorization. In Advances in Neural Information Processing Systems 34, NeurIPS ’21. Curran Associates, Inc., 2021.
+
+Zhiliang Tian, Yingxiu Zhao, Ziyue Huang, Yu-Xiang Wang, Nevin Zhang, and He He. SeqPATE: Differentially private text generation via knowledge distillation, 2022. URL https: //openreview.net/forum?id $^ { = 5 }$ sP_PUUS78v.
+
+Florian Tramer and Dan Boneh. Differentially private learning needs better features (or much more \` data). In Proceedings of the 9th International Conference on Learning Representations, ICLR ’21, 2021.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 30, NIPS ’17, pp. 5998–6008. Curran Associates, Inc., 2017.
+
+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 International Conference on Learning Representations, 2018.
+
+Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), NAACL-HLT ’18, pp. 1112–1122. Association for Computational Linguistics, 2018.
+
+Da Yu, Huishuai Zhang, Wei Chen, and Tie-Yan Liu. Do not let privacy overbill utility: Gradient embedding perturbation for private learning. In Proceedings of the 9th International Conference on Learning Representations, ICLR ’21, 2021a.
+
+Da Yu, Huishuai Zhang, Wei Chen, Jian Yin, and Tie-Yan Liu. Large scale private learning via low-rank reparametrization. In Proceedings of the 38th International Conference on Machine Learning, ICML ’21. JMLR, Inc., 2021b.
+
+Yingxue Zhou, Zhiwei Steven Wu, and Arindam Banerjee. Bypassing the ambient dimension: Private SGD with gradient subspace identification. In Proceedings of the 9th International Conference on Learning Representations, ICLR ’21, 2021.
+
+Table 6: Test accuracy for fine-tuning RoBERTa-Large with different privacy parameters. The number of training samples is denoted by $n$ . The values of $\sigma$ are noise multipliers. Numbers in the brackets are the changes compared to the results in Table 4 $\varepsilon = 6 . 7$ , $\delta = \Theta ( 1 / n ) ,$ ).   
+
+<table><tr><td rowspan=1 colspan=1>Taks</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>δ=1/n</td><td rowspan=1 colspan=1>δ=1/10n</td><td rowspan=1 colspan=1>δ=1/100n</td><td rowspan=1 colspan=1>δ=1/1000n</td><td rowspan=1 colspan=1>Accuracy (in %)</td></tr><tr><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>1.88</td><td rowspan=1 colspan=1>ε=1</td><td rowspan=1 colspan=1>ε = 1.35</td><td rowspan=1 colspan=1>ε=1.49</td><td rowspan=1 colspan=1>ε = 1.61</td><td rowspan=1 colspan=1>86.8 (-1.0%)</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>1.88</td><td rowspan=1 colspan=1>ε=1</td><td rowspan=1 colspan=1>ε = 1.40</td><td rowspan=1 colspan=1>ε= 1.54</td><td rowspan=1 colspan=1>ε = 1.67</td><td rowspan=1 colspan=1>85.2 (-2.2%)</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>3.01</td><td rowspan=1 colspan=1>ε=1</td><td rowspan=1 colspan=1>ε= 1.48</td><td rowspan=1 colspan=1>ε = 1.64</td><td rowspan=1 colspan=1>ε = 1.79</td><td rowspan=1 colspan=1>88.0 (-2.8%)</td></tr><tr><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>3.63</td><td rowspan=1 colspan=1>ε=1</td><td rowspan=1 colspan=1>ε = 1.47</td><td rowspan=1 colspan=1>ε= 1.64</td><td rowspan=1 colspan=1>ε= 1.80</td><td rowspan=1 colspan=1>93.1 (-2.2%)</td></tr><tr><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>0.91</td><td rowspan=1 colspan=1>e=3</td><td rowspan=1 colspan=1>ε = 4.12</td><td rowspan=1 colspan=1>ε= 4.51</td><td rowspan=1 colspan=1> = 4.89</td><td rowspan=1 colspan=1>87.4 (-0.4%)</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>0.93</td><td rowspan=1 colspan=1>ε=3</td><td rowspan=1 colspan=1>ε= 4.10</td><td rowspan=1 colspan=1>= 4.49</td><td rowspan=1 colspan=1>ε= 4.86</td><td rowspan=1 colspan=1>86.8 (-0.6%)</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>1.29</td><td rowspan=1 colspan=1>ε=3</td><td rowspan=1 colspan=1>ε = 4.45</td><td rowspan=1 colspan=1>£= 4.90</td><td rowspan=1 colspan=1>ε = 5.33</td><td rowspan=1 colspan=1>89.9 (-0.9%)</td></tr><tr><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>1.52</td><td rowspan=1 colspan=1>ε=3</td><td rowspan=1 colspan=1>ε = 4.37</td><td rowspan=1 colspan=1>= 4.83</td><td rowspan=1 colspan=1>e = 5.25</td><td rowspan=1 colspan=1>94.1 (-1.2%)</td></tr></table>
+
+# A ADDITIONAL RELATED WORK
+
+There exist other parameter-efficient tuning methods which we did not evaluate in our work. Some of these include random subspace projection (exploiting intrinsic dimensionality (Li et al., 2018; Aghajanyan et al., 2020)), prefix and prompt tuning (Li & Liang, 2021; Lester et al., 2021), tuning only biases (Cai et al., 2020; Ben Zaken et al., 2021), and other architecture variants including Adapters (Pfeiffer et al., 2021; Ruckl ¨ e et al. ´ , 2020). An interesting direction for future work is to see whether parameter-efficient tuning approaches specifically designed for the private setting can achieve higher utility. We also mention zero-shot learning, in which no task-specific dataset is required and thus perfect privacy is achieved. Currently, zero-shot approaches achieve low utility compared to fine-tuning, though it is possible that future models may narrow this gap.
+
+Finally, our investigation fits more broadly into a line of work employing public data for private data analysis. Some works on image classification consider pre-training on a large public dataset and fine-tuning on a smaller private dataset (Abadi et al., 2016; Papernot et al., 2019; Tramer & \` Boneh, 2021; Luo et al., 2021). In particular, Luo et al. (2021) investigate the role of parameter efficiency in private fine-tuning ResNet models, and propose strategies to choose which parameters to fine-tune. One line of work uses unlabeled public data to train a student model (Papernot et al., 2017; 2018; Bassily et al., 2018), including one work simultaneous to our own for natural language generation Tian et al. (2022). Another recent idea uses a small amount of public data to identify a lower-dimensional subspace of the gradients in which to perform private descent (Zhou et al., 2021; Yu et al., 2021a; Kairouz et al., 2021). A simultaneous work of Amid et al. (2021) uses public data in the mirror map for a private mirror descent algorithm. Finally, other works (both theoretical and experimental) investigate the role of public data in private query release, synthetic data generation, and prediction (Ji & Elkan, 2013; Beimel et al., 2016; Alon et al., 2019; Nandi & Bassily, 2020; Bassily et al., 2020a;b; Liu et al., 2021).
+
+# B EXPERIMENTS WITH DIFFERENT PRIVACY PARAMETERS
+
+Now we test our framework under different privacy constraints. Specifically, we run LoRA on the language understanding tasks with various choices of privacy parameters $\varepsilon$ and $\delta$ . We consider both RoBERTa-Base and RoBERTa-Large.
+
+For the RoBERTa-Large model, we set $\varepsilon = 1$ and 3 with $\delta$ being the same as those in Section 4. We use the PRV accountant (Gopi et al., 2021). After getting the noise multipliers, we also reduce the value of $\delta$ and report the corresponding value of $\varepsilon$ . The hyperparameters are the same as those in Section 4. We run experiments on all four tasks, i.e., MNLI $( n \sim 3 9 2 \mathrm { k } )$ ), QQP $( n \sim 3 6 4 \mathrm { k } )$ , QNLI $( n \sim 1 0 4 \mathrm { k } )$ , and SST-2 $( n \sim 6 7 \mathrm { k } )$ . We report the results in Table 6. The performance of our framework is decent even with very tight privacy budgets. For instance, with $\varepsilon \ < \ 2$ and $\delta = 1 / 1 0 0 0 n$ , the accuracy gap between the non-private baseline is only 3.8 for MNLI and 2.1 for SST-2.
+
+![](images/05e8ee3a4a8c0305633a5d019fdee3dc5da5602370a8d5b029ee3a088ca50697.jpg)  
+Figure 2: Test accuracy (in $\%$ ) of fine-tuning the RoBERTa-Base model on MNLI and SST-2 with various choices of $\varepsilon$ .
+
+Table 7: Accuracy for fine-tuning downstream tasks with RoBERTa-Base $( \mathrm { i n } \ \% )$ ). Experiments are run with full-precision. We also scale up the batch size according to the dataset size compared to SST-2. The privacy parameters are $\varepsilon = 6 . 7$ , and $\delta = 1 \mathrm { e } { - } 5$ for SST-2 and QNLI and 1e-6 for MNLI and QQP.
+
+<table><tr><td rowspan=1 colspan=2>Method</td><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>Average Accuracy</td></tr><tr><td rowspan=2 colspan=1>Full</td><td rowspan=1 colspan=1>w/o DP</td><td rowspan=1 colspan=1>87.6</td><td rowspan=1 colspan=1>94.8</td><td rowspan=1 colspan=1>91.9</td><td rowspan=1 colspan=1>92.8</td><td rowspan=1 colspan=1>91.8</td></tr><tr><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>83.2</td><td rowspan=1 colspan=1>85.9</td><td rowspan=1 colspan=1>86.2</td><td rowspan=1 colspan=1>84.8</td><td rowspan=1 colspan=1>85.0</td></tr><tr><td rowspan=1 colspan=1>Adapter</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>84.6</td><td rowspan=1 colspan=1>92.9</td><td rowspan=1 colspan=1>87.4</td><td rowspan=1 colspan=1>89.2</td><td rowspan=1 colspan=1>88.5</td></tr><tr><td rowspan=1 colspan=1>LoRA</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>84.5</td><td rowspan=1 colspan=1>92.7</td><td rowspan=1 colspan=1>87.1</td><td rowspan=1 colspan=1>88.3</td><td rowspan=1 colspan=1>88.2</td></tr></table>
+
+For the RoBERTa-Base model, we try various choices of $\varepsilon$ . The values of $\varepsilon$ are chosen from [0.1, 0.5, 1, 3, 5, 8, 12]. All other settings are the same as those in Section 4. We run experiments on the MNLI and SST-2 datasets. The results are presented in Figure 2. Our framework performs well for a wide range of $\varepsilon$ . We note that our algorithm achieves meaningful accuracy even for very tight privacy parameters $\varepsilon = 0 . 5$ and 1. Such values of $\varepsilon$ are rarely explored when training deep models with differential privacy.
+
+# C FINE-TUNING FOR LANGUAGE UNDERSTANDING TASKS WITH LARGE BATCH SIZE AND FULL-PRECISION
+
+Li et al. (2022) show the performance of fine-tuning the full model can be significantly improved with proper configuration. In this section, we re-evaluate the tasks in Table 3 and 4 under the configuration in Li et al. (2022) and show such a configuration also improves the performance of our methods.
+
+The configuration in Li et al. (2022) has two major differences compared to that in Section 4.1. The first difference is Li et al. (2022) run experiments with full-precision while the experiments in Section 4.1 use half-precision. Using half-precision is a common approach to speed up NLP experiments (Ott et al., 2018). However, half-precision may incur underflow issue which impacts the model performance (Micikevicius et al., 2017). The second difference is they use larger batch size for larger datasets. For example, the batch size for MNLI is roughly six times larger than the batch size for SST-2 in Li et al. (2022). In Section 4.1, we use the same batch size for all datasets.
+
+Table 8: Accuracy for fine-tuning downstream tasks with RoBERTa-Large (in $\%$ ). Experiments are run with full-precision. We also scale up the batch size according to the dataset size compared to SST-2. The privacy parameters are $\varepsilon = 6 . 7$ , and $\delta = 1 { \mathrm e } { - } 5$ for SST-2 and QNLI and $\delta = 1 \mathrm { e } { - } 6$ for MNLI and QQP.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>hod</td><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>Average Accuracy</td></tr><tr><td rowspan=2 colspan=1>Full</td><td rowspan=1 colspan=1>w/o DP</td><td rowspan=1 colspan=1>90.2</td><td rowspan=1 colspan=1>96.4</td><td rowspan=1 colspan=1>92.2</td><td rowspan=1 colspan=1>94.7</td><td rowspan=1 colspan=1>93.4</td></tr><tr><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>86.4</td><td rowspan=1 colspan=1>90.9</td><td rowspan=1 colspan=1>87.5</td><td rowspan=1 colspan=1>89.4</td><td rowspan=1 colspan=1>88.6</td></tr><tr><td rowspan=1 colspan=1>Adapter</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>88.6</td><td rowspan=1 colspan=1>94.5</td><td rowspan=1 colspan=1>87.8</td><td rowspan=1 colspan=1>91.6</td><td rowspan=1 colspan=1>90.6</td></tr><tr><td rowspan=1 colspan=1>LoRA</td><td rowspan=1 colspan=1>DP</td><td rowspan=1 colspan=1>89.0</td><td rowspan=1 colspan=1>95.3</td><td rowspan=1 colspan=1>88.4</td><td rowspan=1 colspan=1>92.4</td><td rowspan=1 colspan=1>91.3</td></tr></table>
+
+![](images/8d1ee7f936c9da231e530217601fc51044f1b84f2e6f3eaacdbbe8f5ab26b1b0.jpg)  
+Figure 3: Test accuracy (in $\%$ ) of fine-tuning RoBERTa-Base with differentially private LoRA on the SST-2 dataset. Our algorithm performs well on a wide range of hyperparameters.
+
+Table 9: Non-private metrics on the E2E NLG task, using full fine-tuning.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>BLEU</td><td rowspan=1 colspan=1>NIST</td><td rowspan=1 colspan=1>MET</td><td rowspan=1 colspan=1>ROUGE-L</td><td rowspan=1 colspan=1>CIDEr</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium</td><td rowspan=1 colspan=1>68.2</td><td rowspan=1 colspan=1>8.62</td><td rowspan=1 colspan=1>46.2</td><td rowspan=1 colspan=1>71.0</td><td rowspan=1 colspan=1>2.47</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large</td><td rowspan=1 colspan=1>68.5</td><td rowspan=1 colspan=1>8.78</td><td rowspan=1 colspan=1>46.0</td><td rowspan=1 colspan=1>69.9</td><td rowspan=1 colspan=1>2.45</td></tr></table>
+
+We follow the above setup and re-evaluate DP-LoRA and DP-Adapter. The results are in Table 7 and 8. The results of full fine-tuning with differential privacy are directly adopted from Li et al. (2022). The configuration in Li et al. (2022) further improves the strong results in Table 3 and 4. For example, we achieve $8 9 . 0 \%$ accuracy on the MNLI dataset, which is only $1 . 2 \%$ lower than the accuracy without DP constraint. Moreover, the benefit of the proposed framework over full finetuning is still clear. The average accuracy of the proposed algorithms is ${ \sim } 3 \%$ higher than that of full fine-tuning.
+
+# D ON THE INFLUENCE OF HYPERPARAMETERS
+
+Here we demonstrate that our algorithms perform well for a wide range of hyperparameters. We study two hyperparameters that are directly related to the variance of noise: clipping threshold and batchsize. The clipping threshold is chosen from $[ 0 . 1 , 1 . 0 , 3 . 0 , 5 . 0 , 1 0 . 0 ]$ and the batchsize is chosen from [200, 500, 1000, 2000, 4000]. We note that we keep the number of updates the same as that in Section 4 when the batchsize is changed. We fine-tune the RoBERTa-Base model with differentially private LoRA $( r = 1 6 )$ ) on the SST-2 dataset. The results are presented in Figure 3. DP LoRA performs well for all the hyperparameters considered. The gap between the best accuracy and the worst accuracy is only $2 \%$ .
+
+# E FULL FINE-TUNING WITH GPT-2
+
+All results in Table 5 (in the main body), both private and non-private, perform fine-tuning using LoRA. In Table 9, we additionally report utility of non-private full fine-tuning. These numbers are taken from Table 1 of Li & Liang (2021). In general, these numbers are slightly lower than those obtained by performing non-private fine-tuning with LoRA.
+
+Table 10: Metrics on the E2E NLG task. Non-DP results from Hu et al. (2021), except for GPT-2- XL, which was not reported in the paper. We ran GPT-2-XL with hyperparameters presented in $\mathrm { H u }$ et al. (2021). Bold indicates the best accuracy with DP. DP parameters are $( \varepsilon = 6 . 0 , \delta = 1 \mathrm { e } { - } 5 )$ . Val perp stands for validation perplexity.
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Val perp</td><td rowspan=1 colspan=1>BLEU</td><td rowspan=1 colspan=1>NIST</td><td rowspan=1 colspan=1>MET</td><td rowspan=1 colspan=1>ROUGE-L</td><td rowspan=1 colspan=1>CIDEr</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Small + DP</td><td rowspan=1 colspan=1>4.51</td><td rowspan=1 colspan=1>63.8</td><td rowspan=1 colspan=1>7.19</td><td rowspan=1 colspan=1>39.5</td><td rowspan=1 colspan=1>67.5</td><td rowspan=1 colspan=1>1.87</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium + DP</td><td rowspan=1 colspan=1>4.02</td><td rowspan=1 colspan=1>65.5</td><td rowspan=1 colspan=1>8.45</td><td rowspan=1 colspan=1>42.7</td><td rowspan=1 colspan=1>67.9</td><td rowspan=1 colspan=1>2.23</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large + DP</td><td rowspan=1 colspan=1>3.87</td><td rowspan=1 colspan=1>66.7</td><td rowspan=1 colspan=1>8.63</td><td rowspan=1 colspan=1>44.0</td><td rowspan=1 colspan=1>67.8</td><td rowspan=1 colspan=1>2.33</td></tr><tr><td rowspan=1 colspan=1>GPT-2-XL + DP</td><td rowspan=1 colspan=1>3.79</td><td rowspan=1 colspan=1>66.1</td><td rowspan=1 colspan=1>8.53</td><td rowspan=1 colspan=1>43.0</td><td rowspan=1 colspan=1>68.1</td><td rowspan=1 colspan=1>2.28</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium</td><td rowspan=1 colspan=1>3.19</td><td rowspan=1 colspan=1>70.4</td><td rowspan=1 colspan=1>8.85</td><td rowspan=1 colspan=1>46.8</td><td rowspan=1 colspan=1>71.8</td><td rowspan=1 colspan=1>2.53</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large</td><td rowspan=1 colspan=1>3.06</td><td rowspan=1 colspan=1>70.4</td><td rowspan=1 colspan=1>8.89</td><td rowspan=1 colspan=1>46.8</td><td rowspan=1 colspan=1>72.0</td><td rowspan=1 colspan=1>2.47</td></tr><tr><td rowspan=1 colspan=1>GPT-2-XL</td><td rowspan=1 colspan=1>3.01</td><td rowspan=1 colspan=1>69.4</td><td rowspan=1 colspan=1>8.78</td><td rowspan=1 colspan=1>46.2</td><td rowspan=1 colspan=1>71.5</td><td rowspan=1 colspan=1>2.49</td></tr></table>
+
+Table 11: Metrics on the E2E NLG task. Bold indicates the best accuracy with DP. DP parameters satisfy $\mathit { \check { \Psi } } ( \varepsilon = 3 . 0 , \delta = 1 \mathrm { e } { - } 5 )$ , $( \varepsilon = 3 . 4 , \delta = 1 / 1 0 n )$ , $( \varepsilon = 3 . 9 , \delta = 1 / 1 0 0 n )$ and $( \varepsilon = 4 . 5 , \delta =$ $1 / 1 0 0 0 n \rangle$ ). Val perp stands for validation perplexity.
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Val perp</td><td rowspan=1 colspan=1>BLEU</td><td rowspan=1 colspan=1>NIST</td><td rowspan=1 colspan=1>MET</td><td rowspan=1 colspan=1>ROUGE-L</td><td rowspan=1 colspan=1>CIDEr</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Small + DP</td><td rowspan=1 colspan=1>4.59</td><td rowspan=1 colspan=1>62.7</td><td rowspan=1 colspan=1>7.03</td><td rowspan=1 colspan=1>39.2</td><td rowspan=1 colspan=1>66.4</td><td rowspan=1 colspan=1>1.85</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium +DP</td><td rowspan=1 colspan=1>4.08</td><td rowspan=1 colspan=1>65.2</td><td rowspan=1 colspan=1>8.31</td><td rowspan=1 colspan=1>42.2</td><td rowspan=1 colspan=1>68.1</td><td rowspan=1 colspan=1>2.22</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large +DP</td><td rowspan=1 colspan=1>3.92</td><td rowspan=1 colspan=1>66.7</td><td rowspan=1 colspan=1>8.60</td><td rowspan=1 colspan=1>43.6</td><td rowspan=1 colspan=1>68.1</td><td rowspan=1 colspan=1>2.29</td></tr><tr><td rowspan=1 colspan=1>GPT-2-XL + DP</td><td rowspan=1 colspan=1>3.85</td><td rowspan=1 colspan=1>67.6</td><td rowspan=1 colspan=1>8.64</td><td rowspan=1 colspan=1>44.9</td><td rowspan=1 colspan=1>68.6</td><td rowspan=1 colspan=1>2.36</td></tr></table>
+
+# F ADDITIONAL EXPERIMENTS ON NATURAL LANGUAGE GENERATION
+
+In this section, we perform additional experiments on private fine-tuning for text generation problems using the GPT-2 series of models. This includes the private fine-tuning of the GPT-2-XL model with 1.5B parameters. There are three main points to note compared to our results in the main body: 1) We show an improved performance on E2E NLG challenge using better hyperparameters; 2) We conduct experiments on E2E dataset with different privacy parameters to show that large language models perform strong even with smaller privacy budgets; 3) Finally, we conduct new experiments on DART dataset.
+
+# F.1 IMPROVING THE PERFORMANCE ON E2E NLG CHALLENGE
+
+We improve the results of Table 5 with the following set of new hyperparameters.
+
+Hyperparameter choice: For LoRA, we choose the bottleneck rank $r = 4$ in (4) and fine-tune $W _ { q }$ and $W _ { v }$ matrices of the attention layers as in the original paper. We optimize using AdamW with learning rate 4e-4, weight decay 1e-2 and train our models for 20 epochs. We use batch size 128. We take the gradient clipping parameter to be 1.0 and the noise multiplier to be 0.6 for the accountant in Gopi et al. (2021), achieving $\varepsilon = 6 . 0 , \delta = 1 \mathrm { e } { - 5 }$ .
+
+Results: The results of our experiments are summarized in the Table 10.
+
+# F.2 EXPERIMENTS WITH DIFFERENT PRIVACY PARAMETERS
+
+On E2E dataset, we test our framework with smaller privacy budgets $\varepsilon < 5$ and $\delta \ll 1 / n$ ) where $n$ is the number of samples in the training data.
+
+Hyperparameter choice: The hyperparameter choices are similar as in Section F.1. The only difference is that we increase the noise multiplier to be 0.71 for the accountant in Gopi et al. (2021), achieving the following $( \varepsilon , \delta )$ pairs: $( \varepsilon = 3 . 0 , \delta = 1 \mathrm { e } { - } 5 )$ , $( \varepsilon = 3 . 4 , \delta = 1 / 1 0 n )$ , $( \varepsilon = 3 . 9 , \delta =$ $1 / 1 0 0 n )$ and $( \varepsilon = 4 . 5 , \delta = 1 / 1 0 0 0 n )$ .
+
+Results: The results of our experiments are summarized in the Table 11.
+
+There are a couple of interesting observations comparing Table 11 with Table 10. First, we observe that although privacy budget is tight in Table 11, the results are quite similar to Table 10, which
+
+Table 12: Metrics on the DART dataset. Non-DP results from Hu et al. (2021), except for GPT-2- XL, which was not reported in the paper. We ran GPT-2-XL with hyperparameters presented in $\mathrm { H u }$ et al. (2021). Bold indicates the best accuracy with DP. DP parameters are $( \varepsilon = 6 . 8 , \delta = 1 \mathrm { e } { - } 5 )$ ). Val perp stands for validation perplexity. Unlike all other metrics, the lower the TER metric is the better for the performance of the model.
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Val perp</td><td rowspan=1 colspan=1>BLEU</td><td rowspan=1 colspan=1>MET</td><td rowspan=1 colspan=1>TER</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Small +DP</td><td rowspan=1 colspan=1>3.82</td><td rowspan=1 colspan=1>38.5</td><td rowspan=1 colspan=1>0.34</td><td rowspan=1 colspan=1>0.53</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium + DP</td><td rowspan=1 colspan=1>3.30</td><td rowspan=1 colspan=1>42.0</td><td rowspan=1 colspan=1>0.36</td><td rowspan=1 colspan=1>0.51</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large + DP</td><td rowspan=1 colspan=1>3.10</td><td rowspan=1 colspan=1>43.1</td><td rowspan=1 colspan=1>0.36</td><td rowspan=1 colspan=1>0.5</td></tr><tr><td rowspan=1 colspan=1>GPT-2-XL + DP</td><td rowspan=1 colspan=1>3.00</td><td rowspan=1 colspan=1>43.8</td><td rowspan=1 colspan=1>0.37</td><td rowspan=1 colspan=1>0.5</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Medium</td><td rowspan=1 colspan=1>2.67</td><td rowspan=1 colspan=1>47.1</td><td rowspan=1 colspan=1>0.39</td><td rowspan=1 colspan=1>0.46</td></tr><tr><td rowspan=1 colspan=1>GPT-2-Large</td><td rowspan=1 colspan=1>2.89</td><td rowspan=1 colspan=1>47.5</td><td rowspan=1 colspan=1>0.39</td><td rowspan=1 colspan=1>0.45</td></tr><tr><td rowspan=1 colspan=1>GPT-2-XL</td><td rowspan=1 colspan=1>2.83</td><td rowspan=1 colspan=1>48.1</td><td rowspan=1 colspan=1>0.39</td><td rowspan=1 colspan=1>0.46</td></tr></table>
+
+shows that our methods also perform very well under stronger privacy guarantees. A more interesting observation is that under smaller epsilon regimes, the performance for private fine-tuning of GPT-2-XL model improves. Observe that the performance improvement is more prominent going from GPT-2-Small to GPT-2-XL in this setting, which may indicate that larger models can be even more effective in private learning when the privacy budgets are tight.
+
+# F.3 PERFORMING EXPERIMENTS ON DART DATASET
+
+We study the DART dataset as a text generation problem for private fine-tuning of GPT-2 series of models.
+
+DART: DART was introduced as an open-domain data-to-text dataset by Nan et al. (2021). The dataset consists of 62K training samples, 6.9K validation samples, and 12K test samples. In comparison to E2E, the dataset is larger and the task is more challenging.
+
+Hyperparameter choice: The hyperparameter choices are similar as in the previous setting. The only difference is that we use batch size 256 for the experiments on DART. This achieves $\varepsilon =$ $6 . 8 , \delta = 1 \mathrm { e } \mathrm { - } 5$ on DART using the accountant in Gopi et al. (2021).
+
+Results: The results of our experiments are summarized in the Table 12.

parse/dev/Uuf2q9TfXGA/Uuf2q9TfXGA.md

@@ -0,0 +1,355 @@
+# TOWARDS UNDERSTANDING ENSEMBLE, KNOWLEDGE DISTILLATION AND SELF-DISTILLATION IN DEEP LEARNING
+
+Zeyuan Allen-Zhu   
+Meta FAIR Labs   
+zeyuanallenzhu@meta.com
+
+Yuanzhi Li Mohamed bin Zayed University of AI Yuanzhi.Li@mbzuai.ac.ae
+
+# ABSTRACT
+
+We formally study how ensemble of deep learning models can improve test accuracy, and how the superior performance of ensemble can be distilled into a single model using knowledge distillation. We consider the challenging case where the ensemble is simply an average of the outputs of a few independently trained neural networks with the same architecture, trained using the same algorithm on the same data set, and they only differ by the random seeds used in the initialization.
+
+We show that ensemble/knowledge distillation in deep learning works very differently from traditional learning theory (such as boosting or NTKs). We develop a theory showing that when data has a structure we refer to as “multi-view”, then ensemble of independently trained neural networks can provably improve test accuracy, and such superior test accuracy can also be provably distilled into a single model. Our result sheds light on how ensemble works in deep learning in a way that is completely different from traditional theorems, and how the “dark knowledge” is hidden in the outputs of the ensemble and can be used in distillation.1
+
+# 1 INTRODUCTION
+
+Ensemble (Dietterich, 2000; Hansen & Salamon, 1990; Polikar, 2006) is one of the most powerful techniques in practice to improve the performance of deep learning. By simply averaging the outputs of merely a few (like 3 or 10) independently-trained neural networks of the same architecture, using the same training method over the same training data, it can significantly boost the prediction accuracy over the test set comparing to individual models. The only difference is the randomness used to initialize these networks and/or the randomness during training. Moreover, it is discovered by Hinton et al. (2015) that such superior performance of the ensemble can be transferred into a single model (of the same size as the individual models) using a technique called knowledge distillation: that is, simply train a single model to match the output of the ensemble (such as ${ \mathfrak { s o o } } \%$ cat $^ +$ $10 \%$ car”, also known as soft labels) as opposite to the true data labels, over the same training data.
+
+On the theory side, there are lots of works studying the superior performance of ensemble from principled perspectives (see full version for citations). However, most of these works only apply to: (1). Boosting: where the coefficients associated with the combinations of the single models are actually trained, instead of simply taking average; (2). Bootstrapping/Bagging: the training data are different for each single model; (3). Ensemble of models of different types and architectures; or (4). Ensemble of random features or decision trees. To the best of our knowledge, none of these cited works apply to the particular type of ensemble that is widely used in deep learning: simply take a uniform average of the output of the learners, which are neural networks with the same architecture and are trained by stochastic gradient descent (SGD) over the same training set. In fact, very critically, for deep learning models:
+
+• TRAINING AVERAGE DOES NOT WORK: if one directly trains to learn an average of individual neural networks initialized by different seeds, the performance is much worse than ensemble. • KNOWLEDGE DISTILLATION WORKS: the superior performance of ensemble in deep learning can be distilled into a single model (Hinton et al., 2015).
+
+![](images/de285772a80e5d3b024c4932fa4ac2d7132a5ff75b8b80087dce702558f1c175.jpg)  
+Figure 1: Ensemble in deep learning is very different from ensemble in random feature mappings. Details in Figure 6.
+
+• SELF-DISTILLATION WORKS: even distilling a single model into another of the same size, there is performance boost. (Furlanello et al., 2018; Mobahi et al., 2020; Zhang et al., 2019)
+
+We are unaware of any satisfactory theoretical explanation for the phenomena above. For instance, as we shall argue, some traditional view for why ensemble works, such as ‘ensemble can enlarge the feature space in random feature mappings’, even give contradictory explanations to the above phenomena, thus cannot explain knowledge distillation or ensemble in deep learning. Motivated by this gap between theory and practice we study the following question for multi-class classification:
+
+# Our theoretical questions:
+
+How does ensemble improve the test-time performance in deep learning when we simply (unweightedly) average over a few independently trained neural networks? – Especially when all the neural networks have the same architecture, are trained over the same data set using the same standard training algorithm and only differ by the random seeds, and even when all single models already have $1 0 0 \%$ training accuracy? How can such superior test-time performance of ensemble be later “distilled” into a single neural network of the same architecture, simply by training the single model to match the output of the ensemble over the same training data set?
+
+Our results. We prove for certain multi-class classification tasks with a special structure we refer to as multi-view, with a training set $\mathcal { Z }$ consisting of $N$ i.i.d. samples from some unknown distribution $\mathcal { D }$ , for certain two-layer convolutional network $f$ with (smoothed-)ReLU activation as learner:
+
+• (Single model has bad test accuracy): there is a value $\mu > 0$ such that when a single model $f$ is trained over $\mathcal { Z }$ using the cross-entropy loss, via gradient descent (GD) starting from random Gaussian initialization, the model can reach zero training error efficiently. However, w.h.p. the prediction (classification) error of $f$ over $\mathcal { D }$ is between $0 . 4 9 \mu$ and $0 . 5 1 \mu$ .
+
+• (Ensemble provably improves test accuracy): let $f _ { 1 } , f _ { 2 } , \cdots , f _ { L }$ be $L = \widetilde { \Omega } ( 1 )$ independently trained single models as above, then w.h.p. $\begin{array} { r } { \overline { { G } } = \frac { 1 } { L } \sum _ { \ell } f _ { \ell } } \end{array}$ has prediction error $\le 0 . 0 1 \mu$ over $\mathcal { D }$ .
+
+• (Ensemble can be distilled into a single model): if we further train (using GD from random initialization) another single model $f _ { 0 }$ (same architecture as each $f _ { \ell } )$ to match the output of $\begin{array} { r } { G = \frac { 1 } { L } \sum _ { \ell } \bar { f } _ { \ell } } \end{array}$ merely over the same training data set $\mathcal { Z }$ , then $f _ { 0 }$ can be trained efficiently and w.h.p. $f _ { 0 }$ will have prediction error $\le 0 . 0 1 \mu$ over $\mathcal { D }$ as well.
+
+• (Self-distillation also improves test accuracy): if we further train (using GD from random initialization) another single model $f ^ { \prime }$ (same architecture as $f _ { 1 } )$ ) to match the output of the single model $f _ { 1 }$ merely over the same training data set $\mathcal { Z }$ , then $f ^ { \prime }$ can be trained efficiently and w.h.p. has prediction error at most $\leq 0 . 2 6 \mu$ over $\mathcal { D }$ . The main idea is that self-distillation is performing “implicit ensemble $^ +$ knowledge distillation”, as we shall argue in Section 4.2.
+
+We defer discussions of our empirical results to Section 5. However, we highlight some of the empirical findings, as they shall confirm and justify our theoretical approach studying ensemble and knowledge distillation in deep learning. Specifically, we give empirical evidences showing that:
+
+• Knowledge distillation does not work for random feature mappings; and ensemble in deep learning is very different from ensemble in random feature mappings (see Figure 1). • Special structures in data (such as the “multi-view” structure we shall introduce) is needed for ensemble of neural networks to work. • The variance due to label noise or the non-convex landscape of training, in the independentlytrained models, may not be connected to the superior performance of ensemble in deep learning.
+
+# 2 OUR METHODOLOGY AND INTUITION
+
+# 2.1 A FAILURE ATTEMPT USING RANDOM FEATURE MAPPINGS
+
+The recent advance in deep learning theory shows that under certain circumstances, neural networks can be treated as a linear function over random feature mappings — see (Allen-Zhu et al., 2019b; Arora et al., 2019b; Daniely et al., 2016; Du et al., $2 0 1 8 \mathrm { b }$ ; Jacot et al., 2018; Zou et al., 2018) and the references therein. In particular, the theory shows when $f : \mathbb { R } ^ { D + d }  \mathbb { R }$ is a neural network with inputs $x \in \mathbb { R } ^ { d }$ and weights $W \in \mathbb { R } ^ { D }$ , in some cases, $f ( W , x )$ can be approximated by:
+
+$$
+f ( W , x ) \approx f ( W _ { 0 } , x ) + \left. W - W _ { 0 } , \nabla _ { W } f ( W _ { 0 } , x ) \right.
+$$
+
+where $W _ { 0 }$ is the random initialization of the neural network, and $\Phi _ { W _ { 0 } } ( x ) : = \nabla _ { W } f ( W _ { 0 } , x )$ is the neural tangent kernel (NTK) feature mapping. This is known as the NTK approach. If this approximation holds, then training a neural network can be approximated by learning a linear function over random features $\Phi _ { W _ { 0 } } ( x )$ , which is very theory-friendly.
+
+Ensemble works for random features / NTK. Traditional theorems (Alhamdoosh & Wang, 2014; Brown et al., 2005a; Bryll et al., 2003; Tsymbal et al., 2005) suggest that the ensemble of independently trained random feature models can indeed significantly improve test-time performance, as it enlarges the feature space from $\Phi _ { W _ { 0 } } ( x )$ to $\{ \Phi _ { W _ { 0 } ^ { ( i ) } } ( x ) \} _ { i \in [ L ] }$ for $L$ many independently sampled W (i)0 . This can be viewed as a feature selection process (Alvarez et al., 2012; Cai et al., 2018; Oliveira et al., 2003; Opitz, 1999; Rokach, 2010), and we have confirmed it for NTK in practice, see Figure 1. However, can we understand ensemble and knowledge distillation in $D L$ as feature selections using NTK? Unfortunately, our empirical results provide many counter examples towards those arguments, see discussions below and Figure 1.
+
+Contradiction 1: training average works even better. Although ensemble of linear functions over NTK features with different random seeds: $f _ { i } ( x ) = \langle W ^ { ( i ) } , \Phi _ { W _ { 0 } ^ { ( i ) } } ( x ) \rangle$ does improve test accuracy, however, such improvement is mainly due to the use of a larger set of random features, whose combinations contain functions that generalize better. To see this, we observe that an even superior performance (than the ensemble) can simply be obtained by directly training $F ( x ) = { \textstyle { \frac { 1 } { L } } } \left( f _ { 1 } + \dot { f } _ { 2 } + \cdot \cdot \cdot + f _ { L } \right)$ from random initialization. In contrast, recall if $f _ { i } ( x )$ ’s are multi-layer neural networks with different random seeds, then training their average barely gives any better performance comparing to individual networks $f _ { i }$ , as now all the $f _ { i }$ ’s are capable of learning the same set of features.
+
+Contradiction 2: knowledge distillation does not work. For NTK feature mappings, we observe that the result obtained by ensemble cannot be distilled at all into individual models, indicating the features selected by ensemble is not contained in the feature $\Phi _ { W _ { 0 } ^ { ( i ) } } ( x )$ of any individual model. In contrast, in actual deep learning, ensemble does not enlarge feature space: so an individual neural network is capable of learning the features of the ensemble model.
+
+In sum, ensemble in deep learning may be very different from ensemble in random features. It may be more accurate to study ensemble / knowledge distillation in deep learning as a feature learning process, instead of a feature selection process. But still, we point out a fundamental difficulty:
+
+# Key challenge:
+
+If a single deep learning model is capable of — through knowledge distillation — learning the features of the ensemble model and achieving better test accuracy comparing to training the single model directly (and the same training accuracy, typically at global optimal of $1 0 0 \%$ ), then why the single model cannot learn these features directly when we train the model to match the true data labels? What is the dark knowledge hidden in the output of ensemble (a.k.a. soft label)2 comparing to the original hard label?
+
+# 2.2 ENSEMBLE IN DEEP LEARNING: A FEATURE LEARNING PROCESS
+
+Before addressing the key challenge, we point out that prior works are very limited with respect to studying neural network training as a feature learning process. Most of the existing works proving that neural networks can learn features only focus on the case when the input is Gaussian or
+
+![](images/eb7526966191bbf13c5b0c009cf56ef17366c59127a72ee090c98bbd82623252.jpg)  
+Figure 2: Illustration of images with multiple views (features) in the ImageNet dataset.
+
+Gaussian-like — see for instance (Kawaguchi, 2016; Soudry & Carmon, 2016; Xie et al., 2016) and many others. However, as we demonstrate in Figure 7 in the full version,
+
+# Ensemble in DL might not improve test accuracy when inputs are Gaussian-like:
+
+Empirically, ensemble does not improve test accuracy in deep learning, in certain scenarios when the distribution of the input data is Gaussian or even mixture of Gaussians. This is true over various learner network structures (fully-connected, residual, convolution neural networks) and various labeling functions (when the labels are generated by linear functions, fully-connected, residual, convolutional networks, with/without label noise, with/without classification margin).
+
+Bias variance view of ensemble: Some prior works also try to attribute the benefit of ensemble as reducing the variance of individual solutions due to label noise or non-convex landscape of the training objective. However, reducing such variance can reduce a convex test loss (typically crossentropy), but not necessarily the test classification error. Concretely, the synthetic experiments in Figure 7 show that, after applying ensemble over Gaussian-like inputs, the variance of the model outputs is reduced but the test accuracy is not improved. We give many more empirical evidences to show that the variance (either from label noise or from the non-convex landscape) is usually not the cause for why ensemble works in deep learning, see Section 5.
+
+Hence, to understand the true benefit of ensemble in deep learning in theory, we would like to study a setting that can approximate practical deep learning, where:
+
+• The input distribution is more structured than standard Gaussian and there is no label noise. (From above discussions, ensemble cannot work for deep learning distribution-freely). • The individual neural networks all are well-trained, in the sense that the training accuracy in the end is $1 0 0 \%$ , and there is nearly no variance in the test accuracy for individual models. (So training never fails.)
+
+In this work, we propose to study a setting of data that we refer to as multi-view, where the above two conditions both hold when we train a two-layer neural networks with (smoothed-)ReLU activations. We also argue that the multi-view structure we consider is fairly common in the data sets used in practice, in particular for vision tasks. We give more details below.
+
+# 2.3 OUR APPROACH: LEARNING MULTI-VIEW DATA
+
+Let us first give a thought experiment to illustrate our approach, and we present the precise mathematical definition of the “multi-view” structure in Section 3. Consider a binary classification problem and four “features” $v _ { 1 } , v _ { 2 } , v _ { 3 } , v _ { 4 }$ . The first two features correspond to the first class label, and the next two features correspond to the second class label. In the data distribution:
+
+• When the label is class 1, then:3
+
+both $v _ { 1 } , v _ { 2 }$ appears with weight 1, one of $v _ { 3 } , v _ { 4 }$ appears with weight 0.1 w.p. $8 0 \%$   
+only $v _ { 1 }$ appears with weight 1, one of $v _ { 3 } , v _ { 4 }$ appears with weight 0.1 w.p. $1 0 \%$   
+only $v _ { 2 }$ appears with weight 1, one of $v _ { 3 } , v _ { 4 }$ appears with weight 0.1 w.p. $1 0 \%$
+
+• When the label is class 2, then
+
+both $v _ { 3 } , v _ { 4 }$ appears with weight 1, one of $v _ { 1 } , v _ { 2 }$ appears with weight 0.1 w.p. $8 0 \%$   
+only $v _ { 3 }$ appears with weight 1, one of $v _ { 1 } , v _ { 2 }$ appears with weight 0.1 w.p. $1 0 \%$   
+only $v _ { 4 }$ appears with weight 1, one of $v _ { 1 } , v _ { 2 }$ appears with weight 0.1 w.p. $1 0 \%$
+
+![](images/e0f9e8e227c2a75d939df4567af9361df69e7978dad47ecaa50e4b1bd774d060.jpg)  
+Figure 3: Visualization of the channels in layer-23 of a ResNet-34 trained on CIFAR-10.
+
+We call the $8 0 \%$ of the data multi-view data: these are the data where multiple features exist and can be used to classify them correctly. We call the rest $2 0 \%$ of the data single-view data: some features for the correct labels are missing. 4
+
+How individual neural networks learn. Under the multi-view data defined above, if we train a neural network using the cross-entropy loss via gradient descent (GD) from random initialization, during the training process of the individual networks, we show that:
+
+• The network will quickly pick up one of the feature $v \in \{ v _ { 1 } , v _ { 2 } \}$ for the first label, and one of the features $v ^ { \prime } \in \bar { \{ v _ { 3 } , v _ { 4 } \} }$ for the second label. So, $9 0 \%$ of the training examples, consisting of all the multi-view data and half of the single-view data (those with feature $v$ or $v ^ { \prime }$ ), are classified correctly. Once classified correctly (with a large margin), these data begin to contribute negligible to gradient by the nature of the cross-entropy loss. • Next, the network will memorize (using e.g. the noise in the data) the remaining $1 0 \%$ of the training examples without learning any new features, due to insufficient amount of left-over samples after the first phase, thus achieving training accuracy $1 0 0 \%$ but test accuracy $9 0 \%$ .
+
+How ensemble improves test accuracy. It is simple why ensemble works. Depending on the randomness of initialization, each individual network will pick up $v _ { 1 }$ or $v _ { 2 }$ each w.p. $5 0 \%$ . Hence, as long as we ensemble ${ \widetilde { O } } ( 1 )$ many independently trained models, w.h.p. their ensemble will pick up both features $\{ v _ { 1 } , v _ { 2 } \}$ and both features $\{ v _ { 3 } , v _ { 4 } \}$ . Thus, all the data will be classified correctly.
+
+How knowledge distillation works. Perhaps less obvious is how knowledge distillation works. Since ensemble learns all the features $v _ { 1 } , v _ { 2 } , v _ { 3 } , v _ { 4 }$ , given a multi-view data with label 1, the ensemble will actually output $\propto ( 2 , 0 . 1 )$ , where the 2 comes from features $v _ { 1 } , v _ { 2 }$ and 0.1 comes from one of $v _ { 3 } , v _ { 4 }$ . On the other hand, an individual model learning only one of $v _ { 3 } , v _ { 4 }$ will actually output $\propto ( 2 , 0 )$ when the feature $v _ { 3 }$ or $v _ { 4 }$ in the data does not match the one learned by the model. Hence, by training the individual model to match the output of the ensemble, the individual model is forced to learn both features $v _ { 3 } , v _ { 4 }$ , even though it has already perfectly classified the training data. This is the “dark knowledge” hidden in the output of the ensemble model. (This theoretical finding is consistent with practice: Figure 8 in the full paper suggests that models trained from knowledge distillation should have learned most of the features, and further computing their ensemble does not give much performance boost.)
+
+Significance of our technique. Our work belongs to the generic framework of feature learning in DL where one proves that certain aspects of the algorithm (e.g. the randomness) affects the order where features are learned. This is fundamentally different from convex optimization, such as kernel method, where (with $\ell _ { 2 }$ regularization) there is an unique global minimum so the choice of the random seed does not matter (thus, ensemble does not help). There are other works that consider other aspects, such as the choice of learning rate, that can affect the order where the features are learned (Li et al., 2019). Our work is fundamentally different: they only focus on the NTK setting where the features are not learned; we study a feature learning process. Recall, the NTK setting cannot be used to explain ensemble and distillation in DL. Our work extends the reach of traditional machine learning theory, where typically the “generalization” is separated from “optimization.” Such “separate” treatment might not be enough to understand how deep learning works.
+
+![](images/3476fc7dda82d2f8192133eea5272f3fe0d58a03061c02df35d8823e259320ef.jpg)  
+Figure 4: Illustration of a multi-view and a single-view data point; the feature vectors can also be combined with feature noise and random noise, see Def. 3.1.
+
+# 3 PROBLEM SETUP
+
+The “multi-view” data distribution is a straight-forward generalization of the intuitive setting in Section 2.3. For simplicity, in the main body, we use example choices of the parameters mainly a function of $k$ (such as $P = k ^ { 2 }$ , $\begin{array} { r } { \gamma = \frac { 1 } { k ^ { 1 . 5 } } } \end{array}$ , $\textstyle \mu = { \frac { k ^ { 1 . 2 } } { N } }$ , $\rho = k ^ { - 0 . 0 1 }$ , $\sigma _ { 0 } = 1 / \sqrt { k }$ as we shall see), and we consider the case when $k$ is sufficiently large. In our full version, we shall give a much larger range of parameters for the theorems to hold.
+
+# 3.1 DATA DISTRIBUTION AND NOTATIONS
+
+We consider learning a $k$ -class classification problem over $P$ -patch inputs, where each patch has dimension $d$ . In symbols, each labelled data is represented by $( X , y )$ where $X = ( x _ { 1 } , x _ { 2 } , \cdot \cdot \cdot , x _ { P } ) \in$ $( \mathbb { R } ^ { d } ) ^ { P }$ is the data vector and $y \in [ k ]$ is the data label. For simplicity, we focus on the case when ${ \dot { P } } = k ^ { 2 }$ , and $d = { \mathsf { p o l y } } ( k )$ for a large polynomial.
+
+We consider the setting when $k$ is sufficiently large.5 We use “w.h.p.” to denote with probability at least $1 - e ^ { - \Omega ( \log ^ { 2 } k ) }$ , and use $\widetilde { O } , \widetilde { \Theta } , \widetilde { \Omega }$ notions to hide polylogarithmic factors in $k$ .
+
+We first assume that each label class $j \in [ k ]$ has multiple associated features, say two features for the simplicity of math, represented by unit feature vectors $v _ { j , 1 } , v _ { j , 2 } \in \mathbb { R } ^ { d }$ . For notation simplicity, we assume that all the features are orthogonal, namely,
+
+$$
+\begin{array} { r } { \forall j , j ^ { \prime } \in [ k ] , \forall \ell , \ell ^ { \prime } \in [ 2 ] , \| v _ { j , \ell } \| _ { 2 } = 1 \quad \mathrm { a n d } v _ { j , \ell } \bot v _ { j ^ { \prime } , \ell ^ { \prime } } \mathrm { w h e n } ( j , \ell ) \ne ( j ^ { \prime } , \ell ^ { \prime } ) } \end{array}
+$$
+
+although our work also extends to the “incoherent” case trivially. We denote by
+
+$$
+\mathcal { V } : = \{ v _ { j , 1 } , v _ { j , 2 } \} _ { j \in [ k ] }
+$$
+
+We consider the following data and label distribution. Let $C _ { p }$ be a global constant, $s \in [ 1 , k ^ { 0 . 2 } ]$ be a sparsity parameter. To be concise, we define the multi-view distribution $\mathcal { D } _ { m }$ and single-view distribution $\mathcal { D } _ { s }$ together. Due to space limitation, here we hide the specification of the random “noise” and defer it to the full version.6
+
+Definition 3.1 (data distributions $\mathcal { D } _ { m }$ and $\mathcal { D } _ { s }$ ). Given $\mathcal { D } \in \{ \mathcal { D } _ { m } , \mathcal { D } _ { s } \}$ , we define $( X , y ) \sim \mathcal { D }$ as follows. First choose the label $y \in [ k ]$ uniformly at random. Then, the data vector $X$ is generated
+
+as follows (also illustrated in Figure 4).
+
+1. Denote $\mathcal { V } ( X ) = \{ v _ { y , 1 } , v _ { y , 2 } \} \cup \mathcal { V } ^ { \prime }$ as the set of feature vectors used in this data vector $X$ , where $\mathcal { V } ^ { \prime }$ is a set of features uniformly sampled from $\left\{ v _ { j ^ { \prime } , 1 } , v _ { j ^ { \prime } , 2 } \right\} _ { j ^ { \prime } \in [ k ] \backslash \{ y \} }$ , each with probability $\frac { s } { k }$ .
+
+2. For each $v \in \mathcal { V } ( X )$ , pick $C _ { p }$ many disjoint patches in $[ P ]$ and denote it as $\mathcal { P } _ { v } ( X ) \subset [ P ]$ (the distribution of these patches can be arbitrary). We denote $\mathcal { P } ( X ) = \cup _ { v \in \mathcal { V } ( X ) } \mathcal { P } _ { v } ( X )$ .
+
+3. If $\mathcal { D } = \mathcal { D } _ { s }$ is the single-view distribution, pick a value ${ \widehat { \ell } } = { \widehat { \ell } } ( X ) \in$ [2] uniformly at random.
+
+4. For each $v \in \mathcal { V } ( X )$ and $p \in { \mathcal { P } } _ { v } ( X )$ , we set $x _ { p } = z _ { p } v + \mathbf { \zeta } ^ { \cdot } n o i s e ^ { , \cdot } \in \mathbb { R } ^ { d }$ , where, the random coefficients $z _ { p } \geq 0$ satisfy that:
+
+In the case of multi-view distribution $\mathcal { D } = \mathcal { D } _ { m }$ ,
+
+$$
+\begin{array} { r l } & { \sum _ { p \in \mathcal { P } _ { v } ( X ) } z _ { p } \in [ 1 , O ( 1 ) ] ~ w h e n ~ v \in \{ v _ { y , 1 } , v _ { y , 2 } \} , \quad ^ { 7 } } \\ & { \sum _ { p \in \mathcal { P } _ { v } ( X ) } z _ { p } \in [ \Omega ( 1 ) , 0 . 4 ] ~ w h e n ~ v \in \mathcal { V } ( X ) \setminus \{ v _ { y , 1 } , v _ { y , 2 } \} , } \end{array}
+$$
+
+In the case of single-view distribution $\mathcal { D } = \mathcal { D } _ { s }$ ,
+
+$$
+\begin{array} { r l } & { \sum _ { p \in \mathcal { P } _ { v } ( X ) } z _ { p } \in [ 1 , O ( 1 ) ] ~ w h e n ~ v = v _ { y , \widehat { \ell } } , } \\ & { \sum _ { p \in \mathcal { P } _ { v } ( X ) } z _ { p } \in [ \rho , O ( \rho ) ] ~ w h e n ~ v = v _ { y , 3 - \widehat { \ell } } , } \\ & { \sum _ { p \in \mathcal { P } _ { v } ( X ) } z _ { p } \in [ \Omega ( \Gamma ) , \Gamma ] ~ w h e n ~ v \in \mathcal { V } ( X ) \setminus \{ v _ { y , 1 } , v _ { y , 2 } \} . } \end{array}
+$$
+
+5. For each $p \in [ P ] \setminus { \mathcal { P } } ( X )$ , we set $x _ { p }$ to consist only of “noise”.
+
+Remark 3.2. The distribution of how to pick ${ \mathcal { P } } ( X )$ and assign $\sum _ { p \in \mathcal { P } _ { v } ( X ) } z _ { p }$ to each patch in $p \in$ ${ \mathcal { P } } _ { v } ( X )$ can be arbitrary (and can depend on other randomness in the data as well). In particular, we have allowed different features $v _ { j , 1 } , v _ { j , 2 }$ to show up with different weights in the data (for example, for multi-view data, some view $v _ { y , 1 }$ can consistently have larger $z _ { p }$ comparing to $v _ { y , 2 }$ ). Yet, we shall prove that the order to learn these features by the learner network can still be flipped depending on the randomness of network initialization.
+
+Interpretation of our data distribution. As we argue more in the full paper, our setting can be tied to a down-sized version of convolutional networks applied to image classification data. With a small kernel size, good features in an image typically appear only at a few patches, and most other patches are random noise or low-magnitude feature noises. More importantly, our noise parameters shall ensure that, the concept class is not learnable by linear classifiers or constant degree polynomials. We believe a (convolutional) neural network with ReLU-like activation is somewhat necessary.
+
+Our final data distribution $\mathcal { D }$ , and the training data set $\mathcal { Z }$ are formally given as follows.
+
+Definition 3.3 ( $\mathcal { D }$ and $\mathcal { Z }$ ). The distribution $\mathcal { D }$ consists of data from $\mathcal { D } _ { m }$ w.p. $1 - \mu$ and from $\mathcal { D } _ { s }$ w.p. $\mu$ . We are given $N$ training samples from $\mathcal { D }$ , and denote the training data set as $\mathcal { Z } = \mathcal { Z } _ { m } \cup \mathcal { Z } _ { s }$ where ${ \mathcal { Z } } _ { m }$ and $\mathcal { Z } _ { s }$ respectively represent multi-view and single-view training data. We write $( X , y ) \sim { \mathcal { Z } }$ as $( X , y )$ sampled uniformly at random from the empirical data set, and denote $N _ { s } = | \mathcal { Z } _ { s } |$ . $W e$ again for simplicity focus on the setting when $\begin{array} { r } { \mu = \frac { \bar { 1 } } { \mathsf { p o l y } ( k ) } } \end{array}$ and we are given samples $N = { \dot { k } } ^ { 1 . 2 } / \mu .$ so each label i appears at least $\widetilde \Omega ( 1 )$ in $\mathcal { Z } _ { s }$ . Our result trivially applies to many other choices of $N$ .
+
+# 3.2 LEARNER NETWORK
+
+We consider a learner network using the following smoothed ReLU activation function $\widetilde { \sf R e L U }$ :
+
+Definition 3.4. For integer $q \geq 2$ and threshold $\varrho = \frac { 1 } { \mathsf { p o l y l o g } ( k ) }$ , the smoothed function $\widetilde { \mathsf { R e L U } } ( z ) : = 0$ for $z \le 0$ ; $\begin{array} { r } { \widetilde { \mathsf { R e L U } } ( z ) : = \frac { z ^ { q } } { q \varrho ^ { q - 1 } } } \end{array}$ for $z \in [ 0 , \varrho ]$ ; and $\begin{array} { r } { \widetilde { \mathsf { R e L U } } ( z ) : = z - ( 1 - \frac { 1 } { q } ) \varrho } \end{array}$ for $z \geq \varrho$ .
+
+Since $\widetilde { \sf R e L U }$ is smooth we denote its gradient as $\widetilde { \mathsf { R e L U } } ^ { \prime } ( z )$ . We focus on $q = 4$ while our result applies to other constants $q \geq 3$ (see full version) or most other forms of smoothing.
+
+The learner network $F ( X ) _ { \cdot } = ( F _ { 1 } ( X ) , \dots , F _ { k } ( X ) ) \in \mathbb { R } ^ { k }$ is a two-layer convolutional network parameterized by $w _ { i , r } \in \mathbb { R } ^ { d }$ for $i \in [ k ] , r \in [ m ]$ , satisfying
+
+$$
+\begin{array} { r l } { \forall i \in [ k ] \colon } & { { } F _ { i } ( X ) = \sum _ { r \in [ m ] } \sum _ { p \in [ P ] } \widetilde { \mathsf { R e L U } } ( \langle w _ { i , r } , x _ { p } \rangle ) } \end{array}
+$$
+
+Although there exists network with $m = 2$ that can classify the data correctly (e.g. $w _ { i , r } = v _ { i , r }$ for $r \in [ 2 ] )$ ), in this paper, for efficient optimization purpose it is convenient to work on a moderate level of over-parameterization: $m \in [ { \mathsf { p o l y l o g } } ( k ) , k ]$ . Our lower bounds hold for any $m$ in this range and upper bounds hold even for small over-parameterization $m = { \mathsf { p o l y l o g } } ( k )$ .
+
+Training a single model. We learn the concept class (namely, the labeled data distribution) using gradient descent with learning rate $\eta > 0$ , over the cross-entropy loss function $L$ using $N$ training data points $\mathcal { Z } = \{ ( X _ { i } , y _ { i } ) \} _ { i \in [ N ] }$ . We denote the empirical loss as:
+
+$$
+\begin{array} { r } { L ( F ) = \frac { 1 } { N } \sum _ { i \in [ N ] } L ( F ; X _ { i } , y _ { i } ) = \mathbb { E } _ { ( X , y ) \sim \mathcal { Z } } [ L ( F ; X , y ) ] } \end{array}
+$$
+
+where $\begin{array} { r } { L ( F ; X , y ) = - \log { \frac { e ^ { F _ { y } ( X ) } } { \sum _ { j \in [ k ] } e ^ { F _ { j } ( X ) } } } } \end{array}$ g eFy(X)Pj∈[k] eFj (X) . We randomly initialize the network F by letting each $w _ { i , r } ^ { ( 0 ) } \sim \mathcal { N } ( 0 , \sigma _ { 0 } ^ { 2 } I )$ for $\sigma _ { 0 } ^ { 2 } = 1 / k$ , which is the most standard initialization people use in practice.
+
+To train a single model, at each iteration $t$ we update using gradient descent (GD):9
+
+$$
+w _ { i , r } ^ { ( t + 1 ) } \gets w _ { i , r } ^ { ( t ) } - \eta \mathbb { E } _ { ( X , y ) \sim \mathcal { Z } } \nabla _ { w _ { i , r } } L ( F ^ { ( t ) } ; X , y )
+$$
+
+We run the algorithm for $T = { \mathsf { p o l y } } ( k ) / \eta$ iterations. We use $F ^ { ( t ) }$ to denote the model $F$ with hidden weights $\{ w _ { i , r } ^ { ( t ) } \}$ at iteration $t$ .
+
+Notations. We denote by $\begin{array} { r } { \mathbf { l o g i t } _ { i } ( F , X ) : = \frac { e ^ { F _ { i } ( X ) } } { \sum _ { j \in [ k ] } e ^ { F _ { j } ( X ) } } , } \end{array}$ = eFi(X)Pj∈[k] eFj (X) . Using this, we can write down
+
+$$
+\forall i \in [ k ] , r \in [ m ] \colon \quad - \nabla _ { w _ { i , r } } L ( F ; X , y ) = ( \mathbb { 1 } _ { i \neq y } - \log \operatorname { i } \mathbf { t } _ { i } ( F , X ) ) \nabla _ { w _ { i , r } } F _ { i } ( X ) ~ .
+$$
+
+# 4 MAIN THEOREMS AND EXPLANATIONS
+
+We now state the main theorems (and the one for self-distillation is in the full paper).10
+
+Theorem 1 (single model). For every sufficiently large $k > 0$ , every $m \in [ { \mathsf { p o l y l o g } } ( k ) , k ] ,$ , every $\eta \leq$ 1poly(k) , suppose we train a single model using the gradient descent update (3.1) starting from the random initialization defined in Section 3.2, then after T = poly(k) many iterations, with probability $\geq 1 - e ^ { - \Omega ( \log ^ { 2 } k ) }$ , the model $F ^ { ( T ) }$ satisfies:
+
+• (training is perfect): meaning for all $( X , y ) \in { \mathcal { Z } }$ , all $i \in [ k ] \setminus \{ y \}$ : ${ \cal F } _ { y } ^ { ( T ) } ( X ) > { \cal F } _ { i } ^ { ( T ) } ( X ) .$
+
+• (test accuracy is consistently bad): meaning that:
+
+$$
+{ \bf P r } _ { ( X , y ) \sim \mathcal { D } } [ \exists i \in [ k ] \setminus \{ y \} : F _ { y } ^ { ( T ) } ( X ) < F _ { i } ^ { ( T ) } ( X ) ] \in [ 0 . 4 9 \mu , 0 . 5 1 \mu ] \ .
+$$
+
+We shall give technical intuitions about why Theorem 1 holds in the full version. But, at a high-level, we shall construct a “lottery winning” set $\mathcal { M } \subseteq [ k ] \times [ 2 ]$ of cardinality $| \mathcal { M } | \in [ k ( 1 - o ( 1 ) ) , k ]$ . It only depends on the random initialization of $F$ . Then, with some effort we can prove that, for every $( i , \ell ) \in \mathcal { M }$ , at the end of the training $F ^ { ( T ) }$ will learn feature $v _ { i , \ell }$ but not learn feature $v _ { i , 3 - \ell }$ . This means for those single-view data $( X , y )$ with $y = i$ and ${ \widehat { \ell } } ( X ) = 3 - \ell$ , the final network $F ^ { ( T ) }$ will predict its label wrong. This is why the final test accuracy is around $0 . 5 \mu$ .
+
+Note the property that test accuracy consistently belongs to the range $[ 0 . 4 9 \mu , 0 . 5 1 \mu ]$ should be reminiscent of message $\textcircled{5}$ in Figure 6, where multiple single models, although starting from different random initialization, in practice does have a relatively small variance in test accuracies.
+
+Ensemble. Suppose $\{ F ^ { [ \ell ] } \} _ { \ell \in [ K ] }$ are $K = \widetilde \Omega ( 1 )$ independently trained models of $F$ with $m =$ polylog $( k )$ for $\begin{array} { r } { T = O \big ( \frac { \mathsf { p o l y } ( k ) } { \eta } \big ) } \end{array}$ iterations (i.e., the same setting as Theorem 1 except we only need a small over-parameterization $m = { \mathsf { p o l y l o g } } ( k ) .$ ). Let us define their ensemble
+
+$$
+\begin{array} { r } { G ( X ) = \frac { \widetilde { \Theta } ( 1 ) } { K } \sum _ { \ell } F ^ { [ \ell ] } ( X ) } \end{array}
+$$
+
+Theorem 2 (ensemble). In the same setting as Theorem $I$ except now we only need a small $m =$ polylog $( k )$ , we have for the ensemble model $G$ in (4.1), with probability at least $1 - e ^ { - \Omega ( \log ^ { 2 } k ) }$ :
+
+• (training is perfect): meaning for all $( X , y ) \in { \mathcal { Z } }$ , for all $i \in [ k ] \setminus \{ y \}$ : $G _ { y } ( X ) > G _ { i } ( X )$ .
+
+• (test accuracy is almost perfect): meaning that:
+
+$$
+{ \bf P r } _ { ( X , y ) \sim { \mathcal D } } [ \exists i \in [ k ] \setminus \{ y \} : G _ { y } ( X ) < G _ { i } ( X ) ] \le 0 . 0 0 1 \mu ~ .
+$$
+
+As we discussed in Section 2.3, the reason Theorem 2 holds attributes to the fact that those lottery winning sets $\mathcal { M }$ depend on the random initialization of the networks; and therefore, when multiple models are put together, their “union” of $\mathcal { M }$ shall cover all possible features $\{ v _ { i , \ell } \} _ { ( i , \ell ) \in [ k ] \times [ 2 ] }$ . Moreover, our theorem only requires individual $K = \widetilde \Omega ( 1 )$ models for ensemble, which is indeed “averaging the output of a few independently trained models”.
+
+# 4.1 KNOWLEDGE DISTILLATION FOR ENSEMBLE
+
+We consider a knowledge distillation algorithm given the existing ensemble model $G$ (see (4.1)) as follows. For every label $i \in [ k ]$ , let us define the truncated scaled logit as (for $\begin{array} { r } { \tau = \frac { 1 } { \log ^ { 2 } k } ) } \end{array}$
+
+$$
+\begin{array} { r } { \mathbf { l o g i t } _ { i } ^ { \tau } ( F , X ) = \frac { e ^ { \operatorname* { m i n } \{ \tau ^ { 2 } F _ { i } ( X ) , 1 \} / \tau } } { \sum _ { j \in [ k ] } e ^ { \operatorname* { m i n } \{ \tau ^ { 2 } F _ { j } ( X ) , 1 \} / \tau } } } \end{array}
+$$
+
+(This should be reminiscent of the logit function with temperature used by the original knowledge distillation work (Hinton et al., 2015); we use truncation instead which is easier to analyze.)
+
+Now, we train a new network $F$ from random initialization (where the randomness is independent of all of those used in $F ^ { [ \ell ] }$ ). At every iteration $t$ , we update each weight $w _ { i , r }$ by:
+
+$$
+\begin{array} { r } { v _ { i , r } ^ { ( t + 1 ) } = w _ { i , r } ^ { ( t ) } - \eta \nabla _ { w _ { i , r } } L ( F ^ { ( t ) } ) - \eta ^ { \prime } \mathbb { E } _ { ( X , y ) \sim \mathcal { Z } } \left[ \left( \mathbf { l o g } \mathbf { i t } _ { i } ^ { \tau } ( F ^ { ( t ) } , X ) - \mathbf { l o g } \mathbf { i t } _ { i } ^ { \tau } ( G , X ) \right) ^ { - } \nabla _ { w _ { i , r } } F _ { i } ^ { ( t ) } ( X - Y ) \right] , } \end{array}
+$$
+
+Notation. Throughout the paper we denote by $[ a ] ^ { + } = \operatorname* { m a x } \{ 0 , a \}$ and $[ a ] ^ { - } = \operatorname* { m i n } \{ 0 , a \}$ .
+
+This knowledge distillation method (4.3) is almost identical to the one used in the original work (Hinton et al., 2015), except we use a truncation during the training to make it more (theoretically) stable. Moreover, we update the distillation objective using a larger learning rate $\eta ^ { \prime }$ comparing to $\eta$ of the cross-entropy objective. This is also consistent with the training schedule used in (Hinton et al., 2015).
+
+Let $F ^ { ( t ) }$ be the resulting network obtained by (4.3) at iteration $t$ . We have the following theorem:
+
+Theorem 3 (ensemble distillation). Consider the distillation algorithm (4.3) in which $G$ is the ensemble model defined in (4.1). For every k > 0, for m = polylog(k), for every η ≤ 1poly(k) , setting η′ = ηpoly(k), after T = poly(k) many iterations with probability at least $1 - e ^ { - \Omega ( \log ^ { 2 } k ) }$ , for at least $90 \%$ of the iterations $t \leq \dot { T }$ :
+
+• (test accuracy is almost perfect): meaning that:
+
+$$
+\operatorname { \bf P r } _ { ( X , y ) \sim \mathcal { D } } [ \exists i \in [ k ] \setminus \{ y \} : F _ { y } ^ { ( t ) } ( X ) < F _ { i } ^ { ( t ) } ( X ) ] \le 0 . 0 0 1 \mu .
+$$
+
+Remark. Theorem 3 necessarily means that the distilled model $F$ has learned all the features $\underline { { \{ v _ { i , \ell } \} } } _ { ( i , \ell ) \in \lbrack k \rbrack \times \lbrack 2 \rbrack }$ from the ensemble model $G$ . This is consistent with our empirical findings in Figure 8: if one trains multiple individual models using knowledge distillation with different random seeds, then their ensemble gives no further performance boost.
+
+REFERENCES   
+Monther Alhamdoosh and Dianhui Wang. Fast decorrelated neural network ensembles with random weights. Information Sciences, 264:104–117, 2014.   
+Zeyuan Allen-Zhu and Yuanzhi Li. What Can ResNet Learn Efficiently, Going Beyond Kernels? In NeurIPS, 2019a. Full version available at http://arxiv.org/abs/1905.10337.   
+Zeyuan Allen-Zhu and Yuanzhi Li. Can SGD Learn Recurrent Neural Networks with Provable Generalization? In NeurIPS, 2019b. Full version available at http://arxiv.org/abs/ 1902.01028.   
+Zeyuan Allen-Zhu and Yuanzhi Li. Backward feature correction: How deep learning performs deep learning. arXiv preprint arXiv:2001.04413, 2020.   
+Zeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. On the convergence rate of training recurrent neural networks. In NeurIPS, 2019a. Full version available at http://arxiv.org/abs/1810. 12065.   
+Zeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. A convergence theory for deep learning via overparameterization. In ICML, 2019b. Full version available at http://arxiv.org/abs/ 1811.03962.   
+Jose M Alvarez, Yann LeCun, Theo Gevers, and Antonio M Lopez. Semantic road segmentation via multi-scale ensembles of learned features. In European Conference on Computer Vision, pp. 586–595. Springer, 2012.   
+Sanjeev Arora, Simon S Du, Wei Hu, Zhiyuan Li, Ruslan Salakhutdinov, and Ruosong Wang. On exact computation with an infinitely wide neural net. arXiv preprint arXiv:1904.11955, 2019a.   
+Sanjeev Arora, Simon S. Du, Wei Hu, Zhiyuan Li, and Ruosong Wang. Fine-grained analysis of optimization and generalization for overparameterized two-layer neural networks. CoRR, abs/1901.08584, 2019b. URL http://arxiv.org/abs/1901.08584.   
+Veronica Bol ´ on-Canedo and Amparo Alonso-Betanzos. Ensembles for feature selection: A review ´ and future trends. Information Fusion, 52:1–12, 2019.   
+Leo Breiman. Bagging predictors. Machine learning, 24(2):123–140, 1996.   
+Gavin Brown, Jeremy Wyatt, Rachel Harris, and Xin Yao. Diversity creation methods: a survey and categorisation. Information Fusion, 6(1):5–20, 2005a.   
+Gavin Brown, Jeremy L Wyatt, and Peter Tino. Managing diversity in regression ensembles. ˇ Journal of machine learning research, 6(Sep):1621–1650, 2005b.   
+Robert Bryll, Ricardo Gutierrez-Osuna, and Francis Quek. Attribute bagging: improving accuracy of classifier ensembles by using random feature subsets. Pattern recognition, 36(6):1291–1302, 2003.   
+Jie Cai, Jiawei Luo, Shulin Wang, and Sheng Yang. Feature selection in machine learning: A new perspective. Neurocomputing, 300:70–79, 2018.   
+Yuan Cao and Quanquan Gu. Generalization bounds of stochastic gradient descent for wide and deep neural networks. In Advances in Neural Information Processing Systems, pp. 10835–10845, 2019.   
+Victor Chernozhukov, Denis Chetverikov, and Kengo Kato. Comparison and anti-concentration bounds for maxima of gaussian random vectors. Probability Theory and Related Fields, 162(1): 47–70, 2015.   
+Amit Daniely. Sgd learns the conjugate kernel class of the network. In Advances in Neural Information Processing Systems, pp. 2422–2430, 2017.   
+Amit Daniely, Roy Frostig, and Yoram Singer. Toward deeper understanding of neural networks: The power of initialization and a dual view on expressivity. In Advances in Neural Information Processing Systems (NIPS), pp. 2253–2261, 2016.   
+Thomas G Dietterich. Ensemble methods in machine learning. In International workshop on multiple classifier systems, pp. 1–15. Springer, 2000.   
+Simon S Du, Jason D Lee, Haochuan Li, Liwei Wang, and Xiyu Zhai. Gradient descent finds global minima of deep neural networks. arXiv preprint arXiv:1811.03804, November 2018a.   
+Simon S Du, Xiyu Zhai, Barnabas Poczos, and Aarti Singh. Gradient descent provably optimizes over-parameterized neural networks. arXiv preprint arXiv:1810.02054, 2018b.   
+David A Freedman et al. Bootstrapping regression models. The Annals of Statistics, 9(6):1218– 1228, 1981.   
+Yoav Freund and Robert E Schapire. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of computer and system sciences, 55(1):119–139, 1997.   
+Yoav Freund, Robert Schapire, and Naoki Abe. A short introduction to boosting. Journal-Japanese Society For Artificial Intelligence, 14(771-780):1612, 1999.   
+Jerome Friedman, Trevor Hastie, Robert Tibshirani, et al. Additive logistic regression: a statistical view of boosting (with discussion and a rejoinder by the authors). The annals of statistics, 28(2): 337–407, 2000.   
+Jerome H Friedman. Greedy function approximation: a gradient boosting machine. Annals of statistics, pp. 1189–1232, 2001.   
+Tommaso Furlanello, Zachary C Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. arXiv preprint arXiv:1805.04770, 2018.   
+Mikel Galar, Alberto Fernandez, Edurne Barrenechea, Humberto Bustince, and Francisco Herrera. A review on ensembles for the class imbalance problem: bagging-, boosting-, and hybrid-based approaches. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 42(4):463–484, 2011.   
+Behrooz Ghorbani, Song Mei, Theodor Misiakiewicz, and Andrea Montanari. Linearized two-layers neural networks in high dimension. arXiv preprint arXiv:1904.12191, 2019.   
+Boris Hanin and Mihai Nica. Finite depth and width corrections to the neural tangent kernel. arXiv preprint arXiv:1909.05989, 2019.   
+Lars Kai Hansen and Peter Salamon. Neural network ensembles. IEEE transactions on pattern analysis and machine intelligence, 12(10):993–1001, 1990.   
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.   
+Tin Kam Ho. The random subspace method for constructing decision forests. IEEE transactions on pattern analysis and machine intelligence, 20(8):832–844, 1998.   
+Arthur Jacot, Franck Gabriel, and Clement Hongler. Neural tangent kernel: Convergence and gen- ´ eralization in neural networks. In Advances in neural information processing systems, pp. 8571– 8580, 2018.   
+Kenji Kawaguchi. Deep learning without poor local minima. In Advances in Neural Information Processing Systems, pp. 586–594, 2016.   
+Josef Kittler, Mohamad Hatef, Robert PW Duin, and Jiri Matas. On combining classifiers. IEEE transactions on pattern analysis and machine intelligence, 20(3):226–239, 1998.   
+Ron Kohavi, George H John, et al. Wrappers for feature subset selection. Artificial intelligence, 97 (1-2):273–324, 1997.   
+J Zico Kolter and Marcus A Maloof. Dynamic weighted majority: An ensemble method for drifting concepts. Journal of Machine Learning Research, 8(Dec):2755–2790, 2007.   
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.   
+Ludmila I Kuncheva. Combining pattern classifiers: methods and algorithms. John Wiley & Sons, 2014.   
+Yuanzhi Li and Yingyu Liang. Learning overparameterized neural networks via stochastic gradient descent on structured data. In Advances in Neural Information Processing Systems, 2018.   
+Yuanzhi Li, Colin Wei, and Tengyu Ma. Towards explaining the regularization effect of initial large learning rate in training neural networks. arXiv preprint arXiv:1907.04595, 2019.   
+Pankaj Mehta, Marin Bukov, Ching-Hao Wang, Alexandre GR Day, Clint Richardson, Charles K Fisher, and David J Schwab. A high-bias, low-variance introduction to machine learning for physicists. Physics reports, 810:1–124, 2019.   
+Hossein Mobahi, Mehrdad Farajtabar, and Peter L Bartlett. Self-distillation amplifies regularization in hilbert space. arXiv preprint arXiv:2002.05715, 2020.   
+M Arthur Munson and Rich Caruana. On feature selection, bias-variance, and bagging. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 144– 159. Springer, 2009.   
+Chris Olah, Alexander Mordvintsev, and Ludwig Schubert. Feature visualization. Distill, 2(11):e7, 2017. doi: 10.23915/distill.00007. https://distill.pub/2017/feature-visualization.   
+Luiz S Oliveira, Robert Sabourin, Flavio Bortolozzi, and Ching Y Suen. Feature selection for ´ ensembles: A hierarchical multi-objective genetic algorithm approach. In Seventh International Conference on Document Analysis and Recognition, 2003. Proceedings., pp. 676–680. Citeseer, 2003.   
+David W Opitz. Feature selection for ensembles. In AAAI, pp. 379–384, 1999.   
+Robi Polikar. Ensemble based systems in decision making. IEEE Circuits and systems magazine, 6 (3):21–45, 2006.   
+Juan Jose Rodriguez, Ludmila I Kuncheva, and Carlos J Alonso. Rotation forest: A new classifier ´ ensemble method. IEEE transactions on pattern analysis and machine intelligence, 28(10):1619– 1630, 2006.   
+Lior Rokach. Pattern classification using ensemble methods, volume 75. World Scientific, 2010.   
+Lior Rokach and Oded Z Maimon. Data mining with decision trees: theory and applications, volume 69. World scientific, 2008.   
+Robert E Schapire, Yoav Freund, Peter Bartlett, Wee Sun Lee, et al. Boosting the margin: A new explanation for the effectiveness of voting methods. The annals of statistics, 26(5):1651–1686, 1998.   
+Vaishaal Shankar, Alex Fang, Wenshuo Guo, Sara Fridovich-Keil, Ludwig Schmidt, Jonathan Ragan-Kelley, and Benjamin Recht. Neural kernels without tangents. arXiv preprint arXiv:2003.02237, 2020.   
+Daniel Soudry and Yair Carmon. No bad local minima: Data independent training error guarantees for multilayer neural networks. arXiv preprint arXiv:1605.08361, 2016.   
+Alexey Tsymbal, Mykola Pechenizkiy, and Padraig Cunningham. Diversity in search strategies for ´ ensemble feature selection. Information fusion, 6(1):83–98, 2005.   
+Giorgio Valentini. An experimental bias-variance analysis of svm ensembles based on resampling techniques. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 35(6): 1252–1271, 2005.   
+Giorgio Valentini and Thomas G Dietterich. Bias-variance analysis of support vector machines for the development of svm-based ensemble methods. Journal of Machine Learning Research, 5(Jul): 725–775, 2004.   
+Bo Xie, Yingyu Liang, and Le Song. Diversity leads to generalization in neural networks. arXiv preprint Arxiv:1611.03131, 2016.   
+Greg Yang. Scaling limits of wide neural networks with weight sharing: Gaussian process behavior, gradient independence, and neural tangent kernel derivation. arXiv preprint arXiv:1902.04760, 2019.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+Linfeng Zhang, Jiebo Song, Anni Gao, Jingwei Chen, Chenglong Bao, and Kaisheng Ma. Be your own teacher: Improve the performance of convolutional neural networks via self distillation. In ICCV, pp. 3713–3722, 2019.   
+Difan Zou, Yuan Cao, Dongruo Zhou, and Quanquan Gu. Stochastic gradient descent optimizes over-parameterized deep relu networks. arXiv preprint arXiv:1811.08888, 2018.

parse/dev/Uuf2q9TfXGA/Uuf2q9TfXGA_content_list.json

@@ -0,0 +1,1482 @@
+[
+    {
+        "type": "text",
+        "text": "TOWARDS UNDERSTANDING ENSEMBLE, KNOWLEDGE DISTILLATION AND SELF-DISTILLATION IN DEEP LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zeyuan Allen-Zhu   \nMeta FAIR Labs   \nzeyuanallenzhu@meta.com ",
+        "bbox": [
+            183,
+            194,
+            411,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuanzhi Li Mohamed bin Zayed University of AI Yuanzhi.Li@mbzuai.ac.ae ",
+        "bbox": [
+            496,
+            194,
+            745,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            273,
+            544,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We formally study how ensemble of deep learning models can improve test accuracy, and how the superior performance of ensemble can be distilled into a single model using knowledge distillation. We consider the challenging case where the ensemble is simply an average of the outputs of a few independently trained neural networks with the same architecture, trained using the same algorithm on the same data set, and they only differ by the random seeds used in the initialization. ",
+        "bbox": [
+            233,
+            296,
+            764,
+            380
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We show that ensemble/knowledge distillation in deep learning works very differently from traditional learning theory (such as boosting or NTKs). We develop a theory showing that when data has a structure we refer to as “multi-view”, then ensemble of independently trained neural networks can provably improve test accuracy, and such superior test accuracy can also be provably distilled into a single model. Our result sheds light on how ensemble works in deep learning in a way that is completely different from traditional theorems, and how the “dark knowledge” is hidden in the outputs of the ensemble and can be used in distillation.1 ",
+        "bbox": [
+            232,
+            383,
+            764,
+            494
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            336,
+            531
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ensemble (Dietterich, 2000; Hansen & Salamon, 1990; Polikar, 2006) is one of the most powerful techniques in practice to improve the performance of deep learning. By simply averaging the outputs of merely a few (like 3 or 10) independently-trained neural networks of the same architecture, using the same training method over the same training data, it can significantly boost the prediction accuracy over the test set comparing to individual models. The only difference is the randomness used to initialize these networks and/or the randomness during training. Moreover, it is discovered by Hinton et al. (2015) that such superior performance of the ensemble can be transferred into a single model (of the same size as the individual models) using a technique called knowledge distillation: that is, simply train a single model to match the output of the ensemble (such as ${ \\mathfrak { s o o } } \\%$ cat $^ +$ $10 \\%$ car”, also known as soft labels) as opposite to the true data labels, over the same training data. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "On the theory side, there are lots of works studying the superior performance of ensemble from principled perspectives (see full version for citations). However, most of these works only apply to: (1). Boosting: where the coefficients associated with the combinations of the single models are actually trained, instead of simply taking average; (2). Bootstrapping/Bagging: the training data are different for each single model; (3). Ensemble of models of different types and architectures; or (4). Ensemble of random features or decision trees. To the best of our knowledge, none of these cited works apply to the particular type of ensemble that is widely used in deep learning: simply take a uniform average of the output of the learners, which are neural networks with the same architecture and are trained by stochastic gradient descent (SGD) over the same training set. In fact, very critically, for deep learning models: ",
+        "bbox": [
+            174,
+            689,
+            825,
+            828
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• TRAINING AVERAGE DOES NOT WORK: if one directly trains to learn an average of individual neural networks initialized by different seeds, the performance is much worse than ensemble. • KNOWLEDGE DISTILLATION WORKS: the superior performance of ensemble in deep learning can be distilled into a single model (Hinton et al., 2015). ",
+        "bbox": [
+            181,
+            835,
+            825,
+            895
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/de285772a80e5d3b024c4932fa4ac2d7132a5ff75b8b80087dce702558f1c175.jpg",
+        "image_caption": [
+            "Figure 1: Ensemble in deep learning is very different from ensemble in random feature mappings. Details in Figure 6. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            99,
+            787,
+            205
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• SELF-DISTILLATION WORKS: even distilling a single model into another of the same size, there is performance boost. (Furlanello et al., 2018; Mobahi et al., 2020; Zhang et al., 2019) ",
+        "bbox": [
+            183,
+            244,
+            826,
+            273
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We are unaware of any satisfactory theoretical explanation for the phenomena above. For instance, as we shall argue, some traditional view for why ensemble works, such as ‘ensemble can enlarge the feature space in random feature mappings’, even give contradictory explanations to the above phenomena, thus cannot explain knowledge distillation or ensemble in deep learning. Motivated by this gap between theory and practice we study the following question for multi-class classification: ",
+        "bbox": [
+            174,
+            280,
+            825,
+            351
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our theoretical questions: ",
+        "text_level": 1,
+        "bbox": [
+            410,
+            353,
+            591,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "How does ensemble improve the test-time performance in deep learning when we simply (unweightedly) average over a few independently trained neural networks? – Especially when all the neural networks have the same architecture, are trained over the same data set using the same standard training algorithm and only differ by the random seeds, and even when all single models already have $1 0 0 \\%$ training accuracy? How can such superior test-time performance of ensemble be later “distilled” into a single neural network of the same architecture, simply by training the single model to match the output of the ensemble over the same training data set? ",
+        "bbox": [
+            179,
+            371,
+            823,
+            468
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our results. We prove for certain multi-class classification tasks with a special structure we refer to as multi-view, with a training set $\\mathcal { Z }$ consisting of $N$ i.i.d. samples from some unknown distribution $\\mathcal { D }$ , for certain two-layer convolutional network $f$ with (smoothed-)ReLU activation as learner: ",
+        "bbox": [
+            176,
+            483,
+            825,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• (Single model has bad test accuracy): there is a value $\\mu > 0$ such that when a single model $f$ is trained over $\\mathcal { Z }$ using the cross-entropy loss, via gradient descent (GD) starting from random Gaussian initialization, the model can reach zero training error efficiently. However, w.h.p. the prediction (classification) error of $f$ over $\\mathcal { D }$ is between $0 . 4 9 \\mu$ and $0 . 5 1 \\mu$ . ",
+        "bbox": [
+            181,
+            532,
+            825,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• (Ensemble provably improves test accuracy): let $f _ { 1 } , f _ { 2 } , \\cdots , f _ { L }$ be $L = \\widetilde { \\Omega } ( 1 )$ independently trained single models as above, then w.h.p. $\\begin{array} { r } { \\overline { { G } } = \\frac { 1 } { L } \\sum _ { \\ell } f _ { \\ell } } \\end{array}$ has prediction error $\\le 0 . 0 1 \\mu$ over $\\mathcal { D }$ . ",
+        "bbox": [
+            181,
+            597,
+            823,
+            628
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• (Ensemble can be distilled into a single model): if we further train (using GD from random initialization) another single model $f _ { 0 }$ (same architecture as each $f _ { \\ell } )$ to match the output of $\\begin{array} { r } { G = \\frac { 1 } { L } \\sum _ { \\ell } \\bar { f } _ { \\ell } } \\end{array}$ merely over the same training data set $\\mathcal { Z }$ , then $f _ { 0 }$ can be trained efficiently and w.h.p. $f _ { 0 }$ will have prediction error $\\le 0 . 0 1 \\mu$ over $\\mathcal { D }$ as well. ",
+        "bbox": [
+            181,
+            632,
+            826,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• (Self-distillation also improves test accuracy): if we further train (using GD from random initialization) another single model $f ^ { \\prime }$ (same architecture as $f _ { 1 } )$ ) to match the output of the single model $f _ { 1 }$ merely over the same training data set $\\mathcal { Z }$ , then $f ^ { \\prime }$ can be trained efficiently and w.h.p. has prediction error at most $\\leq 0 . 2 6 \\mu$ over $\\mathcal { D }$ . The main idea is that self-distillation is performing “implicit ensemble $^ +$ knowledge distillation”, as we shall argue in Section 4.2. ",
+        "bbox": [
+            183,
+            695,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We defer discussions of our empirical results to Section 5. However, we highlight some of the empirical findings, as they shall confirm and justify our theoretical approach studying ensemble and knowledge distillation in deep learning. Specifically, we give empirical evidences showing that: ",
+        "bbox": [
+            176,
+            772,
+            825,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Knowledge distillation does not work for random feature mappings; and ensemble in deep learning is very different from ensemble in random feature mappings (see Figure 1). • Special structures in data (such as the “multi-view” structure we shall introduce) is needed for ensemble of neural networks to work. • The variance due to label noise or the non-convex landscape of training, in the independentlytrained models, may not be connected to the superior performance of ensemble in deep learning. ",
+        "bbox": [
+            181,
+            824,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 OUR METHODOLOGY AND INTUITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            522,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 A FAILURE ATTEMPT USING RANDOM FEATURE MAPPINGS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            127,
+            632,
+            143
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The recent advance in deep learning theory shows that under certain circumstances, neural networks can be treated as a linear function over random feature mappings — see (Allen-Zhu et al., 2019b; Arora et al., 2019b; Daniely et al., 2016; Du et al., $2 0 1 8 \\mathrm { b }$ ; Jacot et al., 2018; Zou et al., 2018) and the references therein. In particular, the theory shows when $f : \\mathbb { R } ^ { D + d }  \\mathbb { R }$ is a neural network with inputs $x \\in \\mathbb { R } ^ { d }$ and weights $W \\in \\mathbb { R } ^ { D }$ , in some cases, $f ( W , x )$ can be approximated by: ",
+        "bbox": [
+            173,
+            151,
+            826,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/272495e9f0514536ad4c58e90c0ff26bd7883d7ac37b8608ee9bc253ccb40850.jpg",
+        "text": "$$\nf ( W , x ) \\approx f ( W _ { 0 } , x ) + \\left. W - W _ { 0 } , \\nabla _ { W } f ( W _ { 0 } , x ) \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            227,
+            665,
+            243
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { 0 }$ is the random initialization of the neural network, and $\\Phi _ { W _ { 0 } } ( x ) : = \\nabla _ { W } f ( W _ { 0 } , x )$ is the neural tangent kernel (NTK) feature mapping. This is known as the NTK approach. If this approximation holds, then training a neural network can be approximated by learning a linear function over random features $\\Phi _ { W _ { 0 } } ( x )$ , which is very theory-friendly. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ensemble works for random features / NTK. Traditional theorems (Alhamdoosh & Wang, 2014; Brown et al., 2005a; Bryll et al., 2003; Tsymbal et al., 2005) suggest that the ensemble of independently trained random feature models can indeed significantly improve test-time performance, as it enlarges the feature space from $\\Phi _ { W _ { 0 } } ( x )$ to $\\{ \\Phi _ { W _ { 0 } ^ { ( i ) } } ( x ) \\} _ { i \\in [ L ] }$ for $L$ many independently sampled W (i)0 . This can be viewed as a feature selection process (Alvarez et al., 2012; Cai et al., 2018; Oliveira et al., 2003; Opitz, 1999; Rokach, 2010), and we have confirmed it for NTK in practice, see Figure 1. However, can we understand ensemble and knowledge distillation in $D L$ as feature selections using NTK? Unfortunately, our empirical results provide many counter examples towards those arguments, see discussions below and Figure 1. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Contradiction 1: training average works even better. Although ensemble of linear functions over NTK features with different random seeds: $f _ { i } ( x ) = \\langle W ^ { ( i ) } , \\Phi _ { W _ { 0 } ^ { ( i ) } } ( x ) \\rangle$ does improve test accuracy, however, such improvement is mainly due to the use of a larger set of random features, whose combinations contain functions that generalize better. To see this, we observe that an even superior performance (than the ensemble) can simply be obtained by directly training $F ( x ) = { \\textstyle { \\frac { 1 } { L } } } \\left( f _ { 1 } + \\dot { f } _ { 2 } + \\cdot \\cdot \\cdot + f _ { L } \\right)$ from random initialization. In contrast, recall if $f _ { i } ( x )$ ’s are multi-layer neural networks with different random seeds, then training their average barely gives any better performance comparing to individual networks $f _ { i }$ , as now all the $f _ { i }$ ’s are capable of learning the same set of features. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Contradiction 2: knowledge distillation does not work. For NTK feature mappings, we observe that the result obtained by ensemble cannot be distilled at all into individual models, indicating the features selected by ensemble is not contained in the feature $\\Phi _ { W _ { 0 } ^ { ( i ) } } ( x )$ of any individual model. In contrast, in actual deep learning, ensemble does not enlarge feature space: so an individual neural network is capable of learning the features of the ensemble model. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In sum, ensemble in deep learning may be very different from ensemble in random features. It may be more accurate to study ensemble / knowledge distillation in deep learning as a feature learning process, instead of a feature selection process. But still, we point out a fundamental difficulty: ",
+        "bbox": [
+            174,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Key challenge: ",
+        "text_level": 1,
+        "bbox": [
+            449,
+            702,
+            553,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If a single deep learning model is capable of — through knowledge distillation — learning the features of the ensemble model and achieving better test accuracy comparing to training the single model directly (and the same training accuracy, typically at global optimal of $1 0 0 \\%$ ), then why the single model cannot learn these features directly when we train the model to match the true data labels? What is the dark knowledge hidden in the output of ensemble (a.k.a. soft label)2 comparing to the original hard label? ",
+        "bbox": [
+            181,
+            718,
+            823,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ENSEMBLE IN DEEP LEARNING: A FEATURE LEARNING PROCESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            669,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Before addressing the key challenge, we point out that prior works are very limited with respect to studying neural network training as a feature learning process. Most of the existing works proving that neural networks can learn features only focus on the case when the input is Gaussian or ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb7526966191bbf13c5b0c009cf56ef17366c59127a72ee090c98bbd82623252.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of images with multiple views (features) in the ImageNet dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            97,
+            789,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Gaussian-like — see for instance (Kawaguchi, 2016; Soudry & Carmon, 2016; Xie et al., 2016) and many others. However, as we demonstrate in Figure 7 in the full version, ",
+        "bbox": [
+            176,
+            212,
+            821,
+            241
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Ensemble in DL might not improve test accuracy when inputs are Gaussian-like: ",
+        "text_level": 1,
+        "bbox": [
+            205,
+            244,
+            781,
+            258
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Empirically, ensemble does not improve test accuracy in deep learning, in certain scenarios when the distribution of the input data is Gaussian or even mixture of Gaussians. This is true over various learner network structures (fully-connected, residual, convolution neural networks) and various labeling functions (when the labels are generated by linear functions, fully-connected, residual, convolutional networks, with/without label noise, with/without classification margin). ",
+        "bbox": [
+            181,
+            262,
+            823,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Bias variance view of ensemble: Some prior works also try to attribute the benefit of ensemble as reducing the variance of individual solutions due to label noise or non-convex landscape of the training objective. However, reducing such variance can reduce a convex test loss (typically crossentropy), but not necessarily the test classification error. Concretely, the synthetic experiments in Figure 7 show that, after applying ensemble over Gaussian-like inputs, the variance of the model outputs is reduced but the test accuracy is not improved. We give many more empirical evidences to show that the variance (either from label noise or from the non-convex landscape) is usually not the cause for why ensemble works in deep learning, see Section 5. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hence, to understand the true benefit of ensemble in deep learning in theory, we would like to study a setting that can approximate practical deep learning, where: ",
+        "bbox": [
+            173,
+            464,
+            823,
+            493
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• The input distribution is more structured than standard Gaussian and there is no label noise. (From above discussions, ensemble cannot work for deep learning distribution-freely). • The individual neural networks all are well-trained, in the sense that the training accuracy in the end is $1 0 0 \\%$ , and there is nearly no variance in the test accuracy for individual models. (So training never fails.) ",
+        "bbox": [
+            179,
+            500,
+            825,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose to study a setting of data that we refer to as multi-view, where the above two conditions both hold when we train a two-layer neural networks with (smoothed-)ReLU activations. We also argue that the multi-view structure we consider is fairly common in the data sets used in practice, in particular for vision tasks. We give more details below. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 OUR APPROACH: LEARNING MULTI-VIEW DATA",
+        "text_level": 1,
+        "bbox": [
+            173,
+            651,
+            553,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us first give a thought experiment to illustrate our approach, and we present the precise mathematical definition of the “multi-view” structure in Section 3. Consider a binary classification problem and four “features” $v _ { 1 } , v _ { 2 } , v _ { 3 } , v _ { 4 }$ . The first two features correspond to the first class label, and the next two features correspond to the second class label. In the data distribution: ",
+        "bbox": [
+            174,
+            675,
+            825,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• When the label is class 1, then:3 ",
+        "bbox": [
+            184,
+            738,
+            406,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "both $v _ { 1 } , v _ { 2 }$ appears with weight 1, one of $v _ { 3 } , v _ { 4 }$ appears with weight 0.1 w.p. $8 0 \\%$   \nonly $v _ { 1 }$ appears with weight 1, one of $v _ { 3 } , v _ { 4 }$ appears with weight 0.1 w.p. $1 0 \\%$   \nonly $v _ { 2 }$ appears with weight 1, one of $v _ { 3 } , v _ { 4 }$ appears with weight 0.1 w.p. $1 0 \\%$ ",
+        "bbox": [
+            209,
+            757,
+            792,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• When the label is class 2, then ",
+        "bbox": [
+            183,
+            813,
+            398,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "both $v _ { 3 } , v _ { 4 }$ appears with weight 1, one of $v _ { 1 } , v _ { 2 }$ appears with weight 0.1 w.p. $8 0 \\%$   \nonly $v _ { 3 }$ appears with weight 1, one of $v _ { 1 } , v _ { 2 }$ appears with weight 0.1 w.p. $1 0 \\%$   \nonly $v _ { 4 }$ appears with weight 1, one of $v _ { 1 } , v _ { 2 }$ appears with weight 0.1 w.p. $1 0 \\%$ ",
+        "bbox": [
+            220,
+            832,
+            792,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e0f9e8e227c2a75d939df4567af9361df69e7978dad47ecaa50e4b1bd774d060.jpg",
+        "image_caption": [
+            "Figure 3: Visualization of the channels in layer-23 of a ResNet-34 trained on CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            102,
+            785,
+            214
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We call the $8 0 \\%$ of the data multi-view data: these are the data where multiple features exist and can be used to classify them correctly. We call the rest $2 0 \\%$ of the data single-view data: some features for the correct labels are missing. 4 ",
+        "bbox": [
+            174,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "How individual neural networks learn. Under the multi-view data defined above, if we train a neural network using the cross-entropy loss via gradient descent (GD) from random initialization, during the training process of the individual networks, we show that: ",
+        "bbox": [
+            176,
+            305,
+            823,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• The network will quickly pick up one of the feature $v \\in \\{ v _ { 1 } , v _ { 2 } \\}$ for the first label, and one of the features $v ^ { \\prime } \\in \\bar { \\{ v _ { 3 } , v _ { 4 } \\} }$ for the second label. So, $9 0 \\%$ of the training examples, consisting of all the multi-view data and half of the single-view data (those with feature $v$ or $v ^ { \\prime }$ ), are classified correctly. Once classified correctly (with a large margin), these data begin to contribute negligible to gradient by the nature of the cross-entropy loss. • Next, the network will memorize (using e.g. the noise in the data) the remaining $1 0 \\%$ of the training examples without learning any new features, due to insufficient amount of left-over samples after the first phase, thus achieving training accuracy $1 0 0 \\%$ but test accuracy $9 0 \\%$ . ",
+        "bbox": [
+            179,
+            354,
+            825,
+            470
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "How ensemble improves test accuracy. It is simple why ensemble works. Depending on the randomness of initialization, each individual network will pick up $v _ { 1 }$ or $v _ { 2 }$ each w.p. $5 0 \\%$ . Hence, as long as we ensemble ${ \\widetilde { O } } ( 1 )$ many independently trained models, w.h.p. their ensemble will pick up both features $\\{ v _ { 1 } , v _ { 2 } \\}$ and both features $\\{ v _ { 3 } , v _ { 4 } \\}$ . Thus, all the data will be classified correctly. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "How knowledge distillation works. Perhaps less obvious is how knowledge distillation works. Since ensemble learns all the features $v _ { 1 } , v _ { 2 } , v _ { 3 } , v _ { 4 }$ , given a multi-view data with label 1, the ensemble will actually output $\\propto ( 2 , 0 . 1 )$ , where the 2 comes from features $v _ { 1 } , v _ { 2 }$ and 0.1 comes from one of $v _ { 3 } , v _ { 4 }$ . On the other hand, an individual model learning only one of $v _ { 3 } , v _ { 4 }$ will actually output $\\propto ( 2 , 0 )$ when the feature $v _ { 3 }$ or $v _ { 4 }$ in the data does not match the one learned by the model. Hence, by training the individual model to match the output of the ensemble, the individual model is forced to learn both features $v _ { 3 } , v _ { 4 }$ , even though it has already perfectly classified the training data. This is the “dark knowledge” hidden in the output of the ensemble model. (This theoretical finding is consistent with practice: Figure 8 in the full paper suggests that models trained from knowledge distillation should have learned most of the features, and further computing their ensemble does not give much performance boost.) ",
+        "bbox": [
+            173,
+            541,
+            825,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Significance of our technique. Our work belongs to the generic framework of feature learning in DL where one proves that certain aspects of the algorithm (e.g. the randomness) affects the order where features are learned. This is fundamentally different from convex optimization, such as kernel method, where (with $\\ell _ { 2 }$ regularization) there is an unique global minimum so the choice of the random seed does not matter (thus, ensemble does not help). There are other works that consider other aspects, such as the choice of learning rate, that can affect the order where the features are learned (Li et al., 2019). Our work is fundamentally different: they only focus on the NTK setting where the features are not learned; we study a feature learning process. Recall, the NTK setting cannot be used to explain ensemble and distillation in DL. Our work extends the reach of traditional machine learning theory, where typically the “generalization” is separated from “optimization.” Such “separate” treatment might not be enough to understand how deep learning works. ",
+        "bbox": [
+            174,
+            702,
+            823,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3476fc7dda82d2f8192133eea5272f3fe0d58a03061c02df35d8823e259320ef.jpg",
+        "image_caption": [
+            "Figure 4: Illustration of a multi-view and a single-view data point; the feature vectors can also be combined with feature noise and random noise, see Def. 3.1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            820,
+            223
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            268,
+            825,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            417,
+            348,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The “multi-view” data distribution is a straight-forward generalization of the intuitive setting in Section 2.3. For simplicity, in the main body, we use example choices of the parameters mainly a function of $k$ (such as $P = k ^ { 2 }$ , $\\begin{array} { r } { \\gamma = \\frac { 1 } { k ^ { 1 . 5 } } } \\end{array}$ , $\\textstyle \\mu = { \\frac { k ^ { 1 . 2 } } { N } }$ , $\\rho = k ^ { - 0 . 0 1 }$ , $\\sigma _ { 0 } = 1 / \\sqrt { k }$ as we shall see), and we consider the case when $k$ is sufficiently large. In our full version, we shall give a much larger range of parameters for the theorems to hold. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATA DISTRIBUTION AND NOTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            531,
+            480,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider learning a $k$ -class classification problem over $P$ -patch inputs, where each patch has dimension $d$ . In symbols, each labelled data is represented by $( X , y )$ where $X = ( x _ { 1 } , x _ { 2 } , \\cdot \\cdot \\cdot , x _ { P } ) \\in$ $( \\mathbb { R } ^ { d } ) ^ { P }$ is the data vector and $y \\in [ k ]$ is the data label. For simplicity, we focus on the case when ${ \\dot { P } } = k ^ { 2 }$ , and $d = { \\mathsf { p o l y } } ( k )$ for a large polynomial. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider the setting when $k$ is sufficiently large.5 We use “w.h.p.” to denote with probability at least $1 - e ^ { - \\Omega ( \\log ^ { 2 } k ) }$ , and use $\\widetilde { O } , \\widetilde { \\Theta } , \\widetilde { \\Omega }$ notions to hide polylogarithmic factors in $k$ . ",
+        "bbox": [
+            174,
+            617,
+            823,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first assume that each label class $j \\in [ k ]$ has multiple associated features, say two features for the simplicity of math, represented by unit feature vectors $v _ { j , 1 } , v _ { j , 2 } \\in \\mathbb { R } ^ { d }$ . For notation simplicity, we assume that all the features are orthogonal, namely, ",
+        "bbox": [
+            174,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2ecc5952494987733d94a54e17a4c159e8d4766330db4ded5e92ee486edc58c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\forall j , j ^ { \\prime } \\in [ k ] , \\forall \\ell , \\ell ^ { \\prime } \\in [ 2 ] , \\| v _ { j , \\ell } \\| _ { 2 } = 1 \\quad \\mathrm { a n d } v _ { j , \\ell } \\bot v _ { j ^ { \\prime } , \\ell ^ { \\prime } } \\mathrm { w h e n } ( j , \\ell ) \\ne ( j ^ { \\prime } , \\ell ^ { \\prime } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            704,
+            748,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "although our work also extends to the “incoherent” case trivially. We denote by ",
+        "bbox": [
+            173,
+            727,
+            691,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6c08a55ba084ac034d659725056a29ae720138b0e8241d2e933f27436497ea0.jpg",
+        "text": "$$\n\\mathcal { V } : = \\{ v _ { j , 1 } , v _ { j , 2 } \\} _ { j \\in [ k ] }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            747,
+            491,
+            765
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider the following data and label distribution. Let $C _ { p }$ be a global constant, $s \\in [ 1 , k ^ { 0 . 2 } ]$ be a sparsity parameter. To be concise, we define the multi-view distribution $\\mathcal { D } _ { m }$ and single-view distribution $\\mathcal { D } _ { s }$ together. Due to space limitation, here we hide the specification of the random “noise” and defer it to the full version.6 ",
+        "bbox": [
+            173,
+            771,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.1 (data distributions $\\mathcal { D } _ { m }$ and $\\mathcal { D } _ { s }$ ). Given $\\mathcal { D } \\in \\{ \\mathcal { D } _ { m } , \\mathcal { D } _ { s } \\}$ , we define $( X , y ) \\sim \\mathcal { D }$ as follows. First choose the label $y \\in [ k ]$ uniformly at random. Then, the data vector $X$ is generated ",
+        "bbox": [
+            173,
+            832,
+            823,
+            862
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "as follows (also illustrated in Figure 4). ",
+        "bbox": [
+            174,
+            103,
+            434,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. Denote $\\mathcal { V } ( X ) = \\{ v _ { y , 1 } , v _ { y , 2 } \\} \\cup \\mathcal { V } ^ { \\prime }$ as the set of feature vectors used in this data vector $X$ , where $\\mathcal { V } ^ { \\prime }$ is a set of features uniformly sampled from $\\left\\{ v _ { j ^ { \\prime } , 1 } , v _ { j ^ { \\prime } , 2 } \\right\\} _ { j ^ { \\prime } \\in [ k ] \\backslash \\{ y \\} }$ , each with probability $\\frac { s } { k }$ . ",
+        "bbox": [
+            173,
+            127,
+            825,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. For each $v \\in \\mathcal { V } ( X )$ , pick $C _ { p }$ many disjoint patches in $[ P ]$ and denote it as $\\mathcal { P } _ { v } ( X ) \\subset [ P ]$ (the distribution of these patches can be arbitrary). We denote $\\mathcal { P } ( X ) = \\cup _ { v \\in \\mathcal { V } ( X ) } \\mathcal { P } _ { v } ( X )$ . ",
+        "bbox": [
+            176,
+            164,
+            825,
+            194
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3. If $\\mathcal { D } = \\mathcal { D } _ { s }$ is the single-view distribution, pick a value ${ \\widehat { \\ell } } = { \\widehat { \\ell } } ( X ) \\in$ [2] uniformly at random. ",
+        "bbox": [
+            176,
+            200,
+            795,
+            219
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4. For each $v \\in \\mathcal { V } ( X )$ and $p \\in { \\mathcal { P } } _ { v } ( X )$ , we set $x _ { p } = z _ { p } v + \\mathbf { \\zeta } ^ { \\cdot } n o i s e ^ { , \\cdot } \\in \\mathbb { R } ^ { d }$ , where, the random coefficients $z _ { p } \\geq 0$ satisfy that: ",
+        "bbox": [
+            174,
+            224,
+            825,
+            255
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the case of multi-view distribution $\\mathcal { D } = \\mathcal { D } _ { m }$ , ",
+        "bbox": [
+            197,
+            261,
+            504,
+            276
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/125499601cd9ce47bfd8d51ae21891c42f47844b5a741cccd2dbd3be10df2faa.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\sum _ { p \\in \\mathcal { P } _ { v } ( X ) } z _ { p } \\in [ 1 , O ( 1 ) ] ~ w h e n ~ v \\in \\{ v _ { y , 1 } , v _ { y , 2 } \\} , \\quad ^ { 7 } } \\\\ & { \\sum _ { p \\in \\mathcal { P } _ { v } ( X ) } z _ { p } \\in [ \\Omega ( 1 ) , 0 . 4 ] ~ w h e n ~ v \\in \\mathcal { V } ( X ) \\setminus \\{ v _ { y , 1 } , v _ { y , 2 } \\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            281,
+            617,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the case of single-view distribution $\\mathcal { D } = \\mathcal { D } _ { s }$ , ",
+        "bbox": [
+            196,
+            324,
+            506,
+            339
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8da332f8aa701b228992ab873c29fc9e32ca1074e315d6c4e6e29008664f835b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\sum _ { p \\in \\mathcal { P } _ { v } ( X ) } z _ { p } \\in [ 1 , O ( 1 ) ] ~ w h e n ~ v = v _ { y , \\widehat { \\ell } } , } \\\\ & { \\sum _ { p \\in \\mathcal { P } _ { v } ( X ) } z _ { p } \\in [ \\rho , O ( \\rho ) ] ~ w h e n ~ v = v _ { y , 3 - \\widehat { \\ell } } , } \\\\ & { \\sum _ { p \\in \\mathcal { P } _ { v } ( X ) } z _ { p } \\in [ \\Omega ( \\Gamma ) , \\Gamma ] ~ w h e n ~ v \\in \\mathcal { V } ( X ) \\setminus \\{ v _ { y , 1 } , v _ { y , 2 } \\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            344,
+            596,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5. For each $p \\in [ P ] \\setminus { \\mathcal { P } } ( X )$ , we set $x _ { p }$ to consist only of “noise”. ",
+        "bbox": [
+            176,
+            402,
+            611,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Remark 3.2. The distribution of how to pick ${ \\mathcal { P } } ( X )$ and assign $\\sum _ { p \\in \\mathcal { P } _ { v } ( X ) } z _ { p }$ to each patch in $p \\in$ ${ \\mathcal { P } } _ { v } ( X )$ can be arbitrary (and can depend on other randomness in the data as well). In particular, we have allowed different features $v _ { j , 1 } , v _ { j , 2 }$ to show up with different weights in the data (for example, for multi-view data, some view $v _ { y , 1 }$ can consistently have larger $z _ { p }$ comparing to $v _ { y , 2 }$ ). Yet, we shall prove that the order to learn these features by the learner network can still be flipped depending on the randomness of network initialization. ",
+        "bbox": [
+            173,
+            421,
+            826,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Interpretation of our data distribution. As we argue more in the full paper, our setting can be tied to a down-sized version of convolutional networks applied to image classification data. With a small kernel size, good features in an image typically appear only at a few patches, and most other patches are random noise or low-magnitude feature noises. More importantly, our noise parameters shall ensure that, the concept class is not learnable by linear classifiers or constant degree polynomials. We believe a (convolutional) neural network with ReLU-like activation is somewhat necessary. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our final data distribution $\\mathcal { D }$ , and the training data set $\\mathcal { Z }$ are formally given as follows. ",
+        "bbox": [
+            173,
+            609,
+            740,
+            626
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.3 ( $\\mathcal { D }$ and $\\mathcal { Z }$ ). The distribution $\\mathcal { D }$ consists of data from $\\mathcal { D } _ { m }$ w.p. $1 - \\mu$ and from $\\mathcal { D } _ { s }$ w.p. $\\mu$ . We are given $N$ training samples from $\\mathcal { D }$ , and denote the training data set as $\\mathcal { Z } = \\mathcal { Z } _ { m } \\cup \\mathcal { Z } _ { s }$ where ${ \\mathcal { Z } } _ { m }$ and $\\mathcal { Z } _ { s }$ respectively represent multi-view and single-view training data. We write $( X , y ) \\sim { \\mathcal { Z } }$ as $( X , y )$ sampled uniformly at random from the empirical data set, and denote $N _ { s } = | \\mathcal { Z } _ { s } |$ . $W e$ again for simplicity focus on the setting when $\\begin{array} { r } { \\mu = \\frac { \\bar { 1 } } { \\mathsf { p o l y } ( k ) } } \\end{array}$ and we are given samples $N = { \\dot { k } } ^ { 1 . 2 } / \\mu .$ so each label i appears at least $\\widetilde \\Omega ( 1 )$ in $\\mathcal { Z } _ { s }$ . Our result trivially applies to many other choices of $N$ . ",
+        "bbox": [
+            173,
+            630,
+            828,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 LEARNER NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            361,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider a learner network using the following smoothed ReLU activation function $\\widetilde { \\sf R e L U }$ : ",
+        "bbox": [
+            169,
+            760,
+            790,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.4. For integer $q \\geq 2$ and threshold $\\varrho = \\frac { 1 } { \\mathsf { p o l y l o g } ( k ) }$ , the smoothed function $\\widetilde { \\mathsf { R e L U } } ( z ) : = 0$ for $z \\le 0$ ; $\\begin{array} { r } { \\widetilde { \\mathsf { R e L U } } ( z ) : = \\frac { z ^ { q } } { q \\varrho ^ { q - 1 } } } \\end{array}$ for $z \\in [ 0 , \\varrho ]$ ; and $\\begin{array} { r } { \\widetilde { \\mathsf { R e L U } } ( z ) : = z - ( 1 - \\frac { 1 } { q } ) \\varrho } \\end{array}$ for $z \\geq \\varrho$ . ",
+        "bbox": [
+            173,
+            785,
+            826,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since $\\widetilde { \\sf R e L U }$ is smooth we denote its gradient as $\\widetilde { \\mathsf { R e L U } } ^ { \\prime } ( z )$ . We focus on $q = 4$ while our result applies to other constants $q \\geq 3$ (see full version) or most other forms of smoothing. ",
+        "bbox": [
+            173,
+            838,
+            826,
+            871
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The learner network $F ( X ) _ { \\cdot } = ( F _ { 1 } ( X ) , \\dots , F _ { k } ( X ) ) \\in \\mathbb { R } ^ { k }$ is a two-layer convolutional network parameterized by $w _ { i , r } \\in \\mathbb { R } ^ { d }$ for $i \\in [ k ] , r \\in [ m ]$ , satisfying ",
+        "bbox": [
+            171,
+            102,
+            825,
+            133
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/01f3212b1ba15eb6c2f4162f72f7f9adb0c7e0a6b6036d4b35eedab15c1ede6c.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\forall i \\in [ k ] \\colon } & { { } F _ { i } ( X ) = \\sum _ { r \\in [ m ] } \\sum _ { p \\in [ P ] } \\widetilde { \\mathsf { R e L U } } ( \\langle w _ { i , r } , x _ { p } \\rangle ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            137,
+            686,
+            162
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Although there exists network with $m = 2$ that can classify the data correctly (e.g. $w _ { i , r } = v _ { i , r }$ for $r \\in [ 2 ] )$ ), in this paper, for efficient optimization purpose it is convenient to work on a moderate level of over-parameterization: $m \\in [ { \\mathsf { p o l y l o g } } ( k ) , k ]$ . Our lower bounds hold for any $m$ in this range and upper bounds hold even for small over-parameterization $m = { \\mathsf { p o l y l o g } } ( k )$ . ",
+        "bbox": [
+            173,
+            172,
+            825,
+            231
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Training a single model. We learn the concept class (namely, the labeled data distribution) using gradient descent with learning rate $\\eta > 0$ , over the cross-entropy loss function $L$ using $N$ training data points $\\mathcal { Z } = \\{ ( X _ { i } , y _ { i } ) \\} _ { i \\in [ N ] }$ . We denote the empirical loss as: ",
+        "bbox": [
+            173,
+            236,
+            825,
+            280
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f0f250fb77e7de2cc7dd0607bf6a36f70ad342ffc2697548a2cd031691222f3.jpg",
+        "text": "$$\n\\begin{array} { r } { L ( F ) = \\frac { 1 } { N } \\sum _ { i \\in [ N ] } L ( F ; X _ { i } , y _ { i } ) = \\mathbb { E } _ { ( X , y ) \\sim \\mathcal { Z } } [ L ( F ; X , y ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            286,
+            691,
+            306
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { L ( F ; X , y ) = - \\log { \\frac { e ^ { F _ { y } ( X ) } } { \\sum _ { j \\in [ k ] } e ^ { F _ { j } ( X ) } } } } \\end{array}$ g eFy(X)Pj∈[k] eFj (X) . We randomly initialize the network F by letting each $w _ { i , r } ^ { ( 0 ) } \\sim \\mathcal { N } ( 0 , \\sigma _ { 0 } ^ { 2 } I )$ for $\\sigma _ { 0 } ^ { 2 } = 1 / k$ , which is the most standard initialization people use in practice. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To train a single model, at each iteration $t$ we update using gradient descent (GD):9 ",
+        "bbox": [
+            173,
+            366,
+            717,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07a8292b41e33e470fa6c0cc981e4fdd237174e70b7bf71855d6e9b6ea26a581.jpg",
+        "text": "$$\nw _ { i , r } ^ { ( t + 1 ) } \\gets w _ { i , r } ^ { ( t ) } - \\eta \\mathbb { E } _ { ( X , y ) \\sim \\mathcal { Z } } \\nabla _ { w _ { i , r } } L ( F ^ { ( t ) } ; X , y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            387,
+            663,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We run the algorithm for $T = { \\mathsf { p o l y } } ( k ) / \\eta$ iterations. We use $F ^ { ( t ) }$ to denote the model $F$ with hidden weights $\\{ w _ { i , r } ^ { ( t ) } \\}$ at iteration $t$ . ",
+        "bbox": [
+            176,
+            415,
+            825,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Notations. We denote by $\\begin{array} { r } { \\mathbf { l o g i t } _ { i } ( F , X ) : = \\frac { e ^ { F _ { i } ( X ) } } { \\sum _ { j \\in [ k ] } e ^ { F _ { j } ( X ) } } , } \\end{array}$ = eFi(X)Pj∈[k] eFj (X) . Using this, we can write down ",
+        "bbox": [
+            173,
+            457,
+            763,
+            484
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f1e3665ce4930f89fb1397dfd9ddc9f55ad56bbbeae6c08e1ecf276c9b9fddf7.jpg",
+        "text": "$$\n\\forall i \\in [ k ] , r \\in [ m ] \\colon \\quad - \\nabla _ { w _ { i , r } } L ( F ; X , y ) = ( \\mathbb { 1 } _ { i \\neq y } - \\log \\operatorname { i } \\mathbf { t } _ { i } ( F , X ) ) \\nabla _ { w _ { i , r } } F _ { i } ( X ) ~ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            489,
+            769,
+            508
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 MAIN THEOREMS AND EXPLANATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            529,
+            534,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now state the main theorems (and the one for self-distillation is in the full paper).10 ",
+        "bbox": [
+            174,
+            556,
+            743,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (single model). For every sufficiently large $k > 0$ , every $m \\in [ { \\mathsf { p o l y l o g } } ( k ) , k ] ,$ , every $\\eta \\leq$ 1poly(k) , suppose we train a single model using the gradient descent update (3.1) starting from the random initialization defined in Section 3.2, then after T = poly(k) many iterations, with probability $\\geq 1 - e ^ { - \\Omega ( \\log ^ { 2 } k ) }$ , the model $F ^ { ( T ) }$ satisfies: ",
+        "bbox": [
+            174,
+            577,
+            825,
+            647
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• (training is perfect): meaning for all $( X , y ) \\in { \\mathcal { Z } }$ , all $i \\in [ k ] \\setminus \\{ y \\}$ : ${ \\cal F } _ { y } ^ { ( T ) } ( X ) > { \\cal F } _ { i } ^ { ( T ) } ( X ) .$ ",
+        "bbox": [
+            174,
+            652,
+            789,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• (test accuracy is consistently bad): meaning that: ",
+        "bbox": [
+            183,
+            678,
+            522,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5578a44d6a9fbf8e9dc766a49e44318300233b0a5f5b1880b75ce07e96a8691d.jpg",
+        "text": "$$\n{ \\bf P r } _ { ( X , y ) \\sim \\mathcal { D } } [ \\exists i \\in [ k ] \\setminus \\{ y \\} : F _ { y } ^ { ( T ) } ( X ) < F _ { i } ^ { ( T ) } ( X ) ] \\in [ 0 . 4 9 \\mu , 0 . 5 1 \\mu ] \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            696,
+            740,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We shall give technical intuitions about why Theorem 1 holds in the full version. But, at a high-level, we shall construct a “lottery winning” set $\\mathcal { M } \\subseteq [ k ] \\times [ 2 ]$ of cardinality $| \\mathcal { M } | \\in [ k ( 1 - o ( 1 ) ) , k ]$ . It only depends on the random initialization of $F$ . Then, with some effort we can prove that, for every $( i , \\ell ) \\in \\mathcal { M }$ , at the end of the training $F ^ { ( T ) }$ will learn feature $v _ { i , \\ell }$ but not learn feature $v _ { i , 3 - \\ell }$ . This means for those single-view data $( X , y )$ with $y = i$ and ${ \\widehat { \\ell } } ( X ) = 3 - \\ell$ , the final network $F ^ { ( T ) }$ will predict its label wrong. This is why the final test accuracy is around $0 . 5 \\mu$ . ",
+        "bbox": [
+            173,
+            731,
+            825,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Note the property that test accuracy consistently belongs to the range $[ 0 . 4 9 \\mu , 0 . 5 1 \\mu ]$ should be reminiscent of message $\\textcircled{5}$ in Figure 6, where multiple single models, although starting from different random initialization, in practice does have a relatively small variance in test accuracies. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ensemble. Suppose $\\{ F ^ { [ \\ell ] } \\} _ { \\ell \\in [ K ] }$ are $K = \\widetilde \\Omega ( 1 )$ independently trained models of $F$ with $m =$ polylog $( k )$ for $\\begin{array} { r } { T = O \\big ( \\frac { \\mathsf { p o l y } ( k ) } { \\eta } \\big ) } \\end{array}$ iterations (i.e., the same setting as Theorem 1 except we only need a small over-parameterization $m = { \\mathsf { p o l y l o g } } ( k ) .$ ). Let us define their ensemble ",
+        "bbox": [
+            173,
+            101,
+            825,
+            154
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05dfe2916e2ac597cf7bfac6aca7a957c60880ef04130ecf20399290dd5eca63.jpg",
+        "text": "$$\n\\begin{array} { r } { G ( X ) = \\frac { \\widetilde { \\Theta } ( 1 ) } { K } \\sum _ { \\ell } F ^ { [ \\ell ] } ( X ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            159,
+            589,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (ensemble). In the same setting as Theorem $I$ except now we only need a small $m =$ polylog $( k )$ , we have for the ensemble model $G$ in (4.1), with probability at least $1 - e ^ { - \\Omega ( \\log ^ { 2 } k ) }$ : ",
+        "bbox": [
+            173,
+            185,
+            828,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• (training is perfect): meaning for all $( X , y ) \\in { \\mathcal { Z } }$ , for all $i \\in [ k ] \\setminus \\{ y \\}$ : $G _ { y } ( X ) > G _ { i } ( X )$ . ",
+        "bbox": [
+            176,
+            222,
+            784,
+            241
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• (test accuracy is almost perfect): meaning that: ",
+        "bbox": [
+            184,
+            244,
+            509,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b339ba3ff217bf980502d2289c4000d658a5d12960e63510550aa1560bf93673.jpg",
+        "text": "$$\n{ \\bf P r } _ { ( X , y ) \\sim { \\mathcal D } } [ \\exists i \\in [ k ] \\setminus \\{ y \\} : G _ { y } ( X ) < G _ { i } ( X ) ] \\le 0 . 0 0 1 \\mu ~ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            263,
+            704,
+            282
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As we discussed in Section 2.3, the reason Theorem 2 holds attributes to the fact that those lottery winning sets $\\mathcal { M }$ depend on the random initialization of the networks; and therefore, when multiple models are put together, their “union” of $\\mathcal { M }$ shall cover all possible features $\\{ v _ { i , \\ell } \\} _ { ( i , \\ell ) \\in [ k ] \\times [ 2 ] }$ . Moreover, our theorem only requires individual $K = \\widetilde \\Omega ( 1 )$ models for ensemble, which is indeed “averaging the output of a few independently trained models”. ",
+        "bbox": [
+            173,
+            292,
+            826,
+            368
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.1 KNOWLEDGE DISTILLATION FOR ENSEMBLE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            380,
+            527,
+            395
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We consider a knowledge distillation algorithm given the existing ensemble model $G$ (see (4.1)) as follows. For every label $i \\in [ k ]$ , let us define the truncated scaled logit as (for $\\begin{array} { r } { \\tau = \\frac { 1 } { \\log ^ { 2 } k } ) } \\end{array}$ ",
+        "bbox": [
+            171,
+            404,
+            823,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84041ced75d779ee2eeb7b069b1262bc32e0936fcd35c5e7363ad383d4db3106.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { l o g i t } _ { i } ^ { \\tau } ( F , X ) = \\frac { e ^ { \\operatorname* { m i n } \\{ \\tau ^ { 2 } F _ { i } ( X ) , 1 \\} / \\tau } } { \\sum _ { j \\in [ k ] } e ^ { \\operatorname* { m i n } \\{ \\tau ^ { 2 } F _ { j } ( X ) , 1 \\} / \\tau } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            440,
+            632,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(This should be reminiscent of the logit function with temperature used by the original knowledge distillation work (Hinton et al., 2015); we use truncation instead which is easier to analyze.) ",
+        "bbox": [
+            171,
+            476,
+            823,
+            505
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Now, we train a new network $F$ from random initialization (where the randomness is independent of all of those used in $F ^ { [ \\ell ] }$ ). At every iteration $t$ , we update each weight $w _ { i , r }$ by: ",
+        "bbox": [
+            173,
+            511,
+            825,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9298e622309a14fc42b930be6a78e1a5b0fc958595896551628484acb6ae83a.jpg",
+        "text": "$$\n\\begin{array} { r } { v _ { i , r } ^ { ( t + 1 ) } = w _ { i , r } ^ { ( t ) } - \\eta \\nabla _ { w _ { i , r } } L ( F ^ { ( t ) } ) - \\eta ^ { \\prime } \\mathbb { E } _ { ( X , y ) \\sim \\mathcal { Z } } \\left[ \\left( \\mathbf { l o g } \\mathbf { i t } _ { i } ^ { \\tau } ( F ^ { ( t ) } , X ) - \\mathbf { l o g } \\mathbf { i t } _ { i } ^ { \\tau } ( G , X ) \\right) ^ { - } \\nabla _ { w _ { i , r } } F _ { i } ^ { ( t ) } ( X - Y ) \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            546,
+            839,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Notation. Throughout the paper we denote by $[ a ] ^ { + } = \\operatorname* { m a x } \\{ 0 , a \\}$ and $[ a ] ^ { - } = \\operatorname* { m i n } \\{ 0 , a \\}$ . ",
+        "bbox": [
+            171,
+            599,
+            766,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This knowledge distillation method (4.3) is almost identical to the one used in the original work (Hinton et al., 2015), except we use a truncation during the training to make it more (theoretically) stable. Moreover, we update the distillation objective using a larger learning rate $\\eta ^ { \\prime }$ comparing to $\\eta$ of the cross-entropy objective. This is also consistent with the training schedule used in (Hinton et al., 2015). ",
+        "bbox": [
+            173,
+            622,
+            825,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Let $F ^ { ( t ) }$ be the resulting network obtained by (4.3) at iteration $t$ . We have the following theorem: ",
+        "bbox": [
+            169,
+            699,
+            808,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (ensemble distillation). Consider the distillation algorithm (4.3) in which $G$ is the ensemble model defined in (4.1). For every k > 0, for m = polylog(k), for every η ≤ 1poly(k) , setting η′ = ηpoly(k), after T = poly(k) many iterations with probability at least $1 - e ^ { - \\Omega ( \\log ^ { 2 } k ) }$ , for at least $90 \\%$ of the iterations $t \\leq \\dot { T }$ : ",
+        "bbox": [
+            173,
+            718,
+            825,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• (test accuracy is almost perfect): meaning that: ",
+        "bbox": [
+            184,
+            815,
+            509,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1356c15b693b3f8d7444fd81daa451aca7f296d56e67c579a634ff6d343fb520.jpg",
+        "text": "$$\n\\operatorname { \\bf P r } _ { ( X , y ) \\sim \\mathcal { D } } [ \\exists i \\in [ k ] \\setminus \\{ y \\} : F _ { y } ^ { ( t ) } ( X ) < F _ { i } ^ { ( t ) } ( X ) ] \\le 0 . 0 0 1 \\mu .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            834,
+            702,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Remark. Theorem 3 necessarily means that the distilled model $F$ has learned all the features $\\underline { { \\{ v _ { i , \\ell } \\} } } _ { ( i , \\ell ) \\in \\lbrack k \\rbrack \\times \\lbrack 2 \\rbrack }$ from the ensemble model $G$ . This is consistent with our empirical findings in Figure 8: if one trains multiple individual models using knowledge distillation with different random seeds, then their ensemble gives no further performance boost. ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nMonther Alhamdoosh and Dianhui Wang. Fast decorrelated neural network ensembles with random weights. Information Sciences, 264:104–117, 2014.   \nZeyuan Allen-Zhu and Yuanzhi Li. What Can ResNet Learn Efficiently, Going Beyond Kernels? In NeurIPS, 2019a. Full version available at http://arxiv.org/abs/1905.10337.   \nZeyuan Allen-Zhu and Yuanzhi Li. Can SGD Learn Recurrent Neural Networks with Provable Generalization? In NeurIPS, 2019b. Full version available at http://arxiv.org/abs/ 1902.01028.   \nZeyuan Allen-Zhu and Yuanzhi Li. Backward feature correction: How deep learning performs deep learning. arXiv preprint arXiv:2001.04413, 2020.   \nZeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. On the convergence rate of training recurrent neural networks. In NeurIPS, 2019a. Full version available at http://arxiv.org/abs/1810. 12065.   \nZeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. A convergence theory for deep learning via overparameterization. In ICML, 2019b. Full version available at http://arxiv.org/abs/ 1811.03962.   \nJose M Alvarez, Yann LeCun, Theo Gevers, and Antonio M Lopez. Semantic road segmentation via multi-scale ensembles of learned features. In European Conference on Computer Vision, pp. 586–595. Springer, 2012.   \nSanjeev Arora, Simon S Du, Wei Hu, Zhiyuan Li, Ruslan Salakhutdinov, and Ruosong Wang. On exact computation with an infinitely wide neural net. arXiv preprint arXiv:1904.11955, 2019a.   \nSanjeev Arora, Simon S. Du, Wei Hu, Zhiyuan Li, and Ruosong Wang. Fine-grained analysis of optimization and generalization for overparameterized two-layer neural networks. CoRR, abs/1901.08584, 2019b. URL http://arxiv.org/abs/1901.08584.   \nVeronica Bol ´ on-Canedo and Amparo Alonso-Betanzos. Ensembles for feature selection: A review ´ and future trends. Information Fusion, 52:1–12, 2019.   \nLeo Breiman. Bagging predictors. Machine learning, 24(2):123–140, 1996.   \nGavin Brown, Jeremy Wyatt, Rachel Harris, and Xin Yao. Diversity creation methods: a survey and categorisation. Information Fusion, 6(1):5–20, 2005a.   \nGavin Brown, Jeremy L Wyatt, and Peter Tino. Managing diversity in regression ensembles. ˇ Journal of machine learning research, 6(Sep):1621–1650, 2005b.   \nRobert Bryll, Ricardo Gutierrez-Osuna, and Francis Quek. Attribute bagging: improving accuracy of classifier ensembles by using random feature subsets. Pattern recognition, 36(6):1291–1302, 2003.   \nJie Cai, Jiawei Luo, Shulin Wang, and Sheng Yang. Feature selection in machine learning: A new perspective. Neurocomputing, 300:70–79, 2018.   \nYuan Cao and Quanquan Gu. Generalization bounds of stochastic gradient descent for wide and deep neural networks. In Advances in Neural Information Processing Systems, pp. 10835–10845, 2019.   \nVictor Chernozhukov, Denis Chetverikov, and Kengo Kato. Comparison and anti-concentration bounds for maxima of gaussian random vectors. Probability Theory and Related Fields, 162(1): 47–70, 2015.   \nAmit Daniely. Sgd learns the conjugate kernel class of the network. In Advances in Neural Information Processing Systems, pp. 2422–2430, 2017.   \nAmit Daniely, Roy Frostig, and Yoram Singer. Toward deeper understanding of neural networks: The power of initialization and a dual view on expressivity. In Advances in Neural Information Processing Systems (NIPS), pp. 2253–2261, 2016.   \nThomas G Dietterich. Ensemble methods in machine learning. In International workshop on multiple classifier systems, pp. 1–15. Springer, 2000.   \nSimon S Du, Jason D Lee, Haochuan Li, Liwei Wang, and Xiyu Zhai. Gradient descent finds global minima of deep neural networks. arXiv preprint arXiv:1811.03804, November 2018a.   \nSimon S Du, Xiyu Zhai, Barnabas Poczos, and Aarti Singh. Gradient descent provably optimizes over-parameterized neural networks. arXiv preprint arXiv:1810.02054, 2018b.   \nDavid A Freedman et al. Bootstrapping regression models. The Annals of Statistics, 9(6):1218– 1228, 1981.   \nYoav Freund and Robert E Schapire. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of computer and system sciences, 55(1):119–139, 1997.   \nYoav Freund, Robert Schapire, and Naoki Abe. A short introduction to boosting. Journal-Japanese Society For Artificial Intelligence, 14(771-780):1612, 1999.   \nJerome Friedman, Trevor Hastie, Robert Tibshirani, et al. Additive logistic regression: a statistical view of boosting (with discussion and a rejoinder by the authors). The annals of statistics, 28(2): 337–407, 2000.   \nJerome H Friedman. Greedy function approximation: a gradient boosting machine. Annals of statistics, pp. 1189–1232, 2001.   \nTommaso Furlanello, Zachary C Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. arXiv preprint arXiv:1805.04770, 2018.   \nMikel Galar, Alberto Fernandez, Edurne Barrenechea, Humberto Bustince, and Francisco Herrera. A review on ensembles for the class imbalance problem: bagging-, boosting-, and hybrid-based approaches. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 42(4):463–484, 2011.   \nBehrooz Ghorbani, Song Mei, Theodor Misiakiewicz, and Andrea Montanari. Linearized two-layers neural networks in high dimension. arXiv preprint arXiv:1904.12191, 2019.   \nBoris Hanin and Mihai Nica. Finite depth and width corrections to the neural tangent kernel. arXiv preprint arXiv:1909.05989, 2019.   \nLars Kai Hansen and Peter Salamon. Neural network ensembles. IEEE transactions on pattern analysis and machine intelligence, 12(10):993–1001, 1990.   \nGeoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.   \nTin Kam Ho. The random subspace method for constructing decision forests. IEEE transactions on pattern analysis and machine intelligence, 20(8):832–844, 1998.   \nArthur Jacot, Franck Gabriel, and Clement Hongler. Neural tangent kernel: Convergence and gen- ´ eralization in neural networks. In Advances in neural information processing systems, pp. 8571– 8580, 2018.   \nKenji Kawaguchi. Deep learning without poor local minima. In Advances in Neural Information Processing Systems, pp. 586–594, 2016.   \nJosef Kittler, Mohamad Hatef, Robert PW Duin, and Jiri Matas. On combining classifiers. IEEE transactions on pattern analysis and machine intelligence, 20(3):226–239, 1998.   \nRon Kohavi, George H John, et al. Wrappers for feature subset selection. Artificial intelligence, 97 (1-2):273–324, 1997.   \nJ Zico Kolter and Marcus A Maloof. Dynamic weighted majority: An ensemble method for drifting concepts. Journal of Machine Learning Research, 8(Dec):2755–2790, 2007.   \nAlex Krizhevsky. Learning multiple layers of features from tiny images. 2009.   \nLudmila I Kuncheva. Combining pattern classifiers: methods and algorithms. John Wiley & Sons, 2014.   \nYuanzhi Li and Yingyu Liang. Learning overparameterized neural networks via stochastic gradient descent on structured data. In Advances in Neural Information Processing Systems, 2018.   \nYuanzhi Li, Colin Wei, and Tengyu Ma. Towards explaining the regularization effect of initial large learning rate in training neural networks. arXiv preprint arXiv:1907.04595, 2019.   \nPankaj Mehta, Marin Bukov, Ching-Hao Wang, Alexandre GR Day, Clint Richardson, Charles K Fisher, and David J Schwab. A high-bias, low-variance introduction to machine learning for physicists. Physics reports, 810:1–124, 2019.   \nHossein Mobahi, Mehrdad Farajtabar, and Peter L Bartlett. Self-distillation amplifies regularization in hilbert space. arXiv preprint arXiv:2002.05715, 2020.   \nM Arthur Munson and Rich Caruana. On feature selection, bias-variance, and bagging. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 144– 159. Springer, 2009.   \nChris Olah, Alexander Mordvintsev, and Ludwig Schubert. Feature visualization. Distill, 2(11):e7, 2017. doi: 10.23915/distill.00007. https://distill.pub/2017/feature-visualization.   \nLuiz S Oliveira, Robert Sabourin, Flavio Bortolozzi, and Ching Y Suen. Feature selection for ´ ensembles: A hierarchical multi-objective genetic algorithm approach. In Seventh International Conference on Document Analysis and Recognition, 2003. Proceedings., pp. 676–680. Citeseer, 2003.   \nDavid W Opitz. Feature selection for ensembles. In AAAI, pp. 379–384, 1999.   \nRobi Polikar. Ensemble based systems in decision making. IEEE Circuits and systems magazine, 6 (3):21–45, 2006.   \nJuan Jose Rodriguez, Ludmila I Kuncheva, and Carlos J Alonso. Rotation forest: A new classifier ´ ensemble method. IEEE transactions on pattern analysis and machine intelligence, 28(10):1619– 1630, 2006.   \nLior Rokach. Pattern classification using ensemble methods, volume 75. World Scientific, 2010.   \nLior Rokach and Oded Z Maimon. Data mining with decision trees: theory and applications, volume 69. World scientific, 2008.   \nRobert E Schapire, Yoav Freund, Peter Bartlett, Wee Sun Lee, et al. Boosting the margin: A new explanation for the effectiveness of voting methods. The annals of statistics, 26(5):1651–1686, 1998.   \nVaishaal Shankar, Alex Fang, Wenshuo Guo, Sara Fridovich-Keil, Ludwig Schmidt, Jonathan Ragan-Kelley, and Benjamin Recht. Neural kernels without tangents. arXiv preprint arXiv:2003.02237, 2020.   \nDaniel Soudry and Yair Carmon. No bad local minima: Data independent training error guarantees for multilayer neural networks. arXiv preprint arXiv:1605.08361, 2016.   \nAlexey Tsymbal, Mykola Pechenizkiy, and Padraig Cunningham. Diversity in search strategies for ´ ensemble feature selection. Information fusion, 6(1):83–98, 2005.   \nGiorgio Valentini. An experimental bias-variance analysis of svm ensembles based on resampling techniques. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 35(6): 1252–1271, 2005.   \nGiorgio Valentini and Thomas G Dietterich. Bias-variance analysis of support vector machines for the development of svm-based ensemble methods. Journal of Machine Learning Research, 5(Jul): 725–775, 2004.   \nBo Xie, Yingyu Liang, and Le Song. Diversity leads to generalization in neural networks. arXiv preprint Arxiv:1611.03131, 2016.   \nGreg Yang. Scaling limits of wide neural networks with weight sharing: Gaussian process behavior, gradient independence, and neural tangent kernel derivation. arXiv preprint arXiv:1902.04760, 2019.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   \nLinfeng Zhang, Jiebo Song, Anni Gao, Jingwei Chen, Chenglong Bao, and Kaisheng Ma. Be your own teacher: Improve the performance of convolutional neural networks via self distillation. In ICCV, pp. 3713–3722, 2019.   \nDifan Zou, Yuan Cao, Dongruo Zhou, and Quanquan Gu. Stochastic gradient descent optimizes over-parameterized deep relu networks. arXiv preprint arXiv:1811.08888, 2018. ",
+        "bbox": [
+            171,
+            99,
+            826,
+            897
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            73,
+            826,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            63,
+            828,
+            815
+        ],
+        "page_idx": 11
+    }
+]