Add files using upload-large-folder tool

parse/train/BkMiWhR5K7/BkMiWhR5K7.md

@@ -0,0 +1,605 @@
+# PRIOR CONVICTIONS: BLACK-BOX ADVERSARIAL ATTACKS WITH BANDITS AND PRIORS
+
+Andrew Ilyas∗, Logan Engstrom∗, Aleksander M ˛adry {ailyas, engstrom, madry}@mit.edu MIT CSAIL
+
+# ABSTRACT
+
+We study the problem of generating adversarial examples in a black-box setting in which only loss-oracle access to a model is available. We introduce a framework that conceptually unifies much of the existing work on black-box attacks, and we demonstrate that the current state-of-the-art methods are optimal in a natural sense. Despite this optimality, we show how to improve black-box attacks by bringing a new element into the problem: gradient priors. We give a bandit optimization-based algorithm that allows us to seamlessly integrate any such priors, and we explicitly identify and incorporate two examples. The resulting methods use two to four times fewer queries and fail two to five times less than the current state-of-the-art. 1
+
+# 1 INTRODUCTION
+
+Recent research has shown that neural networks exhibit significant vulnerability to adversarial examples, or slightly perturbed inputs designed to fool the network prediction. This vulnerability is present in a wide range of settings, from situations in which inputs are fed directly to classifiers (Szegedy et al., 2013; Carlini et al., 2016) to highly variable real-world environments (Kurakin et al., 2016; Athalye et al., 2017). Researchers have developed a host of methods to construct such attacks (Goodfellow et al., 2014; Moosavi-Dezfooli et al., 2015; Carlini & Wagner, 2017; Madry et al., 2017), most of which correspond to first order (i.e., gradient based) methods. These attacks turn out to be highly effective: in many cases, only a few gradient steps suffice to construct an adversarial perturbation.
+
+A significant shortcoming of many of these attacks, however, is that they fundamentally rely on the white-box threat model. That is, they crucially require direct access to the gradient of the classification loss of the attacked network. In many real-world situations, expecting this kind of complete access is not realistic. In such settings, an attacker can only issue classification queries to the targeted network, which corresponds to a more restrictive black box threat model.
+
+Recent work (Chen et al., 2017; Bhagoji et al., 2017; Ilyas et al., 2017) provides a number of attacks for this threat model. Chen et al. (2017) show how to use a basic primitive of zeroth order optimization, the finite difference method, to estimate the gradient from classification queries and then use it (in addition to a number of optimizations) to mount a gradient based attack. The method indeed successfully constructs adversarial perturbations. It comes, however, at the cost of introducing a significant overhead in terms of the number of queries needed. For instance, attacking an ImageNet (Russakovsky et al., 2015) classifier requires hundreds of thousands of queries. Subsequent work (Ilyas et al., 2017) improves this dependence significantly, but still falls short of fully mitigating this issue (see Section 4.1 for a more detailed analysis).
+
+# 1.1 OUR CONTRIBUTIONS
+
+We revisit zeroth-order optimization in the context of adversarial example generation, both from an empirical and theoretical perspective. We propose a new approach for generating black-box adversarial examples, using bandit optimization in order to exploit prior information about the gradient, which we show is necessary to break through the optimality of current methods. We evaluate our approach on the task of generating black-box adversarial examples, where the methods obtained from integrating two example priors significantly outperform state-of-the-art approaches.
+
+Concretely, in this work:
+
+1. We formalize the gradient estimation problem as the central problem in the context of query-efficient black-box attacks. We then show how the resulting framework unifies the previous attack methodology. We prove that the least squares method, a classic primitive in signal processing, not only constitutes an optimal solution to the general gradient estimation problem but also is essentially equivalent to the current-best black-box attack methods.   
+2. We demonstrate that, despite this seeming optimality of these methods, we can still improve upon them by exploiting an aspect of the problem that has been not considered previously: the priors we have on the distribution of the gradient. We identify two example classes of such priors, and show that they indeed lead to better predictors of the gradient.   
+3. Finally, we develop a bandit optimization framework for generating black-box adversarial examples which allows for the seamless integration of priors. To demonstrate its effectiveness, we show that leveraging the two aforementioned priors yields black-box attacks that are 2-5 times more query efficient and less failure-prone than the state of the art.
+
+Table 1: Summary of effectiveness of $\ell _ { 2 }$ and $\ell _ { \infty }$ ImageNet attacks on Inception v3 using NES, bandits with time prior (BanditsT ), and bandits with time and data-dependent priors (Bandits $_ { T D }$ ). Note that in the first column, the average number of queries is calculated only over successful attacks, and we enforce a query limit of 10,000 queries. For purposes of direct comparison, the last column calculates the average number of queries used for only the images that NES (previous SOTA) was successful on. Our most powerful attack uses 2-4 times fewer queries, and fails 2-5 times less often.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">Avg. Queries</td><td colspan="2">Failure Rate</td><td colspan="2">Queries on NES Success</td></tr><tr><td>l8</td><td>l2</td><td>l8</td><td>l2</td><td>l8</td><td>l2</td></tr><tr><td>NES</td><td>1735</td><td>2938</td><td>22.2%</td><td>34.4%</td><td>1735</td><td>2938</td></tr><tr><td>BanditsT</td><td>1781</td><td>2690</td><td>11.6%</td><td>30.4%</td><td>1214</td><td>2421</td></tr><tr><td>BanditsTD</td><td>1117</td><td>1858</td><td>4.6%</td><td>15.5%</td><td>703</td><td>999</td></tr></table>
+
+# 2 BLACK-BOX ATTACKS AND THE GRADIENT ESTIMATION PROBLEM
+
+Adversarial examples are natural inputs to a machine learning system that have been carefully perturbed in order to induce misbehaviour of the system, under a constraint on the magnitude of the pertubation (under some metric). For image classifiers, this misbehaviour can be either classification as a specific class other than the original one (the targeted attack) or misclassification (the untargeted attack). For simplicity and to make the presentation of the overarching framework focused, in this paper we restrict our attention to the untargeted case. Both our algorithms and the whole framework can be, however, easily adapted to the targeted setting. Also, we consider the most standard threat model in which adversarial perturbations must have $\ell _ { p }$ -norm, for some fixed $p$ , less than some $\epsilon _ { p }$ .
+
+# 2.1 FIRST-ORDER ADVERSARIAL ATTACKS
+
+Suppose that we have some classifier $C ( x )$ with a corresponding classification loss function $L ( x , y )$ , where $x$ is some input and $y$ its corresponding label. In order to generate a misclassified input from some input-label pair $( x , y )$ , we want to find an adversarial example $x ^ { \prime }$ which maximizes $L ( x ^ { \prime } , y )$ but still remains $\epsilon _ { p }$ -close to the original input. We can thus formulate our adversarial attack problem as the following constrained optimization task:
+
+$$
+x ^ { \prime } = \underset { x ^ { \prime } : \| x ^ { \prime } - x \| _ { p } \leq \epsilon _ { p } } { \arg \operatorname* { m a x } } L ( x ^ { \prime } , y )
+$$
+
+First order methods tend to be very successful at solving the problem despite its non-convexity (Goodfellow et al., 2014; Carlini & Wagner, 2017; Madry et al., 2017). A first order method used as the backbone of some of the most powerful white-box adversarial attacks for $\ell _ { p }$ bounded adversaries is
+
+projected gradient descent $( P G D )$ . This iterative method, given some input $x$ and its correct label $y$ , computes a perturbed input $x _ { k }$ by applying $k$ steps of the following update (with $x _ { 0 } = x $ )
+
+$$
+\begin{array} { r } { x _ { l } = \Pi _ { B _ { p } ( x , \epsilon ) } ( x _ { l - 1 } + \eta s _ { l } ) \qquad \mathrm { w i t h } \ s _ { l } = \Pi _ { \partial B _ { p } ( 0 , 1 ) } \nabla _ { x } L ( x _ { l - 1 } , y ) } \end{array}
+$$
+
+Here, $\Pi _ { S }$ is the projection onto the set $S$ , $B _ { p } ( x ^ { \prime } , \varepsilon ^ { \prime } )$ is the $\ell _ { p }$ ball of radius $\varepsilon ^ { \prime }$ around $x ^ { \prime }$ , $\eta$ is the step size, and $\partial U$ is the boundary of a set $U$ . Also, as is standard in continuous optimization, we make $s _ { l }$ be the projection of the gradient $\nabla _ { x } L ( x _ { l - 1 } , y )$ at $x _ { l - 1 }$ onto the unit $\ell _ { p }$ ball. This way we ensure that $s _ { l }$ corresponds to the unit $\ell _ { p }$ -norm vector that has the largest inner product with $\nabla _ { x } L ( x _ { l - 1 } , y )$ . (Note that, in the case of the $\ell _ { 2 }$ -norm, $s _ { l }$ is simply the normalized gradient but in the case of, e.g., the $\ell _ { \infty }$ -norm, $s _ { l }$ corresponds to the sign vector, $\operatorname { s g n } \left( \nabla _ { \boldsymbol { x } } L ( x _ { l - 1 } , y ) \right)$ of the gradient.)
+
+So, intuitively, the PGD update perturbs the input in the direction that (locally) increases the loss the most. Observe that due to the projection in (1), $x _ { k }$ is always a valid perturbation of $x$ , as desired.
+
+# 2.2 BLACK-BOX ADVERSARIAL ATTACKS
+
+The projected gradient descent (PGD) method described above is designed to be used in the context of so-called white-box attacks. That is, in the setting where the adversary has full access to the gradient $\nabla _ { x } L ( x , y )$ of the loss function of the attacked model. In many practical scenarios, however, this kind of access is not available—in the corresponding, more realistic black-box setting, the adversary has only access to an oracle that returns for a given input $( x , y )$ , only the value of the loss $L ( x , y )$ .
+
+One might expect that PGD is thus not useful in such black-box setting. It turns out, however, that this intuition is incorrect. Specifically, one can still estimate the gradient using only such value queries. (In fact, this kind of estimator is the backbone of so-called zeroth-order optimization frameworks (Spall, 2005).) The most canonical primitive in this context is the finite difference method. This method estimates the directional derivative $D _ { v } f ( x ) = \langle \nabla _ { x } f ( x ) , v \rangle$ of some function $f$ at a point $x$ in the direction of a vector $v$ as
+
+$$
+D _ { v } f ( x ) = \langle \nabla _ { x } f ( x ) , v \rangle \approx \left( f ( x + \delta v ) - f ( x ) \right) / \delta .
+$$
+
+Here, the step size $\delta > 0$ governs the quality of the gradient estimate. Smaller $\delta$ gives more accurate estimates but also decreases reliability, due to precision and noise issues. Consequently, in practice, $\delta$ is a tunable parameter. Now, we can just use finite differences to construct an estimate of the gradient. To this end, one can find the $d$ components of the gradient by estimating the inner products of the gradient with all the standard basis vectors $e _ { 1 } , \ldots , e _ { d }$ :
+
+$$
+\widehat { \nabla } _ { x } L ( x , y ) = \sum _ { k = 1 } ^ { d } e _ { k } \left( L ( x + \delta e _ { k } , y ) - L ( x , y ) \right) / \delta \approx \sum _ { k = 1 } ^ { d } e _ { k } \langle \nabla _ { x } L ( x , y ) , e _ { k } \rangle
+$$
+
+We can then easily implement the PGD attack (c.f. (1)) using this estimator:
+
+$$
+\begin{array} { r } { x _ { l } = \Pi _ { B _ { p } ( x , \epsilon ) } ( x _ { l - 1 } + \eta \widehat { s _ { l } } ) \qquad \mathrm { w i t h } \quad \widehat { s } _ { l } = \Pi _ { \partial B _ { p } ( 0 , 1 ) } \widehat { \nabla } _ { x } L ( x _ { l - 1 } , y ) } \end{array}
+$$
+
+Indeed, Chen et al. (2017) were the first to use finite differences methods in this basic form to power PGD–based adversarial attack in the black-box setting. This basic attack was shown to be successful but, since its query complexity is proportional to the dimension, its resulting query complexity was prohibitively large. For example, the Inception v3 (Szegedy et al., 2015) classifier on the ImageNet dataset has dimensionality $\mathtt { d } = 2 6 8 , 2 0 3$ and thus this method would require 268,204 queries. (It is worth noting, however, that Chen et al. (2017) developed additional methods to, at least partially, reduce this query complexity.)
+
+# 2.3 BLACK-BOX ATTACKS WITH IMPERFECT GRADIENT ESTIMATORS
+
+In the light of the above discussion, one can wonder if the algorithm (4) can be made more queryefficient. A natural idea here would be to avoid fully estimating the gradient and rely instead only on its imperfect estimators. This gives rise to the following question: How accurate of an gradient estimate is necessary to execute a successful PGD attack?
+
+We examine this question first in the simplest possible setting: one in which we only take a single PGD step (i.e., the case of $k = 1$ ). Previous work (Goodfellow et al., 2014) indicates that such an attack can already be quite powerful. So, we study how the effectiveness of this attack varies with gradient estimator accuracy. Our experiments, shown in Figure 1, suggest that it is feasible to generate adversarial examples without estimating correctly even most of the coordinates of the gradient. For example, in the context of $\ell _ { \infty }$ attacks, setting a randomly selected $20 \%$ of the coordinates in the gradient to match the true gradient (and making the remaining coordinates have random sign) is sufficient to fool the classifier on more than $60 \%$ images with single-step PGD. Our experiments thus demonstrate that an adversary is likely to be able to cause a misclassification by performing the iterated PGD attack, even when driven by a gradient estimate that is largely imperfect.
+
+![](images/7781c5c74950697a662802f9697348105e386b35d19d1a500bd91931f43e9553.jpg)  
+Figure 1: The fraction of correctly estimated coordinates of $\operatorname { s g n } ( \nabla _ { x } L ( x , y ) )$ required to successfully execute the single-step PGD (also known as FGSM) attack, with $\epsilon = 0 . 0 5$ . In the experiment, for each $k$ , the top $k$ percent – chosen either by magnitude $( \mathrm { t o p - k } )$ or randomly $( \mathtt { r a n d o m - k } )$ ) – of the signs of the coordinates are set correctly, and the rest are set to $+ 1$ or $- 1$ at random. The adversariality rate is the portion of 1,000 random ImageNet images misclassified after one FGSM step. For example, estimating only $20 \%$ of coordinates correctly leads to misclassification for $> 6 0 \%$ of images.
+
+# 2.4 THE GRADIENT ESTIMATION PROBLEM
+
+The above discussion makes it clear that successful attacks do not require a perfect gradient estimation, provided this estimate is suitably constructed. It is still unclear, however, how to efficiently find this kind of imperfect but helpful estimator. Continuous optimization methodology suggests that the key characteristic needed from our estimator is for it to have a sufficiently large inner product with the actual gradient. We thus capture this challenge as the following gradient estimation problem:
+
+Definition 1 (Gradient estimation problem). For an input/label pair $( x , y )$ and a loss function $L _ { i }$ , let $\boldsymbol { g } ^ { * } = \nabla _ { \boldsymbol { x } } L ( \boldsymbol { x } , \boldsymbol { y } )$ be the gradient of $L$ at $( x , y )$ . Then the goal of the gradient estimation problem is to find a unit vector $\widehat g$ maximizing the inner product
+
+$$
+\mathbb { E } \left[ \widehat { \boldsymbol { g } } ^ { T } \boldsymbol { g } ^ { * } \right] ,
+$$
+
+from a limited number of (possibly adaptive) function value queries $L ( x ^ { \prime } , y ^ { \prime } )$ . (The expectation here is taken over the randomness of the estimation algorithm.)
+
+One useful perspective on the above gradient estimation problem stems from casting the recovery of $g ^ { * }$ in (5) as an underdetermined vector estimation task. That is, one can view each execution of the finite difference method (see (2)) as computing an inner product query in which we obtain the value of the inner product of $g ^ { * }$ and some chosen direction vector $A _ { i }$ . Now, if we execute $k$ such queries, and $k < d$ (which is the regime we are interested in), the information acquired in this process can be expressed as the following (underdetermined) linear regression problem $A g ^ { * } = y$ , where the rows of the matrix $A$ correspond to the queries $A _ { 1 } , \ldots , A _ { k }$ and the entries of the vector $y$ gives us the corresponding inner product values.
+
+Relation to compressive sensing. The view of the gradient estimation problem we developed bears striking similarity to the compressive sensing setting (Foucart & Rauhut, 2013). Thus one might wonder if the toolkit of that area could be applied here. Compressive sensing crucially requires, however, certain sparsity structure in the estimated signal (here, in the gradient $g ^ { * }$ ) and, to our knowledge, the loss gradients do not exhibit such a structure. (We discuss this further in Appendix B.)
+
+The least squares method. In light of this, we turn our attention to another classical signal-processing method: norm-minimizing $\ell _ { 2 }$ least squares estimation. This method approaches the estimation problem posed in (5) by casting it as an undetermined linear regression problem of the form $A g ^ { * } = b$ , where we can choose the matrix $A$ (the rows of $A$ correspond to inner product queries with $g ^ { * }$ ). Then, it obtains the solution $\widehat g$ to the regression problem by solving:
+
+$$
+\operatorname* { m i n } _ { \widehat { \boldsymbol { g } } } \| \widehat { \boldsymbol { g } } \| _ { 2 } \qquad \mathrm { s . t . ~ } A \widehat { \boldsymbol { g } } = \boldsymbol { y } .
+$$
+
+A reasonable choice for $A$ (via Johnson & Lindenstrauss (1984) and related results) is the distancepreserving random Gaussian projection matrix, i.e. $A _ { i j }$ normally distributed.
+
+The resulting algorithm turns out to yield solutions that are approximately those given by Natural Evolution Strategies (NES), which (Ilyas et al., 2017) previously applied to black-box attacks. In particular, in Appendix A, we prove the following theorem.
+
+Theorem 1 (NES and Least Squares equivalence). Let $\hat { x } _ { N E S }$ be the Gaussian $k$ -query NES estimator of a $d$ -dimensional gradient $\textbf {  { g } }$ and let $\hat { x } _ { L S Q }$ be the minimal-norm $k$ -query least-squares estimator of $\textbf {  { g } }$ . For any $p > 0$ , with probability at least $1 - p$ we have that
+
+$$
+\begin{array} { r } { \langle \hat { x } _ { L S Q } , \pmb { g } \rangle - \langle \hat { x } _ { N E S } , \pmb { g } \rangle \leq O \left( \sqrt { ( k / d ) \cdot \log ^ { 3 } \left( ( k / p ) \right) } \right) \| \pmb { g } \| ^ { 2 } . } \end{array}
+$$
+
+Note that when we work in the underdetermined setting, i.e., when $k \ll d$ (which is the setting we are interested in), the right hand side bound becomes vanishingly small. Thus, the equivalence indeed holds. In fact, using the precise statement (given and proved in Appendix A), we can show that Theorem 1 provides us with a non-vacuous equivalence bound. Further, it turns out that one can exploit this equivalence to prove that the algorithm proposed in Ilyas et al. (2017) is not only natural but optimal, as the least-squares estimate is an information-theoretically optimal gradient estimate in the regime where $k = d$ , and an error-minimizing estimator in the regime where $k < < d$ .
+
+Theorem 2 (Least-squares optimality (Proof in Appendix A)). For a linear regression problem $y = A g$ with known $A$ and $y$ , unknown $\mathbf { \pmb { g } }$ , and isotropic Gaussian errors, the least-squares estimator is finite-sample efficient, i.e. the minimum-variance unbiased (MVU) estimator of the latent vector $\textbf {  { g } }$
+
+Theorem 3 (Least-squares optimality (Proof in Meir (1994))). In the underdetermined setting, i.e. when $k < < d$ , the minimum-norm least squares estimate (xˆLSQ in Theorem 1) is the minimumvariance (and thus minimum-error, since bias is fixed) estimator with no empirical loss.
+
+# 3 BLACK-BOX ADVERSARIAL ATTACKS WITH PRIORS
+
+The optimality of least squares strongly suggests that we have reached the limit of query-efficiency of black-box adversarial attacks. But is this really the case? Surprisingly, we show that an improvement is still possible. The key observation is that the optimality we established of least-squares (and by Theorem 1, the NES approach in (Ilyas et al., 2017)) holds only for the most basic setting of the gradient estimation problem, a setting where we assume that the target gradient is a truly arbitrary and completely unknown vector.
+
+However, in the context we care about this assumption does not hold – there is actually plenty of prior knowledge about the gradient available. Firstly, the input with respect to which we compute the gradient is not arbitrary and exhibits locally predictable structure which is consequently reflected in the gradient. Secondly, when performing iterative gradient attacks (e.g. PGD), the gradients used in successive iterations are likely to be heavily correlated.
+
+The above observations motivate our focus on prior information as an integral element of the gradient estimation problem. Specifically, we enhance Definition 1 by making its objective
+
+$\mathbb { E } \left[ \widehat { \boldsymbol { g } } ^ { T } \boldsymbol { g } ^ { * } | \boldsymbol { I } \right]$ , where $I$ is prior information available to us.
+
+This change in perspective gives rise to two important questions: does there exist prior information that can be useful to us?, and does there exist an algorithmic way to exploit this information? We show that the answer to both of these questions is affirmative.
+
+# 3.1 GRADIENT PRIORS
+
+Consider a gradient $\nabla _ { x } L ( x , y )$ of the loss function corresponding to some input $( x , y )$ . Does there exist some kind of prior that can be extracted from the dataset $\{ x _ { i } \}$ , in general, and the input $( x , y )$
+
+in particular, that can be used as a predictor of the gradient? We demonstrate that it is indeed the case, and give two example classes of such priors.
+
+Time-dependent priors. The first class of priors we consider are time-dependent priors, a standard example of which is what we refer to as the “multi-step prior.” We find that along the trajectory taken by estimated gradients, successive gradients are in fact heavily correlated. We show this empirically by taking steps along the optimization path generated by running the NES estimator at each point, and plotting the normalized inner product (cosine similarity) between successive gradients, given by
+
+$$
+\begin{array} { r l } { \frac { \langle \nabla _ { x } L ( x _ { t } , y ) , \nabla _ { x } L ( x _ { t + 1 } , y ) \rangle } { | | \nabla _ { x } L ( x _ { t } , y ) | | _ { 2 } | | \nabla _ { x } L ( x _ { t + 1 } , y ) | | _ { 2 } } \quad } & { t \in \{ 1 \ldots T - 1 \} . } \end{array}
+$$
+
+![](images/160a371af5bb1a84c89942353c84dcb61158efe51c2bd7c9953619b37f24e2e0.jpg)  
+Figure 2: Cosine similarity between the gradients at the current and previous steps along the optimization trajectory of NES PGD attacks, averaged over 1000 random ImageNet images.
+
+![](images/50e81a114935c44b9cafffa2e8474f97c1322c0d970b6c0fa8e4e1eefc7e61d5.jpg)  
+Figure 3: Cosine similarity of “tiled” image gradient with original image gradient versus the length of the square tiles, averaged over 5,000 randomly selected ImageNet images.
+
+Figure 2 demonstrates that there indeed is a non-trivial correlation between successive gradients— typically, the gradients of successive steps (using step size from Ilyas et al. (2017)) have a cosine similarity of about 0.9. Successive gradients continue to correlate at higher step sizes: Appendix B shows that the trend continues even at step size 4.0 (a typical value for the total perturbation bound $\varepsilon$ ). This indicates that there indeed is a potential gain from incorporating this correlation into our iterative optimization. To utilize this gain, we intend to use the gradients at time $t - 1$ as a prior for the gradient at time $t$ , where both the prior and the gradient estimate itself evolve over iterations.
+
+Data-dependent priors. We find that the time-dependent prior discussed above is not the only type of prior one can exploit here. Namely, we can also use the structure of the inputs themselves to reduce query complexity (in fact, the existence of such data-dependent priors is what makes machine learning successful in the first place).
+
+In the case of image classification, a simple and heavily exploited example of such a prior stems from the fact that images tend to exhibit a spatially local similarity (i.e. pixels that are close together tend to be similar). We find that this similarity also extends to the gradients: specifically, whenever two coordinates $( i , j )$ and $( k , l )$ of $\nabla _ { x } L ( x , y )$ are close, we expect $\mathsf { \bar { V } } _ { x } L ( x , y ) _ { i j } \approx \nabla _ { x } \bar { L ( x , y ) } _ { k l }$ too. To corroborate and quantify this phenomenon, we compare $\nabla _ { x } L ( x , y )$ with an average-pooled, or “tiled”, version (with “tile length” $k$ ) of the same signal. An example of such an average-blurred gradient can be seen in Appendix B. More concretely, we apply to the gradient the mean pooling operation with kernel size $( k , k , 1 )$ and stride $( k , k , 1 )$ , then upscale the spatial dimensions by $k$ . We then measure the cosine similarity between the average-blurred gradient and the gradient itself. Our results, shown in Figure 3, demonstrate that the gradients of images are locally similar enough to allow for average-blurred gradients to maintain relatively high cosine similarity with the actual gradients, even when the tiles are large. Our results suggest that we can reduce the dimensionality of our problem by a factor of $k ^ { 2 }$ (for reasonably large $k$ ) and still estimate a vector pointing close to the same direction as the original gradient. This factor, as we show later, leads to significantly improved black-box adversarial attack performance.
+
+# 3.2 A FRAMEWORK FOR GRADIENT ESTIMATION WITH PRIORS
+
+Given the availability of these informative gradient priors, we now need a framework that enables us to easily incorporate these priors into our construction of black-box adversarial attacks. Our proposed method builds on the framework of bandit optimization, a fundamental tool in online convex optimization Hazan (2016). In the bandit optimization framework, an agent plays a game that consists of a sequence of rounds. In round $t$ , the agent must choose a valid action, and then by playing the action incurs a loss given by a loss function $\ell _ { t } ( \cdot )$ that is unknown to the agent. After playing the action, he/she only learns the loss that the chosen action incurs; the loss function is specific to the round $t$ and may change arbitrarily between rounds. The goal of the agent is to minimize the average loss incurred over all rounds, and the success of the agent is usually quantified by comparing the total loss incurred to that of the best expert in hindsight (the best single-action policy). By the nature of this formulation, the rounds of this game can not be treated as independent — to perform well, the agent needs to keep track of some latent record that aggregates information learned over a sequence of rounds. This latent record usually takes a form of a vector $v _ { t }$ that is constrained to a specified (convex) set $\kappa$ . As we will see, this aspect of the bandit optimization framework will provide us with a convenient way to incorporate prior information into our gradient prediction.
+
+An overview of gradient estimation with bandits. We can cast the gradient estimation problem as an bandit optimization problem in a fairly direct manner. Specifically, we let the action at each round $t$ be a gradient estimate $g _ { t }$ (based on our latent vector $v _ { t }$ ), and the loss $\ell _ { t }$ correspond to the (negative) inner product between this prediction and the actual gradient. Note that we will never have a direct access to this loss function $\ell _ { t }$ but we are able to evaluate its value on a particular prediction vector $g _ { t }$ via the finite differences method (2) (which is all that the bandits optimization framework requires us to be able to do).
+
+Just as this choice of the loss function $\ell _ { t }$ allows us to quantify performance on the gradient estimation problem, the latent vector $v _ { t }$ will allow us to algorithmically incorporate prior information into our predictions. Looking at the two example priors we consider, the time-dependent prior will be reflected by carrying over the latent vector between the gradient estimations at different points. Data-dependent priors will be captured by enforcing that our latent vector has a particular structure. For the specific prior we quantify in the preceding section (data-dependent prior for images), we will simply reduce the dimensionality of the latent vector via average-pooling (“tiling“), removing the need for extra queries to discern components of the gradient that are spatially close.
+
+# 3.3 IMPLEMENTING GRADIENT ESTIMATION IN THE BANDIT FRAMEWORK
+
+We now describe our bandit framework for adversarial example generation in more detail. Note that the algorithm is general and can be used to construct black-box adversarial examples where the perturbation is constrained to any convex set $\ell _ { p }$ -norm constraints being a special case). We discuss the algorithm in its general form, and then provide versions explicitly applied to the $\ell _ { 2 }$ and $\ell _ { \infty }$ cases.
+
+As previously mentioned, the latent vector $v _ { t } \in \mathcal { K }$ serves as a prior on the gradient for the corresponding round $t - \mathrm { i n }$ fact, we make our prediction $g _ { t }$ be exactly $v _ { t }$ projected onto the appropriate space, and thus we set $\kappa$ to be an extension of the space of valid adversarial perturbations (e.g. $\mathbb { R } ^ { n }$ for $\ell _ { 2 }$ examples, $[ - 1 , 1 ] ^ { n }$ for $\ell _ { \infty }$ examples). Our loss function $\ell _ { t }$ is defined as
+
+$$
+\ell _ { t } ( g ) = - \langle \nabla L ( x , y ) , \frac { g } { | | g | | } \rangle ,
+$$
+
+for a given gradient estimate $g$ , where we access this inner product via finite differences. Here, $L ( x , y )$ is the classification loss on an image $x$ with true class $y$ .
+
+The crucial element of our algorithm will thus be the method of updating the latent vector $v _ { t }$ . We will adapt here the canonical “reduction from bandit information” (Hazan, 2016). Specifically, our update procedure is parametrized by an estimator $\Delta _ { t }$ of the gradient $\nabla _ { \boldsymbol { v } } \ell _ { t } ( { \boldsymbol { v } } )$ , and a first-order update step $\mathcal { A } \left( \mathcal { K } \times \mathbb { R } ^ { \mathrm { d i m } ( \mathcal { K } ) } \to \mathcal { K } \right)$ , which maps the latent vector $v _ { t }$ and the estimated gradient of $\ell _ { t }$ with respect to $v _ { t }$ (which we denote $\Delta _ { t }$ ) to a new latent vector $v _ { t + 1 }$ . The resulting general algorithm is presented as Algorithm 1.
+
+In our setting, we make the estimator $\Delta$ of the gradient $- \nabla _ { v } \langle \nabla L ( x , y ) , v \rangle$ of the loss $\ell$ be the standard spherical gradient estimator (see Hazan (2016)). We take a two-query estimate of the expectation, and employ antithetic sampling which results in the estimate being computed as
+
+$$
+\Delta = \frac { \ell ( v + \delta \pmb { u } ) - \ell ( v - \delta \pmb { u } ) } { \delta } \pmb { u } ,
+$$
+
+# Algorithm 1 Gradient Estimation with Bandit Optimization
+
+<table><tr><td colspan="2">1: procedure BANDIT-OPT-LOSS-GRAD-EST(x, yinit)</td></tr><tr><td colspan="2">Uo ↑ A()</td></tr><tr><td>2: 3:</td><td>for each round t =1,...,T do</td></tr><tr><td>4:</td><td>// Our loss in round t is lt(gt)= -(VxL(x,yinit), gt)</td></tr><tr><td>5:</td><td>gt←Ut-1</td></tr><tr><td>6:</td><td>△t ←GRAD-EsT(x,yinit, Ut-1) // Estimated Gradient of lt</td></tr><tr><td>7:</td><td>Ut ←A(Ut-1,△t)</td></tr><tr><td>8:</td><td></td></tr><tr><td>9:</td><td>g↑UT</td></tr><tr><td></td><td>return IIəx [g]</td></tr></table>
+
+where $\textbf { \em u }$ is a Gaussian vector sampled from $\mathcal { N } ( 0 , \textstyle \frac { 1 } { d } I )$ . The resulting algorithm for calculating the gradient estimate given the current latent vector $v$ , input $x$ and the initial label $y$ is Algorithm 2.
+
+# Algorithm 2 Single-query spherical estimate of $\nabla _ { v } \langle \nabla L ( x , y ) , v \rangle$
+
+<table><tr><td colspan="2">1: procedure GRAD-EsT(x,y, U)</td></tr><tr><td colspan="2">2: u ← N(O,¹I) // Query vector</td></tr><tr><td>3:</td><td>{q1,q2} ← {u+δu,u-δu} // Antithetic samples</td></tr><tr><td>4:</td><td>lt(q1)=-(VL(x,y）,q1)~ L(x,y)-L(∞+eq1,3) 2// Gradient estimation loss at q1</td></tr><tr><td>5:</td><td>lt(q2)=-(L(x,y),L(e)//raientestitiost</td></tr><tr><td>6:</td><td>△← lt(q1)-lt(q2）u= L(x+cq2,y）-L(x+cq1.y）</td></tr><tr><td>7: 8:</td><td>8 SE // Note that due to cancellations we can actually evaluate △ with only two queries to L</td></tr><tr><td>return △</td><td></td></tr></table>
+
+A crucial point here is that the above gradient estimator $\Delta _ { t }$ parameterizing the bandit reduction has no direct relation to the “gradient estimation problem” as defined in Section 2.4. It is simply a general mechanism by which we can update the latent vector $v _ { t }$ in bandit optimization. It is the actions $g _ { t }$ (equal to $\boldsymbol { v } _ { t }$ ) which provide proposed solutions to the gradient estimation problem from Section 2.4.
+
+The choice of the update rule $\mathcal { A }$ tends to be natural once the convex set $\kappa$ is known. For $\ b { \mathcal { K } } = \mathbb { R } ^ { n }$ , we can simply use gradient ascent:
+
+$$
+v _ { t } = \mathcal { A } ( v _ { t - 1 } , \Delta _ { t } ) : = v _ { t - 1 } + \eta \cdot \Delta _ { t }
+$$
+
+and the exponentiated gradients (EG) update when the constraint is an $\ell _ { \infty }$ bound (i.e. $\displaystyle { \mathcal { K } } = [ - 1 , 1 ] ^ { n } )$ :
+
+$$
+\begin{array} { l } { { p _ { t - 1 } = \displaystyle { \frac { 1 } { 2 } \left( v _ { t - 1 } + 1 \right) } } } \\ { { \mathrm { } } } \\ { { p _ { t } = \displaystyle A ( g _ { t - 1 } , \Delta _ { t } ) : = \displaystyle { \frac { 1 } { Z } p _ { t - 1 } \exp ( \eta \cdot \Delta _ { t } ) } \quad \mathrm { s . t . } Z = p _ { t - 1 } \exp ( \eta \cdot \Delta _ { t } ) + ( 1 - p _ { t - 1 } ) \exp ( - \eta \cdot \Delta _ { t } ) } } \\ { { v _ { t } = 2 p _ { t } - 1 } } \end{array}
+$$
+
+Finally, in order to translate our gradient estimation algorithm into an efficient method for constructing black-box adversarial examples, we interleave our iterative gradient estimation algorithm with an iterative update of the image itself, using the boundary projection of $g _ { t }$ in place of the gradient (c.f. (1)). This results in a general, efficient, prior-exploiting algorithm for constructing black-box adversarial examples. The resulting algorithm in the $\ell _ { 2 }$ -constrained case is shown in Algorithm 3.
+
+# 4 EXPERIMENTS AND EVALUATION
+
+We evaluate our bandit approach described in Section 3 and the natural evolutionary strategies (NES) approach of Ilyas et al. (2017) on their effectiveness in generating untargeted adversarial examples. We consider both the $\ell _ { 2 }$ and $\ell _ { \infty }$ threat models on the ImageNet (Russakovsky et al., 2015) dataset, in terms of success rate and query complexity. We further investigate loss and gradient estimate quality over the optimization trajectory in each method. To show the method extends to other datasets,
+
+# Algorithm 3 Adversarial Example Generation with Bandit Optimization for $\ell _ { 2 }$ norm perturbations
+
+<table><tr><td colspan="2">1: procedure ADVERSARIAL-BANDIT-L2(Xinit, Yinit)</td></tr><tr><td>2: / / C(-) returns top class</td><td></td></tr><tr><td>3:</td><td>vo ← O1xd // If data prior, d &lt; dim(x); Ut (△t) up (down)-sampled before (after) line 8</td></tr><tr><td>4:</td><td>xo ← Xinit // Adversarial image to be constructed</td></tr><tr><td>5:</td><td>while C(x) = yinit do</td></tr><tr><td>6:</td><td>gt←Ut-1</td></tr><tr><td>7:</td><td>xt←xt-1+h· gt //Boundary projection g standard PGD: c.f. (Rigolet, 2015) 11gt1l2 Ilgt1</td></tr><tr><td>8:</td><td>△t ← GRAD-EsT(xt-1, yinit, Ut-1) // Estimated Gradient of lt</td></tr><tr><td>9:</td><td>Ut ←Ut-1+n·△t</td></tr><tr><td>10:</td><td>t↑t+1</td></tr><tr><td>return Xt-1</td><td></td></tr></table>
+
+we also compare to NES in the CIFAR- $\ell _ { \infty }$ threat model; in all threat models, we show results on Inception-v3, Resnet-50, and VGG16 classifiers.
+
+In evaluating our approach, we test both the bandit approach with time prior (Bandits $_ T$ ), and our bandit approach with the given examples of both the data and time priors $\mathrm { ( B a n d i t s } _ { T D }$ ). We use 10,000 and 1,000 randomly selected images (scaled to $[ 0 , 1 ] )$ to evaluate all approaches on ImageNet and CIFAR-10 respectively. For NES, Bandits $_ T$ , and Bandit $_ { T D }$ we found hyperparameters (given in Appendix C, along with the experimental parameters) via grid search.
+
+# 4.1 RESULTS
+
+For ImageNet, we record the effectiveness of the different approaches in both threat models in Table 1 $\ell _ { 2 }$ and $\ell _ { \infty }$ perturbation constraints), where we show the attack success rate and the mean number of queries (of the successful attacks) needed to generate an adversarial example for the Inception-v3 classifier (results for other classifiers in Appendix F). For all attacks, we limit the attacker to at most 10,000 oracle queries. As shown in Table 1, our bandits framework with both data-dependent and time prior (Bandits $_ { T D }$ ), is six and three times less failure-prone than the previous state of the art (NES (Ilyas et al., 2017)) in the $\ell _ { \infty }$ and $\ell _ { 2 }$ settings, respectively. Despite the higher success rate, our method actually uses around half as many queries as NES. In particular, when restricted to the inputs on which NES is successful in generating adversarial examples, our attacks are 2.5 and 5 times as query-efficient for the $\ell _ { \infty }$ and $\ell _ { 2 }$ settings, respectively. In Appendix G, we also compare against the AutoZOOM method of Tu et al. (2018), where we show that our Bandits $_ { T D }$ method at a higher $1 0 0 \%$ success rate is over $6$ times as query-efficient. Finally, we also have similar results for CIFAR-10 under the $\ell _ { \infty }$ threat model, which can be found in Appendix E.
+
+We also further quantify the performance of our methods in terms of black-box attacks, and gradient estimation. Specifically, we first measure average queries per success after reaching a certain success rate (Figure 4a), which indicates the dependence of the query count on the desired success rate. The data shows that for any fixed success rate, our methods are more query-efficient than NES, and (due to the exponential trend) suggest that the difference may be amplified for higher success rates. We then plot the loss of the classifier over time (averaged over all images), and performance on the gradient estimation problem for both $\ell _ { \infty }$ and $\ell _ { 2 }$ cases (which, crucially, corresponds directly to the expectation we maximize in (7). We show these three plots for $\ell _ { \infty }$ in Figure 4, and show the results for $\ell _ { 2 }$ (which are extremely similar) in Appendix D, along with CDFs showing the success of each method as a function of the query limit. We find that on every metric in both threat models, our methods strictly dominate NES in terms of performance.
+
+# 5 RELATED WORK
+
+All known techniques for generating adversarial examples in the black-box setting so far rely on either iterative optimization schemes (our focus) or so-called substitute networks and transferability.
+
+In the first line of work, algorithms use queries to gradually perturb a given input to maximize a corresponding loss, causing misclassification. Nelson et al. (2012) presented the first such iterative attack on a special class of binary classifiers. Later, Xu et al. (2016) gave an algorithm for fooling a real-world system with black-box attacks. Specifically, they fool PDF document malware classifier by using a genetic algorithms-based attack. Soon after, Narodytska & Kasiviswanathan (2017) described the first black-box attack on deep neural networks; the algorithm uses a greedy search algorithm that selectively changes individual pixel values. Chen et al. (2017) were the first to design black-box attack based on finite-differences and gradient based optimization. The method uses coordinate descent to attack black-box neural networks, and introduces various optimizations to decrease sample complexity. Building on the work of Chen et al. (2017), Ilyas et al. (2017) designed a black-box attack strategy that also uses finite differences but via natural evolution strategies (NES) to estimate the gradients. They then used their algorithm as a primitive in attacks on more restricted threat models.
+
+![](images/7177ddd785fc401efae7fb6e723179501f8154c819cc22e4952afb0e2c59f838.jpg)  
+Figure 4: (left) Average number of queries per successful image as a function of the number of total successful images; at any desired success rate, our methods use significantly less queries per successful image than NES, and the trend suggests that this gap increases with the desired success rate. (center) The loss over time, averaged over all images; (right) The correlation of the latent vector with the true gradient $g$ , which is precisely the gradient estimation objective we define.
+
+In a concurrent line of work, Papernot et al. (2017) introduce a method for attacking models with so-called substitute networks. Here, the attacker trains a model – called a substitute network – to mimic the target network’s decisions (obtained with black-box queries) , then uses (white-box) adversarial examples for the substitute network to attack the original model. Adversarial examples generated with these methods Papernot et al. (2017); Liu et al. (2016) tend to transfer to a target MNIST or CIFAR classifier. We note, however, that for attacking single inputs, the overall query efficiency of this type of methods tends to be worse than that of the gradient estimation based ones. Substitute models are also thus far unable to make targeted black-box adversarial examples.
+
+# 6 CONCLUSION
+
+We develop a new, unifying perspective on black-box adversarial attacks. This perspective casts the construction of such attacks as a gradient estimation problem. We prove that a standard least-squares estimator both captures the existing state-of-the-art approaches to black-box adversarial attacks, and actually is, in a certain natural sense, an optimal solution to the problem.
+
+We then break the barrier posed by this optimality by considering a previously unexplored aspect of the problem: the fact that there exists plenty of extra prior information about the gradient that one can exploit to mount a successful adversarial attack. We identify two examples of such priors: a “time-dependent” prior that corresponds to similarity of the gradients evaluated at similar inputs, and a “data-dependent” prior derived from the latent structure present in the input space.
+
+Finally, we develop a bandit optimization approach to black-box adversarial attacks that allows for a seamless integration of such priors. The resulting framework significantly outperforms state-of-the-art by a factor of two to six in terms of success rate and query efficiency. Our results thus open a new avenue towards finding priors for construction of even more efficient black-box adversarial attacks.
+
+# ACKNOWLEDGMENTS
+
+We thank Ludwig Schmidt for suggesting the connection between LSQ and NES. AM supported in part by NSF grants CCF-1553428 and CNS-1815221. LE supported in part by a Siebel Foundation Scholarship and IBM Watson AI grant. AI supported by an Analog Devices Fellowship.
+
+# REFERENCES
+
+Anish Athalye, Logan Engstrom, Andrew Ilyas, and Kevin Kwok. Synthesizing robust adversarial examples. CoRR, abs/1707.07397, 2017. URL http://arxiv.org/abs/1707.07397.
+
+Arjun Nitin Bhagoji, Warren He, Bo Li, and Dawn Song. Exploring the space of black-box attacks on deep neural networks. arXiv preprint arXiv:1712.09491, 2017.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In Security and Privacy (SP), 2017 IEEE Symposium on, pp. 39–57. IEEE, 2017.
+
+Nicholas Carlini, Pratyush Mishra, Tavish Vaidya, Yuankai Zhang, Micah Sherr, Clay Shields, David Wagner, and Wenchao Zhou. Hidden voice commands. In USENIX Security Symposium, pp. 513–530, 2016.
+
+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 Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017.
+
+Simon Foucart and Holger Rauhut. A mathematical introduction to compressive sensing, volume 1. Birkhäuser Basel, 2013.
+
+A. Gittens and J. A. Tropp. Tail bounds for all eigenvalues of a sum of random matrices. ArXiv e-prints, apr 2011.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Alexander N Gorban, Ivan Yu Tyukin, Danil V Prokhorov, and Konstantin I Sofeikov. Approximation with random bases: Pro et contra. Information Sciences, 364:129–145, 2016.
+
+Elad Hazan. Introduction to online convex optimization. Foundations and Trends in Optimization, 2(3-4):157–325, 2016. ISSN 2167-3888. doi: 10.1561/2400000013. URL http://dx.doi. org/10.1561/2400000013.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1712.07113, 2017.
+
+William B Johnson and Joram Lindenstrauss. Extensions of lipschitz mappings into a hilbert space. Contemporary mathematics, 26(189-206):1, 1984.
+
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+B. Laurent and P. Massart. Adaptive estimation of a quadratic functional by model selection. The Annals of Statistics, 28(5):1302–1338, 10 2000. doi: 10.1214/aos/1015957395. URL https: //doi.org/10.1214/aos/1015957395.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. arXiv preprint arXiv:1611.02770, 2016.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Ron Meir. Bias, variance and the combination of least squares estimators. In NIPS, 1994.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. CoRR, abs/1511.04599, 2015. URL http: //arxiv.org/abs/1511.04599.
+
+Nina Narodytska and Shiva Kasiviswanathan. Simple black-box adversarial attacks on deep neural networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), pp. 1310–1318. IEEE, 2017.
+
+Blaine Nelson, Benjamin IP Rubinstein, Ling Huang, Anthony D Joseph, Steven J Lee, Satish Rao, and JD Tygar. Query strategies for evading convex-inducing classifiers. Journal of Machine Learning Research, 13(May):1293–1332, 2012.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519. ACM, 2017.
+
+Phillipe Rigollet. Mathematics of machine learning course notes: Projected gradient descent, 2015. URL https://ocw.mit.edu/courses/mathematics/ 18-657-mathematics-of-machine-learning-fall-2015/lecture-notes/ MIT18_657F15_L12.pdf.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115 (3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+James C Spall. Introduction to stochastic search and optimization: estimation, simulation, and control, volume 65. John Wiley & Sons, 2005.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. corr abs/1512.00567 (2015), 2015.
+
+Chun-Chen Tu, Pai-Shun 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. CoRR, abs/1805.11770, 2018.
+
+Weilin Xu, Yanjun Qi, and David Evans. Automatically evading classifiers. In Proceedings of the 2016 Network and Distributed Systems Symposium, 2016.
+
+# A PROOFS
+
+Theorem 1 (NES and Least Squares equivalence). Let $\hat { x } _ { N E S }$ be the Gaussian $k$ -query NES estimator of a $d$ -dimensional gradient $\textbf {  { g } }$ and let $\hat { x } _ { L S Q }$ be the minimal-norm $k$ -query least-squares estimator of $\textbf {  { g } }$ . For any $p > 0$ , with probability at least $1 - p$ we have that
+
+$$
+\left. \hat { x } _ { L S Q } , \pmb { g } \right. - \left. \hat { x } _ { N E S } , \pmb { g } \right. \leq O \left( \sqrt { \frac { k } { d } \cdot \log ^ { 3 } \left( \frac { k } { p } \right) } \right) \left. \ b { g } \right. ^ { 2 } ,
+$$
+
+and in particular,
+
+$$
+\left. \hat { x } _ { L S Q } , \pmb { g } \right. - \left. \hat { x } _ { N E S } , \pmb { g } \right. \leq 8 \sqrt { \frac { 2 k } { d } \cdot \log ^ { 3 } \left( \frac { 2 k + 2 } { p } \right) } \left( 1 + \frac { \kappa } { \sqrt { d } } \right) { | | \pmb { g } | | ^ { 2 } }
+$$
+
+with probability at least $1 - p ,$ , where
+
+$$
+\kappa \leq 2 \sqrt { \log \left( \frac { 2 k ( k + 1 ) } { p } \right) } .
+$$
+
+Proof. Let us first recall our estimation setup. We have $k$ query vectors $\delta _ { i } \in \mathbb { R } ^ { d }$ drawn from an i.i.d Gaussian distribution whose expected squared norm is one, i.e. $\delta _ { i } \sim \mathcal { N } ( 0 , \frac { 1 } { d } I )$ , for each $1 \leq i \leq k$ . Let the vector $\ b { y } \in \mathbb { R } ^ { k }$ denote the inner products of $\delta _ { i } \mathbf { s }$ with the gradient, i.e.
+
+$$
+y _ { i } : = \langle \delta _ { i } , \pmb { g } \rangle ,
+$$
+
+for each $1 \leq i \leq k$ . We define the matrix $A$ to be a $k \times d$ matrix with the $\delta _ { i } \mathrm { s }$ being its rows. That is, we have
+
+$$
+A g = y .
+$$
+
+Now, recall that the closed forms of the two estimators we are interested in are given by
+
+$$
+\begin{array} { r l } & { \hat { x } _ { N E S } = A ^ { T } \pmb { y } = A ^ { T } A \pmb { g } } \\ & { \hat { x } _ { L S Q } = A ^ { T } ( A A ^ { T } ) ^ { - 1 } \pmb { y } = A ^ { T } ( A A ^ { T } ) ^ { - 1 } A \pmb { g } , } \end{array}
+$$
+
+which implies that
+
+$$
+\begin{array} { r l } & { \langle \hat { x } _ { N E S } , \pmb { g } \rangle = \pmb { g } ^ { T } A ^ { T } A \pmb { g } } \\ & { \langle \hat { x } _ { L S Q } , \pmb { g } \rangle = \pmb { g } ^ { T } A ^ { T } ( A A ^ { T } ) ^ { - 1 } A \pmb { g } . } \end{array}
+$$
+
+We can bound the difference between these two inner products as
+
+$$
+\begin{array} { r l } & { \left. \hat { x } _ { L S Q } , g \right. - \left. \hat { x } _ { N E S } , \pmb { g } \right. = \pmb { g } ^ { T } A ^ { T } \left[ ( A A ^ { T } ) ^ { - 1 } - I \right] A \pmb { g } } \\ & { \qquad \leq \left| \left| g ^ { T } A ^ { T } \right| \right| \left| \left| ( A A ^ { T } ) ^ { - 1 } - I \right| \right| \left| | A g | \right| } \\ & { \qquad \leq \left| \left| ( A A ^ { T } ) ^ { - 1 } - I \right| \right| \left| | A g | \right| ^ { 2 } . } \end{array}
+$$
+
+Now, to bound the first term in (12), observe that
+
+$$
+( A A ^ { T } ) ^ { - 1 } = \left( I - ( I - A A ^ { T } ) \right) ^ { - 1 } = \sum _ { l = 0 } ^ { \infty } ( I - A A ^ { T } ) ^ { l }
+$$
+
+and thus
+
+$$
+I - ( A A ^ { T } ) ^ { - 1 } = \sum _ { l = 1 } ^ { \infty } ( A A ^ { T } - I ) ^ { l } .
+$$
+
+(Note that the first term in the above sum has been canceled out.) This gives us that
+
+$$
+\big | \big | I - ( A A ^ { T } ) ^ { - 1 } \big | \big | \leq \sum _ { l = 1 } ^ { \infty } \big | \big | A A ^ { T } - I \big | \big | ^ { l }
+$$
+
+$$
+\begin{array} { r l } & { \leq \frac { \left| \left| A A ^ { T } - I \right| \right| } { 1 - \left| \left| A A ^ { T } - I \right| \right| } } \\ & { \leq 2 \left| \left| A A ^ { T } - I \right| \right| , } \end{array}
+$$
+
+as long as $\begin{array} { r } { \left| \left| A A ^ { T } - I \right| \right| \leq \frac { 1 } { 2 } } \end{array}$ (which, as we will see, is indeed the case with high probability).
+
+Our goal thus becomes bounding $\left| \left| A A ^ { T } - I \right| \right| = \lambda _ { m a x } ( A A ^ { T } - I )$ , where $\lambda _ { m a x } ( \cdot )$ denotes the largest (in absolute value) eigenvalue. Observe that $A A ^ { T }$ and $- I$ commute and are simultaneously diagonalizable. As a result, for any $1 \leq i \leq k$ , we have that the $i$ -th largest eigenvalue $\lambda _ { i } ( A A ^ { T } - \dot { I } )$ of $\bar { \boldsymbol { A } } \boldsymbol { A } ^ { T } - \boldsymbol { I }$ can be written as
+
+$$
+\lambda _ { i } ( A A ^ { T } - I ) = \lambda _ { i } ( A A ^ { T } ) + \lambda _ { i } ( - I ) _ { i } = \lambda _ { i } ( A A ^ { T } ) - 1 .
+$$
+
+So, we need to bound
+
+$$
+\lambda _ { m a x } ( A A ^ { T } - I ) = \operatorname* { m a x } \left\{ \lambda _ { 1 } ( A A ^ { T } ) - 1 , 1 - \lambda _ { k } ( A A ^ { T } ) \right\}
+$$
+
+To this end, recall that $\mathbb { E } [ A A ^ { T } ] = I$ (since the rows of $A$ are sampled from the distribution $\textstyle { \mathcal { N } } ( 0 , { \frac { 1 } { d } } I ) )$ ), and thus, by the covariance estimation theorem of Gittens and Tropp Gittens & Tropp (2011) (see Corollary 7.2) (and union bounding over the two relevant events), we have that
+
+$$
+\begin{array} { r l } & { \operatorname { \mathrm { \mathrm { \Large ~ { \tt ~ { \tt ~ { \tt ~ { \tt ~ { \tt ~ { \tt ~ { \tt ~ { \tt ~ { \tt ~ { \alpha ~ } ~ { \Lambda } ~ } } } } } } } } } } } } ( \lambda A ^ { T } - I ) \geq \varepsilon ) = \operatorname* { P r } } ( \lambda _ { 1 } ( A A ^ { T } ) \geq 1 + \varepsilon \mathrm { \ o r } \lambda _ { k } ( A A ^ { T } ) \geq 1 - \varepsilon )  \\ & { \quad \quad \quad = \operatorname* { P r } ( \lambda _ { 1 } ( A A ^ { T } ) \geq \lambda _ { 1 } ( I ) + \varepsilon \mathrm { \ o r } \lambda _ { k } ( A A ^ { T } ) \geq \lambda _ { k } ( I ) - \varepsilon ) \leq 2 k \cdot \exp \left( - \frac { d } { 3 \lambda _ { 1 } } \right) . } \end{array}
+$$
+
+Setting
+
+$$
+\varepsilon = \sqrt { \frac { 3 2 k \log ( 2 ( k + 1 ) / p ) } { d } } ,
+$$
+
+ensuring that $\varepsilon \leq \frac { 1 } { 2 }$ , gives us
+
+$$
+\operatorname* { P r } \left( \lambda _ { m a x } ( A A ^ { T } ) - 1 \geq \sqrt { \frac { 3 2 k \log ( 2 ( k + 1 ) / p ) } { d } } \right) \leq \frac { k } { k + 1 } p .
+$$
+
+and thus
+
+$$
+\left| \left| ( A A ^ { T } ) ^ { - 1 } - I \right| \right| \leq \sqrt { \frac { 3 2 k \log ( 2 ( k + 1 ) / p ) } { d } } ,
+$$
+
+with probability at least $\begin{array} { r } { \mathrm { ~ 1 ~ - ~ } \frac { k } { k + 1 } p } \end{array}$
+
+To bound the second term in (12), we note that all the vectors $\delta _ { i }$ are chosen independently of the vector $\textbf {  { g } }$ and each other. So, if we consider the set $\{ \hat { g } , \hat { \delta _ { 1 } } , \dotsc , \hat { \delta _ { k } } \}$ of $k + 1$ corresponding normalized directions, we have (see, e.g., (Gorban et al., 2016)) that the probability that any two of them have the (absolute value of) their inner product be larger than some $\begin{array} { r } { \varepsilon ^ { \prime } = \sqrt { \frac { 2 \log ( 2 ( k + 1 ) / p ) } { d } } } \end{array}$ is at most
+
+$$
+\exp \left\{ - ( k + 1 ) ^ { 2 } e ^ { - d ( \varepsilon ^ { \prime } ) ^ { 2 } / 2 } \right\} = \exp \left\{ - 2 \frac { k + 1 } { p } \right\} \leq \frac { p } { 2 ( k + 1 ) } .
+$$
+
+On the other hand, we note that each $\delta _ { i }$ is a random vector sampled from the distribution $\mathcal { N } ( 0 , \textstyle \frac { 1 } { d } \pmb { I } _ { d } )$ , so we have that (see, e.g., Lemma 1 in (Laurent $\&$ Massart, 2000)), for any $1 \leq i \leq k$ and any $\varepsilon ^ { \prime \prime } > 0$ ,
+
+$$
+\operatorname* { P r } \left( | | \delta _ { i } | | ^ { 2 } \geq 1 + \varepsilon ^ { \prime \prime } \right) \leq \exp \left\{ - { \frac { ( \varepsilon ^ { \prime \prime } ) ^ { 2 } d } { 4 } } \right\} .
+$$
+
+Setting
+
+$$
+\varepsilon ^ { \prime \prime } = 2 \sqrt { \frac { \log ( 2 k ( k + 1 ) / p ) } { d } }
+$$
+
+yields
+
+$$
+P \left( | | \delta _ { i } | | ^ { 2 } \geq 1 + 2 { \sqrt { \frac { \log ( 2 ( k + 1 ) k / p ) } { d } } } \right) \leq { \frac { p } { 2 k ( k + 1 ) } } .
+$$
+
+Applying these two bounds (and, again, union bounding over all the relevant events), we get that
+
+$$
+\begin{array} { l } { \displaystyle \left. | A g \right. | ^ { 2 } = \sum _ { i = 1 } ^ { k } ( A g ) _ { i } ^ { 2 } } \\ { \displaystyle \quad \leq d \cdot \left( \frac { 2 \log \left( \frac { 2 ( k + 1 ) } { p } \right) } { d } \right) \left( 1 + 2 \sqrt { \frac { \log \left( \frac { 2 k ( k + 1 ) } { p } \right) } { d } } \right) \left. | g \right. | ^ { 2 } } \\ { \displaystyle \qquad \leq 2 \log \left( \frac { 2 ( k + 1 ) } { p } \right) \left( 1 + 2 \sqrt { \frac { 2 \log \left( \frac { 2 ( k + 1 ) } { p } \right) } { d } } \right) \left. | g \right. | ^ { 2 } } \end{array}
+$$
+
+with probability at most $\frac { p } { k { + } 1 }$
+
+Finally, by plugging the above bound and the bound (13) into the bound (12), we obtain that
+
+$$
+\begin{array} { r l } & { g \rangle - \langle \hat { x } _ { N E S } , g \rangle \leq \left( \sqrt { \frac { 3 2 k \log ( 2 ( k + 1 ) / p ) } { d } } \right) \cdot 2 \log \left( \frac { 2 ( k + 1 ) } { p } \right) \left( 1 + 2 \sqrt { \frac { 2 \log \left( \frac { 2 ( k + 1 ) } { p } \right) } { d } } \right) \left. g \right. } \\ & { \qquad \leq 8 \sqrt { \frac { 2 k } { d } \cdot \log ^ { 3 } \left( \frac { 2 k + 2 } { p } \right) } \left( 1 + \frac { \kappa } { \sqrt { d } } \right) \left. g \right. ^ { 2 } , } \end{array}
+$$
+
+with probability $1 - p$ , where
+
+$$
+\kappa = 2 \sqrt { \log \left( \frac { 2 k ( k + 1 ) } { p } \right) } .
+$$
+
+This completes the proof.
+
+Theorem 2 (Least-Squares Optimality). For a fixed projection matrix $A$ and under the following observation model of isotropic Gaussian noise: $\pmb { y } = A \pmb { g } + \vec { \varepsilon }$ where $\varepsilon \sim \mathcal { N } ( 0 , \varepsilon I d )$ , the least-squares estimator as in Theorem 1, $\hat { x } _ { L S Q } = A ^ { T } ( A A ^ { T } ) ^ { - 1 } y$ is a finite-sample efficient (minimum-variance unbiased) estimator of the parameter $\textbf {  { g } }$ .
+
+Proof. Proving the theorem requires an application of the Cramer-Rao Lower Bound theorem:
+
+Theorem 3 (Cramer-Rao Lower Bound). Given a parameter $\theta$ , an observation distribution $p ( x ; \theta )$ , and an unbiased estimator $\hat { \theta }$ that uses only samples from $p ( x ; \theta )$ , then (subject to Fisher regularity conditions trivially satisfied by Gaussian distributions),
+
+$C o \nu \left[ \hat { \theta } - \theta \right] = \operatorname { \mathbb { E } } \left[ ( \hat { \theta } - \theta ) ( \hat { \theta } - \theta ) ^ { T } \right] \ge \left[ I ( \theta ) \right] ^ { - 1 }$ where $I ( \theta )$ is the Fisher matrix: $[ I ( \theta ) ] _ { i j } = - \mathbb { E } \left[ \frac { \partial \log p ( x ; \theta ) } { \partial \theta _ { i } \partial \theta _ { j } } \right]$
+
+Now, note that the Cramer-Rao bound implies that if the variance of the estimator $\hat { \theta }$ is the inverse of the Fisher matrix, $\hat { \theta }$ must be the minimum-variance unbiased estimator. Recall the following form of the Fisher matrix:
+
+$$
+I ( \theta ) = \mathbb { E } \left[ \left( \frac { \partial \log p ( x ; \theta ) } { \partial \theta } \right) \left( \frac { \partial \log p ( x ; \theta ) } { \partial \theta } \right) ^ { T } \right]
+$$
+
+Now, suppose we had the following equality, which we can then simplify using the preceding equation:
+
+$$
+\begin{array} { c } { \displaystyle I ( \theta ) \left( \hat { \theta } - \theta \right) = \frac { \partial \log p ( x ; \theta ) } { \partial \theta } } \\ { \displaystyle \left( I ( \theta ) \left( \hat { \theta } - \theta \right) \right) \left( I ( \theta ) \left( \hat { \theta } - \theta \right) \right) ^ { T } = \left( \frac { \partial \log p ( x ; \theta ) } { \partial \theta } \right) \left( \frac { \partial \log p ( x ; \theta ) } { \partial \theta } \right) ^ { T } } \\ { \displaystyle \mathbb { E } \left[ \left( I ( \theta ) \left( \hat { \theta } - \theta \right) \right) \left( I ( \theta ) \left( \hat { \theta } - \theta \right) \right) ^ { T } \right] = \mathbb { E } \left[ \left( \frac { \partial \log p ( x ; \theta ) } { \partial \theta } \right) \left( \frac { \partial \log p ( x ; \theta ) } { \partial \theta } \right) ^ { T } \right] } \\ { \displaystyle I ( \theta ) \mathbb { E } \left[ \left( \hat { \theta } - \theta \right) ( \hat { \theta } - \theta ) ^ { T } \right] I ( \theta ) = I ( \theta ) } \end{array}
+$$
+
+Multiplying the preceding by $[ I ( \theta ) ] ^ { - 1 }$ on both the left and right sides yields:
+
+$$
+\mathbb { E } \left[ ( \hat { \theta } - \theta ) ( \hat { \theta } - \theta ) ^ { T } \right] = \left[ I ( \theta ) \right] ^ { - 1 } ,
+$$
+
+which tells us that (15) is a sufficient condition for finite-sample efficiency (minimal variance). We show that this condition is satisfied in our case, where we have $y \sim A g + \varepsilon , \hat { \theta } = \hat { x } _ { L S Q }$ , and $\theta = \pmb { g }$ We begin by computing the Fisher matrix directly, starting from the distribution of the samples $y$ :
+
+$$
+\begin{array} { c } { { p ( y ; g ) = \displaystyle \frac { 1 } { \sqrt { ( 2 \pi \varepsilon ) ^ { d } } } \exp \left\{ \frac { 1 } { 2 \varepsilon } ( y - A g ) ^ { T } ( y - A g ) \right\} } } \\ { { { \log p ( y ; g ) = \displaystyle \frac { d } { 2 } \log { ( 2 \pi \varepsilon ) } + \frac { 1 } { 2 \varepsilon } ( y - A g ) ^ { T } ( y - A g ) } } } \\ { { { \frac { \partial \log { p ( y ; g ) } } { \partial g } = \displaystyle \frac { 1 } { 2 \varepsilon } \left( 2 A ^ { T } ( y - A g ) \right) } } } \\ { { { { } } } } \\ { { { = \displaystyle \frac { 1 } { \varepsilon } A ^ { T } ( y - A g ) } } } \end{array}
+$$
+
+Using (14),
+
+$$
+\begin{array} { l } { { \displaystyle I ( { \pmb g } ) = { \mathbb E } \left[ \left( \frac { 1 } { \varepsilon } A ^ { T } ( { \pmb y } - A { \pmb g } ) \right) \left( \frac { 1 } { \varepsilon } A ^ { T } ( { \pmb y } - A { \pmb g } ) \right) ^ { T } \right] } } \\ { { \displaystyle \ = \frac { 1 } { \varepsilon ^ { 2 } } A ^ { T } { \mathbb E } \left[ ( { \pmb y } - A { \pmb g } ) ( { \pmb y } - A { \pmb g } ) ^ { T } \right] A } } \end{array}
+$$
+
+$$
+\begin{array} { l } { { { \bf \Pi } = \displaystyle \frac { 1 } { \varepsilon ^ { 2 } } A ^ { T } ( \varepsilon { \bf I } d ) A } } \\ { { { \bf \Pi } = \displaystyle \frac { 1 } { \varepsilon } A ^ { T } A } } \end{array}
+$$
+
+Finally, note that we can write:
+
+$$
+\begin{array} { r l } & { I ( \pmb { g } ) ( \hat { x } _ { L S Q } - \pmb { g } ) = \frac { 1 } { \varepsilon } A ^ { T } A ( A ^ { T } ( A A ^ { T } ) ^ { - 1 } y - \pmb { g } ) } \\ & { \qquad = \frac { 1 } { \varepsilon } ( A ^ { T } y - A ^ { T } A \pmb { g } ) } \\ & { \qquad = \frac { \partial \log p ( y ; \pmb { g } ) } { \partial \pmb { g } } , } \end{array}
+$$
+
+which concludes the proof, as we have shown that $\hat { x } _ { L S Q }$ satisfies the condition (15), which in turn implies finite-sample efficiency.
+
+Claim 1. Applying the precise bound that we can derive from Theorem $^ { l }$ on an ImageNet-sized dataset ( $d = 3 0 0 0 0 0 \mathrm { \Omega }$ ) and using $k = 1 0 0$ queries (what we use in our $\ell _ { \infty }$ threat model and ten times that used for our $\ell _ { 2 }$ threat model),
+
+$$
+\langle \hat { x } _ { L S Q } , \pmb { g } \rangle - \langle \hat { x } _ { N E S } , \pmb { g } \rangle \leq \frac { 5 } { 4 } | | \boldsymbol { g } | | ^ { 2 } .
+$$
+
+For 10 queries,
+
+$$
+\langle \hat { x } _ { L S Q } , \pmb { g } \rangle - \langle \hat { x } _ { N E S } , \pmb { g } \rangle \leq \frac { 1 } { 2 } | | \boldsymbol { g } | | ^ { 2 } .
+$$
+
+# B OMITTED FIGURES
+
+# B.1 COMPRESSIVE SENSING
+
+Compressed sensing approaches can, in some cases, solve the optimization problem presented in Section 2.4. However, these approaches require sparsity to improve over the least squares method. Here we show the lack of sparsity in gradients through a classifier on a set of canonical bases for images. In Figure 5, we plot the fraction of $\ell _ { 2 }$ weight accounted for by the largest $k$ components in randomly chosen image gradients when using two canonical bases: standard and wavelet (db4). While lack of sparsity in these bases does not strictly preclude the existence of a basis on which gradients are sparse, it suggests the lack of a fundamental structural sparsity in gradients through a convolutional neural network.
+
+![](images/fc5edb351081165fa9a9ae3df52f1659532205f4cf16adfb7b3c1fae69671bee.jpg)  
+Figure 5: Sparsity in standard, wavelet (db4 wavelets), and PCA-constructed bases for the gradients of 5,000 randomly chosen example images in the ImageNet validation set. The y-axis shows the mean fraction of $\ell _ { 2 }$ weight held by the largest $k$ vectors over the set of 5,000 chosen images. The $\mathbf { X }$ -axis varies $k$ . The gradients are taken through a standardly trained Inception v3 network. None of the bases explored induce significant sparsity.
+
+# B.2 TILING
+
+An example of the tiling procedure applied to a gradient can be seen in Figure 6.
+
+![](images/dba17539962d2519cbe43eac0e6a02d3af6f03077654827a4664d31e21a23ca7.jpg)  
+Figure 6: Average blurred gradient with kernel size or “tile length” 5. The original gradient can be seen in 6a, and the “tiled” or average blurred gradient can be seen in 6b
+
+# B.3 TIME-DEPENDENT PRIORS AT HIGHER STEP SIZES
+
+We show in Figure 7 that the correlation between successive gradients on the NES trajectory are signficantly correlated, even at much higher step sizes (up to $\ell _ { 2 }$ norm of 4.0, which is a typical value for $\varepsilon$ , the total adversarial perturbation bound and thus an absolute bound on step size). This serves as further motivation for the time-dependent prior.
+
+![](images/2601855269c883f52828dbcffd4305a80670e474720170f2e0bca04a3be75321.jpg)  
+Figure 7: Figure 2 repeated for several step sizes, showing that the successive correlation between gradients continues even at higher step sizes.
+
+# C HYPERPARAMETERS
+
+Table 2: Hyperparameters for the NES approach.   
+
+<table><tr><td rowspan="2">Hyperparameter</td><td colspan="3">Value</td></tr><tr><td>ImageNet lo</td><td>ImageNet l2</td><td>CIFAR10 l0</td></tr><tr><td>Samples per step</td><td>100</td><td>10</td><td>50</td></tr><tr><td>Learning Rate</td><td>0.01</td><td>0.3</td><td>0.01</td></tr></table>
+
+Table 3: Hyperparameters for the bandits approach (variables names as used in pseudocode).   
+
+<table><tr><td rowspan="2">Hyperparameter</td><td colspan="3">Value</td></tr><tr><td>ImageNet lo</td><td>ImageNet l2</td><td>CIFAR10 l0</td></tr><tr><td>η (OCO learning rate)</td><td>100</td><td>0.1</td><td>100</td></tr><tr><td>h (Image lp learning rate)</td><td>0.005</td><td>0.5</td><td>0.0001</td></tr><tr><td>δ (Bandit exploration)</td><td>0.01</td><td>0.01</td><td>0.01</td></tr><tr><td>η (Finite difference probe)</td><td>0.01</td><td>0.01</td><td>0.01</td></tr><tr><td>Tile size (Data-dependent prior only)</td><td>(6px)2</td><td>(6px)²</td><td>(10px)²</td></tr></table>
+
+Table 4: Experimental setup for comparing Bandits-NES. Setup and results for comparison with Tu et al. (2018) in Appendix G   
+
+<table><tr><td rowspan="2">Parameter</td><td colspan="3">Value</td></tr><tr><td>ImageNet lo</td><td>ImageNet l2</td><td>CIFAR10 loo</td></tr><tr><td>Max allowed queries</td><td></td><td>10,000</td><td></td></tr><tr><td>Test set size</td><td>10,000</td><td>10,000</td><td>1,000</td></tr><tr><td>Allowed perturbation ε</td><td>0.05</td><td>5.0</td><td>0.05</td></tr></table>
+
+![](images/c271ea286ab448a1680b91a06ea20b068e500f581d3be8f1b0c5b7fb2d37ca88.jpg)  
+Figure 8: Average loss and cosine distance versus number of queries used over the approaches’ optimization trajectories in the two threat models. We average each cosine distance and loss point at each query number over 100 images from the evaluation set.
+
+![](images/e142598a01f1fccc179c6ad8660b12f02eeb97a1f8064be62282bb445ff4ea6f.jpg)  
+Figure 9: Cumulative distribution functions for the number of queries required to create an adversarial example in the $\ell _ { 2 }$ and $\ell _ { \infty }$ settings for the NES, bandits with time prior (BanditsT ), and bandits with time and data-dependent priors (BanditsTD) approaches. Note that the CDFs do not converge to one, as the approaches sometimes cannot find an adversarial example in less than 10,000 queries.
+
+![](images/85d158553e50bf61ca5a0c1d589eaf40bb29970c27c80a07869676c62a503653.jpg)  
+Figure 10: The average number of queries used per successful image for each method when reaching a specified success rate: we compare NES Ilyas et al. (2017), Bandits $T$ (our method with time prior only), and BanditsTD (our method with both data and time priors) and find that our methods strictly dominate NES—that is, for any desired sucess rate, our methods take strictly less queries per successful image than NES.
+
+# E RESULTS FOR CIFAR-10
+
+Here, we give results for the CIFAR-10 dataset, comparing our best method (Bandits $_ { T D }$ ) and NES. We train Inception-v3, ResNet-50, and VGG16 classifiers by fine-tuning the standard PyTorch ImageNet classifiers. As such, all images are upsampled to $2 2 4 \times 2 2 4$ $( 2 9 9 \times 2 9 9 )$ for ResNet-50 and VGG16 (and Inception-v3). Just as for ImageNet, we use a maximum $\ell _ { \infty }$ perturbation of 0.05, where images are scaled to $[ 0 , 1 ]$ .
+
+Table 5: Summary of effectiveness of $\ell _ { \infty }$ CIFAR10 attacks on Inception v3, ResNet-50, and VGG16 (I, R, V) using NES and bandits with time and data-dependent priors (Bandits $_ { T D }$ ). Note that in the first column, the average number of queries is calculated only over successful attacks, and we enforce a query limit of 10,000 queries. For purposes of direct comparison, the last column calculates the average number of queries used for only the images that NES (previous SOTA) was successful on. Our most powerful attack uses 2-4 times fewer queries, and fails 2-22 times less often.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="3"> Avg. Queries</td><td colspan="3">Failure Rate</td><td colspan="3">Queries on NES Success</td></tr><tr><td>I</td><td>R</td><td>V</td><td>I</td><td>R</td><td>V</td><td>I</td><td>R</td><td>V</td></tr><tr><td>NES</td><td>1202</td><td>1317</td><td>879</td><td>22%</td><td>31%</td><td>27%</td><td>1202</td><td>1317</td><td>879</td></tr><tr><td>BanditsTD</td><td>602</td><td>554</td><td>509</td><td>0.6%</td><td>12%</td><td>18%</td><td>439</td><td>399</td><td>388</td></tr></table>
+
+# F RESULTS FOR OTHER CLASSIFIERS
+
+Here, we give results for the ImageNet dataset, comparing our best method (Bandits $_ { T D }$ ) and NES for Inception-v3 (also shown in Table 1), VGG16, and ResNet50 classifiers. Note that we do not fine-tune the hyperparameters to the new classifiers, but simply use the hyperparameters found for Inception-v3. Nevertheless, our best method consistently outperforms NES on black-box attacks.
+
+Table 6: Summary of effectiveness of $\ell _ { \infty }$ and $\ell _ { 2 }$ ImageNet attacks on Inception v3, ResNet-50, and VGG16 (I, R, V) using NES and bandits with time and data-dependent priors (Bandit $_ { T D }$ ). Note that in the first column, the average number of queries is calculated only over successful attacks, and we enforce a query limit of 10,000 queries. For purposes of direct comparison, the last column calculates the average number of queries used for only the images that NES (previous SOTA) was successful on. Our most powerful attack uses 2-4 times fewer queries, and fails 2-5 times less often.
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Attack</td><td colspan="3">Avg. Queries</td><td colspan="3">Failure Rate</td><td colspan="3">#Q on NES Success</td></tr><tr><td>I</td><td>R</td><td>V</td><td>I</td><td>R</td><td>V</td><td>I</td><td>R</td><td>V</td></tr><tr><td rowspan="2">l2</td><td>NES</td><td>2938</td><td>2193</td><td>1244</td><td>34.4%</td><td>10.1%</td><td>11.6%</td><td>2938</td><td>2193</td><td>1244</td></tr><tr><td>BanditsTD</td><td>1858</td><td>993</td><td>594</td><td>15.5%</td><td>9.7%</td><td>17.2%</td><td>999</td><td>1195</td><td>1219</td></tr><tr><td rowspan="2">l</td><td>NES</td><td>1735</td><td>1397</td><td>764</td><td>22.2%</td><td>10.4%</td><td>10.5%</td><td>1735</td><td>1397</td><td>764</td></tr><tr><td>BanditsTD</td><td>1117</td><td>722</td><td>370</td><td>4.6%</td><td>3.4%</td><td>8.4%</td><td>703</td><td>594</td><td>339</td></tr></table>
+
+# G COMPARISON TO (TU ET AL, 2018)
+
+To compare with the method of Tu et al. (2018), we consider the same classifier and dataset (Inceptionv3 and Imagenet) under the same $\ell _ { 2 }$ threat model. Note that Tu et al. (2018) use mean rather than maximum $\ell _ { 2 }$ perturbation to evaluate their attacks (since the method is based on a Lagrangian relaxation). To ensure a fair comparison we compare against the average number of queries to reach the adversarial examples bounded within a pertubation budget of $2 \cdot 1 0 ^ { - 4 }$ , which is explicitly reported byTu et al. (2018).
+
+For the bandits approach, we used Bandits $_ T$ , (the bandits method with the time prior) and Bandits $_ { T D }$ (the bandits method with both time and data prior) and run the methods until $100 \%$ success is reached. We use the same hyperparameters from the untargeted ImageNet experiments (given in Appendix C). Our findings, given in Table 7 show that our best method achieves an $100 \%$ success rate, and an over 6-fold reduction in queries. Note that the method of Tu et al. (2018) achieves $100 \%$ success rate in general, but only constrains the mean $\ell _ { 2 }$ perturbation, and thus actually achieves a strictly less than $1 0 0 \%$ success rate with this perturbation threshold.
+
+Table 7: Comparison against coordinate-based query efficient finite differences attacks from Tu et al. (2018), using the ImageNet dataset, with a maximum $\ell _ { 2 }$ constraint of 0.0002 per-pixel normalized (which is equal to a max- $\cdot \ell _ { 2 }$ threshold reported by Tu et al. (2018)). For our methods (Bandits $_ T$ and Bandits $_ { T D }$ ) we use the same hyperparameters as in our comparison to NES, which are given in Appendix C.
+
+<table><tr><td>Attack</td><td>Avg. Queries</td><td>Success Rate</td></tr><tr><td>AutoZOOM-BiLin (Tu et al., 2018)</td><td>15,064</td><td>&lt;100%</td></tr><tr><td>AutoZOOM-AE (Tu et al., 2018)</td><td>14,914</td><td>&lt;100%</td></tr><tr><td>BanditsT (Ours)</td><td>4455</td><td>100%</td></tr><tr><td>BanditsTD (Ours)</td><td>2297</td><td>100%</td></tr></table>

parse/train/ByxGSsR9FQ/ByxGSsR9FQ.md

@@ -0,0 +1,463 @@
+# $L _ { 2 }$ -NONEXPANSIVE NEURAL NETWORKS
+
+Haifeng Qian & Mark N. Wegman
+
+IBM Research Yorktown Heights, NY 10598, USA qianhaifeng,wegman@us.ibm.com
+
+# ABSTRACT
+
+This paper proposes a class of well-conditioned neural networks in which a unit amount of change in the inputs causes at most a unit amount of change in the outputs or any of the internal layers. We develop the known methodology of controlling Lipschitz constants to realize its full potential in maximizing robustness, with a new regularization scheme for linear layers, new ways to adapt nonlinearities and a new loss function. With MNIST and CIFAR-10 classifiers, we demonstrate a number of advantages. Without needing any adversarial training, the proposed classifiers exceed the state of the art in robustness against white-box $L _ { 2 }$ -bounded adversarial attacks. They generalize better than ordinary networks from noisy data with partially random labels. Their outputs are quantitatively meaningful and indicate levels of confidence and generalization, among other desirable properties.
+
+# 1 INTRODUCTION
+
+Artificial neural networks are often ill-conditioned systems in that a small change in the inputs can cause significant changes in the outputs (Szegedy et al., 2014). This results in poor robustness and vulnerability under adversarial attacks which has been reported on a variety of networks including image classification (Carlini & Wagner, $2 0 1 7 \mathrm { a }$ ; Goodfellow et al., 2014), speech recognition (Kreuk et al., 2018; Alzantot et al., 2018; Carlini & Wagner, 2018), image captioning (Chen et al., 2017) and natural language processing (Gao et al., 2018; Ebrahimi et al., 2017). These issues bring up both theoretical questions of how neural networks generalize (Kawaguchi et al., 2017; Xu & Mannor, 2012) and practical concerns of security in applications (Akhtar & Mian, 2018).
+
+A number of remedies have been proposed for these issues and will be discussed in Section 4. Whitebox defense is particularly difficult and many proposals have failed. For example, Athalye et al. (2018) reported that out of eight recent defense works, only Madry et al. (2017) survived strong attacks. So far the mainstream and most successful remedy is that of adversarial training (Madry et al., 2017). However, as will be shown in Tables 1 and 2, the robustness by adversarial training diminishes when a white-box attacker (Carlini & Wagner, 2017a) is allowed to use more iterations.
+
+This paper explores a different approach and demonstrates that a combination of the following three conditions results in enhanced robustness: 1) the Lipschitz constant of a network from inputs to logits is no greater than 1 with respect to the $L _ { 2 }$ -norm; 2) the loss function explicitly maximizes confidence gap, which is the difference between the largest and second largest logits of a classifier; 3) the network architecture restricts confidence gaps as little as possible. We will elaborate.
+
+There are previous works that achieve the first condition (Cisse et al., 2017; Hein & Andriushchenko, 2017) or bound responses to input perturbations by other means (Kolter & Wong, 2017; Raghunathan et al., 2018; Haber & Ruthotto, 2017). For example, Parseval networks (Cisse et al., 2017) bound the Lipschitz constant by requiring each linear or convolution layer be composed of orthonormal filters. However, the reported robustness and guarantees are often under weak attacks or with low noise magnitude, and none of these works has demonstrated results that are comparable to adversarial training.
+
+In contrast, we are able to build MNIST and CIFAR-10 classifiers, without needing any adversarial training, that exceed the state of the art (Madry et al., 2017) in robustness against white-box $L _ { 2 }$ - bounded adversarial attacks. The defense is even stronger if adversarial training is added. We will refer to these networks as $L _ { 2 }$ -nonexpansive neural networks (L2NNNs). Our advantage comes from a set of new techniques: our weight regularization, which is key in enforcing the first condition, allows greater degrees of freedom in parameter training than the scheme in Cisse et al. (2017); a new loss function is specially designed for the second condition; we adapt various layers in new ways for the third condition, for example norm-pooling and two-sided ReLU, which will be presented later.
+
+Let us begin with intuitions behind the second and third conditions. Consider a multi-class classifier. Let $g \left( \mathbf { x } \right)$ denote its confidence gap for an input data point $\mathbf { x }$ . If the classifier is a single L2NNN,1 we have a guarantee2 that the classifier will not change its answer as long as the input $\mathbf { x }$ is modified by no more than an $L _ { 2 }$ -norm of $g \left( \mathbf { x } \right) / \sqrt { 2 }$ . Therefore maximizing the average confidence gap directly boosts robustness and this motivates the second condition. To explain the third condition, let us introduce the notion of preserving distance: the distance between any pair of input vectors with two different labels ought to be preserved as much as possible at the outputs, while we do not care about the distance between a pair with the same label. Let $d \left( \mathbf { x _ { 1 } } , \mathbf { x _ { 2 } } \right)$ denote the $L _ { 2 }$ -distance between the output logit-vectors for two input points $\mathbf { x _ { 1 } }$ and $\mathbf { x _ { 2 } }$ that have different labels and that are classified correctly. It is straightforward to verify the condition3 of $g \left( \mathbf { x _ { 1 } } \right) + g \left( \mathbf { x _ { 2 } } \right) \leq { \sqrt { 2 } } \cdot d \left( \mathbf { x _ { 1 } } , \mathbf { x _ { 2 } } \right)$ . Therefore a network that maximizes confidence gaps well must be one that preserves distance well. Ultimately some distances are preserved while others are lost, and ideally the decision of which distance to lose is made by parameter training rather than by artifacts of network architecture. Hence the third condition involves distance-preserving architecture choices that leave the decision to parameter training as much as possible, and this motivates many of our design decisions such as Sections 2.2 and 2.3.
+
+In practice we employ the strategy of divide and conquer and build each layer as a nonexpansive map with respect to the $L _ { 2 }$ -norm. It is straightforward to see that a feedforward network composed of nonexpansive layers must implement a nonexpansive map overall. How to adapt subtleties like recursion and splitting-reconvergence is included in the appendix.
+
+Besides being robust against adversarial noises, L2NNNs have other desirable properties. They generalize better from noisy training labels than ordinary networks: for example, when $7 5 \%$ of MNIST training labels are randomized, an L2NNN still achieves $9 3 . 1 \%$ accuracy on the test set, in contrast to $7 5 . 2 \%$ from the best ordinary network. The problem of exploding gradients, which is common in training ordinary networks, is avoided because the gradient of any output with respect to any internal signal is bounded between -1 and 1. Unlike ordinary networks, the confidence gap of an L2NNN classifier is a quantitatively meaningful indication of confidence on individual data points, and the average gap is an indication of generalization.
+
+# 2 $L _ { 2 }$ -NONEXPANSIVE NEURAL NETWORKS
+
+This section describes how to adapt some individual operators in neural networks for L2NNNs.   
+Discussions on splitting-reconvergence, recursion and normalization are in the appendix.
+
+# 2.1 WEIGHTS
+
+This section covers both the matrix-vector multiplication in a fully connected layer and the convolution calculation between input tensor and weight tensor in a convolution layer. The convolution calculation can be viewed as a set of vector-matrix multiplications: we make shifted copies of the input tensor and shuffle the copies into a set of small vectors such that each vector contains input entries in one tile; we reshape the weight tensor into a matrix by flattening all but the dimension of the output filters; then convolution is equivalent to multiplying each of the said small vectors with the flattened weight matrix. Therefore, in both cases, a basic operator is $\mathbf { y } = W \mathbf { x }$ . To be a nonexpansive map with respect to the $L _ { 2 }$ -norm, a necessary and sufficient condition is
+
+$$
+\begin{array} { r c l } { \mathbf { y } ^ { \mathrm { T } } \mathbf { y } \leq \mathbf { x } ^ { \mathrm { T } } \mathbf { x } } & { \implies } & { \mathbf { x } ^ { \mathrm { T } } W ^ { \mathrm { T } } W \mathbf { x } \leq \mathbf { x } ^ { \mathrm { T } } \mathbf { x } , \quad \forall \mathbf { x } \in \mathbb { R } ^ { N } } \\ & & { \rho \left( W ^ { \mathrm { T } } W \right) \leq 1 } \end{array}
+$$
+
+where $\rho$ denotes the spectral radius of a matrix.
+
+The exact condition of (1) is difficult to incorporate into training. Instead we use an upper bound:4
+
+$$
+\rho \left( W ^ { \mathrm { T } } W \right) \leq b \left( W \right) \triangleq \operatorname* { m i n } \left( r ( W ^ { \mathrm { T } } W ) , r ( W W ^ { \mathrm { T } } ) \right) , \quad \mathrm { w h e r e } \ r \left( M \right) = \operatorname* { m a x } _ { i } \sum _ { j } \left| M _ { i , j } \right| \leq r \leq M .
+$$
+
+The above is where our linear and convolution layers differ from those in Cisse et al. (2017): they require $W W ^ { \mathrm { T } }$ to be an identity matrix, and it is straightforward to see that their scheme is only one special case that makes $b \left( W \right)$ equal to 1. Instead of forcing filters to be orthogonal to each other, our bound of $b \left( W \right)$ provides parameter training with greater degrees of freedom.
+
+One simple way to use (2) is replacing $W$ with $W ^ { \prime } = W / \sqrt { b \left( W \right) }$ in weight multiplications, and this would enforce that the layer is strictly nonexpansive. Another method is described in the appendix.
+
+As mentioned, convolution can be viewed as a first layer of making copies and a second layer of vector-matrix multiplications. With the above regularization, the multiplication layer is nonexpansive. Hence we only need to ensure that the copying layer is nonexpansive. For filter size of $K _ { 1 }$ by $K _ { 2 }$ and strides of $S _ { 1 }$ by $S _ { 2 }$ , we simply divide the input tensor by a factor of $\sqrt { \lceil K _ { 1 } / S _ { 1 } \rceil \cdot \lceil K _ { 2 } / S _ { 2 } \rceil }$ .
+
+# 2.2 RELU AND OTHERS
+
+Let us turn our attention to the third condition from Section 1. ReLU, tanh and sigmoid are nonexpansive but do not preserve distance well. This section presents a method that improves ReLU and is generalizable to other nonlinearities. A different approach to improve sigmoid is in the appendix.
+
+To understand the weakness of ReLU, let us consider two input data points A and B, and suppose that a ReLU in the network receives two different negative values for A and B and outputs zero for both. Comparing the A-B distance before and after this ReLU layer, there is a distance loss and this particular ReLU contributes to it. We use two-sided ReLU which is a function from $\mathbb { R }$ to $\mathbb { R } ^ { 2 }$ and simply computes $\scriptstyle { \mathrm { R e L U } } ( x )$ and $\mathrm { R e L U } ( - x )$ . Two-sided ReLU has been studied in Shang et al. (2016) in convolution layers for accuracy improvement. It is straightforward to verify that two-sided ReLU is nonexpansive with respect to any $L _ { p }$ -norm and that it preserves distance in the above scenario. We will empirically verify its effectiveness in increasing confidence gaps in Section 3.
+
+Two-sided ReLU is a special case of the following general technique. Let $f ( x )$ be a nonexpansive and monotonically increasing scalar function, and note that ReLU, tanh and sigmoid all fit these conditions. We can define a function from $\mathbb { R }$ to $\mathbb { R } ^ { 2 }$ that computes $f ( x )$ and ${ \bar { f } } ( x ) - x$ . Such a new function is nonexpansive with respect to any $L _ { p }$ -norm5 and preserves distance better than $f ( x )$ alone.
+
+# 2.3 POOLING
+
+The popular max-pooling is nonexpansive, but does not preserve distance as much as possible. Consider a scenario where the inputs to pooling are activations that represent edge detection, and consider two images A and B such that A contains an edge that passes a particular pooling window while B does not. Inside this window, A has positive values while B has all zeroes. For this window, the A-B distance before pooling is the $L _ { 2 }$ -norm of A’s values, yet if max-pooling is used, the A-B distance after pooling becomes the largest of A’s values, which can be substantially smaller than the former. Thus we suffer a loss of distance between A and B while passing this pooling layer.
+
+We replace max-pooling with norm-pooling, which was reported in Boureau et al. (2010) to occasionally increase accuracy. Instead of taking the max of values inside a pooling window, we take the $L _ { 2 }$ -norm of them. It is straightforward to verify that norm-pooling is nonexpansive6 and would entirely preserve the $L _ { 2 }$ -distance between A and B in the hypothetical scenario above. Other $L _ { p }$ -norms can also be used. We will verify its effectiveness in increasing confidence gaps in Section 3.
+
+If pooling windows overlap, we divide the input tensor by $\sqrt { K }$ where $K$ is the maximum number of pooling windows in which an entry can appear, similar to convolution layers discussed earlier.
+
+# 2.4 LOSS FUNCTION
+
+For a classifier with $K$ labels, we recommend building it as $K$ overlapping L2NNNs, each of which outputs a single logit for one label. In an architecture with no split layers, this simply implies that these $K$ L2NNNs share all but the last linear layer and that the last linear layer is decomposed into $K$ single-output linear filters, one in each L2NNN. For a multi-L2NNN classifier, we have a guarantee7 that the classifier will not change its answer as long as the input $\mathbf { x }$ is modified by no more than an $L _ { 2 }$ -norm of $g \left( \mathbf { x } \right) / 2$ , where again $g \left( \mathbf { x } \right)$ denotes the confidence gap. As mentioned in Section 1, a single-L2NNN classifier has a guarantee of $g \left( \mathbf { x } \right) / \sqrt { 2 }$ . Although this seems better on the surface, it is more difficult to achieve large confidence gaps. We will assume the multi-L2NNN approach.
+
+We use a loss function with three terms, with trade-off hyperparameters $\gamma$ and $\omega$
+
+$$
+\mathcal { L } = \mathcal { L } _ { a } + \gamma \cdot \mathcal { L } _ { b } + \omega \cdot \mathcal { L } _ { c }
+$$
+
+Let $y _ { 1 } , y _ { 2 } , \cdots , y _ { K }$ be outputs from the L2NNNs. The first loss term is
+
+$$
+\mathcal { L } _ { a } = \mathrm { s o f t m a x - c r o s s - e n t r o p y } \left( u _ { 1 } y _ { 1 } , u _ { 2 } y _ { 2 } , \cdot \cdot \cdot , u _ { K } y _ { K } , \mathrm { l a b e l } \right)
+$$
+
+where $u _ { 1 } , u _ { 2 } , \cdots , u _ { K }$ are trainable parameters. The second loss term is
+
+$$
+\mathcal { L } _ { b } = \operatorname { s o f t m a x - c r o s s - e n t r o p y } \left( v y _ { 1 } , v y _ { 2 } , \cdot \cdot \cdot , v y _ { K } , \mathrm { l a b e l } \right)
+$$
+
+where $v$ can be either a trainable parameter or a hyperparameter. Note that $u _ { 1 } , u _ { 2 } , \cdots , u _ { K }$ and $v$ are not part of the classifier and are not used during inference. The third loss term is
+
+$$
+\mathcal { L } _ { c } = \frac { \mathrm { a v e r a g e } \left( \log \left( 1 - \mathrm { s o f t m a x } \left( z y _ { 1 } , z y _ { 2 } , \cdot \cdot \cdot , z y _ { K } \right) _ { \mathrm { l a b e l } } \right) \right) } { z }
+$$
+
+where $z$ is a hyperparameter.
+
+The rationale for the first loss term (4) is that it mimics cross-entropy loss of an ordinary network. If an ordinary network has been converted to L2NNNs by multiplying each layer with a small constant, its original outputs can be recovered by scaling up L2NNN outputs with certain constants, which is enabled by the formula (4). Hence this loss term is meant to guide the training process to discover any feature that an ordinary network can discover. The rationale for the second loss term (5) is that it is directly related to the classification accuracy. Multiplying L2NNN outputs uniformly with $v$ does not change the output label and only adapts to the value range of L2NNN outputs and drive towards better nominal accuracy. The third loss term (6) approximates average confidence gap: the log term is a soft measure of a confidence gap (for a correct prediction), and is asymptotically linear for larger gap values. The hyperparameter $z$ controls the degree of softness, and has relatively low impact on the magnitude of loss due to the division by $z$ ; if we increase $z$ then (6) asymptotically becomes the average of minus confidence gaps for correct predictions and zeroes for incorrect predictions. Therefore loss (6) encourages large confidence gaps and yet is smooth and differentiable.
+
+A notable variation of (3) is one that combines with adversarial training. Our implementation applies the technique of Madry et al. (2017) on the first loss term (4): we use distorted inputs in calculating ${ \mathcal { L } } _ { a }$ . The results are reported in Tables 1 and 2 as Model 4. Another possibility is to use distorted inputs in calculating $\mathcal { L } _ { a }$ and $\mathcal { L } _ { b }$ , while $\mathcal { L } _ { c }$ should be based on original inputs.
+
+# 3 EXPERIMENTS
+
+Experiments are divided into three groups to study different properties of L2NNNs. Our MNIST   
+and CIFAR-10 classifiers are available at   
+http://researcher.watson.ibm.com/group/9298
+
+# 3.1 ROBUSTNESS
+
+This section evaluates robustness of L2NNN classifiers for MNIST and CIFAR-10 and compares against the state of the art Madry et al. (2017). The robustness metric is accuracy under whitebox non-targeted $L _ { 2 }$ -bounded attacks. The attack code of Carlini & Wagner (2017a) is used. We downloaded the classifiers8 of Madry et al. (2017) and report their robustness against $L _ { 2 }$ -bounded attacks in Tables 1 and 2.9 Note that their defense diminishes as the attacks are allowed more iterations. Figure 1 illustrates one example of this effect: the first image is an attack on MNIST Model 2 (0 recognized as 5) found after 1K iterations, with noise $L _ { 2 }$ -norm of 4.4, while the second picture is one found after 10K iterations, the same 0 recognized as 5, with noise $L _ { 2 }$ -norm of 2.1. We hypothesize that adversarial training alone provides little absolute defense at the noise levels used in the two tables: adversarial examples still exist and are only more difficult to find. The fact that in Table 2 Model 2 accuracy is lower in the $1 0 0 0 \mathrm { x } 1 0$ row than the 10K row further supports our hypothesis.
+
+![](images/da57723153f7c018a85b9b5209c1e577c647b94bbf65702044e8f0421b4b7c1e.jpg)  
+Figure 1: Attacks on Model 2 found after 1K and 10K iterations: the same 0 recognized as 5.
+
+Table 1: Accuracies of MNIST classifiers under white-box non-targeted attacks with noise $L _ { 2 }$ -norm limit of 3. MaxIter is the max number of iterations the attacker uses. Model 1 is an ordinarily trained model. Model 2 is the model from Madry et al. (2017). Model 3 is L2NNN without adversarial training. Model 4 is L2NNN with adversarial training.   
+
+<table><tr><td>MaxIter</td><td>Model1</td><td>Model2</td><td>Model3</td><td>Model4</td></tr><tr><td>Natural</td><td>99.1%</td><td>98.5%</td><td>98.7%</td><td>98.2%</td></tr><tr><td>100</td><td>70.2%</td><td>91.7%</td><td>77.6%</td><td>75.6%</td></tr><tr><td>1000</td><td>0.05%</td><td>51.5%</td><td>20.3%</td><td>24.4%</td></tr><tr><td>10K</td><td>0%</td><td>16.0%</td><td>20.1%</td><td>24.4%</td></tr><tr><td>100K</td><td>0%</td><td>9.8%</td><td>20.1%</td><td>24.4%</td></tr><tr><td>1M</td><td>0%</td><td>7.6%</td><td>20.1%</td><td>24.4%</td></tr></table>
+
+Table 2: Accuracies of CIFAR-10 classifiers under white-box non-targeted attacks with noise $L _ { 2 }$ - norm limit of 1.5. MaxIter is the max number of iterations the attacker uses, and $1 0 0 0 \mathrm { x } 1 0$ indicates 10 runs each with 1000 iterations. Model 1 is an ordinarily network. Model 2 is the model from Madry et al. (2017). Model 3 is L2NNN without adversarial training. Model 4 is L2NNN with adversarial training.   
+
+<table><tr><td>MaxIter</td><td>Model1</td><td>Model2</td><td>Model3</td><td>Model4</td></tr><tr><td>Natural</td><td>95.0%</td><td>87.1%</td><td>79.2%</td><td>77.2%</td></tr><tr><td>100</td><td>0%</td><td>13.9%</td><td>10.2%</td><td>20.8%</td></tr><tr><td>1000</td><td>0%</td><td>9.4%</td><td>10.1%</td><td>20.4%</td></tr><tr><td>10K</td><td>0%</td><td>9.0%</td><td>10.1%</td><td>20.4%</td></tr><tr><td>1000x10</td><td>0%</td><td>8.7%</td><td>10.1%</td><td>20.4%</td></tr><tr><td>100K</td><td>0%</td><td>NA</td><td>10.1%</td><td>20.4%</td></tr></table>
+
+In contrast, the defense of the L2NNN models remain constant when the attacks are allowed more iterations, specifically MNIST Models beyond 10K iterations and CIFAR-10 Models beyond 1000 iterations. The reason is that L2NNN classifiers achieve their defense by creating a confidence gap between the largest logit and the rest, and that half of this gap is a lower bound of $L _ { 2 }$ -norm of distortion to the input data in order to change the classification. Hence L2NNN’s defense comes from a minimum-distortion guarantee. Although adversarial training alone may also increase the minimum distortion limit for misclassification, as suggested in Carlini et al. (2017) for a small network, that limit likely does not reach the levels used in Tables 1 and 2 and hence the defense depends on how likely the attacker can reach a lower-distortion misclassification. Consequently when the attacks are allowed to make more attempts the defense with guarantee stands while the other diminishes.
+
+For both MNIST and CIFAR-10, adding adversarial training boosts the robustness of Model 4. We hypothesize that adversarial training lowers local Lipschitz constants in certain parts of the input space, specifically around the training images, and therefore makes local robustness guarantees larger (Hein & Andriushchenko, 2017). To test this hypothesis on MNIST Models 3 and 4, we measure the average $L _ { 2 }$ -norm of their Jacobian matrices, averaged over the first 1000 images in the test set, and the results are 1.05 for Model 3 and 0.83 for Model 4. Note that the $L _ { 2 }$ -norm of Jacobian can be greater than 1 for multi-L2NNN classifiers. These measurements are consistent with, albeit does not prove, the hypothesis.
+
+Table 3: Ablation studies: MNIST model without weight regularization; one without $\mathcal { L } _ { c }$ loss; one with max-pooling instead of norm-pooling; one without two-sided ReLU; Gap is average confidence gap. R-Accu is under attacks with 1000 iterations and with noise $L _ { 2 }$ -norm limit of 3.   
+
+<table><tr><td></td><td>Accu.</td><td>Gap</td><td>R-Accu.</td></tr><tr><td> no weight reg.</td><td>99.4%</td><td>68.3</td><td>0%</td></tr><tr><td>no Lc loss</td><td>99.2%</td><td>2.2</td><td>8.9%</td></tr><tr><td>no norm-pooling</td><td>98.8%</td><td>1.3</td><td>9.9%</td></tr><tr><td>no two-sided ReLU</td><td>98.0%</td><td>2.5</td><td>15.1%</td></tr></table>
+
+To test the effects of various components of our method, we build models for each of which we disable a different technique during training. The results are reported in Table 3. To put the confidence gap values in context, our MNIST Model 3 has an average gap of 2.8. The first one is without weight regularization of Section 2.1 and it becomes an ordinary network which has little defense against adversarial attacks; its large average confidence gap is meaningless. For the second one we remove the third loss term (6) and for the third one we replace norm-pooling with regular max-pooling, both resulting in smaller average confidence gap and less defense against attacks. For the fourth one, we replace two-sided ReLU with regular ReLU, and this leads to degradation in nominal accuracy, average confidence gap and robustness. Parseval networks (Cisse et al., 2017) can be viewed as models without $\mathcal { L } _ { c }$ term, norm-pooling or two-sided ReLU, and with a more restrictive scheme for weight matrix regularization.
+
+Model 3 in Table 1 and the second row of Table 3 are two points along a trade-off curve that are controllable by varying hyperparameter $\omega$ in loss function (3). Other trade-off points have nominal accuracy and under-attack accuracy of $( 9 8 . 8 \% , 1 9 . 1 \% )$ , $( 9 8 . 4 \% , 2 2 . 6 \% )$ ) and $( 9 7 . 9 \% , 2 4 . 7 \% )$ respectively. Similar trade-offs have been reported by other robustness works including adversarial training (Tsipras et al., 2019) and adversarial polytope (Wong et al., 2018). It remains an open question whether such trade-off is a necessary part of life, and please see Section 3.3 for further discussion on the L2NNN trade-off.
+
+Table 4: Accuracy of L2NNN classifiers under white-box non-targeted attacks with 1000 iterations and with noise $L _ { \infty }$ -norm limit of $\epsilon$ .   
+
+<table><tr><td></td><td>E</td><td>Model3</td><td>Model4</td></tr><tr><td>MNIST</td><td>0.1</td><td>90.9%</td><td>92.4%</td></tr><tr><td>MNIST</td><td>0.3</td><td>7.0%</td><td>44.0%</td></tr><tr><td>CIFAR-10</td><td>8/256</td><td>32.3%</td><td>42.5%</td></tr></table>
+
+Although we primarily focus on defending against $L _ { 2 }$ -bounded adversarial attacks in this work, we achieve some level of robustness against $L _ { \infty }$ -bounded attacks as a by-product. Table 4 shows our results, again measured with the attack code of Carlini & Wagner (2017a). The $\epsilon$ values match those used in Raghunathan et al. (2018); Kolter & Wong (2017); Madry et al. (2017). Our MNIST $L _ { \infty }$ results are on par with Raghunathan et al. (2018); Kolter & Wong (2017) but not as good as Madry et al. (2017). Our CIFAR-10 Model 4 is on par with Madry et al. (2017) for $L _ { \infty }$ defense.
+
+# 3.2 MEANINGFUL OUTPUTS
+
+This section discusses how to understand and utilize L2NNNs’ output values. We observe strong correlation between the confidence gap of L2NNN and the magnitude of distortion needed to force it to misclassify, and images are included in appendix.
+
+In the next experiment, we sort test data by the confidence gap of a classifier on each image. Then we divide the sorted data into 10 bins and report accuracy separately on each bin in Figure 2. We repeat this experiment for Model 2 (Madry et al., 2017) and our Model 3 of Tables 1 and 2. Note that the L2NNN model shows better correlation between confidence and robustness: for MNIST our first bin is $9 5 \%$ robust and second bin is $6 7 \%$ robust. This indicates that the L2NNN outputs are much more quantitatively meaningful than those of ordinary neural networks.
+
+![](images/d0f80dad0b74eb1a43332954cefa973c5c6eac108615c3dd523d5427d81b5f29.jpg)  
+Figure 2: Accuracy percentages of classifiers on test data bin-sorted by the confidence gap.
+
+It is an important property that an L2NNN has an easily accessible measurement on how robust its decisions are. Since robustness is easily measurable, it can be optimized directly, and we believe that this is the primary reason that we can demonstrate the robustness results of Tables 1 and 2. This can also be valuable in real-life applications where we need to quantify how reliable a decision is.
+
+One of the other practical implications of this property is that we can form hybrid models which use L2NNN outputs when the confidence is high and a different model when the confidence of the L2NNN is low. This creates another dimension of trade-off between nominal accuracy and robustness that one can take advantage of in an application. We built such a hybrid model for MNIST with the switch threshold of 1.0 and achieved nominal accuracy of $9 9 . 3 \%$ , where only $6 . 9 \%$ of images were delegated to the alternative classifier. We built such a hybrid model for CIFAR-10 with the switch threshold of 0.1 and achieved nominal accuracy of $8 9 . 4 \%$ , where $2 5 \%$ of images were delegated. To put these threshold values in context, MNIST Model 3 has an average gap of 2.8 and CIFAR-10 Model 3 has an average gap of 0.34. In other words, if for a data point the L2NNN confidence gap is substantially below average, the classification is delegated to the alternative classifier, and this way we can recover nominal accuracy at a moderate cost of robustness.
+
+# 3.3 GENERALIZATION VERSUS MEMORIZATION
+
+This section studies L2NNN’s generalization through a noisy-data experiment where we randomize some or all MNIST training labels. The setup is similar to Zhang et al. (2017), except that we added three scenarios where $2 5 \%$ , $5 0 \%$ and $7 5 \%$ of training labels are scrambled.
+
+Table 5 shows the comparison between L2NNNs and ordinary networks. Dropout rate and weightdecay weight are tuned for each WD/DR run, and each $\mathrm { W D + D R + E S }$ run uses the combined hyperparameters from its row. In early-stopping runs, 5000 training images are withheld as validation set and training stops when loss on validation set stops decreasing. The L2NNNs do not use weight decay, dropout or early stopping. L2NNNs achieve the best accuracy in all three partially-scrambled scenarios, and it is remarkable that an L2NNN can deliver $9 3 . 1 \%$ accuracy on test set when three quarters of training labels are random. More detailed data and discussions are in the appendix.
+
+Table 5: Accuracy comparison of MNIST classifiers that are trained on noisy data. Rand is the percentage of training labels that are randomized. WD is weight decay. DR is dropout. ES is early stopping. Gap1 is L2NNN’s average confidence gap on training set and Gap2 is that on test set.   
+
+<table><tr><td rowspan="2">Rand</td><td colspan="5">Ordinary network</td><td colspan="3">L2NNN</td></tr><tr><td>Vanilla</td><td>WD</td><td>DR</td><td>ES</td><td>WD+DR+ES</td><td></td><td>Gap1</td><td>Gap2</td></tr><tr><td>0</td><td>99.4%</td><td>99.0%</td><td>99.2%</td><td>99.0%</td><td>99.3%</td><td>98.7%</td><td>2.84</td><td>2.82</td></tr><tr><td>25%</td><td>90.4%</td><td>91.1%</td><td>91.8%</td><td>96.2%</td><td>98.0%</td><td>98.5%</td><td>0.64</td><td>0.63</td></tr><tr><td>50%</td><td>65.5%</td><td>67.7%</td><td>72.6%</td><td>81.0%</td><td>88.3%</td><td>96.0%</td><td>0.58</td><td>0.60</td></tr><tr><td>75%</td><td>41.5%</td><td>44.9%</td><td>41.8%</td><td>75.2%</td><td>66.4%</td><td>93.1%</td><td>0.86</td><td>0.89</td></tr><tr><td>100%</td><td>9.7%</td><td>9.1%</td><td>9.4%</td><td>NA</td><td>NA</td><td>11.9%</td><td>0.09</td><td>0.01</td></tr></table>
+
+Table 6: Training-accuracy-versus-confidence-gap trade-off points of L2NNNs on $5 0 \%$ -scrambled MNIST training labels.   
+
+<table><tr><td>on training set Accu.</td><td>Gap</td><td>on test set Accu. Gap</td></tr><tr><td>98.7%</td><td>0.17</td><td>79.0% 0.12</td></tr><tr><td>96.5%</td><td>0.21</td><td>79.3% 0.18</td></tr><tr><td>89.4%</td><td>0.22</td><td>86.3% 0.20</td></tr><tr><td>70.1%</td><td>0.36</td><td>93.4% 0.37</td></tr><tr><td>66.1%</td><td>0.45</td><td>93.7% 0.47</td></tr><tr><td>59.8%</td><td>0.58</td><td>96.0% 0.60</td></tr></table>
+
+To illustrate why L2NNNs generalize better than ordinary networks from noisy data, we show in Table 6 trade-off points between accuracy and confidence gap on the $5 0 \%$ -scrambled training set. These trade-off points are achieved by changing hyperparameters $\omega$ in (3) and $v$ in (5). In a noisy training set, there exist data points that are close to each other yet have different labels. For a pair of such points, if an L2NNN is to classify both points correctly, the two confidence gaps must be small. Therefore, in order to achieve large average confidence gap, an L2NNN must misclassify some of the training data. In Table 6, as we adjust the loss function to favor larger average gap, the L2NNNs are forced to make more and more mistakes on the training set. The results suggest that loss is minimized when an L2NNN misclassifies some of the scrambled labels while fitting the $5 0 \%$ original labels with large gaps, and parameter training discovers this trade-off automatically. Hence we see in Table 6 increasing accuracies and gaps on the test set. The above is a trade-off between memorization (training-set accuracy) and generalization (training-set average gap), and we hypothesize that L2NNN’s trade-off between nominal accuracy and robustness, reported in Section 3.1, is due to the same mechanism. To be fair, dropout and early stopping are also able to sacrifice accuracy on a noisy training set, however they do so through different mechanisms that tend to be brittle, and Table 5 suggests that L2NNN’s mechanism is superior. More discussions and the trade-off tables for $2 5 \%$ and $7 5 \%$ scenarios are in the appendix.
+
+Another interesting observation is that the average confidence gap dramatically shrinks in the last row of Table 5 where the training is pure memorization. This is not surprising again due to training data points that are close to each other yet have different labels. The practical implication is that after an L2NNN model is trained, one can simply measure its average confidence gap to know whether and how much it has learned to generalize rather than to memorize the training data.
+
+# 4 RELATED WORK
+
+Adversarial defense is a well-known difficult problem (Szegedy et al., 2014; Goodfellow et al., 2014; Carlini & Wagner, 2017a; Athalye et al., 2018; Gilmer et al., 2018). There are many avenues to defense (Carlini & Wagner, 2017b; Meng & Chen, 2017), and here we will focus on defense works that fortify a neural network itself instead of introducing additional components.
+
+The mainstream approach has been adversarial training, where examples of successful attacks on a classifier itself are used in training (Tramer et al., 2017; Zantedeschi et al., 2017). The work of \` Madry et al. (2017) has the best results to date and effectively flattens gradients around training data points, and, prior to our work, it is the only work that achieves sizable white-box defense. It has been reported in Carlini et al. (2017) that, for a small network, adversarial training indeed increases the average minimum $L _ { 1 }$ -norm and $L _ { \infty }$ -norm of noise needed to change its classification. However, in view of results of Tables 1 and 2, adversarial-training results may be susceptible to strong attacks. The works of Drucker & Le Cun (1992); Ross & Doshi-Velez (2017) are similar to adversarial training in aiming to flatten gradients around training data set but use different mechanisms.
+
+While the above approaches fortify a network around training data points, others aim to bound a network’s responses to input perturbations over the entire input space. For example, Haber & Ruthotto (2017) models ResNet as an ordinary differential equation and derive stability conditions. Other examples include Kolter & Wong (2017); Raghunathan et al. (2018); Wong et al. (2018) which achieved provable guarantees against $L _ { \infty }$ -bounded attacks. However there exist scalability issues with respect to network depth, and the reported results so far are against relatively weak attacks or low noise magnitude. As shown in Table 4, we can match their measured $L _ { \infty }$ -bounded defense.
+
+Controlling Lipschitz constants also regularizes a network over the entire input space. Szegedy et al. (2014) is the seminal work that brings attention to this topic. Bartlett et al. (2017) proposes the notion of spectrally-normalized margins as an indicator of generalization, which are strongly related to our confidence gap. Pascanu et al. (2013) studies the role of the spectral radius of weight matrices in the vanishing and the exploding gradient problems. Yoshida & Miyato (2017) proposes a method to regularize the spectral radius of weight matrices and shows its effect in reducing generalization gap. The work on Parseval networks (Cisse et al., 2017) shows that it is possible to control Lipschitz constants of neural networks through regularization. The core of their work is to constrain linear and convolution layer weights to be composed of Parseval tight frames, i.e., orthonormal filters, and thereby force the Lipschitz constant of these layers to be 1; they also propose to restrict aggregation operations. The reported robustness results of Cisse et al. (2017), however, are much weaker than those by adversarial training in Madry et al. (2017). We differ from Parseval networks in a number of ways. Our linear and convolution layers do not require filters to be orthogonal to each other and subsume Parseval layers as a special case, and therefore provide more freedom to parameter training. We use non-standard techniques, e.g. two-sided ReLU, to modify various network components to maximize confidence gaps while keeping the network nonexpansive, and we propose a new loss function for the same purpose. We are unable to obtain Parseval networks for a direct comparison, however it is possible to get a rough idea of what the comparison might be by looking at Table 3 which shows the impacts of those new techniques. The work of Hein & Andriushchenko (2017) makes an important point regarding guarantees provided by local Lipschitz constants, which helps explain many observations in our results, including why adversarial training on L2NNNs leads to lasting robustness gains. The regularization proposed by Hein & Andriushchenko (2017) however is less practical and again introduces reliance on the coverage of training data points.
+
+# 5 CONCLUSIONS AND FUTURE WORK
+
+In this work we have presented $L _ { 2 }$ -nonexpansive neural networks which are well-conditioned systems by construction. Practical techniques are developed for building these networks. Their properties are studied through experiments and benefits demonstrated, including that our MNIST and CIFAR-10 classifiers exceed the state of the art in robustness against white-box adversarial attacks, that they are robust against partially random training labels, and that they output confidence gaps which are strongly correlated with robustness and generalization. There are a number of future directions, for example, other applications of L2NNN, L2NNN-friendly neural network architectures, and the relation between L2NNNs and interpretability.
+
+# REFERENCES
+
+Naveed Akhtar and Ajmal Mian. Threat of adversarial attacks on deep learning in computer vision: A survey. arXiv preprint arXiv:1801.00553, 2018.
+
+Moustafa Alzantot, Bharathan Balaji, and Mani Srivastava. Did you hear that? Adversarial examples against automatic speech recognition. arXiv preprint arXiv:1801.00554, 2018.
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.
+
+Peter L Bartlett, Dylan J Foster, and Matus J Telgarsky. Spectrally-normalized margin bounds for neural networks. In Advances in Neural Information Processing Systems, pp. 6241–6250, 2017.
+
+Y-Lan Boureau, Jean Ponce, and Yann LeCun. A theoretical analysis of feature pooling in visual recognition. In International Conference on Machine Learning, pp. 111–118, 2010.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In Proceedings of the IEEE Symposium on Security and Privacy, pp. 39–57, 2017a.
+
+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, pp. 3–14. ACM, 2017b.
+
+Nicholas Carlini and David Wagner. Audio adversarial examples: Targeted attacks on speech-totext. arXiv preprint arXiv:1801.01944, 2018.
+
+Nicholas Carlini, Guy Katz, Clark Barrett, and David L Dill. Provably minimally-distorted adversarial examples. arXiv preprint arXiv:1709.10207, 2017.
+
+Hongge Chen, Huan Zhang, Pin-Yu Chen, Jinfeng Yi, and Cho-Jui Hsieh. Show-and-fool: Crafting adversarial examples for neural image captioning. arXiv preprint arXiv:1712.02051, 2017.
+
+Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In International Conference on Machine Learning, pp. 854–863, 2017.
+
+Harris Drucker and Yann Le Cun. Improving generalization performance using double backpropagation. IEEE Transactions on Neural Networks, 3(6):991–997, 1992.
+
+Javid Ebrahimi, Anyi Rao, Daniel Lowd, and Dejing Dou. Hotflip: White-box adversarial examples for nlp. arXiv preprint arXiv:1712.06751, 2017.
+
+Ji Gao, Jack Lanchantin, Mary Lou Soffa, and Yanjun Qi. Black-box generation of adversarial text sequences to evade deep learning classifiers. arXiv preprint arXiv:1801.04354, 2018.
+
+Justin Gilmer, Luke Metz, Fartash Faghri, Samuel S Schoenholz, Maithra Raghu, Martin Wattenberg, and Ian Goodfellow. Adversarial spheres. arXiv preprint arXiv:1801.02774, 2018.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Eldad Haber and Lars Ruthotto. Stable architectures for deep neural networks. Inverse Problems, 34(1):014004, 2017.
+
+Matthias Hein and Maksym Andriushchenko. Formal guarantees on the robustness of a classifier against adversarial manipulation. In Advances in Neural Information Processing Systems, pp. 2263–2273, 2017.
+
+Kenji Kawaguchi, Leslie Pack Kaelbling, and Yoshua Bengio. Generalization in deep learning. arXiv preprint arXiv:1710.05468, 2017.
+
+J. Zico Kolter and Eric Wong. Provable defenses against adversarial examples via the convex outer adversarial polytope. arXiv preprint arXiv:1711.00851, 2017.
+
+Felix Kreuk, Yossi Adi, Moustapha Cisse, and Joseph Keshet. Fooling end-to-end speaker verification by adversarial examples. arXiv preprint arXiv:1801.03339, 2018.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Dongyu Meng and Hao Chen. Magnet: a two-pronged defense against adversarial examples. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pp. 135–147. ACM, 2017.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pp. 1310–1318, 2013.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. arXiv preprint arXiv:1801.09344, 2018.
+
+Andrew Slavin Ross and Finale Doshi-Velez. Improving the adversarial robustness and interpretability of deep neural networks by regularizing their input gradients. arXiv preprint arXiv:1711.09404, 2017.
+
+Wenling Shang, Kihyuk Sohn, Diogo Almeida, and Honglak Lee. Understanding and improving convolutional neural networks via concatenated rectified linear units. In International Conference on Machine Learning, pp. 2217–2225, 2016.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In Proceedings of International Conference on Learning Representations, 2014.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patric \` k McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+Dimitris Tsipras, Shibani Santurkar, Logan Engstrom, Alexander Turner, and Aleksander Madry. Robustness may be at odds with accuracy. In International Conference on Learning Representations, 2019.
+
+Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In Advances in Neural Information Processing Systems, 2018.
+
+Huan Xu and Shie Mannor. Robustness and generalization. Machine learning, 86(3):391–423, 2012.
+
+Yuichi Yoshida and Takeru Miyato. Spectral norm regularization for improving the generalizability of deep learning. arXiv preprint arXiv:1705.10941, 2017.
+
+Valentina Zantedeschi, Maria-Irina Nicolae, and Ambrish Rawat. Efficient defenses against adversarial attacks. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 39–49. ACM, 2017.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In Proceedings of International Conference on Learning Representations, 2017.
+
+# A $L _ { 2 }$ -NONEXPANSIVE NETWORK COMPONENTS
+
+# A.1 ADDITIONAL METHODS FOR WEIGHT REGULARIZATION
+
+There are numerous ways to utilize the bound of (2). The main text describes a simple method of using $W ^ { \prime } = W / \sqrt { b \left( W \right) }$ to enforce strict nonexpansiveness. The following is an alternative.
+
+Approximate nonexpansiveness can be achieved by adding a penalty to the loss function whenever $b \left( W \right)$ exceeds 1, for example:
+
+$$
+\mathcal { L } _ { W } = \operatorname* { m i n } \left( l ( W ^ { \mathrm { T } } W ) , l ( W W ^ { \mathrm { T } } ) \right) , \mathrm { ~ w h e r e ~ } l \left( M \right) = \sum _ { i } \operatorname* { m a x } \left( \sum _ { j } \left| M _ { i , j } \right| - 1 , 0 \right)
+$$
+
+The sum of (7) losses over all layers becomes a fourth term in the loss function (3), multiplied with one additional hyperparameter. This would lead to an approximate L2NNN with trade-offs between how much its layers violate (1) with surrogate (2) versus other objectives in the loss function.
+
+In practice, we have found that it is beneficial to begin neural network training with the regularization scheme of (7), which allows larger learning rates, and switch to the first scheme of using $W ^ { \prime }$ , which avoids artifacts of an extra hyperparameter, when close to convergence. Of course if the goal is building approximate L2NNNs one can use (7) all the way.
+
+# A.2 SIGMOID AND OTHERS
+
+Sigmoid is nonexpansive as is, but does not preserve distance as much as possible. A better way is to replace sigmoid with the following operator
+
+$$
+s \left( x \right) = t \cdot { \mathrm { s i g m o i d } } \left( { \frac { 4 x } { t } } \right)
+$$
+
+where $t > 0$ is a trainable parameter and each neuron has its own $t$ . In general, the requirement for any scalar nonlinearity is that its derivative is bounded between $^ { - 1 }$ and 1. If a nonlinearity violates this condition, a shrinking multiplier can be applied. If the actual range of derivative is narrower, as in the case of sigmoid, an enlarging multiplier can be applied to preserve distance.
+
+For further improvement, (8) can be combined with the general form of the two-sided ReLU of Section 2.2. Then the new nonlinearity is a function from $\mathbb { R }$ to $\mathbb { R } ^ { 2 }$ that computes $s ( x )$ and $s ( x ) - x$
+
+# A.3 SPLITTING AND RECONVERGENCE
+
+There are different kinds of splitting in neural networks. Some splitting is not followed by reconvergence. For example, a classifier may have common layers followed by split layers for each label, and such an architecture can be viewed as multiple L2NNNs that overlap at the common layers and each contain one stack of split layers. In such cases, no modification is needed because there is no splitting within each individual L2NNN.
+
+Some splitting, however, is followed by reconvergence. In fact, convolution and pooling layers discussed earlier can be viewed as splitting, and reconvergence happens at the next layer. Another common example is skip-level connections such as in ResNet. Such splitting should be viewed as making two copies of a certain vector. Let the before-split vector be $\mathbf { x } _ { \mathrm { 0 } }$ , and we make two copies as
+
+$$
+\begin{array} { l } { \mathbf { x } _ { 1 } = t \cdot \mathbf { x } _ { 0 } } \\ { \mathbf { x } _ { 2 } = \sqrt { 1 - t ^ { 2 } } \cdot \mathbf { x } _ { 0 } } \end{array}
+$$
+
+where $t \in [ 0 , 1 ]$ is a trainable parameter.
+
+In the case of ResNet, the reconvergence is an add operator, which should be treated as vectormatrix multiplication as in Section 2.1, but with much simplified forms. Let $\mathbf { x } _ { 1 }$ be the skip-level connections and $f \left( \mathbf { x } _ { 2 } \right)$ be the channels of convolution outputs to be added with $\mathbf { x } _ { 1 }$ , we perform the addition as
+
+$$
+\mathbf { y } = t \cdot \mathbf { x } _ { 1 } + { \sqrt { 1 - t ^ { 2 } } } \cdot f \left( \mathbf { x } _ { 2 } \right)
+$$
+
+where $t \in [ 0 , 1 ]$ is a trainable parameter and could be a common parameter with (9).
+
+ResNet-like reconvergence is referred to as aggregation layers in Cisse et al. (2017) and a different formula was used:
+
+$$
+\mathbf { y } = { \boldsymbol { \alpha } } \cdot \mathbf { x } _ { 1 } + \left( 1 - { \boldsymbol { \alpha } } \right) \cdot f \left( \mathbf { x } _ { 2 } \right)
+$$
+
+where $\alpha \in [ 0 , 1 ]$ is a trainable parameter. Because splitting is not modified in Cisse et al. (2017), their scheme may seem approximately equivalent to ours if a common $t$ parameter is used for (9) and (10). However, there is a substantial difference: in many ResNet blocks, $f \left( \mathbf { x } _ { 2 } \right)$ is a subset of rather than all of the output channels of convolution layers, and our scheme does not apply the shrinking factor of $\sqrt { 1 - t ^ { 2 } }$ on channels that are not part of $f \left( \mathbf { x } _ { 2 } \right)$ and therefore better preserve distances. In contrast, because splitting is not modified, at reconvergence the scheme of Cisse et al. (2017) must apply the shrinking factor of $1 - \alpha$ on all outputs of convolution layers, regardless of whether a channel is part of the aggregation or not. To state the difference in more general terms, our scheme enables splitting and reconvergence at arbitrary levels of granularity and multiplies shrinking factors to only the necessary components. We can also have a different $t$ per channel or even per entry.
+
+To be fair, the scheme of Cisse et al. (2017) has an advantage of being nonexpansive with respect to any $L _ { p }$ -norm. However, for $L _ { 2 }$ -norm, it is inferior to ours in preserving distances and maximizing confidence gaps.
+
+# A.4 RECURSION
+
+There are multiple ways to interpret recurrent neural networks (RNN) as L2NNNs. One way is to view an unrolled RNN as multiple overlapping L2NNNs where each L2NNN generates the output at one time step. Under this interpretation, nothing special is needed and recurrent inputs to a neuron are simply treated as ordinary inputs.
+
+Another way to interpret an RNN is to view unrolled RNN as a single L2NNN that generates outputs at all time steps. Under this interpretation, recurrent connections are treated as splitting at their sources and should be handled as in (9).
+
+# A.5 NORMALIZATION
+
+Normalization operations are limited in an L2NNN. Subtracting mean is nonexpansive and allowed, and subtract-mean operation can be performed on arbitrary subsets of any layer. Subtracting batch mean is also allowed because it can be viewed as subtracting a bias parameter. However, scaling, e.g., division by standard deviation or batch standard deviation is only allowed if the multiplying factors are between -1 and 1. To satisfy this in practice, one simple method is to divide all multiplying factors in a normalization layer by the largest of their absolute values.
+
+# B MNIST IMAGES
+
+![](images/a9af584c85aef02ef32e1938023e110490e30aa97d41648cb7476233b508c0d7.jpg)  
+Figure 3: Original and distorted images of MNIST digits in test set with the largest confidence gaps. Mstk denotes the misclassified labels. Dist denotes the $L _ { 2 }$ -norm of the distortion noise.
+
+Let us begin by showing MNIST images with the largest confidence gaps in Figure 3 and those with the smallest confidence gaps in Figure 4. They include images before and after attacks as well as Model 3’s confidence gap, the misclassified label and $L _ { 2 }$ -norm of the added noise. The images with large confidence gaps seem to be ones that are most different from other digits, while some of the images with small confidence gaps are genuinely ambiguous. It’s worth noting the strong correlation between the confidence gap of L2NNN and the magnitude of distortion needed to force it to misclassify. Also note that our guarantee states that the minimum $L _ { 2 }$ -norm of noise is half of the confidence gap, but in reality the needed noise is much stronger than the guarantee. The reason is that the true local guarantee is in fact larger due to local Lipschitz constants, as pointed out by Hein & Andriushchenko (2017).
+
+![](images/182d34a6596c6ec67e9ae8287f8d1b00646d0b3761e3330be9ea3d1c29114375.jpg)  
+Figure 4: Original and distorted images of MNIST digits in test set with the smallest confidence gaps. Mstk denotes the misclassified output label. Dist denotes the $L _ { 2 }$ -norm of the distortion noise.
+
+![](images/e7666e7a78a2874a3848cb52e536683a6caff0ce3995ec8d432b550abcc17fd7.jpg)  
+Figure 5: Original image of 0; attack on Model 2 (Madry et al., 2017) found after 1K iterations; attack on Model 2 found after 10K iterations; attack on Model 3 (L2NNN) found after 1M iterations. The latter three all lead to misclassification as 5.
+
+Figure 5 shows additional details regarding the example in Figure 1. The first image is the original image of a zero. The second image is an attack on Model 2 (Madry et al., 2017) found after 1K iterations, with noise $L _ { 2 }$ -norm of 4.4. The third is one found after 10K iterations for Model 2, with noise $L _ { 2 }$ -norm of 2.1. The last image is the best attack on our Model 3 found after one million iterations, with noise $L _ { 2 }$ -norm of 3.5. These illustrates the trend shown in Table 1 that the defense by adversarial training diminishes as the attacks are allowed more iterations, while L2NNNs withstand strong attacks and it requires more noise to fool an L2NNN. It’s worth noting that the slow degradation of Model 2’s accuracy is an artifact of the attacker (Carlini & Wagner, 2017a): when gradients are near zero in some parts of the input space, which is true for MNIST Model 2 due to adversarial training, it takes more iterations to make progress. It is conceivable that, with a more advanced attacker, Model 2 could drop quickly to $7 . 6 \%$ . What truly matter are the robust accuracies where we advance the state of the art from $7 . 6 \%$ to $2 4 . 4 \%$ .
+
+# C DETAILS OF SCRAMBLED-LABEL EXPERIMENTS
+
+For ordinary networks in Table 5, we use two network architectures. The first has 4 layers and is the architecture used in Madry et al. (2017). The second has 22 layers and is the architecture of Models 3 and 4 in Table 1, which includes norm-pooling and two-sided ReLU. Results of ordinary networks using these two architectures are in Tables 7 and 8 respectively. The ordinary-network section of Table 5 is entry-wise max of Tables 7 and 8.
+
+In Tables 7 and 8, dropout rate and weight-decay weight are tuned for each WD/DR run, and each $\mathrm { W D + D R + E S }$ run uses the combined hyperparameters from its row. In early-stopping runs, 5000 training images are withheld as validation set and training stops when loss on validation set stops decreasing. Each ES or $\mathrm { W D + D R + E S }$ entry is an average over ten runs to account for randomness of the validation set. The L2NNNs do not use weight decay, dropout or early stopping.
+
+Table 9 shows L2NNN trade-off points between accuracy and confidence gap on the $2 5 \%$ -scrambled training set. Table 10 shows L2NNN trade-off points between accuracy and confidence gap on the $7 5 \%$ -scrambled training set. Like Table 6, they demonstrate the trade-off mechanism between memorization (training-set accuracy) and generalization (training-set average gap).
+
+Table 7: Accuracies of non-L2NNN MNIST classifiers that use a 4-layer architecture and that are trained on training data with various amounts of scrambled labels. Rand is the percentage of training labels that are randomized. WD is weight decay. DR is dropout. ES is early stopping.   
+
+<table><tr><td rowspan="2">Rand</td><td colspan="5">Ordinary network</td></tr><tr><td>Vanilla</td><td>WD</td><td>DR</td><td>ES</td><td>WD+DR+ES</td></tr><tr><td>0</td><td>98.9%</td><td>99.0%</td><td>99.2%</td><td>99.0%</td><td>99.3%</td></tr><tr><td>25%</td><td>82.5%</td><td>91.1%</td><td>91.8%</td><td>79.1%</td><td>98.0%</td></tr><tr><td>50%</td><td>57.7%</td><td>67.7%</td><td>72.6%</td><td>66.4%</td><td>88.3%</td></tr><tr><td>75%</td><td>32.1%</td><td>44.9%</td><td>41.8%</td><td>52.7%</td><td>66.4%</td></tr><tr><td>100%</td><td>9.5%</td><td>8.9%</td><td>9.4%</td><td>NA</td><td>NA</td></tr></table>
+
+Table 8: Accuracies of non-L2NNN MNIST classifiers that use a 22-layer architecture and that are trained on training data with various amounts of scrambled labels. Rand is the percentage of training labels that are randomized. WD is weight decay. DR is dropout. ES is early stopping.   
+
+<table><tr><td rowspan="2">Rand</td><td colspan="5">Ordinary network</td></tr><tr><td>Vanilla</td><td>WD</td><td>DR</td><td>ES</td><td>WD+DR+ES</td></tr><tr><td>0</td><td>99.4%</td><td>99.0%</td><td>99.0%</td><td>99.0%</td><td>99.0%</td></tr><tr><td>25%</td><td>90.4%</td><td>86.5%</td><td>89.8%</td><td>96.2%</td><td>90.3%</td></tr><tr><td>50%</td><td>65.5%</td><td>62.5%</td><td>63.7%</td><td>81.0%</td><td>83.1%</td></tr><tr><td>75%</td><td>41.5%</td><td>38.2%</td><td>40.2%</td><td>75.2%</td><td>61.9%</td></tr><tr><td>100%</td><td>9.7%</td><td>9.1%</td><td>8.8%</td><td>NA</td><td>NA</td></tr></table>
+
+To be fair, dropout and early stopping are also able to sacrifice accuracy on a noisy training set. For example, the DR run in the $5 0 \%$ -scrambled row in Table 7 has $6 7 . 5 \%$ accuracy on the training set and $7 2 . 6 \%$ on the test set. However, the underlying mechanisms are very different from that of L2NNN. Dropout (Srivastava et al., 2014) has an effect of data augmentation, and, with a noisy training set, dropout can create a situation where the effective data complexity exceeds the network capacity. Therefore, the parameter training is stalled at a lowered accuracy on the training set, and we get better performance if the model tends to fit more of original labels and less of the scrambled labels. The mechanism of early stopping is straightforward and simply stops the training when it is mostly memorizing scrambled labels. We get better performance from early stopping if the parameter training tends to fit the original labels early. These mechanisms from dropout and early stopping are both brittle and may not allow parameter training enough opportunity to learn from the useful data points with original labels. The comparison in Table 5 suggests that they are inferior to L2NNN’s trade-off mechanism as discussed in Section 3.3 and illustrated in Tables 6, 9 and 10. The L2NNNs in this paper do not use weight decay, dropout or early stopping, however it is conceivable that dropout may be complementary to L2NNNs.
+
+# D PROOFS
+
+Lemma 1. Let $g \left( \mathbf { x } \right)$ denote a single-L2NNN classifier’s confidence gap for an input data point x. The classifier will not change its answer as long as the input $\mathbf { x }$ is modified by no more than an $L _ { 2 }$ -norm of $g \left( \mathbf { x } \right) / \sqrt { 2 }$ .
+
+Proof. Let $\mathbf { y } \left( \mathbf { x } \right) = \left[ y _ { 1 } \left( \mathbf { x } \right) , y _ { 2 } \left( \mathbf { x } \right) , \cdots , y _ { K } \left( \mathbf { x } \right) \right]$ denote logit vector of a single-L2NNN classifier for an input data point $\mathbf { x }$ . Let $\mathbf { x _ { 1 } }$ and $\mathbf { x _ { 2 } }$ be two input vectors such that the classifier outputs different labels $i$ and $j$ . By definitions, we have the following inequalities:
+
+$$
+\begin{array} { r l } & { y _ { i } \left( \mathbf { x _ { 1 } } \right) - y _ { j } \left( \mathbf { x _ { 1 } } \right) \geq g \left( \mathbf { x _ { 1 } } \right) } \\ & { y _ { i } \left( \mathbf { x _ { 2 } } \right) - y _ { j } \left( \mathbf { x _ { 2 } } \right) \leq 0 } \end{array}
+$$
+
+Table 9: Training-accuracy-versus-confidence-gap trade-off points of L2NNNs on $2 5 \%$ -scrambled MNIST training labels.   
+
+<table><tr><td>on training set Accu.</td><td>Gap</td><td>on test set Accu. Gap</td></tr><tr><td>99.6%</td><td>0.12</td><td>92.6% 0.10</td></tr><tr><td>97.6%</td><td>0.20</td><td>95.7% 0.17</td></tr><tr><td>78.6%</td><td>0.31</td><td>98.2% 0.30</td></tr><tr><td>77.2%</td><td>0.64</td><td>98.5% 0.63</td></tr></table>
+
+Table 10: Training-accuracy-versus-confidence-gap trade-off points of L2NNNs on $7 5 \%$ -scrambled MNIST training labels.   
+
+<table><tr><td>on training set Accu.</td><td>Gap</td><td>on test set Accu. Gap</td></tr><tr><td>97.9%</td><td>0.07</td><td>49.8% 0.03</td></tr><tr><td>93.0%</td><td>0.09</td><td>59.2% 0.05</td></tr><tr><td>75.9%</td><td>0.10</td><td>70.0% 0.08</td></tr><tr><td>58.0%</td><td>0.18</td><td>80.4% 0.17</td></tr><tr><td>46.2%</td><td>0.29</td><td>86.8% 0.30</td></tr><tr><td>40.1%</td><td>0.44</td><td>89.8% 0.46</td></tr><tr><td>34.7%</td><td>0.86</td><td>93.1% 0.89</td></tr></table>
+
+Because the classifier is a single L2NNN, it must be true that:
+
+$$
+\begin{array} { r l } { \| \mathbf { x } _ { 2 } - \mathbf { x } _ { 1 } \| _ { 2 } \geq \| \mathbf { y } \left( \mathbf { x } _ { 2 } \right) - \mathbf { y } \left( \mathbf { x } _ { 1 } \right) \| _ { 2 } } & { } \\ & { \geq \sqrt { \left( g _ { \xi } \left( \mathbf { x } _ { 2 } \right) - g _ { \xi } \left( \mathbf { x } _ { 1 } \right) \right) ^ { 2 } + \left( y _ { \xi } \left( \mathbf { x } _ { 2 } \right) - y _ { \xi } \left( \mathbf { x } _ { 1 } \right) \right) ^ { 2 } } } \\ & { = \sqrt { \left( g _ { \xi } \left( \mathbf { x } _ { 1 } \right) - y _ { \xi } \left( \mathbf { x } _ { 2 } \right) \right) ^ { 2 } + \left( y _ { \xi } \left( \mathbf { x } _ { 2 } \right) - y _ { \xi } \left( \mathbf { x } _ { 1 } \right) \right) ^ { 2 } } } \\ & { \geq \sqrt { \frac { \left( y _ { \xi } \left( \mathbf { x } _ { 1 } \right) - y _ { \xi } \left( \mathbf { x } _ { 2 } \right) + y _ { \xi } \left( \mathbf { x } _ { 2 } \right) - y _ { \xi } \left( \mathbf { x } _ { 1 } \right) \right) ^ { 2 } } { 2 } } } \\ & { = \sqrt { \frac { \left( \left( y _ { \xi } \left( \mathbf { x } _ { 1 } \right) - y _ { \xi } \left( \mathbf { x } _ { 1 } \right) \right) + \left( y _ { \xi } \left( \mathbf { x } _ { 2 } \right) - y _ { \xi } \left( \mathbf { x } _ { 2 } \right) \right) \right) ^ { 2 } } { 2 } } } \\ & { \geq \sqrt { \frac { \left( g _ { \xi } \left( \mathbf { x } _ { 1 } \right) + 0 \right) ^ { 2 } } { 2 } } } \\ & { = g _ { \left( \mathbf { x } _ { 1 } \right) } / \sqrt { 2 } } \end{array}
+$$
+
+Lemma 2. Let $g \left( \mathbf { x } \right)$ denote a classifier’s confidence gap for an input data point x. Let $d \left( \mathbf { x _ { 1 } } , \mathbf { x _ { 2 } } \right)$ denote the $L _ { 2 }$ -distance between the output logit-vectors for two input points $\mathbf { x _ { 1 } }$ and $\mathbf { x _ { 2 } }$ that have different labels and that are classified correctly. Then this condition holds: $g \left( \mathbf { x _ { 1 } } \right) + g \left( \mathbf { x _ { 2 } } \right) \ \leq$ ${ \sqrt { 2 } } \cdot d \left( \mathbf { x _ { 1 } } , \mathbf { x _ { 2 } } \right)$ .
+
+Proof. Let y $\mathbf { \sigma } \left( \mathbf { x } \right) = \left[ y _ { 1 } \left( \mathbf { x } \right) , y _ { 2 } \left( \mathbf { x } \right) , \cdot \cdot \cdot , y _ { K } \left( \mathbf { x } \right) \right]$ denote logit vector of a classifier for an input data point $\mathbf { x }$ . Let $i$ and $j$ be the labels for $\mathbf { x _ { 1 } }$ and $\mathbf { x _ { 2 } }$ . By definitions, we have the following inequalities:
+
+$$
+\begin{array} { r } { y _ { i } \left( \mathbf { x _ { 1 } } \right) - y _ { j } \left( \mathbf { x _ { 1 } } \right) \geq g \left( \mathbf { x _ { 1 } } \right) } \\ { y _ { j } \left( \mathbf { x _ { 2 } } \right) - y _ { i } \left( \mathbf { x _ { 2 } } \right) \geq g \left( \mathbf { x _ { 2 } } \right) } \end{array}
+$$
+
+Therefore,
+
+$$
+\begin{array} { r l } { d ( \mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } ) \triangleq    \mathbf { y } ( \mathbf { x } _ { 2 } ) - \mathbf { y } ( \mathbf { x } _ { 1 } )   _ { 2 } } & { } \\ & { \leq \sqrt { (  ( \mathbf { y } _ { 1 } ( \mathbf { x } _ { 2 } ) ) - y _ { 1 } ( \mathbf { x } _ { 1 } )  ^ { 2 } + ( y _ { 1 } ( \mathbf { x } _ { 2 } ) - y _ { 1 } ( \mathbf { x } _ { 1 } ) ) ^ { 2 } } } \\ & { = \sqrt { ( y _ { 1 } ( \mathbf { x } _ { 1 } ) - y _ { 1 } ( \mathbf { x } _ { 2 } ) ) ^ { 2 } + ( y _ { 2 } ( \mathbf { x } _ { 2 } ) - y _ { 2 } ( \mathbf { x } _ { 1 } ) ) ^ { 2 } } } \\ & { \leq \sqrt { \frac { ( y _ { 1 } ( \mathbf { x } _ { 1 } ) - y _ { 1 } ( \mathbf { x } _ { 2 } ) + y _ { 2 } ( \mathbf { x } _ { 2 } ) - y _ { 1 } ( \mathbf { x } _ { 1 } ) ) ^ { 2 } } { 2 } } } \\ & { = \sqrt { \frac { ( ( y _ { 1 } ( \mathbf { x } _ { 1 } ) - y _ { 2 } ( \mathbf { x } _ { 1 } ) ) + ( y _ { 2 } ( \mathbf { x } _ { 2 } ) - y _ { 1 } ( \mathbf { x } _ { 2 } ) ) ) ^ { 2 } } { 2 } } } \\ & { \geq \sqrt { \frac { ( ( y _ { 1 } ( \mathbf { x } _ { 1 } ) + ( y _ { 2 } ( \mathbf { x } _ { 2 } ) ) ^ { 2 } ) } { 2 } } } \\ & { = \frac { g ( \mathbf { x } _ { 1 } ) + g ( \mathbf { x } _ { 2 } ) } { \sqrt { 2 } } } \\ & { = \frac { g ( \mathbf { x } _ { 1 } ) + g ( \mathbf { x } _ { 2 } ) } { \sqrt { 2 } } } \end{array}
+$$
+
+Lemma 3. For any $a \geq 0$ , $b \geq 0$ , $p \geq 1$ , the following inequality holds: $a ^ { p } + b ^ { p } \leq ( a + b ) ^ { p }$ .
+
+Proof. If $a$ and $b$ are both zero, the inequality holds. If at least one of $a$ and $b$ is nonzero:
+
+$$
+\begin{array} { c } { { a ^ { p } + b ^ { p } = ( a + b ) ^ { p } \cdot \displaystyle \left( \frac { a } { a + b } \right) ^ { p } + ( a + b ) ^ { p } \cdot \displaystyle \left( \frac { b } { a + b } \right) ^ { p } } } \\ { { \leq ( a + b ) ^ { p } \cdot \displaystyle \frac { a } { a + b } + ( a + b ) ^ { p } \cdot \displaystyle \frac { b } { a + b } } } \\ { { = ( a + b ) ^ { p } } } \end{array}
+$$
+
+Lemma 4. Let $f ( x )$ be a nonexpansive and monotonically increasing scalar function. Define a function from $\mathbb { R }$ to $\mathbb { R } ^ { 2 }$ : $\mathbf { h } ( x ) = [ f ( x ) , f ( x ) - x ]$ . Then $\mathbf { h } ( x )$ is nonexpansive with respect to any $L _ { p }$ -norm.
+
+Proof. For any $x _ { 1 } > x _ { 2 }$ , by definition we have the following inequalities:
+
+$$
+\begin{array} { l } { f ( x _ { 1 } ) - f ( x _ { 2 } ) \geq 0 } \\ { f ( x _ { 1 } ) - f ( x _ { 2 } ) \leq x _ { 1 } - x _ { 2 } } \end{array}
+$$
+
+For any $p \geq 1$ , invoking Lemma 3 with $a = f ( x _ { 1 } ) - f ( x _ { 2 } )$ and $b = x _ { 1 } - x _ { 2 } - f ( x _ { 1 } ) + f ( x _ { 2 } )$ , we have:
+
+$$
+\begin{array} { r l r } & { } & { \left( ( f ( x _ { 1 } ) - f ( x _ { 2 } ) ) ^ { p } + ( x _ { 1 } - x _ { 2 } - f ( x _ { 1 } ) + f ( x _ { 2 } ) ) ^ { p } \leq ( x _ { 1 } - x _ { 2 } ) ^ { p } \right. } \\ & { } & { \left. ( ( ( f ( x _ { 1 } ) - f ( x _ { 2 } ) ) ^ { p } + ( x _ { 1 } - x _ { 2 } - f ( x _ { 1 } ) + f ( x _ { 2 } ) ) ^ { p } ) ^ { 1 / p } \leq x _ { 1 } - x _ { 2 } \right. } \\ & { } & { \left. ( | f ( x _ { 1 } ) - f ( x _ { 2 } ) | ^ { p } + | ( f ( x _ { 1 } ) - x _ { 1 } ) - ( f ( x _ { 2 } ) - x _ { 2 } ) | ^ { p } ) ^ { 1 / p } \leq x _ { 1 } - x _ { 2 } \right. } \\ & { } & { \left. \| \mathbf { h } ( x _ { 1 } ) - \mathbf { h } ( x _ { 2 } ) \| _ { p } \leq x _ { 1 } - x _ { 2 } \right. } \end{array}
+$$
+
+Lemma 5. Norm-pooling within each pooling window is a nonexpansive map with respect to $L _ { 2 }$ - norm.
+
+Proof. Let $\mathbf { x _ { 1 } }$ and $\mathbf { x _ { 2 } }$ be two vectors with the size of a pooling window. By triangle inequality, we have
+
+$$
+\begin{array} { r } { \| \mathbf { x _ { 1 } } - \mathbf { x _ { 2 } } \| _ { 2 } + \| \mathbf { x _ { 1 } } \| _ { 2 } \geq \| \mathbf { x _ { 2 } } \| _ { 2 } } \\ { \| \mathbf { x _ { 1 } } - \mathbf { x _ { 2 } } \| _ { 2 } + \| \mathbf { x _ { 2 } } \| _ { 2 } \geq \| \mathbf { x _ { 1 } } \| _ { 2 } } \end{array}
+$$
+
+Therefore,
+
+$$
+\begin{array} { r } { \| \mathbf { x _ { 1 } } - \mathbf { x _ { 2 } } \| _ { 2 } \geq \| \mathbf { x _ { 2 } } \| _ { 2 } - \| \mathbf { x _ { 1 } } \| _ { 2 } } \\ { \| \mathbf { x _ { 1 } } - \mathbf { x _ { 2 } } \| _ { 2 } \geq \| \mathbf { x _ { 1 } } \| _ { 2 } - \| \mathbf { x _ { 2 } } \| _ { 2 } } \end{array}
+$$
+
+Therefore,
+
+$$
+\| \mathbf { x _ { 1 } } - \mathbf { x _ { 2 } } \| _ { 2 } \geq | \| \mathbf { x _ { 1 } } \| _ { 2 } - \| \mathbf { x _ { 2 } } \| _ { 2 } |
+$$
+
+Lemma 6. Let $g \left( \mathbf { x } \right)$ denote a multi-L2NNN classifier’s confidence gap for an input data point x. The classifier will not change its answer as long as the input $\mathbf { x }$ is modified by no more than an $L _ { 2 }$ -norm of $g \left( \mathbf { x } \right) / 2$ .
+
+Proof. Let $\mathbf { y } \left( \mathbf { x } \right) = \left[ y _ { 1 } \left( \mathbf { x } \right) , y _ { 2 } \left( \mathbf { x } \right) , \cdot \cdot \cdot , y _ { K } \left( \mathbf { x } \right) \right]$ denote logit vector of a multi-L2NNN classifier for an input data point x. Let $\mathbf { x _ { 1 } }$ and $\mathbf { x _ { 2 } }$ be two input vectors such that the classifier outputs different labels $i$ and $j$ . By definitions, we have the following inequalities:
+
+$$
+\begin{array} { r l } & { y _ { i } \left( \mathbf { x _ { 1 } } \right) - y _ { j } \left( \mathbf { x _ { 1 } } \right) \geq g \left( \mathbf { x _ { 1 } } \right) } \\ & { y _ { i } \left( \mathbf { x _ { 2 } } \right) - y _ { j } \left( \mathbf { x _ { 2 } } \right) \leq 0 } \end{array}
+$$
+
+For a multi-L2NNN classifier, each logit is a nonexpansive function of the input, and it must be true that:
+
+$$
+\begin{array} { r } { \| \mathbf { x _ { 2 } } - \mathbf { x _ { 1 } } \| _ { 2 } \geq \left| y _ { i } \left( \mathbf { x _ { 1 } } \right) - y _ { i } \left( \mathbf { x _ { 2 } } \right) \right| } \\ { \| \mathbf { x _ { 2 } } - \mathbf { x _ { 1 } } \| _ { 2 } \geq \left| y _ { j } \left( \mathbf { x _ { 2 } } \right) - y _ { j } \left( \mathbf { x _ { 1 } } \right) \right| } \end{array}
+$$
+
+Therefore,
+
+$$
+{ \begin{array} { r l } & { \left\| \mathbf { x } _ { 2 } - \mathbf { x } _ { 1 } \right\| _ { 2 } \geq { \frac { \left| y _ { i } \left( \mathbf { x } _ { 1 } \right) - y _ { i } \left( \mathbf { x } _ { 2 } \right) \right| + \left| y _ { j } \left( \mathbf { x } _ { 2 } \right) - y _ { j } \left( \mathbf { x } _ { 1 } \right) \right| } { 2 } } } \\ & { \qquad \geq { \frac { \left| y _ { i } \left( \mathbf { x } _ { 1 } \right) - y _ { i } \left( \mathbf { x } _ { 2 } \right) + y _ { j } \left( \mathbf { x } _ { 2 } \right) - y _ { j } \left( \mathbf { x } _ { 1 } \right) \right| } { 2 } } } \\ & { \qquad = { \frac { \left| \left( y _ { i } \left( \mathbf { x } _ { 1 } \right) - y _ { j } \left( \mathbf { x } _ { 1 } \right) \right) + \left( y _ { j } \left( \mathbf { x } _ { 2 } \right) - y _ { i } \left( \mathbf { x } _ { 2 } \right) \right) \right| } { 2 } } } \\ & { \qquad \geq { \frac { \left| g \left( \mathbf { x } _ { 1 } \right) + 0 \right| } { 2 } } } \\ & { \qquad = g \left( \mathbf { x } _ { 1 } \right) / 2 } \end{array} }
+$$

parse/train/EnmG3G5SYR/EnmG3G5SYR.md

@@ -0,0 +1,403 @@
+# Provable Benefits of Actor-Critic Methods for Offline Reinforcement Learning
+
+Andrea Zanette⇤ University of California, Berkeley zanette@berkeley.edu
+
+Martin J. Wainwright University of California, Berkeley wainwrig@berkeley.edu
+
+Emma Brunskill Stanford University ebrun@stanford.edu
+
+# Abstract
+
+Actor-critic methods are widely used in offline reinforcement learning practice, but are not so well-understood theoretically. We propose a new offline actor-critic algorithm that naturally incorporates the pessimism principle, leading to several key advantages compared to the state of the art. The algorithm can operate when the Bellman evaluation operator is closed with respect to the action value function of the actor’s policies; this is a more general setting than the low-rank MDP model. Despite the added generality, the procedure is computationally tractable as it involves the solution of a sequence of second-order programs. We prove an upper bound on the suboptimality gap of the policy returned by the procedure that depends on the data coverage of any arbitrary, possibly data dependent comparator policy. The achievable guarantee is complemented with a minimax lower bound that is matching up to logarithmic factors.
+
+# 1 Introduction
+
+The problem of learning a near-optimal policy is a core challenge in reinforcement learning (RL). In many settings, it is beneficial to be able to learn a good policy using only a pre-collected set of data, without further exploration with the environment; this problem is known as offline or batch policy learning. The offline setting has unique challenges due to the incomplete information about the Markov decision process (MDP) encoded in the available dataset. For example, due to maximization bias, a naive offline algorithm can return a policy with a severely overestimated value. In order to avoid such undesirable behavior, researchers have introduced the idea of pessimism under uncertainty, and there is now a growing literature (e.g., Liu et al. (2020); Jin et al. (2020b); Buckman et al. (2020); Kumar et al. (2019); Kidambi et al. (2020); Yu et al. (2020)) on different ways in which pessimism can be incorporated. See Appendix B for additional references and discussion of this body of work.
+
+At a high level, incorporating pessimism prevents algorithms from settling down on uncertain policies whose value might be misleadingly high under the current dataset due to statistical errors. By using pessimism, uncertain policies are penalized in such a way that only those policies robust to statistical errors are returned. The principle can be implemented in at least two different ways: (a) by penalizing policies that are far from the one that generated the dataset; or (b) by penalizing the value functions of policies not well covered by the dataset. In this paper, we take the latter avenue.
+
+# 1.1 Overview and our contributions
+
+Implementing pessimism with function approximation is challenging for several reasons. First, uncertainty must be estimated with particular care. On one hand, underestimating it can fail to correct the coverage problem. On the other hand, overestimating it leads to policies that are too conservative and thus underperform. Second, the incorporation of pessimism may introduce complex, higher order perturbations into the value function class handled by the algorithm. Similar issues can arise when adding optimistic bonuses in the exploration. The increased complexity of the function class often requires additional assumptions on the model, because the new class needs to interact “nicely” with the Bellman operator. Prior art on pessimism with function approximation has by-passed this problem by making strong model assumptions, such as low-rank transitions Jin et al. (2020b) or algorithm-specific assumptions Liu et al. (2020)
+
+Actor-critic methods: Most past theoretical work on offline reinforcement learning on finding with high probability the policy with the highest performance has focused on algorithms that are either model or value-based2 Liu et al. (2020); Jin et al. $\textcircled { 2 0 2 0 6 }$ ; Buckman et al. (2020); Kidambi et al. (2020); Yu et al. (2020); these often incorporate pessimism into the estimates of the policy performance. Actor-critic methods are a hybrid class of methods that mitigate some deficiencies of methods that are either purely policy or purely value-based Konda and Tsitsiklis $\textcircled { 1 2 0 0 0 } \textcircled { 2 0 0 3 }$ Heess et al. (2015); Haarnoja et al. (2017, 2018); in modern RL, they are widely used in practice (e.g., Levine et al. (2020); Wu et al. (2019, 2021); Kumar et al. (2019, 2020)). An actor-critic method generally consists of an actor that changes the policy in order to maximize its value as estimated by the critic. Given their popularity, it is natural to ask the following question: do actor-critic methods provably offer any advantage in offline RL? The main contribution of this paper is to give a positive answer to this question: by separating the policy optimization from the policy evaluation, both tasks become simpler to design and the pessimism principle can be incorporated more naturally.
+
+Contributions: More specifically, we study the problem of policy learning using linear function approximation in the offline setting. We assume that we are given a batch data set $\mathcal { D }$ , in which each sample consists of a quadruple. The first two components are the state-action pair, corresponding to the state in which a given action was taken, and the last two components correspond to a noisy observation of the reward, and a successor state drawn from the appropriate transition function. Our theory allows for a very general dependence structure among the the state-action pairs in these samples; when the data set is ordered according to how the samples were collected (which need not be related to a trajectory), we allow the state-action pair at any given instant to depend on all past samples. This set-up allows from data collected from arbitrary policies, mixtures of policies, generative models or even in adversarial manner.
+
+Given such a data set, our objective is to find the policy that performs best in the face of uncertainty. In particular, we need to account for the fact that the optimal policy $\pi ^ { * }$ for the underlying MDP may not be well covered by the dataset $\mathcal { D }$ , in which case the associated uncertainty would be prohibitive. In order to achieve this goal, we design an actor-critic procedure that iteratively optimizes a lower bound on the value of the optimal policy. Suppose that we are interested in optimizing the value function at some given initial $s _ { 1 }$ . Our strategy works as follows: for any given policy $\pi$ , we construct a family $\mathcal { M } ( \pi )$ of “statistically plausible” MDPs, and use them to define a simple second-order cone program. By solving this convex program, we obtain value function estimate $\underline { { { V } } } _ { M } ^ { \pi } ( s _ { 1 } ) =$ arg $\mathrm { m i n } _ { M \in \mathcal { M } ( \pi ) } V _ { M } ^ { \pi } \big ( s _ { 1 } \big )$ that—for an appropriately constructed family $\mathcal { M } ( \pi )$ —is guaranteed to be a lower bound on the true value function of $\pi$ in the unknown MDP that generated the dataset. Given a procedure for producing such lower bounds, it is then natural to maximize these lower bounds over some family $\Pi$ of policies. This combination leads to the saddle-point problem
+
+$$
+\operatorname* { m a x } _ { \pi \in \Pi } \operatorname* { m i n } _ { M \in \mathcal { M } ( \pi ) } V _ { M } ^ { \pi } \big ( s _ { 1 } \big ) .
+$$
+
+Note that actor-critic methods fit naturally in this framework: the critic provides a pessimistic evaluation of any given policy $\pi$ , and the actor solves the outer maximization problem over policies.
+
+This decoupling lends itself to a computationally tractable implementation, along with an analysis of the procedure. In particular, we show that the actor’s sequence of estimated policies enjoys online learning-style guarantees with respect to a sequence of pessimistic MDPs implicitly identified by the critic.
+
+The way in which we introduce pessimism is a second key component of the algorithmic framework. In particular, in line with our previous paper Zanette et al. (2020b), we do so without enlarging the prescribed classes of functions and policies. We do so by a direct perturbation of the value functions examined by the critic; there is no addition of pessimistic bonuses or absorbing states. Since the class of value functions is not altered, this method has two main advantages. First, there are no additional model assumptions compared to the standard—that is non-pessimistic—version of the actor-critic method. Second, the complexity of the underlying classes is not increased, thereby allowing us to construct tight confidence intervals and estimation error bounds that are minimax optimal up to logarithmic factors.
+
+The remainder of this paper is organized as follows. We begin in Section $2$ with background on MDPS, and then introduce the modeling assumptions that underlie the analysis of this paper. In Section $3 .$ we introduce the algorithm studied in this paper, namely the Pessimistic Actor Critic for Learning without Exploration (for short, PACLE) algorithm. Section $\boxed { 4 }$ provides statements of our main results and discussion of their consequences, including an upper bound on the PACLE algorithm in Theorem $^ { 1 , }$ and a minimax lower bound in Theorem $\bigstar$ In Section $\bigstar \bigstar$ we provide an outline of the proof of Theorem $\bigstar$ with various technical details as well as the proof of Theorem $\bigstar$ deferred to the appendices. We conclude with a discussion in Section 5.
+
+# 1.2 Notation
+
+For the reader’s convenience, we summarize here some notation used throughout the paper. We let $B _ { d } ( r ) = \{ x \in \mathbb { R } ^ { d } \mid \| x \| _ { 2 } \leq r \}$ denote the Euclidean ball of radius $r \in \mathbb { R }$ in dimension $d$ ; we simply write $\boldsymbol { B }$ when there is no possibility of confusion. For a vector $x \in \mathbb { R } ^ { d }$ , we use $[ x ] _ { i }$ to denote its $i ^ { t h }$ component. We use the $\widetilde O$ notation to denote an upper bound that holds up to constants and log factors in the input parameters $\textstyle { \bigl ( } { \frac { 1 } { \delta } } , d , H { \bigr ) }$ . The notation $\lesssim$ means an upper bound that holds up to a constant, with an analogous definition for $\gtrsim$ .
+
+# 2 Background and problem formulation
+
+We begin by providing some background, before introducing the assumptions that underlie our problem formulation.
+
+# 2.1 Markov decision processes
+
+In this paper, we focus on finite-horizon Markov decision processes, for which we provide a very brief introduction here. See the books Puterman (1994); Bertsekas and Tsitsiklis (1996); Bertsekas $\textcircled { 1 9 9 5 }$ ; Sutton and Barto (2018) for more background and detail. A finite-horizon MDP is specified by a positive integer $\overline { H }$ , and events take place over a sequence of stages indexed by the time step $\boldsymbol { h } \in [ H ] \overset { d e f } { = } \{ 1 , \dots , H \}$ . The underlying dynamics involve a state space $s$ , and are controlled by actions that take values in some action set $\mathcal { A }$ . In this paper, we allow the state space to be arbitrary (continous or discrete), whereas our analysis applies to discrete action spaces. For each time step $h \in [ H ]$ , there is a reward function $r _ { h } : \mathcal { S } \times \mathcal { A } \to \mathbb { R }$ , and for every time step $h$ and state-action pair $( s , a )$ , there is a transition function $\mathbb { P } _ { h } ( \cdot \mid s , a )$ . When at horizon $h$ , if the agent takes action $a$ in state $s$ , it receives a random reward drawn from a distribution $R _ { h } ( s , a )$ with mean $r _ { h } ( s , a )$ , and it then transitions randomly to a next state $s ^ { + }$ drawn from the transition function $\mathbb { P } _ { h } ( \cdot \mid s , a )$ .
+
+A policy $\pi _ { h }$ at stage $h$ is a mapping from the state space $s$ to the action space $\mathcal { A }$ . Given a full policy $\pi = ( \pi _ { 1 } , \ldots , \pi _ { H } )$ , the state-action value function at time step $h$ is given by
+
+$$
+Q _ { h } ^ { \pi } ( s , a ) = r _ { h } ( s , a ) + \mathbb { E } _ { S _ { \ell } \sim \pi \mid ( s , a ) } \sum _ { \ell = h + 1 } ^ { H } r _ { \ell } ( S _ { \ell } , \pi _ { \ell } ( S _ { \ell } ) ) ,
+$$
+
+where the expectation is over the trajectories induced by $\pi$ upon starting from the pair $( s , a )$ . When we omit the starting state-action pair $( s , a )$ , the expectation is intended to start from a fixed state
+
+denoted by $s _ { 1 }$ . The value function associated to $\pi$ is $V _ { h } ^ { \pi } ( s ) = Q _ { h } ^ { \pi } ( s , \pi _ { h } ( s ) )$ . For a given policy $\pi$ , we define the Bellman evaluation operator
+
+$$
+\begin{array} { r } { \mathcal { T } _ { h } ^ { \pi } ( Q _ { h + 1 } ) ( s , a ) = r _ { h } ( s , a ) + \mathbb { E } _ { S ^ { \prime } \sim \mathbb { P } _ { h } ( s , a ) } \mathbb { E } _ { A ^ { \prime } \sim \pi } Q _ { h + 1 } ( S ^ { \prime } , A ^ { \prime } ) . } \end{array}
+$$
+
+Under some regularity conditions Puterman (1994); Shreve and Bertsekas (1978), there always exists an optimal policy $\pi ^ { \star }$ whose value and action-value functions are defined as
+
+$$
+V _ { h } ^ { \star } ( s ) = V _ { h } ^ { \pi ^ { \star } } ( s ) = \operatorname* { s u p } _ { \pi } V _ { h } ^ { \pi } ( s ) , \quad \mathrm { a n d } \quad Q _ { h } ^ { \star } ( s , a ) = Q _ { h } ^ { \pi ^ { \star } } ( s , a ) = \operatorname* { s u p } _ { \pi } Q _ { h } ^ { \pi } ( s , a ) .
+$$
+
+# 2.2 Assumptions on data generation
+
+In this paper, we study a model in which we observe a dataset of the form $\mathcal { D } = \{ ( s _ { i } , a _ { i } , r _ { i } , s _ { i } ^ { + } ) \} _ { i = 1 } ^ { n }$ where $n$ is the total sample size. For each $i \in [ n ] = \{ 1 , 2 , . . . , n \}$ , the tuple $( s _ { i } , a _ { i } )$ corresponds to a state-action pair associated with some time step $h _ { i }$ . We let $\mathcal { F } _ { i }$ be the $\sigma$ -field generated by the samples $\{ ( s _ { j } , a _ { j } , r _ { j } , s _ { j } ^ { + } ) \} _ { j = 1 } ^ { i - 1 }$ that are in the “past” relative to index $i$ . With this notation, we impose the following condition:
+
+Assumption 1 (Data generation). For each $i \in [ n ]$ , the pair $( s _ { i } , a _ { i } )$ is measurable with respect to ${ \mathcal { F } } _ { i }$ . Conditionally on a given pair $( s _ { i } , a _ { i } )$ , the random variable $r _ { i }$ is drawn from a reward distribution $R _ { h _ { i } } ( s _ { i } , a _ { i } )$ that is 1-sub-Gaussian; and the next state $s _ { i } ^ { + }$ is drawn from the distribution $\mathbb { P } _ { h _ { i } } ( s _ { i } , a _ { i } )$ .
+
+Note that the measurability condition allows the choice of $( s _ { i } , a _ { i } )$ to depend arbitrarily on any of the past data with indices $j < i$ . The mild assumption allows for considerable freedom. For example, the state-action pairs may be chosen from (mixture) policies, or they can be generated by an adversarial procedure that changes the data acquisition strategy as feedback is received.
+
+For each $h \in [ H ]$ , we let $\mathcal { T } _ { h }$ denote the subset of observation indices $i \in [ n ]$ such that $h _ { i } = h$ . These index sets define the sub-datasets ${ \mathcal { D } } _ { h } = \{ ( s _ { i } , a _ { i } , r _ { i } , s _ { i } ^ { + } ) , i \in { \mathcal { I } } _ { h } \}$ associated with all samples that are based on be written as rs at time step . $h$ . We define $n _ { h } = | \mathcal { D } _ { h } |$ , so that our total sample size can $\begin{array} { r } { n = \sum _ { h = 1 } ^ { H } n _ { h } } \end{array}$
+
+# 2.3 Policy and function classes
+
+Next we define the policy space $\Pi$ and the action value function space $\mathcal { Q }$ over which we seek solutions. Let $\phi : \mathcal { S } \overset { \cdot } { \times } \overset { \cdot } { \underset { \cdot } { A } } \overset { \cdot } { \mapsto } \overset { \cdot } { \mathbb { R } ^ { d } }$ be a $d$ -dimensional feature mapping. We assume throughout that these feature mappings are normalized such that $\| \phi ( s , a ) \| _ { 2 } \leq 1$ uniformly for all $( s , a )$ -pairs. We consider action-value functions that are linear in $\phi$ , and families of the form
+
+$$
+\mathcal { Q } ( { \boldsymbol { \rho } } ^ { w } ) \stackrel { d e f } { = } \{ ( s , a ) \mapsto \langle \phi ( s , a ) , w \rangle \mid \| w \| _ { 2 } \leq \rho ^ { w } \} ,
+$$
+
+ere $\rho ^ { w } \in ( 0 , 1 ]$ is a user-defined radius. For policies, we consider the associated soft-max
+
+$$
+\Pi _ { s o f t } ( \rho ^ { \theta } ) \overset { d e f } { = } \left\{ \frac { e ^ { \langle \phi ( s , a ) , \theta \rangle } } { \displaystyle \sum _ { a ^ { \prime } \in \mathcal { A } } e ^ { \langle \phi ( s , a ^ { \prime } ) , \theta \rangle } } \ | \ \| \theta \| _ { 2 } \leq \rho ^ { \theta } \right\} ,
+$$
+
+where $\rho ^ { \theta } > 0$ is a second radius.
+
+In the context of our actor-critic algorithm, the weight radius other hand, the actor produces a sequence of soft-max radii $\rho ^ { w }$ ins fixed for all updates. O, indexed by the iterations theof $\{ \rho _ { t } ^ { \theta } \} _ { t = 1 } ^ { T }$ $t$ the actor. This sequence is produced via the update rule in Line $\cdot ^ { 5 }$ of Algorithm $\dot { 1 . }$ The policy radius can be large $\rho ^ { \theta } \gg 1$ but we constrain $\rho ^ { w } \leq 1$ so that the critic’s estimate $Q _ { w } ( \overline { { s , } } a ) = \overline { { \langle \phi ( s , a ) , w \rangle } }$ is bounded by one, i.e., $\begin{array} { r } { \operatorname* { s u p } _ { ( s , a , w ) } | Q _ { w } ( s , a ) | \leq 1 } \end{array}$ .
+
+Recall that our MDP consists of sequence of $H$ distinct stages. Our algorithm and theory allows for the possibility of different feature extractors at each step $h \in [ H ]$ , even with possibly different dimensions. Consequently, in implementing and analyzing the algorithm, there are actually $H$ (possibly different) functional spaces $\{ \mathcal { Q } _ { h } \} _ { h = 1 } ^ { H }$ , along with the associated soft-max policy classes $\{ \Pi _ { h } \} _ { h = 1 } ^ { H }$ . So as to simplify notation, we drop the dependence on the radii when referring to the functional spaces, and implicitly assume that the terminal value function is zero.
+
+# 2.4 A range of function class assumptions
+
+In this section, we discuss a range of assumptions that might be imposed on the class of action-value functions. This discussion serves as motivation for the particular assumption (Bellman restricted closedness—cf. Assumption $\textcircled { 3 }$ that underlies our analysis.
+
+We begin with the least restrictive condition, which is a very natural starting point in our given set-up. If we seek to find the policy $\pi \in \Pi$ with the highest value function, it seems reasonable to require that the following representation condition (approximately) holds.
+
+Assumption 2 (Linear action-value functions $Q ^ { \pi }$ ). The MDP admits a linear action-value function representation for all policies in $\Pi$ , meaning that for each policy $\pi \in \Pi$ and time step $\dot { h } \in [ H ]$ , there exists a vector $w _ { h } ^ { \pi }$ such that
+
+$$
+Q _ { h } ^ { \pi } ( s , a ) = \left. \phi _ { h } ( s , a ) , w _ { h } ^ { \pi } \right. .
+$$
+
+This assumption alone turns out to be inadequate to ensure that effective learning is possible; indeed, the recent papers Zanette (2020); Weisz et al. (2020) establish that even under this condition, there are instances that require exponentially many samples to do better than a random policy.
+
+Given this fact, if one is interested in procedures with polynomial complexity (in both sample size and running time), stronger conditions need to be imposed. In general, the Bellman evaluation operator, even when applied to a linear action-value function, will return a nonlinear value function. The analysis of this paper is based on bounding the Bellman error in the sense of sup-norm deviation from linearity:
+
+Assumption 3 (Bellman Restricted Closedness). The policy and value function spaces $( \Pi , \mathcal { Q } )$ are closed up to $\nu \in \mathbb { R } ^ { H }$ error in the sup-norm if there is a non-negative sequence $\{ \bar { \nu } _ { h } \} _ { h = 1 } ^ { H }$ Qsuch that for each $h \in [ H ]$ , we have
+
+$$
+\operatorname* { s u p } _ { Q _ { h + 1 } \in \mathcal Q _ { h + 1 } } \operatorname* { i n f } _ { Q _ { h } \in \mathcal Q _ { h } } \| Q _ { h } - \mathcal T _ { h } ^ { \pi _ { h + 1 } } Q _ { h + 1 } \| _ { \infty } \leq \nu _ { h } .
+$$
+
+The restricted closedness assumption measures how well we can fit the action-value function resulting from the application of the Bellman evaluation operator to an action value function in $\mathcal { Q }$ and for a policy in $\Pi$ . It enables the analysis of least-squares policy evaluation (e.g., Nedic and ´ Bertsekas (2003)), which will be our starting point when constructing the critic.
+
+Finally, for understanding connections to past work, it is relevant to compare to the low-rank MDP assumption that has been analyzed in recent work Jin et al. (2020a); Yang and Wang $\underline { { ( 2 0 2 0 ) } }$ including in offline RL with pessimismistic guarantees Jin et al. (2020b), as well as in various online settings Agarwal et al. (2020a); Modi et al. (2021); Zanette et al. (2020a).
+
+Assumption 4 (Low-Rank MDP). An MDP is low-rank if for all $h \in [ H ]$ , there exists a reward parameter $w _ { h } \in \mathbb { R } ^ { d }$ and a component-wise positive mapping $\psi _ { h } : S \to \mathbb { R } _ { + } ^ { d }$ such that $\| \psi _ { h } ( s ) \| _ { 1 } = 1$ for all $s \in S$ , and
+
+$$
+\begin{array} { r l r l r } { r _ { h } ( s , a ) = \langle \phi _ { h } ( s , a ) , w _ { h } \rangle , } & { } & { \mathbb { P } _ { h } ( s ^ { \prime } \mid s , a ) = \langle \phi _ { h } ( s , a ) , \psi _ { h } ( s ^ { \prime } ) \rangle , } & { } & { \forall ( s , a , h , s ^ { \prime } ) . } \end{array}
+$$
+
+The following proposition explicates the nested relationship between these three conditions, showing that the low-rank MDP condition is the most restrictive:
+
+Proposition 1 (Low Rank $\subset$ Restricted Closedness $\subset$ Linear $Q ^ { \pi }$ ). For any fixed state-action space, horizon, and feature extractor:
+
+(a) The class of low-rank MDPs is a strict subset of the class of MDPs that satisfy Bellman restricted closedness.   
+(b) The class of MDPs that satisfy Bellman restricted closedness is a strict subset of the linear Q⇡ MDP class.
+
+See Appendix C for the proof of this claim.
+
+Based on Proposition $\bigstar$ we see that any analysis based on assuming Bellman restricted closedness also a fortiori applies to MDPs that satisfy the more stringent low-rank MDP condition.
+
+# 3 The Pessimistic Actor-Critic
+
+Given the set-up thus far, we are now ready to describe the actor-critic algorithm that we analyze in this paper. We refer to it as the Pessimistic Actor Critic for Learning without Exploration, or PACLE for short. We first describe the critic in Section $\underline { { \boldsymbol { \left. 3 . 1 \right. } } }$ and then the actor in Section 3.2. We summarize the actor and critic algorithms, respectively, in pseudocode form in Algorithm 1 and Algorithm 2.
+
+# 3.1 The Critic: Pessimistic Least Square Policy Evaluation
+
+The purpose of the critic is to provide pessimistic value function estimates corresponding to the policy $\pi$ under consideration by the actor. Monte Carlo with importance sampling (IS) is not desirable in this setting, as the policy or distribution that generated the dataset might be unknown and estimation errors on the distribution can accumulate exponentially with the horizon in IS estimators (see e.g. Liu et al. $\textcircled { 2 0 1 8 6 } )$ . Instead, we use a least-squares temporal difference method for policy evaluation, but suitably perturbed to return pessimistic estimates—i.e., lower bounds on the true value function of the given policy $\pi$ . Our method is based on directly perturbing the regression parameters in the least-square estimate. In contrast to bonus-based approaches, this method has the important advantage of ensuring that the action-value function remains linear. The purpose of the perturbations is to compensate for possible statistical errors in estimating the regression parameter due to poor coverage of the given dataset.
+
+Let us now give a precise description of the critic. Given a policy $\pi = ( \pi _ { 1 } , \ldots , \pi _ { H } )$ , the goal of the critic is to minimize the quantity
+
+$$
+\operatorname { \mathbb { E } } _ { A ^ { \prime } \sim \pi _ { 1 } } \left. \phi ( s _ { 1 } , A ^ { \prime } ) , w _ { 1 } \right. = \sum _ { a \in { \mathcal { A } } } \pi _ { 1 } ( a \mid s _ { 1 } ) \left. \phi _ { 1 } ( s _ { 1 } , a ) , w _ { 1 } \right. ,
+$$
+
+which is an estimate of the value function $V ^ { \pi } ( s _ { 1 } )$ for the policy $\pi$ at the initial state $s _ { 1 }$ . The parameter $\boldsymbol { w } _ { 1 } ~ \in ~ \mathbb { R } ^ { d }$ is a vector to be adjusted, one that is determined by a backwards-running sequence of regression problems from $h = H$ down to $h = 1$ .
+
+We introduce the pessimistic perturbations directly to the solution of these regression problems. They involve a norm defined by the cumulative covariance matrix. Recall that $\mathcal { T } _ { h }$ indexes the subset of observations associated with state-action pairs at time step $h$ . For each $h \in [ H ]$ and $i \in \mathcal { T } _ { h }$ , let us write the associated sample as the quadruple $\left( { { s _ { h i } } , { a _ { h i } } , { r _ { h i } } , { s _ { h + 1 , i } } } \right)$ . Introducing the shorthand notation $\phi _ { h i } = \phi _ { h } ( s _ { h i } , a _ { h i } )$ , we define the cumulative covariance matrix
+
+$$
+{ \Sigma } _ { h } \overset { d e f } { = } \Big ( \sum _ { i \in \mathbb { Z } _ { h } } \phi _ { h i } \phi _ { h i } ^ { \top } \Big ) + I _ { d \times d } ,
+$$
+
+where $I _ { d \times d }$ denotes the $d$ -dimensional identity matrix. Notice that the cumulative covariance grows as the number of samples in $\mathcal { T } _ { h }$ increases; we do not normalize it by the local sample size $n _ { h } = | \mathcal { T } _ { h } |$ , so that $\Sigma _ { h }$ effectively represents the amount of information contained in the sub-dataset $\mathcal { D } _ { h }$ at time step $h$ .
+
+Since $\Sigma _ { h }$ is strictly positive definite by construction, it defines a pair of norms
+
+$$
+\begin{array} { r } { \left\| u \right\| _ { \Sigma _ { h } } \overset { d e f } { = } \sqrt { u ^ { \top } \Sigma _ { h } u } , \quad \mathrm { a n d } \quad \left\| u \right\| _ { \Sigma _ { h } ^ { - 1 } } \overset { d e f } { = } \sqrt { u ^ { \top } ( \Sigma _ { h } ) ^ { - 1 } u } . } \end{array}
+$$
+
+Consider the regression problem that is solved in moving backward from time step $h + 1$ to $h$ . Given the weight vector $w _ { h + 1 }$ at time step $h + 1$ , the regularized least-squares estimate of $w _ { h }$ is given by
+
+$$
+\widehat { w } _ { h } \overset { d e f } { = } \Sigma _ { h } ^ { - 1 } \sum _ { k \in \mathbb { Z } _ { h } } \phi _ { h k } \Bigl [ r _ { h k } + \sum _ { a \in \mathcal { A } } \pi _ { h + 1 } ( a \mid s _ { h + 1 , k } ) \left. \phi _ { h + 1 } ( s _ { h + 1 , k } , a ) , w _ { h + 1 } \right. \Bigr ] .
+$$
+
+We introduce pessimism by directly perturbing the weight vectors themselves—that is, we search for weight vector $w _ { h }$ such that $\overline { { w _ { h } } } \overline { { = } } \xi _ { h } + \bar { \widehat { w } } _ { h }$ , where the pessimism vector $\xi _ { h } \in \mathbb { R } ^ { d }$ satisfies a bound of the form $\| \xi _ { h } \| _ { \Sigma _ { h } } \le \alpha _ { h }$ , for a user-defined parameter $\alpha _ { h }$ .
+
+In detail, the critic takes as input the dataset $\mathcal { D }$ , a policy $\pi$ , a sequence of tolerance parameters $\alpha = ( \alpha _ { 1 } , \ldots , \alpha _ { H } )$ , weight radii $\rho ^ { w } = ( \rho _ { 1 } ^ { w } , \dots , \rho _ { H } ^ { w } )$ with each $\rho _ { h } ^ { w } ~ \in ~ ( 0 , 1 ]$ . The optimization variables consist of the regression vectors $w = ( w _ { 1 } , \dots , w _ { H } ) \in (  { \mathbb { R } } ^ { d } ) ^ { H }$ and the pessimism vectors $\xi = ( \xi _ { 1 } , \dots , \xi _ { H } ) \in (  { \mathbb { R } } ^ { d } ) ^ { H }$ . The critic then solves the convex program
+
+$$
+\left( \xi ^ { \pi } , \underline { { \upsilon } } ^ { \pi } \right) \overset { d e f } { = } \arg \operatorname* { m i n } _ { \xi \in ( \mathbb { R } ^ { d } ) ^ { H } } \sum _ { a \in \mathcal { A } } \pi _ { 1 } ( a  { | } s _ { 1 } )  { \langle } \phi _ { 1 } ( s _ { 1 } , a ) , w _ { 1 } \rangle
+$$
+
+with the terminal condition $w _ { H + 1 } = 0$ , and subject to the constraints
+
+$$
+w _ { h } = \xi _ { h } + \Sigma _ { h } ^ { - 1 } \sum _ { k \in \mathcal { Z } _ { h } } \phi _ { h k } \left[ r _ { h k } + \sum _ { a \in \mathcal { A } } \pi _ { h + 1 } ( a \mid s _ { h + 1 , k } ) \left. \phi _ { h + 1 } { \left( s _ { h + 1 , k } , a \right) } , w _ { h + 1 } \right. \right] ,
+$$
+
+and
+
+$$
+\| \xi _ { h } \| _ { \Sigma _ { h } } ^ { 2 } \le \alpha _ { h } ^ { 2 } , \qquad \| w _ { h } \| _ { 2 } ^ { 2 } \le ( \rho _ { h } ^ { w } ) ^ { 2 }
+$$
+
+for all $h \in [ H ]$ . Here the matrices $\Sigma _ { h }$ were previously defined in equation $( 8 )$ .
+
+The convex program $\textcircled { 1 0 }$ consists of a linear objective subject to quadratic constraints; it is a special case of a second order cone program, and can be efficiently solved with standard convex solvers.
+
+# Algorithm 1 ACTOR (MIRROR DESCENT)
+
+1: Input: Dataset $\mathcal { D }$ , starting state $s _ { 1 }$   
+learning rate $\eta$   
+2: Set $\theta _ { 1 } = ( \vec { 0 } , \ldots , \vec { 0 } )$   
+3: for $t = 1 , 2 , \dots , T$ do   
+4: $\underline { { w } } _ { t } \gets \mathrm { C R I T I C } ( \mathcal { D } , \pi _ { \theta _ { t } } , s _ { 1 } )$   
+5: $\theta _ { t + 1 } = \theta _ { t } + \eta \underline { { w } } _ { t }$   
+6: end for   
+7: Return: Mixture policy ⇡✓1 , . . . , ⇡✓T
+
+<table><tr><td>Algorithm2 CRITIC (PLSPE)</td></tr><tr><td>1: Input: Dataset D, target policy π, start- ing state S1， critic radii {ph}h=1,.., H,</td></tr><tr><td>and parameters {αh}h=1..., H</td></tr><tr><td>2:Solve the optimization program 1 3: Return: Optimal weight vector w</td></tr><tr><td></td></tr></table>
+
+# 3.2 The Actor: Mirror Descent
+
+We now turn to the behavior of the actor. It applies the mirror descent algorithm based on the Kullback Leibler (KL) divergence Bubeck (2014) This combination leads to the exponentiated gradient update rule in every timestep $\overline { { h \in [ H ] } }$ , so that the soft-max policy in moving from iteration $t$ to $t + 1$ is updated as
+
+$$
+\pi _ { t + 1 , h } ( a \mid s ) \propto \pi _ { t , h } ( a \mid s ) e ^ { \eta Q _ { h } ( s , a ) } \qquad \mathrm { f o r } \operatorname { e a c h } \left( s , a \right) \in \mathcal { S } \times \mathcal { A } .
+$$
+
+Here $\eta > 0$ is a stepsize parameter, and our theory specifies a suitable choice.
+
+If the $Q$ -value above from the critic lives in $\mathcal { Q }$ , then it is possible to show that $\pi _ { t + 1 , h } \in \Pi _ { h }$ and the update rule takes a much simpler and computationally more efficient form (cf. Line $^ { 5 } .$ of Algorithm 1), where $w _ { t }$ is the gradient of the value function on the pessimistic MDP implicitly identified by the critic. In this case, the spaces $( \mathcal { Q } , \Pi )$ are said to be compatible Sutton et al. (1999) ; Kakade (2001); Agarwal et al. (2020b); Raskutti and Mukherjee (2015) and the resulting algorithm is often called the Natural Policy Gradient (NPG) (see also Geist et al. $\textcircled { 1 2 0 1 9 }$ ; Shani et al. $\textcircled{2 0 2 0 } )$ By construction, the critic maintains a linear action value function even after pessimistic perturbations. As a consequence, the actor policy space is the simple softmax policy class $\Pi$ and the easier update rule can be used. As we explain in the analysis, this has important statistical benefits.
+
+After $T$ rounds of updates, the mirror descent algorithm that we use here readily achieves online regret rates (in the optimization setting with exact feedback) $\sim 1 / T$ or $\sim 1 / \sqrt { T }$ depending on the analysis Agarwal et al. $\left( \overline { { 2 0 2 0 } } \mathrm { b } \right)$ and the learning rate, although we mention that these rates could potentially be improved Khodadadian et al. (2021); Lan (2021); Bhandari and Russo $\underline { { \left. 2 0 2 0 \right. } }$ .
+
+# 4 Main results
+
+We now turn to the statement of a bound on the performance of the policy $\pi _ { \mathrm { A L G } }$ returned by PACLE. This upper bound involves three terms: an optimization error, an uncertainty term, and a model mis-specification term. The optimization error is given by $\textstyle { \mathcal { C } } ( T ) { \overset { d e f } { = } } 4 H { \sqrt { \frac { \log | A | } { T } } }$ log |A|T ; it captures the rate at which the error decreases as a function of the iterations of the actor. The mis-specification error $\begin{array} { r } { \mathcal { E } _ { \mathrm { m s p } } ( \nu ) \overset { d e f } { = } \sum _ { h = 1 } ^ { H } \nu _ { h } } \end{array}$ is simply the sum of all the stage-wise mis-specification errors; notice h=1  that the mis-specification error does depend on the choice of the radii for the critic $\rho _ { 1 } ^ { w } , \ldots , \rho _ { H } ^ { w }$ in a problem dependent way (cf. Assumption $\bigstar \bigstar \bigstar$ Finally, for each h, define the vector ¯⇡h def= $\mathbb { E } _ { ( S _ { h } , A _ { h } ) \sim \pi } [ \phi _ { h } ( S _ { h } , A _ { h } ) ]$ , where the expectation is over the state-action $\left( S _ { h } , A _ { h } \right)$ encountered at timestep $h$ upon following policy $\pi$ . In terms of these vectors, the uncertainty error is given by
+
+$$
+\mathcal { U } ( \pi ; \alpha ) \overset { d e f } { = } 2 \sum _ { h = 1 } ^ { H } \alpha _ { h } \| \bar { \phi } _ { h } ^ { \pi } \| _ { \Sigma _ { h } ^ { - 1 } } = 2 \sum _ { h = 1 } ^ { H } \alpha _ { h } \sqrt { ( \bar { \phi } _ { h } ^ { \pi } ) ^ { \top } \Sigma _ { h } ^ { - 1 } \bar { \phi } _ { h } ^ { \pi } } ,
+$$
+
+where the cumulative covariance matrix $\Sigma _ { h }$ was defined in equation $( 8 )$ .
+
+D the sequence of cumulative covariance matrices The amount of information from the dataset $\mathcal { D }$ is fully encoded in the uncertainty function $\{ \Sigma _ { h } \} _ { h = 1 } ^ { H }$ and parameters $\{ \alpha _ { h } \} _ { h = 1 } ^ { H }$ U . The more data $\boldsymbol { \mathcal { U } }$ through are available, the more positive definite $\Sigma _ { h }$ is and the smaller the uncertainty function $\mathcal { U } ( \pi ; \alpha )$ becomes for a fixed policy $\pi$ . If the sampling distribution that generates the dataset is fixed, then we can write $\mathcal { U } ( \pi ; \boldsymbol { \alpha } ) \lessapprox \boldsymbol { c } / \bar { \sqrt { n } }$ where $c$ does not depend on $n$ and can be interpreted as the coverage of the sampling distribution with respect to policy $\pi$ .
+
+# 4.1 A guarantee for PACLE
+
+Our main result holds under Assumption $\perp$ on the data collection process. It is based on radii $\{ \rho _ { h } ^ { w } \} _ { h = 1 } ^ { H }$ for the action value function3 that lie in the interval $( 0 , 1 ]$ , and it provides a guarantee relative to the class $\Pi _ { \mathrm { a l l } }$ of all stochastic policies.
+
+Theorem 1 (An achievable guarantee). Suppose that we are given a data set $\mathcal { D }$ collected in a way that respects Assumption 1. Then there are pessimism vectors bounded as $\alpha _ { h } = { \widetilde O } ( \sqrt { d \log ( 1 / \delta ) } ) \dot { + }$ $\nu _ { h } \sqrt { n _ { h } }$ such that, after running $T \geq \log | { \mathcal { A } } |$ rounds of the actor with stepsize $\begin{array} { r } { \eta = \sqrt { \frac { \log | \mathcal { A } | } { T } } } \end{array}$ log |A| , the PACLE procedure returns a policy $\pi _ { \mathrm { A L G } }$ for which
+
+$$
+V _ { 1 } ^ { \pi } ( s _ { 1 } ) - V _ { 1 } ^ { \pi _ { \mathrm { A z e } } } ( s _ { 1 } ) \leq \mathcal { U } ( \pi ; \alpha ) + \underbrace { \sum _ { h = 1 } ^ { H } \nu _ { h } } _ { \mathcal { E } _ { m s p } ( \nu ) } + \underbrace { 4 H \sqrt { \frac { \log | A | } { T } } } _ { \mathcal { C } ( T ) } \qquad u n i f o r m l y o v e r a l l \pi \in \Pi _ { a l l } \nonumber
+$$
+
+with probability exceeding $1 - \delta$ .
+
+The result provides a family of upper bounds on the sub-optimality of the learned policy $\pi _ { \mathrm { A L G } }$ , indexed by the choice of comparator policy $\pi$ , and embodies a tradeoff between the sub-optimality of the comparator $\pi$ and its uncertainty $\mathcal { U } ( \pi ; \alpha )$ . Note that the optimization error $\mathcal { C } ( T )$ can be reduced arbitrarily, while $\alpha$ (and thus $\mathcal { U } ( \pi ; \alpha ) ,$ ) increase only logarithmically with $T$ . As a special case, if we set $\pi = \pi ^ { \star }$ and assume that there is no mis-specification error, then we obtain that the learned policy satisfies a bound of the form
+
+$$
+V _ { 1 } ^ { \pi ^ { \star } } ( s _ { 1 } ) - V _ { 1 } ^ { \pi _ { \mathrm { A L G } } } ( s _ { 1 } ) \leq \mathcal { U } ( \pi ^ { \star } ; \alpha ) + \mathcal { C } ( T )
+$$
+
+with probability at least $1 - \delta$ . Since $\mathcal { C } ( T )$ is well-controlled, this guarantee is satisfied whenever the uncertainty term $\mathcal { U } ( \pi ^ { \star } ; \alpha )$ is small.
+
+More generally, the guarantee $( 1 3 )$ is significantly stronger than most prior work as PACLE competes not just with the optimal policy $\pi ^ { \star }$ , but with all comparator policies simultaneously. Such comparator policies need not necessarily be in the prescribed policy class $\Pi$ . To highlight the strength of this generality, suppose that the uncertainty $\mathcal { U } ( \pi ^ { \star } ; \alpha )$ of the optimal $\pi ^ { \star }$ is not small—it could in fact be infinite. In this case, the bound $( 1 4 )$ would not be useful.
+
+However, suppose that there exists a near-optimal policy—meaning a policy $\pi ^ { + }$ such that ${ V _ { 1 } ^ { \pi ^ { + } } ( s _ { 1 } ) ~ \geq ~ \widetilde { V } _ { 1 } ^ { \star } ( s _ { 1 } ) - \epsilon }$ for some small $\epsilon$ —that is well-covered by the dataset (i.e., for which $\mathcal { U } ( \pi ^ { + } ; \boldsymbol { \alpha } ) \approx 0 )$ ). In this case, Theorem 1 ensures with high probability $V _ { 1 } ^ { \mathrm { A L G } } ( s _ { 1 } ) \gtrsim V _ { 1 } ^ { \star } ( s _ { 1 } ) - \epsilon$ . In contrast, traditional analyses that use only the optimal policy $\pi ^ { \star }$ as a comparator—as opposed to also allowing near-optimal policies—cannot return meaningful guarantees. We note also that the papers Yu et al. $\underline { { \widehat { ( 2 0 2 0 ) } } }$ ; Liu et al. $\underline { { \left\{ 2 0 2 0 \right\} } }$ ; Kidambi et al. (2020) provide results of a similar flavor. These types of guarantees are also provided by some concurrent works Uehara and Sun (2021); Xie et al. (2021)
+
+It should alscritic’s radii $\{ \rho _ { h } ^ { w } \} _ { h = 1 } ^ { H }$ d that Theorem. This choice is $\bigstar$ provides a family of results indexed by the choice of the modeling decision: increasing the radii increases both the approximation power of the function class $\mathcal { Q } _ { h }$ used for regression, but also increases the complexity of the function class $\mathcal { Q } _ { h + 1 }$ to represent (cf. Assumption $\bar { 3 } )$ ; thus, the choice of the radii affects the approximation error $\mathcal { E } _ { \mathrm { m s p } } ( \nu )$ in a problem dependent way.
+
+# 4.2 A lower bound
+
+Thus far, we have stated an upper bound on the quality of the returned policy for a given procedure. Central to this upper bound is the uncertainty function $\mathcal { U } ( \pi ; \alpha )$ . In this section, we show that a term of this form is unavoidable for any procedure. In particular, working within the well-specified setting, we prove a lower bound in terms of the quantity $\begin{array} { r } { \mathcal { U } ( \pi ; \sqrt { d } ) = \sqrt { d } \dot { \sum } _ { h = 1 } ^ { H } \| \bar { \phi } _ { h } ^ { \pi } \| _ { { \Sigma } _ { h } ^ { - 1 } } } \end{array}$ . Recalling that our choice of $\alpha$ scales with $\sqrt { d }$ (along with other logarithmic factors), this lower bound shows that our result is tight up to logarithmic factors.
+
+We show that the lower bound actually holds in a setting that is easier for the learner, in the sense that (1) we restrict to low-rank MDPs, where there is no mis-specification error; and (2) the mechanism that generates the dataset is non-adaptive, and so certainly satisfies Assumption 1.
+
+Theorem 2 (Information-theoretic lower bound). For a given horizon $H$ and dimension $d$ , consider a sample size $n \geq 2 d ^ { 3 } H ^ { 3 }$ . There is a class $\mathcal { M }$ of low-rank MDPs and a data generating procedure satisfying Assumption 1 such that for any policy $\widehat { \pi } _ { \mathrm { A L G } }$ , we have
+
+$$
+\operatorname* { s u p } _ { M \in \mathcal { M } } \mathbb { E } _ { M } \left[ V _ { 1 M } ^ { \pi } ( s _ { 1 } ) - V _ { 1 M } ^ { \pi _ { \mathrm { A t o } } } ( s _ { 1 } ) \right] \geq c \mathcal { U } ( \pi ; \sqrt { d } ) \qquad \mathit { u n i f o r m l y o v e r a l l } \pi \in \Pi _ { a l l } ,
+$$
+
+where $c > 0$ is a universal constant.
+
+When $H = 1$ the above result gives a sample complexity lower bound for learning a near optimal policy from batch data in a linear bandit instance.
+
+# 4.3 Comparison to related work
+
+Theorem $^ 1$ automatically implies the typical bound $\mathbb { P } [ V _ { 1 } ^ { \pi _ { \mathrm { A L G } } } ( s _ { 1 } ) \geq V _ { 1 } ^ { \star } ( s _ { 1 } ) - \mathcal { U } ( \pi ^ { \star } ; \alpha ) ] \geq 1 - \delta$ when the comparator policy is the optimal policy $\pi ^ { \star }$ , e.g., Jin et al. (2020b) Rashidinejad et al. $\textcircled { 2 0 2 1 }$ ; Kidambi et al. $\dot { ( 2 0 2 0 ) }$ ; Kumar et al. $\overbrace { ( 2 0 1 9 ) }$ ; Buckman et al. (2020). The guarantee can be written as $\overline { { V _ { 1 } ^ { \mathrm { \tiny ~ A L G } } ( s _ { 1 } ) } } \stackrel { \textstyle > } { \sim } V _ { 1 } ^ { \star } ( s _ { 1 } ) - C / \sqrt { n }$ where $n$ is the number of samples and $C$ is the (scaled) condition number of $\Sigma _ { h } ^ { - 1 }$ . One could interpret $C$ as a concentrability coefficient that expresses the coverage of dataset—through $\Sigma _ { h }$ —with respect to the average direction in feature space $\mathbb { \bar { E } } _ { ( S _ { h } , A _ { h } ) \sim \pi _ { h } ^ { \star } } [ \phi ( S _ { h } , A _ { h } ) ]$ of the optimal policy $\pi ^ { \star }$ . As in the paper Jin et al. $\boxed { 2 0 2 0 6 }$ , such a factor can be small even when traditional concentrability coefficients are large because they depend on state-action visit ratios (see the literature in Appendix B, e.g., Chen and Jiang (2019))
+
+With reference to the results in the paper Jin et al. $\textcircled { 2 0 2 0 6 }$ , our work provides improvements in two distinct ways. First, their upper and lower bounds exhibit a gap of the order $d H$ , which our analysis closes. Second, our analysis holds under the more permissive Assumption 3 (Bellman Restricted Closedness) which includes low-rank MDPs. Of this improvement, a factor of $\sqrt { d }$ is due to the algorithm that we use, and the remainder is due to a more refined construction to certify optimality in Theorem 2. To be clear, our upper and lower bounds differ from theirs by a factor of $H$ due to a different normalization in the value function). We also note that the result of Liu et al.Liu et al.
+
+$\textcircled { 2 0 2 0 }$ can be specialized to the low-rank MDP setting; however, even in this simpler setting, the results would be sub-optimal and also require additional density estimates.
+
+Deriving a computationally tractable model-free algorithm without low-rank dynamics but subject to value function perturbations (e.g., optimistic or pessimistic perturbations) is an open problem even in the more heavily studied online exploration setting: there the current state-of-the art Zanette et al. (2020b); Jin et al. (2021); Du et al. (2021); Jiang et al. (2017) only present computationally intractable algorithms with the exception of Zanette et al. (2020c) for a PAC setting with low inherent Bellman error which however requires an additional “explorability” condition. Due to space constraints, the proof outline is deferred to Appendix A.
+
+# 5 Discussion
+
+In this paper, we have developed and analyzed an actor-critic method procedure, designed for finding near-optimal policies in the offline setting. The PACLE procedure introduces pessimism into the critic’s evaluation of a given policy’s value function, thereby ensuring that, under suitable parameter choices and assumptions, it maintains (with high probability) a lower bound on the true value function. The actor then performs a form of mirror ascent so as to maximize the value of these lower bounds.
+
+An important feature of our method is that it introduces pessimism via direct perturbations of the parameter vectors in a linear function approximation scheme. In this way, we avoid having to impose additional model assumptions; moreover, the pessimism does not substantially increase the complexity of our under value/policy classes, which allows us to provide minimax-optimal guarantees. We note that similar approaches have appeared before in the exploration setting; for example, see the recent papers Zanette et al. (2020b) Jin et al. (2021) Du et al. (2021). These methods enjoy similar advantages in terms of theoretical guarantees, but at the expense of computational tractability. In contrast, the method of this paper entails solving a low-dimensional second-order cone program, a simple class of convex programs for which there exist many polynomial-time algorithms. We enjoy this advantage due to some key differences between the offline and online settings of RL. In the offline setting, it is possible to keep the actor’s update cleanly separated from the evaluation step of the critic, as we have done here; this separation underlies the computational tractability.
+
+Our work leaves open a number of interesting questions for future work. First, it would be interesting to provide some numerical studies of the PACLE’s performance, so as to understand its practical behavior relative to the theoretical guarantees provided here. Also, our analysis here has focused purely on approximation using linear basis expansions; extension to more general function classes is an important next step. Finally, it will be interesting to see to what extent these ideas can be translated to the more challenging setting of exploration.
+
+# Acknowledgements
+
+This work was partially supported by NSF-DMS grant 2015454, NSF-IIS grant 1909365, and NSFFODSI grant 2023505 to MJW, a Stanford Artificial Intelligence Laboratory Toyota gift to EB, and a Office of Naval Research grant DOD-ONR-N00014-18-1-2640 to MJW.
+
+# References
+
+Abbasi-Yadkori, Y., Pal, D., and Szepesvari, C. (2011). Improved algorithms for linear stochastic bandits. In Advances in Neural Information Processing Systems (NIPS). Agarwal, A., Kakade, S., Krishnamurthy, A., and Sun, W. (2020a). Flambe: Structural complexity and representation learning of low rank mdps. arXiv preprint arXiv:2006.10814. Agarwal, A., Kakade, S. M., Lee, J. D., and Mahajan, G. (2020b). Optimality and approximation with policy gradient methods in markov decision processes. In Conference on Learning Theory, pages 64–66. Agarwal, R., Schuurmans, D., and Norouzi, M. (2020c). An optimistic perspective on offline reinforcement learning. In International Conference on Machine Learning, pages 104–114. PMLR.
+
+Antos, A., Munos, R., and Szepesvári, C. (2007). Fitted q-iteration in continuous action-space mdps.   
+Antos, A., Szepesvári, C., and Munos, R. (2008). Learning near-optimal policies with bellmanresidual minimization based fitted policy iteration and a single sample path. Machine Learning, 71(1):89–129.   
+Bertsekas, D. P. (1995). Dynamic programming and stochastic control, volume 1. Athena Scientific, Belmont, MA.   
+Bertsekas, D. P. and Tsitsiklis, J. N. (1996). Neuro-dynamic programming. Athena Scientific.   
+Bhandari, J. and Russo, D. (2020). A note on the linear convergence of policy gradient methods. arXiv preprint arXiv:2007.11120.   
+Bubeck, S. (2014). Convex optimization: Algorithms and complexity. arXiv preprint arXiv:1405.4980.   
+Buckman, J., Gelada, C., and Bellemare, M. G. (2020). The importance of pessimism in fixeddataset policy optimization. arXiv preprint arXiv:2009.06799.   
+Chen, J. and Jiang, N. (2019). Information-theoretic considerations in batch reinforcement learning. In International Conference on Machine Learning, pages 1042–1051.   
+de la Pena, V. H., Lai, T. L., and Shao, Q. M. (2009). Self-normalized processes. Springer.   
+Du, S. S., Kakade, S. M., Lee, J. D., Lovett, S., Mahajan, G., Sun, W., and Wang, R. (2021). Bilinear classes: A structural framework for provable generalization in rl. arXiv preprint arXiv:2103.10897.   
+Duan, Y., Jin, C., and Li, Z. (2021). Risk bounds and rademacher complexity in batch reinforcement learning. arXiv preprint arXiv:2103.13883.   
+Duan, Y. and Wang, M. (2020). Minimax-optimal off-policy evaluation with linear function approximation. arXiv preprint arXiv:2002.09516.   
+Fan, J., Wang, Z., Xie, Y., and Yang, Z. (2020). A theoretical analysis of deep q-learning. In Learning for Dynamics and Control, pages 486–489. PMLR.   
+Farahmand, A.-m., Ghavamzadeh, M., Szepesvári, C., and Mannor, S. (2016). Regularized policy iteration with nonparametric function spaces. The Journal of Machine Learning Research, 17(1):4809–4874.   
+Farahmand, A.-m., Szepesvári, C., and Munos, R. (2010). Error propagation for approximate policy and value iteration. In Advances in Neural Information Processing Systems (NIPS).   
+Farajtabar, M., Chow, Y., and Ghavamzadeh, M. (2018). More robust doubly robust off-policy evaluation. In International Conference on Machine Learning, pages 1447–1456. PMLR.   
+Fu, Z., Yang, Z., and Wang, Z. (2020). Single-timescale actor-critic provably finds globally optimal policy. arXiv preprint arXiv:2008.00483.   
+Geist, M., Scherrer, B., and Pietquin, O. (2019). A theory of regularized markov decision processes. In International Conference on Machine Learning, pages 2160–2169. PMLR.   
+Haarnoja, T., Tang, H., Abbeel, P., and Levine, S. (2017). Reinforcement learning with deep energybased policies. In International Conference on Machine Learning, pages 1352–1361. PMLR.   
+Haarnoja, T., Zhou, A., Abbeel, P., and Levine, S. (2018). Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor.   
+Hao, B., Ji, X., Duan, Y., Lu, H., Szepesvári, C., and Wang, M. (2021). Bootstrapping statistical inference for off-policy evaluation. arXiv preprint arXiv:2102.03607.   
+Heess, N., Wayne, G., Silver, D., Lillicrap, T., Tassa, Y., and Erez, T. (2015). Learning continuous control policies by stochastic value gradients.   
+Jaques, N., Ghandeharioun, A., Shen, J. H., Ferguson, C., Lapedriza, A., Jones, N., Gu, S., and Picard, R. (2019). Way off-policy batch deep reinforcement learning of implicit human preferences in dialog. arXiv preprint arXiv:1907.00456.   
+Jiang, N. and Huang, J. (2020). Minimax value interval for off-policy evaluation and policy optimization. arXiv preprint arXiv:2002.02081.   
+Jiang, N., Krishnamurthy, A., Agarwal, A., Langford, J., and Schapire, R. E. (2017). Contextual decision processes with low Bellman rank are PAC-learnable. In Precup, D. and Teh, Y. W., editors, International Conference on Machine Learning (ICML), volume 70 of Proceedings of Machine Learning Research, pages 1704–1713, International Convention Centre, Sydney, Australia. PMLR.   
+Jiang, N. and Li, L. (2016). Doubly robust off-policy value evaluation for reinforcement learning. In International Conference on Machine Learning, pages 652–661. PMLR.   
+Jin, C., Liu, Q., and Miryoosefi, S. (2021). Bellman eluder dimension: New rich classes of rl problems, and sample-efficient algorithms. arXiv preprint arXiv:2102.00815.   
+Jin, C., Yang, Z., Wang, Z., and Jordan, M. I. (2020a). Provably efficient reinforcement learning with linear function approximation. In Conference on Learning Theory.   
+Jin, Y., Yang, Z., and Wang, Z. (2020b). Is pessimism provably efficient for offline rl? arXiv preprint arXiv:2012.15085.   
+Kakade, S. M. (2001). A natural policy gradient. Advances in neural information processing systems, 14.   
+Kakade, S. M. et al. (2003). On the sample complexity of reinforcement learning. PhD thesis, University of London London, England.   
+Kallus, N. and Uehara, M. (2019). Efficiently breaking the curse of horizon in off-policy evaluation with double reinforcement learning. arXiv preprint arXiv:1909.05850.   
+Khodadadian, S., Jhunjhunwala, P. R., Varma, S. M., and Maguluri, S. T. (2021). On the linear convergence of natural policy gradient algorithm. arXiv preprint arXiv:2105.01424.   
+Kidambi, R., Rajeswaran, A., Netrapalli, P., and Joachims, T. (2020). Morel: Model-based offline reinforcement learning. arXiv preprint arXiv:2005.05951.   
+Konda, V. R. and Tsitsiklis, J. N. (2000). Actor-critic algorithms. In Advances in neural information processing systems, pages 1008–1014.   
+Konda, V. R. and Tsitsiklis, J. N. (2003). On actor-critic algorithms. SIAM Jour. Opt. Control, 42(4):1143–1166.   
+Kumar, A., Fu, J., Tucker, G., and Levine, S. (2019). Stabilizing off-policy q-learning via bootstrapping error reduction. arXiv preprint arXiv:1906.00949.   
+Kumar, A., Zhou, A., Tucker, G., and Levine, S. (2020). Conservative q-learning for offline reinforcement learning. arXiv preprint arXiv:2006.04779.   
+Lan, G. (2021). Policy mirror descent for reinforcement learning: Linear convergence, new sampling complexity, and generalized problem classes. arXiv preprint arXiv:2102.00135.   
+Laroche, R., Trichelair, P., and Des Combes, R. T. (2019). Safe policy improvement with baseline bootstrapping. In International Conference on Machine Learning, pages 3652–3661. PMLR.   
+Levine, S., Kumar, A., Tucker, G., and Fu, J. (2020). Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643.   
+Liao, P., Qi, Z., and Murphy, S. (2020). Batch policy learning in average reward markov decision processes. arXiv preprint arXiv:2007.11771.   
+Liu, Q., Li, L., Tang, Z., and Zhou, D. (2018a). Breaking the curse of horizon: Infinite-horizon off-policy estimation. In Advances in Neural Information Processing Systems, pages 5356–5366.   
+Liu, Y., Gottesman, O., Raghu, A., Komorowski, M., Faisal, A. A., Doshi-Velez, F., and Brunskill, E. (2018b). Representation balancing mdps for off-policy policy evaluation. Advances in Neural Information Processing Systems, 31:2644–2653.   
+Liu, Y., Swaminathan, A., Agarwal, A., and Brunskill, E. (2020). Provably good batch reinforcement learning without great exploration. arXiv preprint arXiv:2007.08202.   
+Mandel, T., Liu, Y.-E., Levine, S., Brunskill, E., and Popovic, Z. (2014). Offline policy evaluation across representations with applications to educational games. In AAMAS, volume 1077.   
+Modi, A., Chen, J., Krishnamurthy, A., Jiang, N., and Agarwal, A. (2021). Model-free representation learning and exploration in low-rank mdps. arXiv preprint arXiv:2102.07035.   
+Munos, R. (2003). Error bounds for approximate policy iteration. In ICML, volume 3, pages 560– 567.   
+Munos, R. (2005). Error bounds for approximate value iteration. In AAAI Conference on Artificial Intelligence (AAAI).   
+Nachum, O., Chow, Y., Dai, B., and Li, L. (2019a). Dualdice: Behavior-agnostic estimation of discounted stationary distribution corrections. arXiv preprint arXiv:1906.04733.   
+Nachum, O. and Dai, B. (2020). Reinforcement learning via fenchel-rockafellar duality. arXiv preprint arXiv:2001.01866.   
+Nachum, O., Dai, B., Kostrikov, I., Chow, Y., Li, L., and Schuurmans, D. (2019b). Algaedice: Policy gradient from arbitrary experience. arXiv preprint arXiv:1912.02074.   
+Nair, A., Dalal, M., Gupta, A., and Levine, S. (2020). Accelerating online reinforcement learning with offline datasets. arXiv preprint arXiv:2006.09359.   
+Nedic, A. and Bertsekas, D. P. (2003). Least squares policy evaluation algorithms with linear func- ´ tion approximation. Discrete Event Dynamic Systems, 13(1):79–110.   
+Puterman, M. L. (1994). Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, Inc., New York, NY, USA.   
+Rashidinejad, P., Zhu, B., Ma, C., Jiao, J., and Russell, S. (2021). Bridging offline reinforcement learning and imitation learning: A tale of pessimism. arXiv preprint arXiv:2103.12021.   
+Raskutti, G. and Mukherjee, S. (2015). The information geometry of mirror descent. IEEE Transactions on Information Theory, 61(3):1451–1457.   
+Shani, L., Efroni, Y., and Mannor, S. (2020). Adaptive trust region policy optimization: Global convergence and faster rates for regularized mdps. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 5668–5675.   
+Shreve, S. E. and Bertsekas, D. P. (1978). Alternative theoretical frameworks for finite horizon discrete-time stochastic optimal control. SIAM Journal on control and optimization, 16(6):953– 978.   
+Siegel, N. Y., Springenberg, J. T., Berkenkamp, F., Abdolmaleki, A., Neunert, M., Lampe, T., Hafner, R., Heess, N., and Riedmiller, M. (2020). Keep doing what worked: Behavioral modelling priors for offline reinforcement learning. arXiv preprint arXiv:2002.08396.   
+Sutton, R. S. and Barto, A. G. (2018). Reinforcement Learning: An Introduction. MIT Press, Cambridge, MA, 2nd edition.   
+Sutton, R. S., McAllester, D. A., Singh, S. P., Mansour, Y., et al. (1999). Policy gradient methods for reinforcement learning with function approximation. In NIPs, volume 99, pages 1057–1063. Citeseer.   
+Tang, Z., Feng, Y., Li, L., Zhou, D., and Liu, Q. (2019). Doubly robust bias reduction in infinite horizon off-policy estimation. arXiv preprint arXiv:1910.07186.   
+Thomas, P. and Brunskill, E. (2016). Data-efficient off-policy policy evaluation for reinforcement learning. In International Conference on Machine Learning, pages 2139–2148.   
+Thomas, P., Theocharous, G., and Ghavamzadeh, M. (2015). High confidence policy improvement. In International Conference on Machine Learning, pages 2380–2388.   
+Thomas, P. S., da Silva, B. C., Barto, A. G., Giguere, S., Brun, Y., and Brunskill, E. (2019). Preventing undesirable behavior of intelligent machines. Science, 366(6468):999–1004.   
+Tsybakov, A. B. (2009). Introduction to Nonparametric Estimation. Springer, New York.   
+Uehara, M., Huang, J., and Jiang, N. (2020). Minimax weight and q-function learning for off-policy evaluation. In International Conference on Machine Learning, pages 9659–9668. PMLR.   
+Uehara, M. and Sun, W. (2021). Pessimistic model-based offline rl: Pac bounds and posterior sampling under partial coverage.   
+Voloshin, C., Jiang, N., and Yue, Y. (2021). Minimax model learning. In International Conference on Artificial Intelligence and Statistics, pages 1612–1620. PMLR.   
+Wainwright, M. J. (2019). High-dimensional statistics: A non-asymptotic viewpoint, volume 48. Cambridge University Press.   
+Wang, L., Cai, Q., Yang, Z., and Wang, Z. (2019). Neural policy gradient methods: Global optimality and rates of convergence. arXiv preprint arXiv:1909.01150.   
+Wang, Z., Novikov, A., Zo˙ łna, K., Springenberg, J. T., Reed, S., Shahriari, B., Siegel, N., Merel, J., Gulcehre, C., Heess, N., et al. (2020). Critic regularized regression. arXiv preprint arXiv:2006.15134.   
+Weisz, G., Amortila, P., and Szepesvári, C. (2020). Exponential lower bounds for planning in mdps with linearly-realizable optimal action-value functions. arXiv preprint arXiv:2010.01374.   
+Wu, Y., Tucker, G., and Nachum, O. (2019). Behavior regularized offline reinforcement learning. arXiv preprint arXiv:1911.11361.   
+Wu, Y., Zhai, S., Srivastava, N., Susskind, J., Zhang, J., Salakhutdinov, R., and Goh, H. (2021). Uncertainty weighted actor-critic for offline reinforcement learning. arXiv preprint arXiv:2105.08140.   
+Xie, T., Cheng, C.-A., Jiang, N., Mineiro, P., and Agarwal, A. (2021). Bellman-consistent pessimism for offline reinforcement learning.   
+Xie, T. and Jiang, N. (2020a). Batch value-function approximation with only realizability. arXiv preprint arXiv:2008.04990.   
+Xie, T. and Jiang, N. (2020b). $\mathbf { Q } ^ { * }$ approximation schemes for batch reinforcement learning: A theoretical comparison. volume 124 of Proceedings of Machine Learning Research, pages 550– 559, Virtual. PMLR.   
+Xie, T., Ma, Y., and Wang, Y.-X. (2019). Towards optimal off-policy evaluation for reinforcement learning with marginalized importance sampling. In Advances in Neural Information Processing Systems, pages 9668–9678.   
+Yang, L. F. and Wang, M. (2020). Reinforcement leaning in feature space: Matrix bandit, kernels, and regret bound. In International Conference on Machine Learning (ICML).   
+Yang, M., Nachum, O., Dai, B., Li, L., and Schuurmans, D. (2020). Off-policy evaluation via the regularized lagrangian. arXiv preprint arXiv:2007.03438.   
+Yin, M., Bai, Y., and Wang, Y.-X. (2020). Near optimal provable uniform convergence in off-policy evaluation for reinforcement learning. arXiv preprint arXiv:2007.03760.   
+Yin, M. and Wang, Y.-X. (2020). Asymptotically efficient off-policy evaluation for tabular reinforcement learning. In International Conference on Artificial Intelligence and Statistics, pages 3948–3958. PMLR.   
+Yu, T., Thomas, G., Yu, L., Ermon, S., Zou, J., Levine, S., Finn, C., and Ma, T. (2020). Mopo: Model-based offline policy optimization. arXiv preprint arXiv:2005.13239.   
+Zanette, A. (2020). Exponential lower bounds for batch reinforcement learning: Batch rl can be exponentially harder than online rl. arXiv preprint arXiv:2012.08005.   
+Zanette, A., Brandfonbrener, D., Pirotta, M., and Lazaric, A. (2020a). Frequentist regret bounds for randomized least-squares value iteration. In AISTATS.   
+Zanette, A., Lazaric, A., Kochenderfer, M., and Brunskill, E. (2020b). Learning near optimal policies with low inherent bellman error. In International Conference on Machine Learning (ICML).   
+Zanette, A., Lazaric, A., Kochenderfer, M. J., and Brunskill, E. (2020c). Provably efficient rewardagnostic navigation with linear value iteration. In Advances in Neural Information Processing Systems.   
+Zhang, J., Koppel, A., Bedi, A. S., Szepesvari, C., and Wang, M. (2020a). Variational policy gradient method for reinforcement learning with general utilities. arXiv preprint arXiv:2007.02151.   
+Zhang, R., Dai, B., Li, L., and Schuurmans, D. (2020b). Gendice: Generalized offline estimation of stationary values. arXiv preprint arXiv:2002.09072.

parse/train/EnmG3G5SYR/EnmG3G5SYR_content_list.json

@@ -0,0 +1,1575 @@
+[
+    {
+        "type": "text",
+        "text": "Provable Benefits of Actor-Critic Methods for Offline Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            245,
+            122,
+            754,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Andrea Zanette⇤ University of California, Berkeley zanette@berkeley.edu ",
+        "bbox": [
+            238,
+            227,
+            464,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Martin J. Wainwright University of California, Berkeley wainwrig@berkeley.edu ",
+        "bbox": [
+            534,
+            226,
+            759,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Emma Brunskill Stanford University ebrun@stanford.edu ",
+        "bbox": [
+            419,
+            289,
+            576,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Actor-critic methods are widely used in offline reinforcement learning practice, but are not so well-understood theoretically. We propose a new offline actor-critic algorithm that naturally incorporates the pessimism principle, leading to several key advantages compared to the state of the art. The algorithm can operate when the Bellman evaluation operator is closed with respect to the action value function of the actor’s policies; this is a more general setting than the low-rank MDP model. Despite the added generality, the procedure is computationally tractable as it involves the solution of a sequence of second-order programs. We prove an upper bound on the suboptimality gap of the policy returned by the procedure that depends on the data coverage of any arbitrary, possibly data dependent comparator policy. The achievable guarantee is complemented with a minimax lower bound that is matching up to logarithmic factors. ",
+        "bbox": [
+            233,
+            398,
+            764,
+            564
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            590,
+            310,
+            607
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The problem of learning a near-optimal policy is a core challenge in reinforcement learning (RL). In many settings, it is beneficial to be able to learn a good policy using only a pre-collected set of data, without further exploration with the environment; this problem is known as offline or batch policy learning. The offline setting has unique challenges due to the incomplete information about the Markov decision process (MDP) encoded in the available dataset. For example, due to maximization bias, a naive offline algorithm can return a policy with a severely overestimated value. In order to avoid such undesirable behavior, researchers have introduced the idea of pessimism under uncertainty, and there is now a growing literature (e.g., Liu et al. (2020); Jin et al. (2020b); Buckman et al. (2020); Kumar et al. (2019); Kidambi et al. (2020); Yu et al. (2020)) on different ways in which pessimism can be incorporated. See Appendix B for additional references and discussion of this body of work. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            775
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "At a high level, incorporating pessimism prevents algorithms from settling down on uncertain policies whose value might be misleadingly high under the current dataset due to statistical errors. By using pessimism, uncertain policies are penalized in such a way that only those policies robust to statistical errors are returned. The principle can be implemented in at least two different ways: (a) by penalizing policies that are far from the one that generated the dataset; or (b) by penalizing the value functions of policies not well covered by the dataset. In this paper, we take the latter avenue. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1.1 Overview and our contributions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            92,
+            434,
+            106
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Implementing pessimism with function approximation is challenging for several reasons. First, uncertainty must be estimated with particular care. On one hand, underestimating it can fail to correct the coverage problem. On the other hand, overestimating it leads to policies that are too conservative and thus underperform. Second, the incorporation of pessimism may introduce complex, higher order perturbations into the value function class handled by the algorithm. Similar issues can arise when adding optimistic bonuses in the exploration. The increased complexity of the function class often requires additional assumptions on the model, because the new class needs to interact “nicely” with the Bellman operator. Prior art on pessimism with function approximation has by-passed this problem by making strong model assumptions, such as low-rank transitions Jin et al. (2020b) or algorithm-specific assumptions Liu et al. (2020) ",
+        "bbox": [
+            173,
+            116,
+            825,
+            257
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Actor-critic methods: Most past theoretical work on offline reinforcement learning on finding with high probability the policy with the highest performance has focused on algorithms that are either model or value-based2 Liu et al. (2020); Jin et al. $\\textcircled { 2 0 2 0 6 }$ ; Buckman et al. (2020); Kidambi et al. (2020); Yu et al. (2020); these often incorporate pessimism into the estimates of the policy performance. Actor-critic methods are a hybrid class of methods that mitigate some deficiencies of methods that are either purely policy or purely value-based Konda and Tsitsiklis $\\textcircled { 1 2 0 0 0 } \\textcircled { 2 0 0 3 }$ Heess et al. (2015); Haarnoja et al. (2017, 2018); in modern RL, they are widely used in practice (e.g., Levine et al. (2020); Wu et al. (2019, 2021); Kumar et al. (2019, 2020)). An actor-critic method generally consists of an actor that changes the policy in order to maximize its value as estimated by the critic. Given their popularity, it is natural to ask the following question: do actor-critic methods provably offer any advantage in offline RL? The main contribution of this paper is to give a positive answer to this question: by separating the policy optimization from the policy evaluation, both tasks become simpler to design and the pessimism principle can be incorporated more naturally. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions: More specifically, we study the problem of policy learning using linear function approximation in the offline setting. We assume that we are given a batch data set $\\mathcal { D }$ , in which each sample consists of a quadruple. The first two components are the state-action pair, corresponding to the state in which a given action was taken, and the last two components correspond to a noisy observation of the reward, and a successor state drawn from the appropriate transition function. Our theory allows for a very general dependence structure among the the state-action pairs in these samples; when the data set is ordered according to how the samples were collected (which need not be related to a trajectory), we allow the state-action pair at any given instant to depend on all past samples. This set-up allows from data collected from arbitrary policies, mixtures of policies, generative models or even in adversarial manner. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            606
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given such a data set, our objective is to find the policy that performs best in the face of uncertainty. In particular, we need to account for the fact that the optimal policy $\\pi ^ { * }$ for the underlying MDP may not be well covered by the dataset $\\mathcal { D }$ , in which case the associated uncertainty would be prohibitive. In order to achieve this goal, we design an actor-critic procedure that iteratively optimizes a lower bound on the value of the optimal policy. Suppose that we are interested in optimizing the value function at some given initial $s _ { 1 }$ . Our strategy works as follows: for any given policy $\\pi$ , we construct a family $\\mathcal { M } ( \\pi )$ of “statistically plausible” MDPs, and use them to define a simple second-order cone program. By solving this convex program, we obtain value function estimate $\\underline { { { V } } } _ { M } ^ { \\pi } ( s _ { 1 } ) =$ arg $\\mathrm { m i n } _ { M \\in \\mathcal { M } ( \\pi ) } V _ { M } ^ { \\pi } \\big ( s _ { 1 } \\big )$ that—for an appropriately constructed family $\\mathcal { M } ( \\pi )$ —is guaranteed to be a lower bound on the true value function of $\\pi$ in the unknown MDP that generated the dataset. Given a procedure for producing such lower bounds, it is then natural to maximize these lower bounds over some family $\\Pi$ of policies. This combination leads to the saddle-point problem ",
+        "bbox": [
+            173,
+            611,
+            825,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/55dfc338cf9998eab1d8e099556f1f629408c203b4efbc96d5725b2503f2b65e.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi \\in \\Pi } \\operatorname* { m i n } _ { M \\in \\mathcal { M } ( \\pi ) } V _ { M } ^ { \\pi } \\big ( s _ { 1 } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            785,
+            575,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that actor-critic methods fit naturally in this framework: the critic provides a pessimistic evaluation of any given policy $\\pi$ , and the actor solves the outer maximization problem over policies. ",
+        "bbox": [
+            176,
+            819,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This decoupling lends itself to a computationally tractable implementation, along with an analysis of the procedure. In particular, we show that the actor’s sequence of estimated policies enjoys online learning-style guarantees with respect to a sequence of pessimistic MDPs implicitly identified by the critic. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The way in which we introduce pessimism is a second key component of the algorithmic framework. In particular, in line with our previous paper Zanette et al. (2020b), we do so without enlarging the prescribed classes of functions and policies. We do so by a direct perturbation of the value functions examined by the critic; there is no addition of pessimistic bonuses or absorbing states. Since the class of value functions is not altered, this method has two main advantages. First, there are no additional model assumptions compared to the standard—that is non-pessimistic—version of the actor-critic method. Second, the complexity of the underlying classes is not increased, thereby allowing us to construct tight confidence intervals and estimation error bounds that are minimax optimal up to logarithmic factors. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The remainder of this paper is organized as follows. We begin in Section $2$ with background on MDPS, and then introduce the modeling assumptions that underlie the analysis of this paper. In Section $3 .$ we introduce the algorithm studied in this paper, namely the Pessimistic Actor Critic for Learning without Exploration (for short, PACLE) algorithm. Section $\\boxed { 4 }$ provides statements of our main results and discussion of their consequences, including an upper bound on the PACLE algorithm in Theorem $^ { 1 , }$ and a minimax lower bound in Theorem $\\bigstar$ In Section $\\bigstar \\bigstar$ we provide an outline of the proof of Theorem $\\bigstar$ with various technical details as well as the proof of Theorem $\\bigstar$ deferred to the appendices. We conclude with a discussion in Section 5. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.2 Notation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            410,
+            274,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For the reader’s convenience, we summarize here some notation used throughout the paper. We let $B _ { d } ( r ) = \\{ x \\in \\mathbb { R } ^ { d } \\mid \\| x \\| _ { 2 } \\leq r \\}$ denote the Euclidean ball of radius $r \\in \\mathbb { R }$ in dimension $d$ ; we simply write $\\boldsymbol { B }$ when there is no possibility of confusion. For a vector $x \\in \\mathbb { R } ^ { d }$ , we use $[ x ] _ { i }$ to denote its $i ^ { t h }$ component. We use the $\\widetilde O$ notation to denote an upper bound that holds up to constants and log factors in the input parameters $\\textstyle { \\bigl ( } { \\frac { 1 } { \\delta } } , d , H { \\bigr ) }$ . The notation $\\lesssim$ means an upper bound that holds up to a constant, with an analogous definition for $\\gtrsim$ . ",
+        "bbox": [
+            173,
+            435,
+            825,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Background and problem formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            524,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We begin by providing some background, before introducing the assumptions that underlie our problem formulation. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            601
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Markov decision processes ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            398,
+            631
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on finite-horizon Markov decision processes, for which we provide a very brief introduction here. See the books Puterman (1994); Bertsekas and Tsitsiklis (1996); Bertsekas $\\textcircled { 1 9 9 5 }$ ; Sutton and Barto (2018) for more background and detail. A finite-horizon MDP is specified by a positive integer $\\overline { H }$ , and events take place over a sequence of stages indexed by the time step $\\boldsymbol { h } \\in [ H ] \\overset { d e f } { = } \\{ 1 , \\dots , H \\}$ . The underlying dynamics involve a state space $s$ , and are controlled by actions that take values in some action set $\\mathcal { A }$ . In this paper, we allow the state space to be arbitrary (continous or discrete), whereas our analysis applies to discrete action spaces. For each time step $h \\in [ H ]$ , there is a reward function $r _ { h } : \\mathcal { S } \\times \\mathcal { A } \\to \\mathbb { R }$ , and for every time step $h$ and state-action pair $( s , a )$ , there is a transition function $\\mathbb { P } _ { h } ( \\cdot \\mid s , a )$ . When at horizon $h$ , if the agent takes action $a$ in state $s$ , it receives a random reward drawn from a distribution $R _ { h } ( s , a )$ with mean $r _ { h } ( s , a )$ , and it then transitions randomly to a next state $s ^ { + }$ drawn from the transition function $\\mathbb { P } _ { h } ( \\cdot \\mid s , a )$ . ",
+        "bbox": [
+            173,
+            641,
+            825,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A policy $\\pi _ { h }$ at stage $h$ is a mapping from the state space $s$ to the action space $\\mathcal { A }$ . Given a full policy $\\pi = ( \\pi _ { 1 } , \\ldots , \\pi _ { H } )$ , the state-action value function at time step $h$ is given by ",
+        "bbox": [
+            171,
+            804,
+            821,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a4f791580c1890a55a2c3fc7ed37e9ce68f1fe362dda4cec86d558c891e810f.jpg",
+        "text": "$$\nQ _ { h } ^ { \\pi } ( s , a ) = r _ { h } ( s , a ) + \\mathbb { E } _ { S _ { \\ell } \\sim \\pi \\mid ( s , a ) } \\sum _ { \\ell = h + 1 } ^ { H } r _ { \\ell } ( S _ { \\ell } , \\pi _ { \\ell } ( S _ { \\ell } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            837,
+            684,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is over the trajectories induced by $\\pi$ upon starting from the pair $( s , a )$ . When we omit the starting state-action pair $( s , a )$ , the expectation is intended to start from a fixed state ",
+        "bbox": [
+            173,
+            883,
+            823,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "denoted by $s _ { 1 }$ . The value function associated to $\\pi$ is $V _ { h } ^ { \\pi } ( s ) = Q _ { h } ^ { \\pi } ( s , \\pi _ { h } ( s ) )$ . For a given policy $\\pi$ , we define the Bellman evaluation operator ",
+        "bbox": [
+            173,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36bb159e6bcaaaf270086d482473b7b0cd3ea099f1945c583c11047fcaed7ad0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { T } _ { h } ^ { \\pi } ( Q _ { h + 1 } ) ( s , a ) = r _ { h } ( s , a ) + \\mathbb { E } _ { S ^ { \\prime } \\sim \\mathbb { P } _ { h } ( s , a ) } \\mathbb { E } _ { A ^ { \\prime } \\sim \\pi } Q _ { h + 1 } ( S ^ { \\prime } , A ^ { \\prime } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            126,
+            709,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Under some regularity conditions Puterman (1994); Shreve and Bertsekas (1978), there always exists an optimal policy $\\pi ^ { \\star }$ whose value and action-value functions are defined as ",
+        "bbox": [
+            171,
+            150,
+            825,
+            179
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0901d844106ab1247a5c0cb75aadfc677495fc00c9f798d68e5cfa6ca72b09ee.jpg",
+        "text": "$$\nV _ { h } ^ { \\star } ( s ) = V _ { h } ^ { \\pi ^ { \\star } } ( s ) = \\operatorname* { s u p } _ { \\pi } V _ { h } ^ { \\pi } ( s ) , \\quad \\mathrm { a n d } \\quad Q _ { h } ^ { \\star } ( s , a ) = Q _ { h } ^ { \\pi ^ { \\star } } ( s , a ) = \\operatorname* { s u p } _ { \\pi } Q _ { h } ^ { \\pi } ( s , a ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            185,
+            761,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 Assumptions on data generation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            228,
+            437,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study a model in which we observe a dataset of the form $\\mathcal { D } = \\{ ( s _ { i } , a _ { i } , r _ { i } , s _ { i } ^ { + } ) \\} _ { i = 1 } ^ { n }$ where $n$ is the total sample size. For each $i \\in [ n ] = \\{ 1 , 2 , . . . , n \\}$ , the tuple $( s _ { i } , a _ { i } )$ corresponds to a state-action pair associated with some time step $h _ { i }$ . We let $\\mathcal { F } _ { i }$ be the $\\sigma$ -field generated by the samples $\\{ ( s _ { j } , a _ { j } , r _ { j } , s _ { j } ^ { + } ) \\} _ { j = 1 } ^ { i - 1 }$ that are in the “past” relative to index $i$ . With this notation, we impose the following condition: ",
+        "bbox": [
+            174,
+            252,
+            825,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1 (Data generation). For each $i \\in [ n ]$ , the pair $( s _ { i } , a _ { i } )$ is measurable with respect to ${ \\mathcal { F } } _ { i }$ . Conditionally on a given pair $( s _ { i } , a _ { i } )$ , the random variable $r _ { i }$ is drawn from a reward distribution $R _ { h _ { i } } ( s _ { i } , a _ { i } )$ that is 1-sub-Gaussian; and the next state $s _ { i } ^ { + }$ is drawn from the distribution $\\mathbb { P } _ { h _ { i } } ( s _ { i } , a _ { i } )$ . ",
+        "bbox": [
+            174,
+            329,
+            825,
+            373
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the measurability condition allows the choice of $( s _ { i } , a _ { i } )$ to depend arbitrarily on any of the past data with indices $j < i$ . The mild assumption allows for considerable freedom. For example, the state-action pairs may be chosen from (mixture) policies, or they can be generated by an adversarial procedure that changes the data acquisition strategy as feedback is received. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For each $h \\in [ H ]$ , we let $\\mathcal { T } _ { h }$ denote the subset of observation indices $i \\in [ n ]$ such that $h _ { i } = h$ . These index sets define the sub-datasets ${ \\mathcal { D } } _ { h } = \\{ ( s _ { i } , a _ { i } , r _ { i } , s _ { i } ^ { + } ) , i \\in { \\mathcal { I } } _ { h } \\}$ associated with all samples that are based on be written as rs at time step . $h$ . We define $n _ { h } = | \\mathcal { D } _ { h } |$ , so that our total sample size can $\\begin{array} { r } { n = \\sum _ { h = 1 } ^ { H } n _ { h } } \\end{array}$ ",
+        "bbox": [
+            173,
+            445,
+            825,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Policy and function classes ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            522,
+            398,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next we define the policy space $\\Pi$ and the action value function space $\\mathcal { Q }$ over which we seek solutions. Let $\\phi : \\mathcal { S } \\overset { \\cdot } { \\times } \\overset { \\cdot } { \\underset { \\cdot } { A } } \\overset { \\cdot } { \\mapsto } \\overset { \\cdot } { \\mathbb { R } ^ { d } }$ be a $d$ -dimensional feature mapping. We assume throughout that these feature mappings are normalized such that $\\| \\phi ( s , a ) \\| _ { 2 } \\leq 1$ uniformly for all $( s , a )$ -pairs. We consider action-value functions that are linear in $\\phi$ , and families of the form ",
+        "bbox": [
+            173,
+            547,
+            825,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8fdd952c2c86c952edf010f60a3cb8f9e4edc03fdedd0c79ce657c621a3f0e72.jpg",
+        "text": "$$\n\\mathcal { Q } ( { \\boldsymbol { \\rho } } ^ { w } ) \\stackrel { d e f } { = } \\{ ( s , a ) \\mapsto \\langle \\phi ( s , a ) , w \\rangle \\mid \\| w \\| _ { 2 } \\leq \\rho ^ { w } \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            612,
+            663,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ere $\\rho ^ { w } \\in ( 0 , 1 ]$ is a user-defined radius. For policies, we consider the associated soft-max ",
+        "bbox": [
+            197,
+            640,
+            772,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9b278d138dbdabb3348c07dfcea91125a63912165da02add21a685e3d2ab4cee.jpg",
+        "text": "$$\n\\Pi _ { s o f t } ( \\rho ^ { \\theta } ) \\overset { d e f } { = } \\left\\{ \\frac { e ^ { \\langle \\phi ( s , a ) , \\theta \\rangle } } { \\displaystyle \\sum _ { a ^ { \\prime } \\in \\mathcal { A } } e ^ { \\langle \\phi ( s , a ^ { \\prime } ) , \\theta \\rangle } } \\ | \\ \\| \\theta \\| _ { 2 } \\leq \\rho ^ { \\theta } \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            661,
+            666,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho ^ { \\theta } > 0$ is a second radius. ",
+        "bbox": [
+            174,
+            728,
+            390,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the context of our actor-critic algorithm, the weight radius other hand, the actor produces a sequence of soft-max radii $\\rho ^ { w }$ ins fixed for all updates. O, indexed by the iterations theof $\\{ \\rho _ { t } ^ { \\theta } \\} _ { t = 1 } ^ { T }$ $t$ the actor. This sequence is produced via the update rule in Line $\\cdot ^ { 5 }$ of Algorithm $\\dot { 1 . }$ The policy radius can be large $\\rho ^ { \\theta } \\gg 1$ but we constrain $\\rho ^ { w } \\leq 1$ so that the critic’s estimate $Q _ { w } ( \\overline { { s , } } a ) = \\overline { { \\langle \\phi ( s , a ) , w \\rangle } }$ is bounded by one, i.e., $\\begin{array} { r } { \\operatorname* { s u p } _ { ( s , a , w ) } | Q _ { w } ( s , a ) | \\leq 1 } \\end{array}$ . ",
+        "bbox": [
+            173,
+            748,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Recall that our MDP consists of sequence of $H$ distinct stages. Our algorithm and theory allows for the possibility of different feature extractors at each step $h \\in [ H ]$ , even with possibly different dimensions. Consequently, in implementing and analyzing the algorithm, there are actually $H$ (possibly different) functional spaces $\\{ \\mathcal { Q } _ { h } \\} _ { h = 1 } ^ { H }$ , along with the associated soft-max policy classes $\\{ \\Pi _ { h } \\} _ { h = 1 } ^ { H }$ . So as to simplify notation, we drop the dependence on the radii when referring to the functional spaces, and implicitly assume that the terminal value function is zero. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 A range of function class assumptions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            475,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss a range of assumptions that might be imposed on the class of action-value functions. This discussion serves as motivation for the particular assumption (Bellman restricted closedness—cf. Assumption $\\textcircled { 3 }$ that underlies our analysis. ",
+        "bbox": [
+            173,
+            116,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We begin with the least restrictive condition, which is a very natural starting point in our given set-up. If we seek to find the policy $\\pi \\in \\Pi$ with the highest value function, it seems reasonable to require that the following representation condition (approximately) holds. ",
+        "bbox": [
+            174,
+            165,
+            823,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2 (Linear action-value functions $Q ^ { \\pi }$ ). The MDP admits a linear action-value function representation for all policies in $\\Pi$ , meaning that for each policy $\\pi \\in \\Pi$ and time step $\\dot { h } \\in [ H ]$ , there exists a vector $w _ { h } ^ { \\pi }$ such that ",
+        "bbox": [
+            174,
+            212,
+            825,
+            255
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f89277d4830e68afc135f53b861091ce0ae6dbdb6b73845394366716f6cee89.jpg",
+        "text": "$$\nQ _ { h } ^ { \\pi } ( s , a ) = \\left. \\phi _ { h } ( s , a ) , w _ { h } ^ { \\pi } \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            262,
+            593,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This assumption alone turns out to be inadequate to ensure that effective learning is possible; indeed, the recent papers Zanette (2020); Weisz et al. (2020) establish that even under this condition, there are instances that require exponentially many samples to do better than a random policy. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given this fact, if one is interested in procedures with polynomial complexity (in both sample size and running time), stronger conditions need to be imposed. In general, the Bellman evaluation operator, even when applied to a linear action-value function, will return a nonlinear value function. The analysis of this paper is based on bounding the Bellman error in the sense of sup-norm deviation from linearity: ",
+        "bbox": [
+            173,
+            356,
+            825,
+            426
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3 (Bellman Restricted Closedness). The policy and value function spaces $( \\Pi , \\mathcal { Q } )$ are closed up to $\\nu \\in \\mathbb { R } ^ { H }$ error in the sup-norm if there is a non-negative sequence $\\{ \\bar { \\nu } _ { h } \\} _ { h = 1 } ^ { H }$ Qsuch that for each $h \\in [ H ]$ , we have ",
+        "bbox": [
+            173,
+            430,
+            825,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bfe0cf8b37c064038b97fa3a13417e3bf14ec5ba24f8256f30fd55ad58af343b.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { Q _ { h + 1 } \\in \\mathcal Q _ { h + 1 } } \\operatorname* { i n f } _ { Q _ { h } \\in \\mathcal Q _ { h } } \\| Q _ { h } - \\mathcal T _ { h } ^ { \\pi _ { h + 1 } } Q _ { h + 1 } \\| _ { \\infty } \\leq \\nu _ { h } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            479,
+            658,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The restricted closedness assumption measures how well we can fit the action-value function resulting from the application of the Bellman evaluation operator to an action value function in $\\mathcal { Q }$ and for a policy in $\\Pi$ . It enables the analysis of least-squares policy evaluation (e.g., Nedic and ´ Bertsekas (2003)), which will be our starting point when constructing the critic. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, for understanding connections to past work, it is relevant to compare to the low-rank MDP assumption that has been analyzed in recent work Jin et al. (2020a); Yang and Wang $\\underline { { ( 2 0 2 0 ) } }$ including in offline RL with pessimismistic guarantees Jin et al. (2020b), as well as in various online settings Agarwal et al. (2020a); Modi et al. (2021); Zanette et al. (2020a). ",
+        "bbox": [
+            174,
+            608,
+            825,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 4 (Low-Rank MDP). An MDP is low-rank if for all $h \\in [ H ]$ , there exists a reward parameter $w _ { h } \\in \\mathbb { R } ^ { d }$ and a component-wise positive mapping $\\psi _ { h } : S \\to \\mathbb { R } _ { + } ^ { d }$ such that $\\| \\psi _ { h } ( s ) \\| _ { 1 } = 1$ for all $s \\in S$ , and ",
+        "bbox": [
+            173,
+            670,
+            825,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/59332ee2351a4b66a1b0eedcb8a964fa27a14e08bcd15da01821cbc3666fb37f.jpg",
+        "text": "$$\n\\begin{array} { r l r l r } { r _ { h } ( s , a ) = \\langle \\phi _ { h } ( s , a ) , w _ { h } \\rangle , } & { } & { \\mathbb { P } _ { h } ( s ^ { \\prime } \\mid s , a ) = \\langle \\phi _ { h } ( s , a ) , \\psi _ { h } ( s ^ { \\prime } ) \\rangle , } & { } & { \\forall ( s , a , h , s ^ { \\prime } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            720,
+            784,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The following proposition explicates the nested relationship between these three conditions, showing that the low-rank MDP condition is the most restrictive: ",
+        "bbox": [
+            174,
+            757,
+            825,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 (Low Rank $\\subset$ Restricted Closedness $\\subset$ Linear $Q ^ { \\pi }$ ). For any fixed state-action space, horizon, and feature extractor: ",
+        "bbox": [
+            173,
+            804,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(a) The class of low-rank MDPs is a strict subset of the class of MDPs that satisfy Bellman restricted closedness.   \n(b) The class of MDPs that satisfy Bellman restricted closedness is a strict subset of the linear Q⇡ MDP class. ",
+        "bbox": [
+            200,
+            844,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "See Appendix C for the proof of this claim. ",
+        "bbox": [
+            176,
+            90,
+            457,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Based on Proposition $\\bigstar$ we see that any analysis based on assuming Bellman restricted closedness also a fortiori applies to MDPs that satisfy the more stringent low-rank MDP condition. ",
+        "bbox": [
+            173,
+            125,
+            825,
+            155
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 The Pessimistic Actor-Critic ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            174,
+            442,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the set-up thus far, we are now ready to describe the actor-critic algorithm that we analyze in this paper. We refer to it as the Pessimistic Actor Critic for Learning without Exploration, or PACLE for short. We first describe the critic in Section $\\underline { { \\boldsymbol { \\left. 3 . 1 \\right. } } }$ and then the actor in Section 3.2. We summarize the actor and critic algorithms, respectively, in pseudocode form in Algorithm 1 and Algorithm 2. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 The Critic: Pessimistic Least Square Policy Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            280,
+            593,
+            296
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The purpose of the critic is to provide pessimistic value function estimates corresponding to the policy $\\pi$ under consideration by the actor. Monte Carlo with importance sampling (IS) is not desirable in this setting, as the policy or distribution that generated the dataset might be unknown and estimation errors on the distribution can accumulate exponentially with the horizon in IS estimators (see e.g. Liu et al. $\\textcircled { 2 0 1 8 6 } )$ . Instead, we use a least-squares temporal difference method for policy evaluation, but suitably perturbed to return pessimistic estimates—i.e., lower bounds on the true value function of the given policy $\\pi$ . Our method is based on directly perturbing the regression parameters in the least-square estimate. In contrast to bonus-based approaches, this method has the important advantage of ensuring that the action-value function remains linear. The purpose of the perturbations is to compensate for possible statistical errors in estimating the regression parameter due to poor coverage of the given dataset. ",
+        "bbox": [
+            173,
+            306,
+            825,
+            459
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let us now give a precise description of the critic. Given a policy $\\pi = ( \\pi _ { 1 } , \\ldots , \\pi _ { H } )$ , the goal of the critic is to minimize the quantity ",
+        "bbox": [
+            171,
+            464,
+            823,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64f56c98cd9d7d0d777994db654d8e255045a2428494f73f436350f6cd39f64f.jpg",
+        "text": "$$\n\\operatorname { \\mathbb { E } } _ { A ^ { \\prime } \\sim \\pi _ { 1 } } \\left. \\phi ( s _ { 1 } , A ^ { \\prime } ) , w _ { 1 } \\right. = \\sum _ { a \\in { \\mathcal { A } } } \\pi _ { 1 } ( a \\mid s _ { 1 } ) \\left. \\phi _ { 1 } ( s _ { 1 } , a ) , w _ { 1 } \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            501,
+            692,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which is an estimate of the value function $V ^ { \\pi } ( s _ { 1 } )$ for the policy $\\pi$ at the initial state $s _ { 1 }$ . The parameter $\\boldsymbol { w } _ { 1 } ~ \\in ~ \\mathbb { R } ^ { d }$ is a vector to be adjusted, one that is determined by a backwards-running sequence of regression problems from $h = H$ down to $h = 1$ . ",
+        "bbox": [
+            174,
+            544,
+            825,
+            587
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We introduce the pessimistic perturbations directly to the solution of these regression problems. They involve a norm defined by the cumulative covariance matrix. Recall that $\\mathcal { T } _ { h }$ indexes the subset of observations associated with state-action pairs at time step $h$ . For each $h \\in [ H ]$ and $i \\in \\mathcal { T } _ { h }$ , let us write the associated sample as the quadruple $\\left( { { s _ { h i } } , { a _ { h i } } , { r _ { h i } } , { s _ { h + 1 , i } } } \\right)$ . Introducing the shorthand notation $\\phi _ { h i } = \\phi _ { h } ( s _ { h i } , a _ { h i } )$ , we define the cumulative covariance matrix ",
+        "bbox": [
+            173,
+            593,
+            825,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/53fea1a7210926cbd413fe8d7a7755f8fecb3eec9f1ed71da222f5395bb6559e.jpg",
+        "text": "$$\n{ \\Sigma } _ { h } \\overset { d e f } { = } \\Big ( \\sum _ { i \\in \\mathbb { Z } _ { h } } \\phi _ { h i } \\phi _ { h i } ^ { \\top } \\Big ) + I _ { d \\times d } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            671,
+            602,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $I _ { d \\times d }$ denotes the $d$ -dimensional identity matrix. Notice that the cumulative covariance grows as the number of samples in $\\mathcal { T } _ { h }$ increases; we do not normalize it by the local sample size $n _ { h } = | \\mathcal { T } _ { h } |$ , so that $\\Sigma _ { h }$ effectively represents the amount of information contained in the sub-dataset $\\mathcal { D } _ { h }$ at time step $h$ . ",
+        "bbox": [
+            174,
+            715,
+            825,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since $\\Sigma _ { h }$ is strictly positive definite by construction, it defines a pair of norms ",
+        "bbox": [
+            173,
+            777,
+            686,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4197ee19ec87c70da3db04ddc301e9ba49fbda28ca944eb2b120f0d440ef9ecd.jpg",
+        "text": "$$\n\\begin{array} { r } { \\left\\| u \\right\\| _ { \\Sigma _ { h } } \\overset { d e f } { = } \\sqrt { u ^ { \\top } \\Sigma _ { h } u } , \\quad \\mathrm { a n d } \\quad \\left\\| u \\right\\| _ { \\Sigma _ { h } ^ { - 1 } } \\overset { d e f } { = } \\sqrt { u ^ { \\top } ( \\Sigma _ { h } ) ^ { - 1 } u } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            800,
+            694,
+            829
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Consider the regression problem that is solved in moving backward from time step $h + 1$ to $h$ . Given the weight vector $w _ { h + 1 }$ at time step $h + 1$ , the regularized least-squares estimate of $w _ { h }$ is given by ",
+        "bbox": [
+            171,
+            835,
+            825,
+            864
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c500c4c79bbc2ec747ae4ffd00bddefac0812878f757758ce8eef40e78885d05.jpg",
+        "text": "$$\n\\widehat { w } _ { h } \\overset { d e f } { = } \\Sigma _ { h } ^ { - 1 } \\sum _ { k \\in \\mathbb { Z } _ { h } } \\phi _ { h k } \\Bigl [ r _ { h k } + \\sum _ { a \\in \\mathcal { A } } \\pi _ { h + 1 } ( a \\mid s _ { h + 1 , k } ) \\left. \\phi _ { h + 1 } ( s _ { h + 1 , k } , a ) , w _ { h + 1 } \\right. \\Bigr ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            872,
+            758,
+            909
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We introduce pessimism by directly perturbing the weight vectors themselves—that is, we search for weight vector $w _ { h }$ such that $\\overline { { w _ { h } } } \\overline { { = } } \\xi _ { h } + \\bar { \\widehat { w } } _ { h }$ , where the pessimism vector $\\xi _ { h } \\in \\mathbb { R } ^ { d }$ satisfies a bound of the form $\\| \\xi _ { h } \\| _ { \\Sigma _ { h } } \\le \\alpha _ { h }$ , for a user-defined parameter $\\alpha _ { h }$ . ",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In detail, the critic takes as input the dataset $\\mathcal { D }$ , a policy $\\pi$ , a sequence of tolerance parameters $\\alpha = ( \\alpha _ { 1 } , \\ldots , \\alpha _ { H } )$ , weight radii $\\rho ^ { w } = ( \\rho _ { 1 } ^ { w } , \\dots , \\rho _ { H } ^ { w } )$ with each $\\rho _ { h } ^ { w } ~ \\in ~ ( 0 , 1 ]$ . The optimization variables consist of the regression vectors $w = ( w _ { 1 } , \\dots , w _ { H } ) \\in (  { \\mathbb { R } } ^ { d } ) ^ { H }$ and the pessimism vectors $\\xi = ( \\xi _ { 1 } , \\dots , \\xi _ { H } ) \\in (  { \\mathbb { R } } ^ { d } ) ^ { H }$ . The critic then solves the convex program ",
+        "bbox": [
+            173,
+            138,
+            825,
+            199
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a7739115f870e9ccd88e210e96445885468d8880161b7e1dff1e62e82ffdad6.jpg",
+        "text": "$$\n\\left( \\xi ^ { \\pi } , \\underline { { \\upsilon } } ^ { \\pi } \\right) \\overset { d e f } { = } \\arg \\operatorname* { m i n } _ { \\xi \\in ( \\mathbb { R } ^ { d } ) ^ { H } } \\sum _ { a \\in \\mathcal { A } } \\pi _ { 1 } ( a  { | } s _ { 1 } )  { \\langle } \\phi _ { 1 } ( s _ { 1 } , a ) , w _ { 1 } \\rangle\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            205,
+            686,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "with the terminal condition $w _ { H + 1 } = 0$ , and subject to the constraints ",
+        "bbox": [
+            173,
+            257,
+            625,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ee3e0e4511c8ab393dcb787fe9b8b38d4b92e1f5479e1b8342a5e448bedb3ce.jpg",
+        "text": "$$\nw _ { h } = \\xi _ { h } + \\Sigma _ { h } ^ { - 1 } \\sum _ { k \\in \\mathcal { Z } _ { h } } \\phi _ { h k } \\left[ r _ { h k } + \\sum _ { a \\in \\mathcal { A } } \\pi _ { h + 1 } ( a \\mid s _ { h + 1 , k } ) \\left. \\phi _ { h + 1 } { \\left( s _ { h + 1 , k } , a \\right) } , w _ { h + 1 } \\right. \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            277,
+            741,
+            314
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            774,
+            286,
+            802,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7dbafa6e22e512981cf2e0bcbc5c5c9a8a40d5693e6b0dce31a5f8e69df21d09.jpg",
+        "text": "$$\n\\| \\xi _ { h } \\| _ { \\Sigma _ { h } } ^ { 2 } \\le \\alpha _ { h } ^ { 2 } , \\qquad \\| w _ { h } \\| _ { 2 } ^ { 2 } \\le ( \\rho _ { h } ^ { w } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            330,
+            454,
+            351
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "for all $h \\in [ H ]$ . Here the matrices $\\Sigma _ { h }$ were previously defined in equation $( 8 )$ . ",
+        "bbox": [
+            176,
+            356,
+            687,
+            373
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The convex program $\\textcircled { 1 0 }$ consists of a linear objective subject to quadratic constraints; it is a special case of a second order cone program, and can be efficiently solved with standard convex solvers. ",
+        "bbox": [
+            171,
+            377,
+            823,
+            407
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 ACTOR (MIRROR DESCENT) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            436,
+            460,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Dataset $\\mathcal { D }$ , starting state $s _ { 1 }$   \nlearning rate $\\eta$   \n2: Set $\\theta _ { 1 } = ( \\vec { 0 } , \\ldots , \\vec { 0 } )$   \n3: for $t = 1 , 2 , \\dots , T$ do   \n4: $\\underline { { w } } _ { t } \\gets \\mathrm { C R I T I C } ( \\mathcal { D } , \\pi _ { \\theta _ { t } } , s _ { 1 } )$   \n5: $\\theta _ { t + 1 } = \\theta _ { t } + \\eta \\underline { { w } } _ { t }$   \n6: end for   \n7: Return: Mixture policy ⇡✓1 , . . . , ⇡✓T ",
+        "bbox": [
+            178,
+            454,
+            467,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8947714303eeb21199a533aaa023d2f102cc2b0579dc0dca0be4cef00526eecd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm2 CRITIC (PLSPE)</td></tr><tr><td>1: Input: Dataset D, target policy π, start- ing state S1， critic radii {ph}h=1,.., H,</td></tr><tr><td>and parameters {αh}h=1..., H</td></tr><tr><td>2:Solve the optimization program 1 3: Return: Optimal weight vector w</td></tr><tr><td></td></tr></table>",
+        "bbox": [
+            529,
+            457,
+            823,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 The Actor: Mirror Descent ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            401,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now turn to the behavior of the actor. It applies the mirror descent algorithm based on the Kullback Leibler (KL) divergence Bubeck (2014) This combination leads to the exponentiated gradient update rule in every timestep $\\overline { { h \\in [ H ] } }$ , so that the soft-max policy in moving from iteration $t$ to $t + 1$ is updated as ",
+        "bbox": [
+            173,
+            613,
+            826,
+            669
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9e1e79245a4c7a8bba27c6921e7b0a5ada06933aa7db3136545ef02cdb7630b.jpg",
+        "text": "$$\n\\pi _ { t + 1 , h } ( a \\mid s ) \\propto \\pi _ { t , h } ( a \\mid s ) e ^ { \\eta Q _ { h } ( s , a ) } \\qquad \\mathrm { f o r } \\operatorname { e a c h } \\left( s , a \\right) \\in \\mathcal { S } \\times \\mathcal { A } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            676,
+            715,
+            695
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here $\\eta > 0$ is a stepsize parameter, and our theory specifies a suitable choice. ",
+        "bbox": [
+            176,
+            702,
+            681,
+            718
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "If the $Q$ -value above from the critic lives in $\\mathcal { Q }$ , then it is possible to show that $\\pi _ { t + 1 , h } \\in \\Pi _ { h }$ and the update rule takes a much simpler and computationally more efficient form (cf. Line $^ { 5 } .$ of Algorithm 1), where $w _ { t }$ is the gradient of the value function on the pessimistic MDP implicitly identified by the critic. In this case, the spaces $( \\mathcal { Q } , \\Pi )$ are said to be compatible Sutton et al. (1999) ; Kakade (2001); Agarwal et al. (2020b); Raskutti and Mukherjee (2015) and the resulting algorithm is often called the Natural Policy Gradient (NPG) (see also Geist et al. $\\textcircled { 1 2 0 1 9 }$ ; Shani et al. $\\textcircled{2 0 2 0 } )$ By construction, the critic maintains a linear action value function even after pessimistic perturbations. As a consequence, the actor policy space is the simple softmax policy class $\\Pi$ and the easier update rule can be used. As we explain in the analysis, this has important statistical benefits. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "After $T$ rounds of updates, the mirror descent algorithm that we use here readily achieves online regret rates (in the optimization setting with exact feedback) $\\sim 1 / T$ or $\\sim 1 / \\sqrt { T }$ depending on the analysis Agarwal et al. $\\left( \\overline { { 2 0 2 0 } } \\mathrm { b } \\right)$ and the learning rate, although we mention that these rates could potentially be improved Khodadadian et al. (2021); Lan (2021); Bhandari and Russo $\\underline { { \\left. 2 0 2 0 \\right. } }$ . ",
+        "bbox": [
+            174,
+            853,
+            825,
+            914
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Main results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            310,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now turn to the statement of a bound on the performance of the policy $\\pi _ { \\mathrm { A L G } }$ returned by PACLE. This upper bound involves three terms: an optimization error, an uncertainty term, and a model mis-specification term. The optimization error is given by $\\textstyle { \\mathcal { C } } ( T ) { \\overset { d e f } { = } } 4 H { \\sqrt { \\frac { \\log | A | } { T } } }$ log |A|T ; it captures the rate at which the error decreases as a function of the iterations of the actor. The mis-specification error $\\begin{array} { r } { \\mathcal { E } _ { \\mathrm { m s p } } ( \\nu ) \\overset { d e f } { = } \\sum _ { h = 1 } ^ { H } \\nu _ { h } } \\end{array}$ is simply the sum of all the stage-wise mis-specification errors; notice h=1  that the mis-specification error does depend on the choice of the radii for the critic $\\rho _ { 1 } ^ { w } , \\ldots , \\rho _ { H } ^ { w }$ in a problem dependent way (cf. Assumption $\\bigstar \\bigstar \\bigstar$ Finally, for each h, define the vector \u0000¯⇡h def= $\\mathbb { E } _ { ( S _ { h } , A _ { h } ) \\sim \\pi } [ \\phi _ { h } ( S _ { h } , A _ { h } ) ]$ , where the expectation is over the state-action $\\left( S _ { h } , A _ { h } \\right)$ encountered at timestep $h$ upon following policy $\\pi$ . In terms of these vectors, the uncertainty error is given by ",
+        "bbox": [
+            173,
+            119,
+            826,
+            266
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79a18c21dec26fd06723d7f4fc5dac4c735ce9d860b480dd00e6c915d196bdf5.jpg",
+        "text": "$$\n\\mathcal { U } ( \\pi ; \\alpha ) \\overset { d e f } { = } 2 \\sum _ { h = 1 } ^ { H } \\alpha _ { h } \\| \\bar { \\phi } _ { h } ^ { \\pi } \\| _ { \\Sigma _ { h } ^ { - 1 } } = 2 \\sum _ { h = 1 } ^ { H } \\alpha _ { h } \\sqrt { ( \\bar { \\phi } _ { h } ^ { \\pi } ) ^ { \\top } \\Sigma _ { h } ^ { - 1 } \\bar { \\phi } _ { h } ^ { \\pi } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            271,
+            699,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where the cumulative covariance matrix $\\Sigma _ { h }$ was defined in equation $( 8 )$ . ",
+        "bbox": [
+            176,
+            320,
+            645,
+            335
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "D the sequence of cumulative covariance matrices The amount of information from the dataset $\\mathcal { D }$ is fully encoded in the uncertainty function $\\{ \\Sigma _ { h } \\} _ { h = 1 } ^ { H }$ and parameters $\\{ \\alpha _ { h } \\} _ { h = 1 } ^ { H }$ U . The more data $\\boldsymbol { \\mathcal { U } }$ through are available, the more positive definite $\\Sigma _ { h }$ is and the smaller the uncertainty function $\\mathcal { U } ( \\pi ; \\alpha )$ becomes for a fixed policy $\\pi$ . If the sampling distribution that generates the dataset is fixed, then we can write $\\mathcal { U } ( \\pi ; \\boldsymbol { \\alpha } ) \\lessapprox \\boldsymbol { c } / \\bar { \\sqrt { n } }$ where $c$ does not depend on $n$ and can be interpreted as the coverage of the sampling distribution with respect to policy $\\pi$ . ",
+        "bbox": [
+            173,
+            340,
+            826,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 A guarantee for PACLE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            380,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our main result holds under Assumption $\\perp$ on the data collection process. It is based on radii $\\{ \\rho _ { h } ^ { w } \\} _ { h = 1 } ^ { H }$ for the action value function3 that lie in the interval $( 0 , 1 ]$ , and it provides a guarantee relative to the class $\\Pi _ { \\mathrm { a l l } }$ of all stochastic policies. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            508
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (An achievable guarantee). Suppose that we are given a data set $\\mathcal { D }$ collected in a way that respects Assumption 1. Then there are pessimism vectors bounded as $\\alpha _ { h } = { \\widetilde O } ( \\sqrt { d \\log ( 1 / \\delta ) } ) \\dot { + }$ $\\nu _ { h } \\sqrt { n _ { h } }$ such that, after running $T \\geq \\log | { \\mathcal { A } } |$ rounds of the actor with stepsize $\\begin{array} { r } { \\eta = \\sqrt { \\frac { \\log | \\mathcal { A } | } { T } } } \\end{array}$ log |A| , the PACLE procedure returns a policy $\\pi _ { \\mathrm { A L G } }$ for which ",
+        "bbox": [
+            174,
+            512,
+            825,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2ddf8e08ebf26f61ddf89447dca9875b0ab1d0c0c8e88ebcf59a5ed01d9123d.jpg",
+        "text": "$$\nV _ { 1 } ^ { \\pi } ( s _ { 1 } ) - V _ { 1 } ^ { \\pi _ { \\mathrm { A z e } } } ( s _ { 1 } ) \\leq \\mathcal { U } ( \\pi ; \\alpha ) + \\underbrace { \\sum _ { h = 1 } ^ { H } \\nu _ { h } } _ { \\mathcal { E } _ { m s p } ( \\nu ) } + \\underbrace { 4 H \\sqrt { \\frac { \\log | A | } { T } } } _ { \\mathcal { C } ( T ) } \\qquad u n i f o r m l y o v e r a l l \\pi \\in \\Pi _ { a l l } \\nonumber\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            587,
+            779,
+            652
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "with probability exceeding $1 - \\delta$ . ",
+        "bbox": [
+            174,
+            657,
+            392,
+            672
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The result provides a family of upper bounds on the sub-optimality of the learned policy $\\pi _ { \\mathrm { A L G } }$ , indexed by the choice of comparator policy $\\pi$ , and embodies a tradeoff between the sub-optimality of the comparator $\\pi$ and its uncertainty $\\mathcal { U } ( \\pi ; \\alpha )$ . Note that the optimization error $\\mathcal { C } ( T )$ can be reduced arbitrarily, while $\\alpha$ (and thus $\\mathcal { U } ( \\pi ; \\alpha ) ,$ ) increase only logarithmically with $T$ . As a special case, if we set $\\pi = \\pi ^ { \\star }$ and assume that there is no mis-specification error, then we obtain that the learned policy satisfies a bound of the form ",
+        "bbox": [
+            173,
+            683,
+            825,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c2580f38b97610c7e6c4052479a4284fb3ad16dfbae800a1aca30e8167ed9648.jpg",
+        "text": "$$\nV _ { 1 } ^ { \\pi ^ { \\star } } ( s _ { 1 } ) - V _ { 1 } ^ { \\pi _ { \\mathrm { A L G } } } ( s _ { 1 } ) \\leq \\mathcal { U } ( \\pi ^ { \\star } ; \\alpha ) + \\mathcal { C } ( T )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            772,
+            642,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "with probability at least $1 - \\delta$ . Since $\\mathcal { C } ( T )$ is well-controlled, this guarantee is satisfied whenever the uncertainty term $\\mathcal { U } ( \\pi ^ { \\star } ; \\alpha )$ is small. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            827
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "More generally, the guarantee $( 1 3 )$ is significantly stronger than most prior work as PACLE competes not just with the optimal policy $\\pi ^ { \\star }$ , but with all comparator policies simultaneously. Such comparator policies need not necessarily be in the prescribed policy class $\\Pi$ . To highlight the strength of this generality, suppose that the uncertainty $\\mathcal { U } ( \\pi ^ { \\star } ; \\alpha )$ of the optimal $\\pi ^ { \\star }$ is not small—it could in fact be infinite. In this case, the bound $( 1 4 )$ would not be useful. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "However, suppose that there exists a near-optimal policy—meaning a policy $\\pi ^ { + }$ such that ${ V _ { 1 } ^ { \\pi ^ { + } } ( s _ { 1 } ) ~ \\geq ~ \\widetilde { V } _ { 1 } ^ { \\star } ( s _ { 1 } ) - \\epsilon }$ for some small $\\epsilon$ —that is well-covered by the dataset (i.e., for which $\\mathcal { U } ( \\pi ^ { + } ; \\boldsymbol { \\alpha } ) \\approx 0 )$ ). In this case, Theorem 1 ensures with high probability $V _ { 1 } ^ { \\mathrm { A L G } } ( s _ { 1 } ) \\gtrsim V _ { 1 } ^ { \\star } ( s _ { 1 } ) - \\epsilon$ . In contrast, traditional analyses that use only the optimal policy $\\pi ^ { \\star }$ as a comparator—as opposed to also allowing near-optimal policies—cannot return meaningful guarantees. We note also that the papers Yu et al. $\\underline { { \\widehat { ( 2 0 2 0 ) } } }$ ; Liu et al. $\\underline { { \\left\\{ 2 0 2 0 \\right\\} } }$ ; Kidambi et al. (2020) provide results of a similar flavor. These types of guarantees are also provided by some concurrent works Uehara and Sun (2021); Xie et al. (2021) ",
+        "bbox": [
+            173,
+            126,
+            826,
+            241
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It should alscritic’s radii $\\{ \\rho _ { h } ^ { w } \\} _ { h = 1 } ^ { H }$ d that Theorem. This choice is $\\bigstar$ provides a family of results indexed by the choice of the modeling decision: increasing the radii increases both the approximation power of the function class $\\mathcal { Q } _ { h }$ used for regression, but also increases the complexity of the function class $\\mathcal { Q } _ { h + 1 }$ to represent (cf. Assumption $\\bar { 3 } )$ ; thus, the choice of the radii affects the approximation error $\\mathcal { E } _ { \\mathrm { m s p } } ( \\nu )$ in a problem dependent way. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            315
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 A lower bound ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            330,
+            316,
+            345
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thus far, we have stated an upper bound on the quality of the returned policy for a given procedure. Central to this upper bound is the uncertainty function $\\mathcal { U } ( \\pi ; \\alpha )$ . In this section, we show that a term of this form is unavoidable for any procedure. In particular, working within the well-specified setting, we prove a lower bound in terms of the quantity $\\begin{array} { r } { \\mathcal { U } ( \\pi ; \\sqrt { d } ) = \\sqrt { d } \\dot { \\sum } _ { h = 1 } ^ { H } \\| \\bar { \\phi } _ { h } ^ { \\pi } \\| _ { { \\Sigma } _ { h } ^ { - 1 } } } \\end{array}$ . Recalling that our choice of $\\alpha$ scales with $\\sqrt { d }$ (along with other logarithmic factors), this lower bound shows that our result is tight up to logarithmic factors. ",
+        "bbox": [
+            173,
+            356,
+            825,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We show that the lower bound actually holds in a setting that is easier for the learner, in the sense that (1) we restrict to low-rank MDPs, where there is no mis-specification error; and (2) the mechanism that generates the dataset is non-adaptive, and so certainly satisfies Assumption 1. ",
+        "bbox": [
+            173,
+            454,
+            821,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Information-theoretic lower bound). For a given horizon $H$ and dimension $d$ , consider a sample size $n \\geq 2 d ^ { 3 } H ^ { 3 }$ . There is a class $\\mathcal { M }$ of low-rank MDPs and a data generating procedure satisfying Assumption 1 such that for any policy $\\widehat { \\pi } _ { \\mathrm { A L G } }$ , we have ",
+        "bbox": [
+            173,
+            501,
+            825,
+            544
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ec38cca65546636428e090934f5191e6cb0594a77c07165ee9c887a456d889a.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { M \\in \\mathcal { M } } \\mathbb { E } _ { M } \\left[ V _ { 1 M } ^ { \\pi } ( s _ { 1 } ) - V _ { 1 M } ^ { \\pi _ { \\mathrm { A t o } } } ( s _ { 1 } ) \\right] \\geq c \\mathcal { U } ( \\pi ; \\sqrt { d } ) \\qquad \\mathit { u n i f o r m l y o v e r a l l } \\pi \\in \\Pi _ { a l l } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            547,
+            769,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where $c > 0$ is a universal constant. ",
+        "bbox": [
+            174,
+            583,
+            411,
+            598
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When $H = 1$ the above result gives a sample complexity lower bound for learning a near optimal policy from batch data in a linear bandit instance. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Comparison to related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            408,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem $^ 1$ automatically implies the typical bound $\\mathbb { P } [ V _ { 1 } ^ { \\pi _ { \\mathrm { A L G } } } ( s _ { 1 } ) \\geq V _ { 1 } ^ { \\star } ( s _ { 1 } ) - \\mathcal { U } ( \\pi ^ { \\star } ; \\alpha ) ] \\geq 1 - \\delta$ when the comparator policy is the optimal policy $\\pi ^ { \\star }$ , e.g., Jin et al. (2020b) Rashidinejad et al. $\\textcircled { 2 0 2 1 }$ ; Kidambi et al. $\\dot { ( 2 0 2 0 ) }$ ; Kumar et al. $\\overbrace { ( 2 0 1 9 ) }$ ; Buckman et al. (2020). The guarantee can be written as $\\overline { { V _ { 1 } ^ { \\mathrm { \\tiny ~ A L G } } ( s _ { 1 } ) } } \\stackrel { \\textstyle > } { \\sim } V _ { 1 } ^ { \\star } ( s _ { 1 } ) - C / \\sqrt { n }$ where $n$ is the number of samples and $C$ is the (scaled) condition number of $\\Sigma _ { h } ^ { - 1 }$ . One could interpret $C$ as a concentrability coefficient that expresses the coverage of dataset—through $\\Sigma _ { h }$ —with respect to the average direction in feature space $\\mathbb { \\bar { E } } _ { ( S _ { h } , A _ { h } ) \\sim \\pi _ { h } ^ { \\star } } [ \\phi ( S _ { h } , A _ { h } ) ]$ of the optimal policy $\\pi ^ { \\star }$ . As in the paper Jin et al. $\\boxed { 2 0 2 0 6 }$ , such a factor can be small even when traditional concentrability coefficients are large because they depend on state-action visit ratios (see the literature in Appendix B, e.g., Chen and Jiang (2019)) ",
+        "bbox": [
+            173,
+            676,
+            825,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "With reference to the results in the paper Jin et al. $\\textcircled { 2 0 2 0 6 }$ , our work provides improvements in two distinct ways. First, their upper and lower bounds exhibit a gap of the order $d H$ , which our analysis closes. Second, our analysis holds under the more permissive Assumption 3 (Bellman Restricted Closedness) which includes low-rank MDPs. Of this improvement, a factor of $\\sqrt { d }$ is due to the algorithm that we use, and the remainder is due to a more refined construction to certify optimality in Theorem 2. To be clear, our upper and lower bounds differ from theirs by a factor of $H$ due to a different normalization in the value function). We also note that the result of Liu et al.Liu et al. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "$\\textcircled { 2 0 2 0 }$ can be specialized to the low-rank MDP setting; however, even in this simpler setting, the results would be sub-optimal and also require additional density estimates. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deriving a computationally tractable model-free algorithm without low-rank dynamics but subject to value function perturbations (e.g., optimistic or pessimistic perturbations) is an open problem even in the more heavily studied online exploration setting: there the current state-of-the art Zanette et al. (2020b); Jin et al. (2021); Du et al. (2021); Jiang et al. (2017) only present computationally intractable algorithms with the exception of Zanette et al. (2020c) for a PAC setting with low inherent Bellman error which however requires an additional “explorability” condition. Due to space constraints, the proof outline is deferred to Appendix A. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            243,
+            294,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have developed and analyzed an actor-critic method procedure, designed for finding near-optimal policies in the offline setting. The PACLE procedure introduces pessimism into the critic’s evaluation of a given policy’s value function, thereby ensuring that, under suitable parameter choices and assumptions, it maintains (with high probability) a lower bound on the true value function. The actor then performs a form of mirror ascent so as to maximize the value of these lower bounds. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "An important feature of our method is that it introduces pessimism via direct perturbations of the parameter vectors in a linear function approximation scheme. In this way, we avoid having to impose additional model assumptions; moreover, the pessimism does not substantially increase the complexity of our under value/policy classes, which allows us to provide minimax-optimal guarantees. We note that similar approaches have appeared before in the exploration setting; for example, see the recent papers Zanette et al. (2020b) Jin et al. (2021) Du et al. (2021). These methods enjoy similar advantages in terms of theoretical guarantees, but at the expense of computational tractability. In contrast, the method of this paper entails solving a low-dimensional second-order cone program, a simple class of convex programs for which there exist many polynomial-time algorithms. We enjoy this advantage due to some key differences between the offline and online settings of RL. In the offline setting, it is possible to keep the actor’s update cleanly separated from the evaluation step of the critic, as we have done here; this separation underlies the computational tractability. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our work leaves open a number of interesting questions for future work. First, it would be interesting to provide some numerical studies of the PACLE’s performance, so as to understand its practical behavior relative to the theoretical guarantees provided here. Also, our analysis here has focused purely on approximation using linear basis expansions; extension to more general function classes is an important next step. Finally, it will be interesting to see to what extent these ideas can be translated to the more challenging setting of exploration. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            637,
+            310,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was partially supported by NSF-DMS grant 2015454, NSF-IIS grant 1909365, and NSFFODSI grant 2023505 to MJW, a Stanford Artificial Intelligence Laboratory Toyota gift to EB, and a Office of Naval Research grant DOD-ONR-N00014-18-1-2640 to MJW. ",
+        "bbox": [
+            176,
+            662,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            726,
+            266,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abbasi-Yadkori, Y., Pal, D., and Szepesvari, C. (2011). Improved algorithms for linear stochastic bandits. In Advances in Neural Information Processing Systems (NIPS). Agarwal, A., Kakade, S., Krishnamurthy, A., and Sun, W. (2020a). Flambe: Structural complexity and representation learning of low rank mdps. arXiv preprint arXiv:2006.10814. Agarwal, A., Kakade, S. M., Lee, J. D., and Mahajan, G. (2020b). Optimality and approximation with policy gradient methods in markov decision processes. In Conference on Learning Theory, pages 64–66. Agarwal, R., Schuurmans, D., and Norouzi, M. (2020c). An optimistic perspective on offline reinforcement learning. In International Conference on Machine Learning, pages 104–114. PMLR. ",
+        "bbox": [
+            171,
+            750,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antos, A., Munos, R., and Szepesvári, C. (2007). Fitted q-iteration in continuous action-space mdps.   \nAntos, A., Szepesvári, C., and Munos, R. (2008). Learning near-optimal policies with bellmanresidual minimization based fitted policy iteration and a single sample path. Machine Learning, 71(1):89–129.   \nBertsekas, D. P. (1995). Dynamic programming and stochastic control, volume 1. Athena Scientific, Belmont, MA.   \nBertsekas, D. P. and Tsitsiklis, J. N. (1996). Neuro-dynamic programming. Athena Scientific.   \nBhandari, J. and Russo, D. (2020). A note on the linear convergence of policy gradient methods. arXiv preprint arXiv:2007.11120.   \nBubeck, S. (2014). Convex optimization: Algorithms and complexity. arXiv preprint arXiv:1405.4980.   \nBuckman, J., Gelada, C., and Bellemare, M. G. (2020). The importance of pessimism in fixeddataset policy optimization. arXiv preprint arXiv:2009.06799.   \nChen, J. and Jiang, N. (2019). Information-theoretic considerations in batch reinforcement learning. In International Conference on Machine Learning, pages 1042–1051.   \nde la Pena, V. H., Lai, T. L., and Shao, Q. M. (2009). Self-normalized processes. Springer.   \nDu, S. S., Kakade, S. M., Lee, J. D., Lovett, S., Mahajan, G., Sun, W., and Wang, R. (2021). Bilinear classes: A structural framework for provable generalization in rl. arXiv preprint arXiv:2103.10897.   \nDuan, Y., Jin, C., and Li, Z. (2021). Risk bounds and rademacher complexity in batch reinforcement learning. arXiv preprint arXiv:2103.13883.   \nDuan, Y. and Wang, M. (2020). Minimax-optimal off-policy evaluation with linear function approximation. arXiv preprint arXiv:2002.09516.   \nFan, J., Wang, Z., Xie, Y., and Yang, Z. (2020). A theoretical analysis of deep q-learning. In Learning for Dynamics and Control, pages 486–489. PMLR.   \nFarahmand, A.-m., Ghavamzadeh, M., Szepesvári, C., and Mannor, S. (2016). Regularized policy iteration with nonparametric function spaces. The Journal of Machine Learning Research, 17(1):4809–4874.   \nFarahmand, A.-m., Szepesvári, C., and Munos, R. (2010). Error propagation for approximate policy and value iteration. In Advances in Neural Information Processing Systems (NIPS).   \nFarajtabar, M., Chow, Y., and Ghavamzadeh, M. (2018). More robust doubly robust off-policy evaluation. In International Conference on Machine Learning, pages 1447–1456. PMLR.   \nFu, Z., Yang, Z., and Wang, Z. (2020). Single-timescale actor-critic provably finds globally optimal policy. arXiv preprint arXiv:2008.00483.   \nGeist, M., Scherrer, B., and Pietquin, O. (2019). A theory of regularized markov decision processes. In International Conference on Machine Learning, pages 2160–2169. PMLR.   \nHaarnoja, T., Tang, H., Abbeel, P., and Levine, S. (2017). Reinforcement learning with deep energybased policies. In International Conference on Machine Learning, pages 1352–1361. PMLR.   \nHaarnoja, T., Zhou, A., Abbeel, P., and Levine, S. (2018). Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor.   \nHao, B., Ji, X., Duan, Y., Lu, H., Szepesvári, C., and Wang, M. (2021). Bootstrapping statistical inference for off-policy evaluation. arXiv preprint arXiv:2102.03607.   \nHeess, N., Wayne, G., Silver, D., Lillicrap, T., Tassa, Y., and Erez, T. (2015). Learning continuous control policies by stochastic value gradients.   \nJaques, N., Ghandeharioun, A., Shen, J. H., Ferguson, C., Lapedriza, A., Jones, N., Gu, S., and Picard, R. (2019). Way off-policy batch deep reinforcement learning of implicit human preferences in dialog. arXiv preprint arXiv:1907.00456.   \nJiang, N. and Huang, J. (2020). Minimax value interval for off-policy evaluation and policy optimization. arXiv preprint arXiv:2002.02081.   \nJiang, N., Krishnamurthy, A., Agarwal, A., Langford, J., and Schapire, R. E. (2017). Contextual decision processes with low Bellman rank are PAC-learnable. In Precup, D. and Teh, Y. W., editors, International Conference on Machine Learning (ICML), volume 70 of Proceedings of Machine Learning Research, pages 1704–1713, International Convention Centre, Sydney, Australia. PMLR.   \nJiang, N. and Li, L. (2016). Doubly robust off-policy value evaluation for reinforcement learning. In International Conference on Machine Learning, pages 652–661. PMLR.   \nJin, C., Liu, Q., and Miryoosefi, S. (2021). Bellman eluder dimension: New rich classes of rl problems, and sample-efficient algorithms. arXiv preprint arXiv:2102.00815.   \nJin, C., Yang, Z., Wang, Z., and Jordan, M. I. (2020a). Provably efficient reinforcement learning with linear function approximation. In Conference on Learning Theory.   \nJin, Y., Yang, Z., and Wang, Z. (2020b). Is pessimism provably efficient for offline rl? arXiv preprint arXiv:2012.15085.   \nKakade, S. M. (2001). A natural policy gradient. Advances in neural information processing systems, 14.   \nKakade, S. M. et al. (2003). On the sample complexity of reinforcement learning. PhD thesis, University of London London, England.   \nKallus, N. and Uehara, M. (2019). Efficiently breaking the curse of horizon in off-policy evaluation with double reinforcement learning. arXiv preprint arXiv:1909.05850.   \nKhodadadian, S., Jhunjhunwala, P. R., Varma, S. M., and Maguluri, S. T. (2021). On the linear convergence of natural policy gradient algorithm. arXiv preprint arXiv:2105.01424.   \nKidambi, R., Rajeswaran, A., Netrapalli, P., and Joachims, T. (2020). Morel: Model-based offline reinforcement learning. arXiv preprint arXiv:2005.05951.   \nKonda, V. R. and Tsitsiklis, J. N. (2000). Actor-critic algorithms. In Advances in neural information processing systems, pages 1008–1014.   \nKonda, V. R. and Tsitsiklis, J. N. (2003). On actor-critic algorithms. SIAM Jour. Opt. Control, 42(4):1143–1166.   \nKumar, A., Fu, J., Tucker, G., and Levine, S. (2019). Stabilizing off-policy q-learning via bootstrapping error reduction. arXiv preprint arXiv:1906.00949.   \nKumar, A., Zhou, A., Tucker, G., and Levine, S. (2020). Conservative q-learning for offline reinforcement learning. arXiv preprint arXiv:2006.04779.   \nLan, G. (2021). Policy mirror descent for reinforcement learning: Linear convergence, new sampling complexity, and generalized problem classes. arXiv preprint arXiv:2102.00135.   \nLaroche, R., Trichelair, P., and Des Combes, R. T. (2019). Safe policy improvement with baseline bootstrapping. In International Conference on Machine Learning, pages 3652–3661. PMLR.   \nLevine, S., Kumar, A., Tucker, G., and Fu, J. (2020). Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643.   \nLiao, P., Qi, Z., and Murphy, S. (2020). Batch policy learning in average reward markov decision processes. arXiv preprint arXiv:2007.11771.   \nLiu, Q., Li, L., Tang, Z., and Zhou, D. (2018a). Breaking the curse of horizon: Infinite-horizon off-policy estimation. In Advances in Neural Information Processing Systems, pages 5356–5366.   \nLiu, Y., Gottesman, O., Raghu, A., Komorowski, M., Faisal, A. A., Doshi-Velez, F., and Brunskill, E. (2018b). Representation balancing mdps for off-policy policy evaluation. Advances in Neural Information Processing Systems, 31:2644–2653.   \nLiu, Y., Swaminathan, A., Agarwal, A., and Brunskill, E. (2020). Provably good batch reinforcement learning without great exploration. arXiv preprint arXiv:2007.08202.   \nMandel, T., Liu, Y.-E., Levine, S., Brunskill, E., and Popovic, Z. (2014). Offline policy evaluation across representations with applications to educational games. In AAMAS, volume 1077.   \nModi, A., Chen, J., Krishnamurthy, A., Jiang, N., and Agarwal, A. (2021). Model-free representation learning and exploration in low-rank mdps. arXiv preprint arXiv:2102.07035.   \nMunos, R. (2003). Error bounds for approximate policy iteration. In ICML, volume 3, pages 560– 567.   \nMunos, R. (2005). Error bounds for approximate value iteration. In AAAI Conference on Artificial Intelligence (AAAI).   \nNachum, O., Chow, Y., Dai, B., and Li, L. (2019a). Dualdice: Behavior-agnostic estimation of discounted stationary distribution corrections. arXiv preprint arXiv:1906.04733.   \nNachum, O. and Dai, B. (2020). Reinforcement learning via fenchel-rockafellar duality. arXiv preprint arXiv:2001.01866.   \nNachum, O., Dai, B., Kostrikov, I., Chow, Y., Li, L., and Schuurmans, D. (2019b). Algaedice: Policy gradient from arbitrary experience. arXiv preprint arXiv:1912.02074.   \nNair, A., Dalal, M., Gupta, A., and Levine, S. (2020). Accelerating online reinforcement learning with offline datasets. arXiv preprint arXiv:2006.09359.   \nNedic, A. and Bertsekas, D. P. (2003). Least squares policy evaluation algorithms with linear func- ´ tion approximation. Discrete Event Dynamic Systems, 13(1):79–110.   \nPuterman, M. L. (1994). Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, Inc., New York, NY, USA.   \nRashidinejad, P., Zhu, B., Ma, C., Jiao, J., and Russell, S. (2021). Bridging offline reinforcement learning and imitation learning: A tale of pessimism. arXiv preprint arXiv:2103.12021.   \nRaskutti, G. and Mukherjee, S. (2015). The information geometry of mirror descent. IEEE Transactions on Information Theory, 61(3):1451–1457.   \nShani, L., Efroni, Y., and Mannor, S. (2020). Adaptive trust region policy optimization: Global convergence and faster rates for regularized mdps. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 5668–5675.   \nShreve, S. E. and Bertsekas, D. P. (1978). Alternative theoretical frameworks for finite horizon discrete-time stochastic optimal control. SIAM Journal on control and optimization, 16(6):953– 978.   \nSiegel, N. Y., Springenberg, J. T., Berkenkamp, F., Abdolmaleki, A., Neunert, M., Lampe, T., Hafner, R., Heess, N., and Riedmiller, M. (2020). Keep doing what worked: Behavioral modelling priors for offline reinforcement learning. arXiv preprint arXiv:2002.08396.   \nSutton, R. S. and Barto, A. G. (2018). Reinforcement Learning: An Introduction. MIT Press, Cambridge, MA, 2nd edition.   \nSutton, R. S., McAllester, D. A., Singh, S. P., Mansour, Y., et al. (1999). Policy gradient methods for reinforcement learning with function approximation. In NIPs, volume 99, pages 1057–1063. Citeseer.   \nTang, Z., Feng, Y., Li, L., Zhou, D., and Liu, Q. (2019). Doubly robust bias reduction in infinite horizon off-policy estimation. arXiv preprint arXiv:1910.07186.   \nThomas, P. and Brunskill, E. (2016). Data-efficient off-policy policy evaluation for reinforcement learning. In International Conference on Machine Learning, pages 2139–2148.   \nThomas, P., Theocharous, G., and Ghavamzadeh, M. (2015). High confidence policy improvement. In International Conference on Machine Learning, pages 2380–2388.   \nThomas, P. S., da Silva, B. C., Barto, A. G., Giguere, S., Brun, Y., and Brunskill, E. (2019). Preventing undesirable behavior of intelligent machines. Science, 366(6468):999–1004.   \nTsybakov, A. B. (2009). Introduction to Nonparametric Estimation. Springer, New York.   \nUehara, M., Huang, J., and Jiang, N. (2020). Minimax weight and q-function learning for off-policy evaluation. In International Conference on Machine Learning, pages 9659–9668. PMLR.   \nUehara, M. and Sun, W. (2021). Pessimistic model-based offline rl: Pac bounds and posterior sampling under partial coverage.   \nVoloshin, C., Jiang, N., and Yue, Y. (2021). Minimax model learning. In International Conference on Artificial Intelligence and Statistics, pages 1612–1620. PMLR.   \nWainwright, M. J. (2019). High-dimensional statistics: A non-asymptotic viewpoint, volume 48. Cambridge University Press.   \nWang, L., Cai, Q., Yang, Z., and Wang, Z. (2019). Neural policy gradient methods: Global optimality and rates of convergence. arXiv preprint arXiv:1909.01150.   \nWang, Z., Novikov, A., Zo˙ łna, K., Springenberg, J. T., Reed, S., Shahriari, B., Siegel, N., Merel, J., Gulcehre, C., Heess, N., et al. (2020). Critic regularized regression. arXiv preprint arXiv:2006.15134.   \nWeisz, G., Amortila, P., and Szepesvári, C. (2020). Exponential lower bounds for planning in mdps with linearly-realizable optimal action-value functions. arXiv preprint arXiv:2010.01374.   \nWu, Y., Tucker, G., and Nachum, O. (2019). Behavior regularized offline reinforcement learning. arXiv preprint arXiv:1911.11361.   \nWu, Y., Zhai, S., Srivastava, N., Susskind, J., Zhang, J., Salakhutdinov, R., and Goh, H. (2021). Uncertainty weighted actor-critic for offline reinforcement learning. arXiv preprint arXiv:2105.08140.   \nXie, T., Cheng, C.-A., Jiang, N., Mineiro, P., and Agarwal, A. (2021). Bellman-consistent pessimism for offline reinforcement learning.   \nXie, T. and Jiang, N. (2020a). Batch value-function approximation with only realizability. arXiv preprint arXiv:2008.04990.   \nXie, T. and Jiang, N. (2020b). $\\mathbf { Q } ^ { * }$ approximation schemes for batch reinforcement learning: A theoretical comparison. volume 124 of Proceedings of Machine Learning Research, pages 550– 559, Virtual. PMLR.   \nXie, T., Ma, Y., and Wang, Y.-X. (2019). Towards optimal off-policy evaluation for reinforcement learning with marginalized importance sampling. In Advances in Neural Information Processing Systems, pages 9668–9678.   \nYang, L. F. and Wang, M. (2020). Reinforcement leaning in feature space: Matrix bandit, kernels, and regret bound. In International Conference on Machine Learning (ICML).   \nYang, M., Nachum, O., Dai, B., Li, L., and Schuurmans, D. (2020). Off-policy evaluation via the regularized lagrangian. arXiv preprint arXiv:2007.03438.   \nYin, M., Bai, Y., and Wang, Y.-X. (2020). Near optimal provable uniform convergence in off-policy evaluation for reinforcement learning. arXiv preprint arXiv:2007.03760.   \nYin, M. and Wang, Y.-X. (2020). Asymptotically efficient off-policy evaluation for tabular reinforcement learning. In International Conference on Artificial Intelligence and Statistics, pages 3948–3958. PMLR.   \nYu, T., Thomas, G., Yu, L., Ermon, S., Zou, J., Levine, S., Finn, C., and Ma, T. (2020). Mopo: Model-based offline policy optimization. arXiv preprint arXiv:2005.13239.   \nZanette, A. (2020). Exponential lower bounds for batch reinforcement learning: Batch rl can be exponentially harder than online rl. arXiv preprint arXiv:2012.08005.   \nZanette, A., Brandfonbrener, D., Pirotta, M., and Lazaric, A. (2020a). Frequentist regret bounds for randomized least-squares value iteration. In AISTATS.   \nZanette, A., Lazaric, A., Kochenderfer, M., and Brunskill, E. (2020b). Learning near optimal policies with low inherent bellman error. In International Conference on Machine Learning (ICML).   \nZanette, A., Lazaric, A., Kochenderfer, M. J., and Brunskill, E. (2020c). Provably efficient rewardagnostic navigation with linear value iteration. In Advances in Neural Information Processing Systems.   \nZhang, J., Koppel, A., Bedi, A. S., Szepesvari, C., and Wang, M. (2020a). Variational policy gradient method for reinforcement learning with general utilities. arXiv preprint arXiv:2007.02151.   \nZhang, R., Dai, B., Li, L., and Schuurmans, D. (2020b). Gendice: Generalized offline estimation of stationary values. arXiv preprint arXiv:2002.09072. ",
+        "bbox": [
+            171,
+            46,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            61,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            56,
+            826,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            77,
+            826,
+            917
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            828,
+            412
+        ],
+        "page_idx": 14
+    }
+]

parse/train/rkxoNnC5FQ/rkxoNnC5FQ.md

@@ -0,0 +1,303 @@
+# SPIGAN: PRIVILEGED ADVERSARIAL LEARNINGFROM SIMULATION
+
+Kuan-Hui Lee, Jie Li, Adrien Gaidon Toyota Research Institute {kuan.lee,jie.li,adrien.gaidon}@tri.global
+
+& German Ros   
+Intel Labs   
+german.ros@intel.com
+
+# ABSTRACT
+
+Deep Learning for Computer Vision depends mainly on the source of supervision. Photo-realistic simulators can generate large-scale automatically labeled synthetic data, but introduce a domain gap negatively impacting performance. We propose a new unsupervised domain adaptation algorithm, called SPIGAN, relying on Simulator Privileged Information (PI) and Generative Adversarial Networks (GAN). We use internal data from the simulator as PI during the training of a target task network. We experimentally evaluate our approach on semantic segmentation. We train the networks on real-world Cityscapes and Vistas datasets, using only unlabeled real-world images and synthetic labeled data with $\mathbf { Z }$ -buffer (depth) PI from the SYNTHIA dataset. Our method improves over no adaptation and state-of-theart unsupervised domain adaptation techniques.
+
+![](images/620aee6d60e218ed2cad3bfd22e7d45f10c1744d029c3f84e48f11d08b86b7fd.jpg)  
+Figure 1: SPIGAN example inputs and outputs. From left to right: input images from a simulator; adapted images from SPIGAN’s generator network; predictions from SPIGAN’s privileged network (depth layers); semantic segmentation predictions from the target task network.
+
+# 1 INTRODUCTION
+
+Learning from as little human supervision as possible is a major challenge in Machine Learning. In Computer Vision, labeling images and videos is the main bottleneck towards achieving large scale learning and generalization. Recently, training in simulation has shown continuous improvements in several tasks, such as optical flow (Mayer et al., 2016), object detection (Mar´ın et al., 2010; Vazquez et al., 2014; Xu et al., 2014; Sun & Saenko, 2014; Peng et al., 2015), tracking (Gaidon et al., 2016), pose and viewpoint estimation (Shotton et al., 2011; Papon & Schoeler, 2015; Su et al., 2015), action recognition (de Souza et al., 2017), and semantic segmentation (Handa et al., 2016; Ros et al., 2016; Richter et al., 2016). However, large domain gaps between synthetic and real domains remain as the main handicap of this type of strategies. This is often addressed by manually labeling some amount of real-world target data to train the model on mixed synthetic and real-world labeled data (supervised domain adaptation). In contrast, several recent unsupervised domain adaptation algorithms have leveraged the potential of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) for pixel-level adaptation in this context (Bousmalis et al., 2017; Shrivastava et al., 2016). These methods often use simulators as black-box generators of $( x , y )$ input / output training samples for the desired task.
+
+Our main observation is that simulators internally know a lot more about the world and how the scene is formed, which we call Privileged Information (PI). This Privileged Information includes physical properties that might be useful for learning. This additional information $z$ is not available in the real-world and is, therefore, generally ignored during learning. In this paper, we propose a novel adversarial learning algorithm, called SPIGAN, to leverage Simulator $P I$ for GAN-based unsupervised learning of a target task network from unpaired unlabeled real-world data.
+
+We jointly learn four different networks: (i) a generator $G$ (to adapt the pixel-level distribution of synthetic images to be more like real ones), (ii) a discriminator $D$ (to distinguish adapted and real images), (iii) a task network $T$ (to predict the desired label $y$ from image $x$ ), and (iv) a privileged network $P$ trained on both synthetic images $x$ and adapted ones $G ( x )$ to predict their associated privileged information $z$ . Our main contribution is a new method to leverage $P I$ from a simulator via the privileged network $P$ , which acts as an auxiliary task and regularizer to the task network $T$ , the main output of our SPIGAN learning algorithm.
+
+We evaluate our approach on semantic segmentation in urban scenes, a challenging real-world task. We use the standard Cityscapes (Cordts et al., 2016) and Vistas (Neuhold et al., 2017) datasets as target real-world data (without using any of the training labels) and SYNTHIA (Ros et al., 2016) as simulator output. Although our method applies to any kind of PI that can be predicted via a deep network (optical flow, instance segmentation, object detection, material properties, forces, ...), we consider one of the most common and simple forms of PI available in any simulator: depth from its z-buffer. We show that SPIGAN can successfully learn a semantic segmentation network $T$ using no real-world labels, partially bridging the sim-to-real gap (see Figure 1). SPIGAN also outperforms related state-of-the-art unsupervised domain adaptation methods.
+
+The rest of the paper is organized as follows. Section 2 presents a brief review of related works. Section 3 presents our SPIGAN unsupervised domain adaptation algorithm using simulator privileged information. We report our quantitative experiments on semantic segmentation in Section 4, and conclude in Section 5.
+
+# 2 RELATED WORK
+
+Domain adaptation (cf. Csurka (2017) for a recent review) is generally approached either as domaininvariant learning (Hoffman et al., 2013; Herath et al., 2017; Yan et al., 2017; Ganin & Lempitsky, 2015) or as a statistical alignment problem (Tzeng et al., 2014; Long et al., 2015). Our work focuses on unsupervised adaptation methods in the context of deep learning. This problem consists in learning a model for a task in a target domain (e.g., semantic segmentation of real-world urban scenes) by combining unlabeled data from this domain with labeled data from a related but different source domain (e.g., synthetic data from simulation). The main challenge is overcoming the domain gap, i.e. the differences between the source and target distributions, without any supervision from the target domain. The Domain Adversarial Neural Network (DANN) (Tzeng et al., 2014; Ganin & Lempitsky, 2015; Ganin et al., 2016) is a popular approach that learns domain invariant features by maximizing domain confusion. This approach has been successfully adopted and extended by many other researchers, e.g., Purushotham et al. (2017); Chen et al. (2017); Zhang et al. (2017). Curriculum Domain Adaptation (Zhang et al., 2017) is a recent evolution for semantic segmentation that reduces the domain gap via a curriculum learning approach (solving simple tasks first, such as global label distribution in the target domain).
+
+Recently, adversarial domain adaptation based on GANs (Goodfellow et al., 2014) have shown encouraging results for unsupervised domain adaptation directly at the pixel level. These techniques learn a generative model for source-to-target image translation, including from and to multiple domains (Taigman et al., 2016; Shrivastava et al., 2016; Zhu et al., 2017; Isola et al., 2017; Kim et al., 2017). In particular, CycleGAN (Zhu et al., 2017) leverages cycle consistency using a forward GAN and a backward GAN to improve the training stability and performance of image-to-image translation. An alternative to GAN is Variational Auto-Encoders (VAEs), which have also been used for image translation (Liu et al., 2017).
+
+Several related works propose GAN-based unsupervised domain adaptation methods to address the specific domain gap between synthetic and real-world images. SimGAN (Shrivastava et al., 2016) leverages simulation for the automatic generation of large annotated datasets with the goal of refining synthetic images to make them look more realistic. Sadat Saleh et al. (2018) effectively leverages synthetic data by treating foreground and background in different manners. Similar to our approach, recent methods consider the final recognition task during the image translation process. Closely related to our work, PixelDA (Bousmalis et al., 2017) is a pixel-level domain adaptation method that jointly trains a task classifier along with a GAN using simulation as its source domain but no privileged information. These approaches focus on simple tasks and visual conditions that are easy to simulate, hence having a low domain gap to begin with.
+
+![](images/8a9cd4ecf85a00e97baf884bc59e53cb15844163bd29a0f79463aef6745e96ae.jpg)  
+Figure 2: SPIGAN learning algorithm from unlabeled real-world images $x _ { r }$ and the unpaired output of a simulator (synthetic images $x _ { s }$ , their labels $y _ { s }$ , e.g. semantic segmentation ground truth, and Privileged Information PI $z _ { s }$ , e.g., depth from the $\mathbf { Z }$ -buffer) modeled as random variables. Four networks are learned jointly: (i) a generator $G ( x _ { s } ) \sim x _ { r }$ , (ii) a discriminator $D$ between $G ( x _ { s } ) =$ $x _ { f }$ and $x _ { r }$ , (iii) a perception task network $T ( x _ { r } ) \sim y _ { r }$ , which is the main target output of SPIGAN (e.g., a semantic segmentation deep net), and (iv) a privileged network $P$ to support the learning of $T$ by predicting the simulator’s $\mathrm { P I } \ z _ { s }$ .
+
+On the other hand, Hoffman et al. (2016b) are the first to study semantic segmentation as the task network in adversarial training. Zhang et al. (2017) uses a curriculum learning style approach to reduce domain gap. Saito et al. (2017) conducts domain adaptation by utilizing the task-specific decision boundaries with classifiers. Sankaranarayanan et al. (2018) leverage the GAN framework by learning general representation shared between the generator and segmentation networks. Chen et al. (2018) use a target guided distillation to encourage the task network to imitate a pretrained model. Zhang et al. (2018) propose to combine appearance and representation adaptation. Tsai et al. (2018) propose an adversarial learning method to adapt in the output (segmentation) space. Zou et al. (2018) generates pseudo-labels based on confidence scores with balanced class distribution and propose an iterative self-training framework.
+
+Our main novelty is the use of Privileged Information from a simulator in a generic way by considering a privileged network in our architecture (see Figure 2). We show that for the challenging task of semantic segmentation of urban scenes, our approach significantly improves by augmenting the learning objective with our auxiliary privileged task, especially in the presence of a large sim-to-real domain gap, the main problem in challenging real-world conditions.
+
+Our work is inspired by Learning Using Privileged Information (LUPI) (Vapnik & Vashist, 2009), which is linked to distillation (Hinton et al., 2015) as shown by Lopez-Paz et al. (2015). LUPI’s goal is to leverage additional data only available at training time. For unsupervised domain adaptation from a simulator, there is a lot of potentially useful information about the generation process that could inform the adaptation. However, that information is only available at training time, as we do not have access to the internals of the real-world data generator. Several works have used privileged information at training time for domain adaptation (Chen et al., 2014; Hoffman et al., 2016a; Li et al., 2014; Sarafianos et al., 2017; Garcia et al., 2018). Hoffman et al. (2016a) leverage RGBD information to help adapt an object detector at the feature level, while Garcia et al. (2018) propose a similar concept of modality distillation for action recognition. Inspired by this line of work, we exploit the privileged information from simulators for sim-to-real unsupervised domain adaptation.
+
+# 3 SIMULATOR PRIVILEGED INFORMATION GAN
+
+# 3.1 UNSUPERVISED LEARNING WITH A SIMULATOR
+
+Our goal is to design a procedure to learn a model (neural network) that solves a perception task (e.g., semantic segmentation) using raw sensory data coming from a target domain (e.g., videos of a car driving in urban environments) without using any ground truth data from the target domain. We formalize this problem as unsupervised domain adaptation from a synthetic domain (source domain) to a real domain (target domain). The source domain consists of labeled synthetic images together with Privileged Information (PI), obtained from the internal data structures of a simulator. The target domain consists of unlabeled images.
+
+The simulated source domain serves as an idealized representation of the world, offering full control of the environment (weather conditions, types of scene, sensor configurations, etc.) with automatic generation of raw sensory data and labels for the task of interest. The main challenge we address in this work is how to overcome the gap between this synthetic source domain and the target domain to ensure generalization of the task network in the real-world without target supervision.
+
+Our main hypothesis is that the PI provided by the simulator is a rich source of information to guide and constrain the training of the target task network. The PI can be defined as any information internal to the simulator, such as depth, optical flow, or physical properties about scene components used during simulation (e.g., materials, forces, etc.). We leverage the simulator’s PI within a GAN framework, called SPIGAN. Our approach is described in the next section.
+
+# 3.2 SPIGAN
+
+Let $X _ { r } ~ = ~ \{ x _ { r } ^ { ( j ) }$ , $j ~ = ~ 1 \ldots N ^ { r } \}$ be a set of $N ^ { r }$ unlabeled real-world images . Let $X _ { s } \ =$ i), y(i)s , z(i)s ), i = 1 . . . N s} be a set of N s simulated images xs with their labels ys and PI   
+$z _ { s }$   
+tends to multiple separate types of $\mathrm { P I }$ .
+
+SPIGAN (cf. Fig. 2) jointly learns a model $( \theta _ { G } , \theta _ { D } , \theta _ { T } , \theta _ { P } )$ , consisting of: (i) a generator $G ( x ; \theta _ { G } )$ , (ii) a discriminator $D ( x ; \theta _ { D } )$ , (iii) a task predictor $T ( x ; \theta _ { T } )$ , and (iv) a privileged network $P ( x ; \theta _ { P } )$ . The generator $G$ is a mapping function, transforming an image $x _ { s }$ in $X _ { s }$ (source domain) to $x _ { f }$ in $X _ { f }$ (adapted or fake domain). SPIGAN aims to make the adapted domain statistically close to the target domain to maximize the accuracy of the task predictor $T ( x ; \theta _ { T } )$ during testing. The discriminator $D$ is expected to tell the difference between $x _ { f }$ and $x _ { r }$ , playing an adversarial game with the generator until a termination criteria is met (refer to section 4.1) . The target task network $T$ is learned on the synthetic $x _ { s }$ and adapted $G ( x _ { s } ; \theta _ { G } )$ images to predict the synthetic label $y _ { s }$ , assuming the generator presents a reasonable degree of label (content) preservation. This assumption is met for the regime of our experiments. Similarly, the privileged network $P$ is trained on the same input but to predict the $\mathrm { P I } ~ z$ , which in turn assumes the generator $G$ is also PI-preserving. During testing only $T ( x ; \theta _ { T } )$ is needed to do inference for the selected perception task.
+
+The main learning goal is to train a model $\theta _ { T }$ that can correctly perform a perception task $T$ in the target real-world domain. All models are trained jointly in order to exploit all available information to constrain the solution space. In this way, the $\mathrm { P I }$ provided by the privileged network $P$ is used to constrain the learning of $T$ and to encourage the generator to model the target domain while being label- and PI-preserving. Our joint learning objective is described in the following section.
+
+# 3.3 LEARNING OBJECTIVE
+
+We design a consistent set of loss functions and domain-specific constraints related to the main prediction task $T$ . We optimize the following minimax objective:
+
+$$
+\operatorname* { m i n } _ { \theta _ { G } , \theta _ { T } , \theta _ { P } } \operatorname* { m a x } _ { \theta _ { D } } \alpha \mathcal { L } _ { \mathrm { G A N } } + \beta \mathcal { L } _ { T } + \gamma \mathcal { L } _ { P } + \delta \mathcal { L } _ { \mathrm { p e r c } }
+$$
+
+where $\alpha , \beta , \gamma , \delta$ are the weights for adversarial loss, task prediction loss, PI regularization, and perceptual regularization respectively, further described below.
+
+Adversarial loss $\mathcal { L } _ { \mathbf { G A N } }$ . Instead of using a standard adversarial loss, we use a least-squares based adversarial loss Mao et al. (2016); Zhu et al. (2017), which stabilizes the training process and generates better image results in our experiments:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { G A N } } ( D , G ) = \mathbb { E } _ { x _ { r } \sim \mathcal { P } _ { r } } [ ( D ( x _ { r } ; \theta _ { D } ) - 1 ) ^ { 2 } ] } \\ & { \quad \quad \quad \quad + \mathbb { E } _ { x _ { s } \sim \mathcal { P } _ { s } } [ D ( G ( x _ { s } ; \theta _ { G } ) ; \theta _ { D } ) ^ { 2 } ] } \end{array}
+$$
+
+where $\mathcal { P } _ { r }$ (resp. $\mathcal { P } _ { s }$ ) denotes the real-world (resp. synthetic) data distribution.
+
+Task prediction loss $\mathcal { L } _ { T }$ . We learn the task network by optimizing its loss over both synthetic images $x _ { s }$ and their adapted version $G ( x _ { s } , \theta _ { G } )$ . This assumes the generator is label-preserving, i.e., that $y _ { s }$ can be used as a label for both images. Thanks to our joint objective, this assumption is directly encouraged during the learning of the generator through the joint estimation of $\theta _ { P }$ , which relates to scene properties captured by the PI. Naturally, different tasks require different loss functions. In our experiments, we consider the task of semantic segmentation and use the standard cross-entropy loss (Eq. 4) over images of size $W \times H$ and a probability distribution over $C$ semantic categories. The total combined loss in the special case of semantic segmentation is therefore:
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } _ { T } ( T , G ) = \mathcal { L } _ { \mathrm { C E } } ( x _ { s } , y _ { s } ) + \mathcal { L } _ { \mathrm { C E } } ( G ( x _ { s } ; \theta _ { G } ) , y _ { s } ) } \\ { \displaystyle \mathcal { L } _ { \mathrm { C E } } ( x , y ) = \frac { - 1 } { W H } \sum _ { u , v } ^ { W , H } \sum _ { c = 1 } ^ { C } \mathbb { 1 } _ { [ c = y _ { u , v } ] } \log ( T ( x ; \theta _ { T } ) _ { u , v } ) } \end{array}
+$$
+
+where $\mathbb { 1 } _ { [ a = b ] }$ is the indicator function.
+
+PI regularization $\mathcal { L } _ { P }$ . Similarly, the auxiliary task of predicting PI also requires different losses depending on the type of PI. In our experiments, we use depth from the $\mathbf { Z }$ -buffer and an $\ell _ { 1 }$ -norm:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { P } ( P , G ) = \rvert | P ( x _ { s } ; \theta _ { P } ) - z _ { s } | | _ { 1 } } \\ & { \qquad + | | P ( G ( x _ { s } ; \theta _ { G } ) ; \theta _ { P } ) - z _ { s } | | _ { 1 } } \end{array}
+$$
+
+Perceptual regularization $\mathcal { L } _ { \mathrm { p e r c } }$ . To maintain the semantics of the source images in the generated images, we additionally use the perceptual loss Johnson et al. (2016); Chen & Koltun (2017):
+
+$$
+\mathcal { L } _ { \mathrm { p e r c } } ( G ) = | | \phi ( x _ { s } ) - \phi ( G ( x _ { s } ; \theta _ { G } ) ) | | _ { 1 }
+$$
+
+where $\phi$ is a mapping from image space to a pre-determined feature space Chen & Koltun (2017) (see 4.1 for more details).
+
+Optimization. In practice, we follow the standard adversarial training strategy to optimize our joint learning objective (Eq. 1). We alternate between updates to the parameters of the discriminator $\theta _ { D }$ , keeping all other parameters fixed, then fix $\theta _ { D }$ and optimize the parameters of the generator $\theta _ { G }$ , the privileged network $\theta _ { P }$ , and most importantly the task network $\theta _ { T }$ . We discuss the details of our implementation, including hyper-parameters, in section 4.1.
+
+# 4 EXPERIMENTS
+
+We evaluate our unsupervised domain adaptation method on the task of semantic segmentation in a challenging real-world domain for which training labels are not available.
+
+As our source synthetic domain, we select the public SYNTHIA dataset (Ros et al., 2016) as synthetic source domain given the availability of automatic annotations and PI. SYNTHIA is a dataset generated from an autonomous driving simulator of urban scenes. These images were generated under different weathers and illumination conditions to maximize visual variability. Pixel-wise segmentation and depth labels are provided for each image. In our experiment, we use the sequence of SYNTHIA-RAND-CITYSCAPES, which contains semantic segmentation labels that are more compatible with Cityscapes.
+
+For target real-world domains, we use the Cityscapes (Cordts et al., 2016) and Mapillary Vistas (Neuhold et al., 2017) datasets. Cityscapes is one of most widely used real-world urban scene image segmentation datasets with images collected around urban streets in Europe. For this dataset, We use the standard split for training and validation with 2, 975 and 500 images respectively. Mapillary Vistas is a larger dataset with a wider variety of scenes, cameras, locations, weathers, and illumination conditions. We use 16, 000 images for training and 2, 000 images for evaluation. During training, none of the labels from the real-world domains are used.
+
+In our experiment, we first evaluate adaptation from SYNTHIA to Cityscapes on 16 classes, following the standard evaluation protocol used in Hoffman et al. (2016b); Zhang et al. (2017); Saito et al. (2017); Sankaranarayanan et al. (2018); Zou et al. (2018). Then we show the positive impact of using PI by conducting ablation study with and without PI (depth) during adaptation from SYNTHIA to both Cityscapes and Vistas, on a common 7 categories ontology. To be consistent with the semantic segmentation best practices, we use standard intersection-over-union (IoU) per category and mean intersection-over-union (mIoU) as our main validation metric.
+
+![](images/3da4f87e4e6e03ec1a538be2ddc0dcc1d24eb3e09d1e909520ffbbc70d72baa2.jpg)  
+Figure 3: Loss curves for the task, perceptual, and privileged parts of the learning objective during the training of SYNTHIA-to-Cityscapes.
+
+![](images/71a089a07f578db5accb9bb8a9d6d3711c24ab649cb2a8cdf6c65e27f9a92103.jpg)  
+Figure 4: Early stopping at the iteration when the discriminator loss is significantly and consistently better than the generator loss (90 here).
+
+# 4.1 IMPLEMENTATION DETAILS
+
+We adapt the generator and discriminator model architectures from CycleGAN (Zhu et al., 2017) and (Johnson et al., 2016). For simplicity, we use a single sim-to-real generator (no cycle consistency) consisting of two down-sampling convolution layers, nine ResNet blocks (He et al., 2016) and two fractionally-strided convolution layers. Our discriminator is a PatchGAN (Isola et al., 2017) network with 3 layers. We use the standard FCN8s architecture Long et al. (2015) for both the task predictor $T$ and the privileged network $P$ , given its ease of training and its acceptance in domain adaptation works Hoffman et al. (2016b). For the perceptual loss $\mathcal { L } _ { \mathrm { p e r c } }$ , we follow the implementation in Chen & Koltun (2017). The feature is constructed by the concatenation of the activations of a pre-trained VGG19 network Witten et al. (2016) of layers ”conv1 $\lrcorner 2 ^ { \ast }$ , ”conv2 $_ { - 2 } \mathbf { \mathit { ^ { , } } }$ , ”conv3 2”, ”conv4 2”, ”conv5 2”.
+
+Following the common protocol in unsupervised domain adaptation Shrivastava et al. (2016); Zhu et al. (2017); Bousmalis et al. (2016); Sankaranarayanan et al. (2018), we set hyper-parameters using a coarse grid search on a small validation set different than the target set. For Cityscapes, we use a subset of the validation set of Vistas, and vice-versa. We found a set of values that are effective across datasets and experiments, which show they have a certain degree of robustness and generalization. The weights in our joint adversarial loss (Eq. 1) are set to $\alpha = 1$ , $\beta = 0 . 5$ , $\gamma = 0 . 1$ , $\delta = 0 . 3 3$ , for the GAN, task, privileged, and perceptual objectives respectively. This confirms that the two most important factors in the objective are the GAN and task losses $\langle \alpha = 1$ , $\beta = 0 . 5$ ). This is intuitive, as the goal is to improve the generalization performance of the task network (the task loss being an empirical proxy) across a potentially large domain gap (addressed first and foremost by the GAN loss). The regularization terms are secondary in the objective, stabilizing the training (perceptual loss) and constraining the adaptation process (privileged loss). Figures 3 and 4 show an example of our loss curves and the stability of our training.
+
+Another critical hyper-parameter for unsupervised learning is the stopping criterion. We observed that the stabilizing effects of the task and privileged losses (Eqs. 3,5) on the GAN objective (Eq. 2) made a simple rule effective for early stopping. We stop training at the iteration when the discriminator loss is significantly and consistently better than the generator loss (iteration 90 in Figure 4). This is inspired by the semi-supervised results of Dai et al. (2017), where effective discriminative adaptation of the task network might not always be linked to the best image generator. We evaluate the methods with two resolutions: $3 2 0 \times 6 4 0$ and $5 1 2 \times 1 0 2 4$ , respectively. Images are resized to the evaluated size during training and evaluation. During training, we sample crops of size $3 2 0 \times 3 2 0$ (resp. $4 0 0 \times 4 0 0 )$ for lower (resp. higher) resolution experiments. In all adversarial learning cases, we do five steps of the generator for every step of the other networks. The Adam optimizer (Kingma & Ba, 2014) is used to adjust all parameters with initial learning rate 0.0002 in our PyTorch implementation (Paszke et al., 2017).
+
+Table 1: Semantic segmentation unsupervised domain adaptation from SYNTHIA to Cityscapes. We present semantic segmentation results with per-class IoU and mean IoU. The highest IoU (at the same resolution) for each class within the compared algorithms is highlighted with bold font.   
+
+<table><tr><td rowspan="3">rrnnrign</td><td rowspan="3">Method</td><td rowspan="3"></td><td rowspan="3">srraar</td><td rowspan="3">Buipling</td><td rowspan="3">1</td><td rowspan="3"></td><td rowspan="3"></td><td rowspan="3">-l</td><td rowspan="3">uIs-L</td><td rowspan="3">Vieeree</td><td rowspan="3">3</td><td rowspan="3">nosiad</td><td rowspan="3"></td><td rowspan="3">3u</td><td rowspan="3"></td><td rowspan="3">mrrriltt</td><td rowspan="3">ealrlr</td><td rowspan="3">ntr eer</td></tr><tr><td></td><td></td></tr><tr><td>reee </td></tr><tr><td>FCNs wild source-only</td><td></td><td>6.4</td><td>17.7</td><td>29.7 1.2</td><td>0.0</td><td>15.1</td><td>0.0</td><td>7.2</td><td>30.3</td><td>66.8</td><td>51.1</td><td>1.5</td><td>47.3</td><td>3.9</td><td>0.1</td><td>0.0</td><td>17.4</td></tr><tr><td rowspan="10">259322</td><td>FCNs wild</td><td>11.5</td><td>19.6</td><td>30.8</td><td>4.4</td><td>0.0</td><td>20.3</td><td>0.1</td><td>11.7</td><td>42.3 68.7</td><td>51.2</td><td>3.8</td><td></td><td>54.0 3.2</td><td>0.2</td><td>0.6</td><td>20.2</td></tr><tr><td>CDA source-only</td><td>5.6</td><td>11.2</td><td>59.6</td><td>0.8</td><td>0.5</td><td>21.5</td><td>8.0 5.3</td><td>72.4</td><td>75.6</td><td>35.1</td><td>9.0</td><td>23.6</td><td>4.5</td><td>0.5</td><td>18.0</td><td>22.0</td></tr><tr><td>CDA</td><td>65.2</td><td>26.1</td><td>74.9</td><td>0.1</td><td>0.5</td><td>10.7 3.7</td><td>3.0</td><td>76.1</td><td>70.6</td><td>47.1</td><td>8.2</td><td>43.2</td><td>20.7</td><td>0.7</td><td>13.1</td><td>29.0</td></tr><tr><td>LSD source-only</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>23.2</td></tr><tr><td>LSD</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>34.5</td></tr><tr><td>Our source-only</td><td>14.2</td><td>12.4</td><td>73.3</td><td>0.5</td><td>0.1</td><td>23.1 5.8</td><td>12.2</td><td>79.4</td><td>78.6</td><td>45.1</td><td>7.8</td><td>32.8</td><td>5.7</td><td>5.6</td><td>1.6</td><td>24.9</td></tr><tr><td>SPIGAN-no-PI</td><td>68.8</td><td>24.5</td><td>73.4</td><td>3.6</td><td>0.1</td><td>22.0 5.8</td><td>8.9</td><td>74.6</td><td>77.3</td><td>41.5</td><td>8.8</td><td>58.2</td><td>15.4</td><td>6.7</td><td>8.4</td><td>31.1</td></tr><tr><td>SPIGAN</td><td>80.5</td><td>38.9</td><td>73.4</td><td>1.8</td><td>0.3</td><td>20.3</td><td>7.9 11.3</td><td>77.1</td><td>77.6</td><td>46.6</td><td>13.2</td><td>63.8</td><td>22.8</td><td>8.8</td><td>11.2</td><td>34.7</td></tr><tr><td>LSD source-only</td><td>30.1</td><td>17.5</td><td>70.2</td><td>5.9</td><td>0.1</td><td>16.7 9.1</td><td>12.6</td><td>74.5</td><td>76.3</td><td>43.9</td><td>13.2</td><td>35.7</td><td>14.3</td><td>3.7</td><td>5.6</td><td>26.8</td></tr><tr><td>LSD CBST source-only</td><td>80.1</td><td>29.1</td><td>77.5</td><td>2.8</td><td>0.4</td><td>26.8 11.1</td><td>18.0</td><td>78.1</td><td>76.7</td><td>48.2</td><td>15.2</td><td>70.5</td><td>17.4</td><td>8.7</td><td>16.7</td><td>36.1</td></tr><tr><td rowspan="8">2222222</td><td></td><td>17.2</td><td>19.7</td><td>73.3</td><td>1.1</td><td>0.0</td><td>19.1 3.0</td><td>9.1</td><td>71.8</td><td>78.3</td><td>37.6</td><td>4.7</td><td>42.2</td><td>9.0</td><td>0.1</td><td>0.9</td><td>22.6</td></tr><tr><td>CBST</td><td>69.9</td><td>28.7</td><td>69.5</td><td>12.1</td><td>0.1</td><td>25.4 11.9</td><td>13.6</td><td>82.0</td><td>81.9</td><td>49.1</td><td>14.5</td><td>66.0</td><td>6.6</td><td>3.7</td><td>32.4</td><td>35.4</td></tr><tr><td>Our source-only</td><td>21.2</td><td>12.3</td><td>69.1 2.8</td><td>0.1</td><td>24.8</td><td>10.4</td><td>15.3</td><td>74.8</td><td>78.2</td><td>50.3</td><td>8.8</td><td>41.9</td><td>18.3</td><td>6.6</td><td>6.8</td><td>27.6</td></tr><tr><td>SPIGAN-no-PI</td><td>69.5</td><td>29.4</td><td>68.7</td><td>4.4</td><td>0.3</td><td>32.4 5.8</td><td>15.0</td><td>81.0</td><td>78.7</td><td>52.2</td><td>13.1</td><td>72.8</td><td>23.6</td><td>7.9</td><td>18.7</td><td>35.8</td></tr><tr><td>SPIGAN</td><td>71.1</td><td>29.8</td><td>71.4</td><td>3.7</td><td>0.3</td><td>33.2</td><td>6.4 15.6</td><td>81.2</td><td>78.9</td><td>52.7</td><td>13.1</td><td>75.9</td><td>25.5</td><td>10.0</td><td>20.5</td><td>36.8</td></tr><tr><td>(LSD) Target-only</td><td>96.5</td><td>74.6</td><td>86.1</td><td>37.1</td><td>33.2</td><td>30.2 39.7</td><td>51.6</td><td>87.3</td><td>90.4</td><td>60.1</td><td>31.7</td><td>88.4</td><td>52.5</td><td>33.6</td><td>59.1</td><td>59.5</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Jasetee</td><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>美</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>CJsuoo</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Jrmee</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>ueunu</td><td rowspan=1 colspan=1>Vairee</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>neeee</td></tr><tr><td rowspan=4 colspan=1>ssdesssts</td><td rowspan=1 colspan=1>FCN source</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>79.6</td><td rowspan=1 colspan=1>51.0</td><td rowspan=1 colspan=1>8.7</td><td rowspan=1 colspan=1>29.0</td><td rowspan=1 colspan=1>50.9</td><td rowspan=1 colspan=1>3.0</td><td rowspan=1 colspan=1>31.6</td><td rowspan=1 colspan=2>36.3</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>SPIGAN-baseSPIGAN-no-PISPIGAN</td><td rowspan=2 colspan=1>?</td><td rowspan=2 colspan=1>√</td><td rowspan=2 colspan=1>82.590.391.2</td><td rowspan=2 colspan=1>52.758.266.4</td><td rowspan=2 colspan=1>7.26.89.6</td><td rowspan=2 colspan=1>30.635.856.8</td><td rowspan=1 colspan=1>52.269.0</td><td rowspan=2 colspan=1>5.69.517.7</td><td rowspan=2 colspan=1>34.252.160.3</td><td rowspan=2 colspan=2>37.946.053.4</td><td rowspan=2 colspan=1>0.340.160.09</td></tr><tr><td rowspan=1 colspan=1>71.5</td></tr><tr><td rowspan=1 colspan=1>FCN target</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>95.2</td><td rowspan=1 colspan=1>78.4</td><td rowspan=1 colspan=1>10.0</td><td rowspan=1 colspan=1>80.1</td><td rowspan=1 colspan=1>82.5</td><td rowspan=1 colspan=1>37.0</td><td rowspan=1 colspan=1>75.1</td><td rowspan=1 colspan=2>65.4</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=5 colspan=1>seisit</td><td rowspan=1 colspan=1>FCN source</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>61.5</td><td rowspan=1 colspan=1>40.8</td><td rowspan=1 colspan=1>10.4</td><td rowspan=1 colspan=1>53.3</td><td rowspan=1 colspan=1>65.7</td><td rowspan=1 colspan=1>16.6</td><td rowspan=1 colspan=1>30.4</td><td rowspan=1 colspan=2>39.8</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=3 colspan=1>SPIGAN-baseSPIGAN-no-PISPIGAN</td><td rowspan=3 colspan=1>√</td><td rowspan=3 colspan=1>√</td><td rowspan=3 colspan=1>59.453.074.1</td><td rowspan=2 colspan=1>29.730.8</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>10.4</td><td rowspan=1 colspan=1>52.2</td><td rowspan=1 colspan=1>5.9</td><td rowspan=1 colspan=1>20.3</td><td rowspan=1 colspan=2>22.7</td><td rowspan=1 colspan=1>0.83</td></tr><tr><td rowspan=1 colspan=1>3.6</td><td rowspan=1 colspan=1>14.6</td><td rowspan=1 colspan=1>53.0</td><td rowspan=1 colspan=1>5.8</td><td rowspan=1 colspan=1>26.9</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>26.8</td><td rowspan=1 colspan=1>0.80</td></tr><tr><td rowspan=1 colspan=1>47.1</td><td rowspan=1 colspan=1>6.8</td><td rowspan=1 colspan=1>43.3</td><td rowspan=1 colspan=1>83.7</td><td rowspan=1 colspan=1>11.2</td><td rowspan=1 colspan=1>42.2</td><td rowspan=1 colspan=2>44.1</td><td rowspan=1 colspan=1>0.42</td></tr><tr><td rowspan=1 colspan=1>FCN target</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>90.4</td><td rowspan=1 colspan=1>76.5</td><td rowspan=1 colspan=1>32.8</td><td rowspan=1 colspan=1>82.8</td><td rowspan=1 colspan=1>94.9</td><td rowspan=1 colspan=1>40.3</td><td rowspan=1 colspan=1>77.4</td><td rowspan=1 colspan=2>70.7</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Table 2: Semantic Segmentation results (per category and mean IoUs, higher is better) for SYNTHIA adapting to Cityscapes and Vistas. The last column is the ratio of images in the validation set for which we observe negative transfer (lower is better).
+
+# 4.2 RESULTS AND DISCUSSION
+
+In this section we present our evaluation of the SPIGAN algorithm in the context of adapting a semantic segmentation network from SYNTHIA to Cityscapes. Depth maps from SYNTHIA are used as PI in the proposed algorithm.
+
+We compare our results to several state-of-art domain adaptation algorithms, including FCNs in the wild (FCNs wild) (Hoffman et al., 2016b), Curriculum DA (CDA) (Zhang et al., 2017), Learning from synthetic data (LSD) (Sankaranarayanan et al., 2018), and Class-balanced Self-Training (CBST) Zou et al. (2018).
+
+Quantitative results for these methods are shown in Table 1 for the semantic segmentation task on the target domain of Cityscapes (validation set). As reference baselines, we include results training only on source images and non-adapted labels. We also provide our algorithm performance without the PI for comparison (i.e., $\gamma = 0$ in Eq. 1, named ”SPIGAN-no-PI”).
+
+Results show that on Cityscapes SPIGAN achieves state-of-the-art semantic segmentation adaptation in terms of mean IoU. A finer analysis of the results attending to individual classes suggests that the use of PI helps to estimate layout-related classes such as road and sidewalk and object-related classes such as person, rider, car, bus and motorcycle. SPIGAN achieves an improvement of $3 \%$ in $3 2 0 \times 6 4 0$ , $1 . 0 \hat { \% }$ in $5 1 2 \times 1 0 2 4$ , in mean IoU with respect to the non-PI method. This improvement is thanks to the regularization provided by $P ( x ; \theta _ { P } )$ during training, which decreases the number of artifacts as shown in Figure 5. This comparison, therefore, confirms our main contribution: a general approach to leveraging synthetic data and $\mathrm { P I }$ from the simulator to improve generalization performance across the sim-to-real domain gap.
+
+# 4.3 ABLATION STUDY
+
+To better understand the proposed algorithm, and the impact of PI, we conduct further experiments comparing SPIGAN (with PI), SPIGAN-no-PI (without PI), and SPIGAN-base (without both PI and perceptual regularization), the task network of SPIGAN trained only on the source domain (FCN source, lower bound, no adaptation), and on the target domain (FCN target, upper bound), all at $3 2 0 \times 6 4 0$ resolution. We also include results on the Vistas dataset, which presents a more challenging adaptation problem due to the higher diversity of its images. For these experiments, we use a 7 semantic classes ontology to produce a balanced ontology common to the three datasets (SYNTHIA, Cityscapes and Vistas). Adaptation results for both target domains are given in Table 2.
+
+In addition to the conventional segmentation performance metrics, we also carried out a study to measure the amount of negative transfer, summarized in Table 2. A negative transfer case is defined as a real-world testing sample that has a mIoU lower than the FCN source prediction (no adaptation).
+
+As shown in Table 2, SPIGAN-no-PI, including perceptual regularization, performs better than SPIGAN-base in both datasets. The performance is generally improved in all categories, which implies that perceptual regularization effectively stabilizes the adaptation during training.
+
+For Cityscapes, the quantitative results in Table 2 show that SPIGAN is able to provide dramatic adaptation as hypothesized. SPIGAN improves the mean IoU by $1 7 . 1 \%$ , with the PI itself providing an improvement of $7 . 4 \%$ . This is consistent with our observation in the previous experiment (Table 1). We also notice that SPIGAN gets significant improvements on ”nature”, ”construction”, and ”vehicle” categories. In addition, SPIGAN is able to improve the IoU by $+ 1 5 \%$ on the ”human” category, a difficult class in semantic segmentation. We provide examples of qualitative results for the adaptation from SYNTHIA to Cityscapes in Figure 5 and Figure 7.
+
+On the Vistas dataset, SPIGAN is able to decrease the domain gap by $+ 4 . 3 \%$ mean IoU. In this case, using PI is crucial to improve generalization performance. SPIGAN-no-PI indeed suffers from negative transfer, with its adapted network performing $- 1 3 \%$ worse than the FCN source without adaptation. Table 2 shows that $8 0 \%$ of the evaluation images have a lower individual IoU after adaptation in the SPIGAN-no-PI case (vs. $4 2 \%$ in the SPIGAN case).
+
+The main difference between the Cityscapes and Vistas results is due to the difference in visual diversity between the datasets. Cityscapes is indeed a more visually uniform benchmark than Vistas: it was recorded in a few German cities in nice weather, whereas Vistas contains crowdsourced data from all over the world with varying cameras, environments, and weathers. This makes Cityscapes more amenable to image translation methods (including SPIGAN-no-PI), as can be seen in Figure 5 where a lot of the visual adaptation happens at the color and texture levels, whereas Figure 6 shows that SYNTHIA images adapted towards Vistas contain a lot more artifacts. Furthermore, a larger domain gap is known to increase the risk of negative transfer (cf. Csurka (2017)). This is indeed what we quantitatively measured in Table 2 and qualitatively confirmed in Figure 6.
+
+SPIGAN suffers from similar but less severe artifacts. As shown in Figure 6, they are more consistent with the depth of the scene, which helps addressing the domain gap and avoids the catastrophic failures visible in the SPIGAN-no-PI case. This consistent improvement brought by PI in both of the experiments not only shows that PI imposes useful constraints that promote better task-oriented training, but also implies that PI more robustly guides the training to reduce domain shift.
+
+By comparing the results on the two different datasets, we also found that all the unsupervised adaptation methods share some similarity in the performance of certain categories. For instance, the ”vehicle” category has seen the largest improvement for both Cityscapes and Vistas. This trend is consistent with the well-known fact that ”object” categories are easier to adapt than ”stuff” Vazquez et al. (2014). However, the same improvement did not appear in the ”human” category mainly because the SYNTHIA subset we used in our experiments contains very few humans. This phenomenon has been recently studied in Sadat Saleh et al. (2018).
+
+# 5 CONCLUSION
+
+We present SPIGAN, a novel method for leveraging synthetic data and Privileged Information (PI) available in simulated environments to perform unsupervised domain adaptation of deep networks. Our approach jointly learns a generative pixel-level adaptation network together with a target task network and privileged information models. We showed that our approach is able to address large domain gaps between synthetic data and target real-world domains, including for challenging realworld tasks like semantic segmentation of urban scenes. For future work, we plan to investigate SPIGAN applied to additional tasks, with different types of PI that can be obtained from simulation.
+
+![](images/87a4b9d18ace4c09cefcbf365caeca81e854bc911e79e3aea688d484076425e7.jpg)  
+Figure 5: Adaptation from SYNTHIA to Cityscapes. (a) Examples of images from the source domain. (b) Source images after the adaptation process w/o Privileged Information. (c) Source images after the adaptation process using SPIGAN.
+
+![](images/d4e4e733a1b35d82f60f02c8a41d9888e81e1ed72394904ad1934c4667bf00e5.jpg)  
+Figure 6: Adaptation from SYNTHIA to Vistas. (a) Examples of images from the source domain. (b) Source images after the adaptation process w/o Privileged Information. (c) Source images after the adaptation process using SPIGAN. Image adaptation is more challenging between these two datasets due to a larger domain gap. Qualitative results indicate that SPIGAN is encoding more regularization in the image generation.
+
+![](images/4b504b33a01d495e8bd967a858d97f03b1fe93a3d47bb3c3136c8e9f5618f21c.jpg)  
+Figure 7: Semantic segmentation results on Cityscapes. For a set of real images (a) we show examples of predicted semantic segmentation masks. SPIGAN predictions (c) are more accurate (i.e., closer to the ground truth (d)) than those produced without PI during training (b).
+
+![](images/da54b531e53ce799dc9896c8b3974f055dd7fd7af1d1285e675f1a9fec5b9d7c.jpg)  
+Figure 8: Semantic segmentation results on Vistas. For a set of real images (a) we show examples of predicted semantic segmentation masks. SPIGAN predictions (c) are more accurate (i.e., closer to the ground truth (d)) than those produced without PI during training (b).
+
+# REFERENCES
+
+Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. In NIPS, 2016.
+
+Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. In Computer Vision and Pattern Recognition, 2017.
+
+Lin Chen, Wen Li, and Dong Xu. Recognizing rgb images by learning from rgb-d data. In Computer Vision and Pattern Recognition, 2014.
+
+Qifeng Chen and Vladlen Koltun. Photographic image synthesis with cascaded refinement networks. In International Conference on Computer Vision, Oct 2017.
+
+Yi-Hsin Chen, Wei-Yu Chen, Yu-Ting Chen, Bo-Cheng Tsai, Yu-Chiang Frank Wang, and Min Sun. No more discrimination: Cross city adaptation of road scene segmenters. In International Conference on Computer Vision, 2017.
+
+Yuhua Chen, Wen Li, and Luc Van Gool. Road: Reality oriented adaptation for semantic segmentation of urban scenes. In Computer Vision and Pattern Recognition, 2018.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The Cityscapes dataset for semantic urban scene understanding. In Computer Vision and Pattern Recognition, 2016.
+
+Gabriela Csurka. Domain Adaptation in Computer Vision Applications. Springer, 2017.
+
+Zihang Dai, Zhilin Yang, Fan Yang, William W. Cohen, and Ruslan Salakhutdinov. Good semisupervised learning that requires a bad GAN. NIPS, 2017.
+
+Cesar Roberto de Souza, Adrien Gaidon, Yohann Cabon, and Antonio Manuel L ´ opez Pe ´ na. Pro- ˜ cedural generation of videos to train deep action recognition networks. In Computer Vision and Pattern Recognition, 2017.
+
+Adrien Gaidon, Qiao Wang, Yohann Cabon, and Eleonora Vig. Virtual worlds as proxy for multiobject tracking analysis. In Computer Vision and Pattern Recognition, 2016.
+
+Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In International Conference on Machine Learning, 2015.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. Journal of Machine Learning Research, 2016.
+
+Nuno Garcia, Pietro Morerio, and Vittorio Murino. Modality distillation with multiple stream networks for action recognition. In European Conference on Computer Vision, 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, 2014.
+
+Ankur Handa, Viorica Patraucean, Vijay Badrinarayanan, Simon Stent, and Roberto Cipolla. Understanding real world indoor scenes with synthetic data. In Computer Vision and Pattern Recognition, 2016.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition, 2016.
+
+Samitha Herath, Mehrtash Harandi, and Fatih Porikli. Learning an invariant hilbert space for domain adaptation. In Computer Vision and Pattern Recognition, 2017.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Judy Hoffman, Erik Rodner, Jeff Donahue, Kate Saenko, and Trevor Darrell. Efficient learning of domain-invariant image representations. In International Conference on Learning Representations, 2013.
+
+Judy Hoffman, Saurabh Gupta, and Trevor Darrell. Learning with side information through modality hallucination. In Computer Vision and Pattern Recognition, 2016a.
+
+Judy Hoffman, Dequan Wang, Fisher Yu, and Trevor Darrell. Fcns in the wild: Pixel-level adversarial and constraint-based adaptation. arXiv preprint arXiv:1612.02649, 2016b.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A. Efros. Image-to-image translation with conditional adversarial networks. In Computer Vision and Pattern Recognition, 2017.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European Conference on Computer Vision. Springer, 2016.
+
+Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. In International Conference on Machine Learning, 2017.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Wen Li, Li Niu, and Dong Xu. Exploiting privileged information from web data for image categorization. In European Conference on Computer Vision, 2014.
+
+Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. arXiv preprint arXiv:1703.00848, 2017.
+
+Mingsheng Long, Yue Cao, Jianmin Wang, and Michael Jordan. Learning transferable features with deep adaptation networks. In International Conference on Machine Learning, 2015.
+
+David Lopez-Paz, Lon Bottou, Bernhard Schlkopf, and Vladimir Vapnik. Unifying distillation and privileged information. arXiv preprint arXiv:1511.03643, 2015.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, and Zhen Wang. Multi-class generative adversarial networks with the l2 loss function. arXiv preprint arXiv:1611.04076, 2016.
+
+Javier Mar´ın, David Vazquez, David Ger ´ onimo, and Antonio M. L ´ opez. Learning appearance in ´ virtual scenarios for pedestrian detection. In Computer Vision and Pattern Recognition, 2010.
+
+Nikolaus Mayer, Eddy Ilg, Philip Hausser, Philipp Fischer, Daniel Cremers, Alexey Dosovitskiy, and Thomas Brox. A large dataset to train convolutional networks for disparity, optical flow, and scene flow estimation. In Computer Vision and Pattern Recognition, 2016.
+
+Gerhard Neuhold, Tobias Ollmann, Samuel Rota Bulo, and Peter Kontschieder. The mapillary vistas \` dataset for semantic understanding of street scenes. In International Conference on Computer Vision, 2017.
+
+Jeremie Papon and Markus Schoeler. Semantic pose using deep networks trained on synthetic RGBD. In International Conference on Computer Vision, 2015.
+
+Adam Paszke, Sam Gross, Soumith Chintala, et al. Pytorch, 2017.
+
+Xingchao Peng, Baochen Sun, Karim Ali, and Kate Saenko. Learning deep object detectors from 3D models. In International Conference on Computer Vision, 2015.
+
+Sanjay Purushotham, Wilka Carvalho, Tanachat Nilanon, and Yan Liu. Variational recurrent adversarial deep domain adaptation. In International Conference on Learning Representations, 2017.
+
+Stephan R. Richter, Vibhav Vineet, Stefan Roth, and Koltun Vladlen. Playing for data: Ground truth from computer games. In European Conference on Computer Vision, 2016.
+
+German Ros, Laura Sellart, Joanna Materzyska, David Vazquez, and Antonio M. L ´ opez. The SYN- ´ THIA dataset: a large collection of synthetic images for semantic segmentation of urban scenes. In Computer Vision and Pattern Recognition, 2016.
+
+Fatemeh Sadat Saleh, Mohammad Sadegh Aliakbarian, Mathieu Salzmann, Lars Petersson, and Jose M. Alvarez. Effective use of synthetic data for urban scene semantic segmentation. In European Conference on Computer Vision, 2018.
+
+Kuniaki Saito, Kohei Watanabe, Yoshitaka Ushiku, and Tatsuya Harada. Maximum classifier discrepancy for unsupervised domain adaptation. arXiv preprint arXiv:1712.02560, 3, 2017.
+
+Swami Sankaranarayanan, Yogesh Balaji, Arpit Jain, Ser Nam Lim, and Rama Chellappa. Learning from synthetic data: Addressing domain shift for semantic segmentation. In Computer Vision and Pattern Recognition, 2018.
+
+Nikolaos Sarafianos, Michalis Vrigkas, and Ioannis A Kakadiaris. Adaptive svm+: Learning with privileged information for domain adaptation. arXiv preprint arXiv:1708.09083, 2017.
+
+Jamie Shotton, Andrew Fitzgibbon, Mat Cook, Toby Sharp, Mark Finocchio, Richard Moore, Alex Kipmanand, and Andrew Blake. Real-time human pose recognition in parts from a single depth image. In Computer Vision and Pattern Recognition, 2011.
+
+Ashish Shrivastava, Tomas Pfister, Oncel Tuzel, Josh Susskind, Wenda Wang, and Russ Webb. Learning from simulated and unsupervised images through adversarial training. arXiv preprint arXiv:1612.07828, 2016.
+
+Hao Su, Charles R. Qi, Yangyan Yi, and Leonidas Guibas. Render for CNN: viewpoint estimation in images using CNNs trained with rendered 3D model views. In International Conference on Computer Vision, 2015.
+
+Baochen Sun and Kate Saenko. From virtual to reality: Fast adaptation of virtual object detectors to real domains. In British Machine Vision Conference, 2014.
+
+Yaniv Taigman, Adam Polyak, and Lior Wolf. Unsupervised cross-domain image generation. arXiv preprint arXiv:1611.02200, 2016.
+
+Yi-Hsuan Tsai, Wei-Chih Hung, Samuel Schulter, Kihyuk Sohn, Ming-Hsuan Yang, and Manmohan Chandraker. Learning to adapt structured output space for semantic segmentation. In Computer Vision and Pattern Recognition, 2018.
+
+Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014.
+
+Vladimir Vapnik and Akshay Vashist. A new learning paradigm: Learning using privileged information. Neural Networks, 2009.
+
+David Vazquez, Antonio M. Lopez, Javier Mar ´ ´ın, Daniel Ponsa, and David Geronimo. Virtual and ´ real world adaptation for pedestrian detection. Transactions on Pattern Analysis and Machine Intelligence, 36(4):797 – 809, 2014.
+
+Ian H Witten, Eibe Frank, Mark A Hall, and Christopher J Pal. Data Mining: Practical machine learning tools and techniques. Morgan Kaufmann, 2016.
+
+Jiaolong Xu, David Vazquez, Antonio M. L ´ opez, Javier Mar ´ ´ın, and Daniel Ponsa. Learning a partbased pedestrian detector in a virtual world. Transaction on Intelligent Transportation Systems, 15(5):2121–2131, 2014.
+
+Ke Yan, Lu Kou, and David Zhang. Learning domain-invariant subspace using domain features and independence maximization. Transactions on Cybernetics, 2017.
+
+Yang Zhang, Philip David, and Boqing Gong. Curriculum domain adaptation for semantic segmentation of urban scenes. In International Conference on Computer Vision, 2017.
+
+Yiheng Zhang, Zhaofan Qiu, Ting Yao, Dong Liu, and Tao Mei. Fully convolutional adaptation networks for semantic segmentation. In Computer Vision and Pattern Recognition, 2018.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In International Conference on Computer Vision, 2017.
+
+Yang Zou, Zhiding Yu, BVK Vijaya Kumar, and Jinsong Wang. Unsupervised domain adaptation for semantic segmentation via class-balanced self-training. In European Conference on Computer Vision, 2018.

parse/train/rkxoNnC5FQ/rkxoNnC5FQ_content_list.json

@@ -0,0 +1,1652 @@
+[
+    {
+        "type": "text",
+        "text": "SPIGAN: PRIVILEGED ADVERSARIAL LEARNINGFROM SIMULATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            820,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kuan-Hui Lee, Jie Li, Adrien Gaidon Toyota Research Institute {kuan.lee,jie.li,adrien.gaidon}@tri.global ",
+        "bbox": [
+            184,
+            170,
+            591,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "& German Ros   \nIntel Labs   \ngerman.ros@intel.com ",
+        "bbox": [
+            612,
+            171,
+            812,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep Learning for Computer Vision depends mainly on the source of supervision. Photo-realistic simulators can generate large-scale automatically labeled synthetic data, but introduce a domain gap negatively impacting performance. We propose a new unsupervised domain adaptation algorithm, called SPIGAN, relying on Simulator Privileged Information (PI) and Generative Adversarial Networks (GAN). We use internal data from the simulator as PI during the training of a target task network. We experimentally evaluate our approach on semantic segmentation. We train the networks on real-world Cityscapes and Vistas datasets, using only unlabeled real-world images and synthetic labeled data with $\\mathbf { Z }$ -buffer (depth) PI from the SYNTHIA dataset. Our method improves over no adaptation and state-of-theart unsupervised domain adaptation techniques. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/620aee6d60e218ed2cad3bfd22e7d45f10c1744d029c3f84e48f11d08b86b7fd.jpg",
+        "image_caption": [
+            "Figure 1: SPIGAN example inputs and outputs. From left to right: input images from a simulator; adapted images from SPIGAN’s generator network; predictions from SPIGAN’s privileged network (depth layers); semantic segmentation predictions from the target task network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            455,
+            815,
+            579
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            648,
+            336,
+            665
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning from as little human supervision as possible is a major challenge in Machine Learning. In Computer Vision, labeling images and videos is the main bottleneck towards achieving large scale learning and generalization. Recently, training in simulation has shown continuous improvements in several tasks, such as optical flow (Mayer et al., 2016), object detection (Mar´ın et al., 2010; Vazquez et al., 2014; Xu et al., 2014; Sun & Saenko, 2014; Peng et al., 2015), tracking (Gaidon et al., 2016), pose and viewpoint estimation (Shotton et al., 2011; Papon & Schoeler, 2015; Su et al., 2015), action recognition (de Souza et al., 2017), and semantic segmentation (Handa et al., 2016; Ros et al., 2016; Richter et al., 2016). However, large domain gaps between synthetic and real domains remain as the main handicap of this type of strategies. This is often addressed by manually labeling some amount of real-world target data to train the model on mixed synthetic and real-world labeled data (supervised domain adaptation). In contrast, several recent unsupervised domain adaptation algorithms have leveraged the potential of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) for pixel-level adaptation in this context (Bousmalis et al., 2017; Shrivastava et al., 2016). These methods often use simulators as black-box generators of $( x , y )$ input / output training samples for the desired task. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our main observation is that simulators internally know a lot more about the world and how the scene is formed, which we call Privileged Information (PI). This Privileged Information includes physical properties that might be useful for learning. This additional information $z$ is not available in the real-world and is, therefore, generally ignored during learning. In this paper, we propose a novel adversarial learning algorithm, called SPIGAN, to leverage Simulator $P I$ for GAN-based unsupervised learning of a target task network from unpaired unlabeled real-world data. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We jointly learn four different networks: (i) a generator $G$ (to adapt the pixel-level distribution of synthetic images to be more like real ones), (ii) a discriminator $D$ (to distinguish adapted and real images), (iii) a task network $T$ (to predict the desired label $y$ from image $x$ ), and (iv) a privileged network $P$ trained on both synthetic images $x$ and adapted ones $G ( x )$ to predict their associated privileged information $z$ . Our main contribution is a new method to leverage $P I$ from a simulator via the privileged network $P$ , which acts as an auxiliary task and regularizer to the task network $T$ , the main output of our SPIGAN learning algorithm. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our approach on semantic segmentation in urban scenes, a challenging real-world task. We use the standard Cityscapes (Cordts et al., 2016) and Vistas (Neuhold et al., 2017) datasets as target real-world data (without using any of the training labels) and SYNTHIA (Ros et al., 2016) as simulator output. Although our method applies to any kind of PI that can be predicted via a deep network (optical flow, instance segmentation, object detection, material properties, forces, ...), we consider one of the most common and simple forms of PI available in any simulator: depth from its z-buffer. We show that SPIGAN can successfully learn a semantic segmentation network $T$ using no real-world labels, partially bridging the sim-to-real gap (see Figure 1). SPIGAN also outperforms related state-of-the-art unsupervised domain adaptation methods. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows. Section 2 presents a brief review of related works. Section 3 presents our SPIGAN unsupervised domain adaptation algorithm using simulator privileged information. We report our quantitative experiments on semantic segmentation in Section 4, and conclude in Section 5. ",
+        "bbox": [
+            176,
+            404,
+            823,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            344,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Domain adaptation (cf. Csurka (2017) for a recent review) is generally approached either as domaininvariant learning (Hoffman et al., 2013; Herath et al., 2017; Yan et al., 2017; Ganin & Lempitsky, 2015) or as a statistical alignment problem (Tzeng et al., 2014; Long et al., 2015). Our work focuses on unsupervised adaptation methods in the context of deep learning. This problem consists in learning a model for a task in a target domain (e.g., semantic segmentation of real-world urban scenes) by combining unlabeled data from this domain with labeled data from a related but different source domain (e.g., synthetic data from simulation). The main challenge is overcoming the domain gap, i.e. the differences between the source and target distributions, without any supervision from the target domain. The Domain Adversarial Neural Network (DANN) (Tzeng et al., 2014; Ganin & Lempitsky, 2015; Ganin et al., 2016) is a popular approach that learns domain invariant features by maximizing domain confusion. This approach has been successfully adopted and extended by many other researchers, e.g., Purushotham et al. (2017); Chen et al. (2017); Zhang et al. (2017). Curriculum Domain Adaptation (Zhang et al., 2017) is a recent evolution for semantic segmentation that reduces the domain gap via a curriculum learning approach (solving simple tasks first, such as global label distribution in the target domain). ",
+        "bbox": [
+            174,
+            520,
+            825,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, adversarial domain adaptation based on GANs (Goodfellow et al., 2014) have shown encouraging results for unsupervised domain adaptation directly at the pixel level. These techniques learn a generative model for source-to-target image translation, including from and to multiple domains (Taigman et al., 2016; Shrivastava et al., 2016; Zhu et al., 2017; Isola et al., 2017; Kim et al., 2017). In particular, CycleGAN (Zhu et al., 2017) leverages cycle consistency using a forward GAN and a backward GAN to improve the training stability and performance of image-to-image translation. An alternative to GAN is Variational Auto-Encoders (VAEs), which have also been used for image translation (Liu et al., 2017). ",
+        "bbox": [
+            174,
+            734,
+            823,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Several related works propose GAN-based unsupervised domain adaptation methods to address the specific domain gap between synthetic and real-world images. SimGAN (Shrivastava et al., 2016) leverages simulation for the automatic generation of large annotated datasets with the goal of refining synthetic images to make them look more realistic. Sadat Saleh et al. (2018) effectively leverages synthetic data by treating foreground and background in different manners. Similar to our approach, recent methods consider the final recognition task during the image translation process. Closely related to our work, PixelDA (Bousmalis et al., 2017) is a pixel-level domain adaptation method that jointly trains a task classifier along with a GAN using simulation as its source domain but no privileged information. These approaches focus on simple tasks and visual conditions that are easy to simulate, hence having a low domain gap to begin with. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a9cd4ecf85a00e97baf884bc59e53cb15844163bd29a0f79463aef6745e96ae.jpg",
+        "image_caption": [
+            "Figure 2: SPIGAN learning algorithm from unlabeled real-world images $x _ { r }$ and the unpaired output of a simulator (synthetic images $x _ { s }$ , their labels $y _ { s }$ , e.g. semantic segmentation ground truth, and Privileged Information PI $z _ { s }$ , e.g., depth from the $\\mathbf { Z }$ -buffer) modeled as random variables. Four networks are learned jointly: (i) a generator $G ( x _ { s } ) \\sim x _ { r }$ , (ii) a discriminator $D$ between $G ( x _ { s } ) =$ $x _ { f }$ and $x _ { r }$ , (iii) a perception task network $T ( x _ { r } ) \\sim y _ { r }$ , which is the main target output of SPIGAN (e.g., a semantic segmentation deep net), and (iv) a privileged network $P$ to support the learning of $T$ by predicting the simulator’s $\\mathrm { P I } \\ z _ { s }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            75,
+            825,
+            233
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            361,
+            823,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, Hoffman et al. (2016b) are the first to study semantic segmentation as the task network in adversarial training. Zhang et al. (2017) uses a curriculum learning style approach to reduce domain gap. Saito et al. (2017) conducts domain adaptation by utilizing the task-specific decision boundaries with classifiers. Sankaranarayanan et al. (2018) leverage the GAN framework by learning general representation shared between the generator and segmentation networks. Chen et al. (2018) use a target guided distillation to encourage the task network to imitate a pretrained model. Zhang et al. (2018) propose to combine appearance and representation adaptation. Tsai et al. (2018) propose an adversarial learning method to adapt in the output (segmentation) space. Zou et al. (2018) generates pseudo-labels based on confidence scores with balanced class distribution and propose an iterative self-training framework. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our main novelty is the use of Privileged Information from a simulator in a generic way by considering a privileged network in our architecture (see Figure 2). We show that for the challenging task of semantic segmentation of urban scenes, our approach significantly improves by augmenting the learning objective with our auxiliary privileged task, especially in the presence of a large sim-to-real domain gap, the main problem in challenging real-world conditions. ",
+        "bbox": [
+            174,
+            583,
+            823,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work is inspired by Learning Using Privileged Information (LUPI) (Vapnik & Vashist, 2009), which is linked to distillation (Hinton et al., 2015) as shown by Lopez-Paz et al. (2015). LUPI’s goal is to leverage additional data only available at training time. For unsupervised domain adaptation from a simulator, there is a lot of potentially useful information about the generation process that could inform the adaptation. However, that information is only available at training time, as we do not have access to the internals of the real-world data generator. Several works have used privileged information at training time for domain adaptation (Chen et al., 2014; Hoffman et al., 2016a; Li et al., 2014; Sarafianos et al., 2017; Garcia et al., 2018). Hoffman et al. (2016a) leverage RGBD information to help adapt an object detector at the feature level, while Garcia et al. (2018) propose a similar concept of modality distillation for action recognition. Inspired by this line of work, we exploit the privileged information from simulators for sim-to-real unsupervised domain adaptation. ",
+        "bbox": [
+            173,
+            660,
+            825,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SIMULATOR PRIVILEGED INFORMATION GAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            588,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 UNSUPERVISED LEARNING WITH A SIMULATOR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            542,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to design a procedure to learn a model (neural network) that solves a perception task (e.g., semantic segmentation) using raw sensory data coming from a target domain (e.g., videos of a car driving in urban environments) without using any ground truth data from the target domain. We formalize this problem as unsupervised domain adaptation from a synthetic domain (source domain) to a real domain (target domain). The source domain consists of labeled synthetic images together with Privileged Information (PI), obtained from the internal data structures of a simulator. The target domain consists of unlabeled images. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The simulated source domain serves as an idealized representation of the world, offering full control of the environment (weather conditions, types of scene, sensor configurations, etc.) with automatic generation of raw sensory data and labels for the task of interest. The main challenge we address in this work is how to overcome the gap between this synthetic source domain and the target domain to ensure generalization of the task network in the real-world without target supervision. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our main hypothesis is that the PI provided by the simulator is a rich source of information to guide and constrain the training of the target task network. The PI can be defined as any information internal to the simulator, such as depth, optical flow, or physical properties about scene components used during simulation (e.g., materials, forces, etc.). We leverage the simulator’s PI within a GAN framework, called SPIGAN. Our approach is described in the next section. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 SPIGAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            343,
+            279,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $X _ { r } ~ = ~ \\{ x _ { r } ^ { ( j ) }$ , $j ~ = ~ 1 \\ldots N ^ { r } \\}$ be a set of $N ^ { r }$ unlabeled real-world images . Let $X _ { s } \\ =$ i), y(i)s , z(i)s ), i = 1 . . . N s} be a set of N s simulated images xs with their labels ys and PI   \n$z _ { s }$   \ntends to multiple separate types of $\\mathrm { P I }$ . ",
+        "bbox": [
+            174,
+            367,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "SPIGAN (cf. Fig. 2) jointly learns a model $( \\theta _ { G } , \\theta _ { D } , \\theta _ { T } , \\theta _ { P } )$ , consisting of: (i) a generator $G ( x ; \\theta _ { G } )$ , (ii) a discriminator $D ( x ; \\theta _ { D } )$ , (iii) a task predictor $T ( x ; \\theta _ { T } )$ , and (iv) a privileged network $P ( x ; \\theta _ { P } )$ . The generator $G$ is a mapping function, transforming an image $x _ { s }$ in $X _ { s }$ (source domain) to $x _ { f }$ in $X _ { f }$ (adapted or fake domain). SPIGAN aims to make the adapted domain statistically close to the target domain to maximize the accuracy of the task predictor $T ( x ; \\theta _ { T } )$ during testing. The discriminator $D$ is expected to tell the difference between $x _ { f }$ and $x _ { r }$ , playing an adversarial game with the generator until a termination criteria is met (refer to section 4.1) . The target task network $T$ is learned on the synthetic $x _ { s }$ and adapted $G ( x _ { s } ; \\theta _ { G } )$ images to predict the synthetic label $y _ { s }$ , assuming the generator presents a reasonable degree of label (content) preservation. This assumption is met for the regime of our experiments. Similarly, the privileged network $P$ is trained on the same input but to predict the $\\mathrm { P I } ~ z$ , which in turn assumes the generator $G$ is also PI-preserving. During testing only $T ( x ; \\theta _ { T } )$ is needed to do inference for the selected perception task. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main learning goal is to train a model $\\theta _ { T }$ that can correctly perform a perception task $T$ in the target real-world domain. All models are trained jointly in order to exploit all available information to constrain the solution space. In this way, the $\\mathrm { P I }$ provided by the privileged network $P$ is used to constrain the learning of $T$ and to encourage the generator to model the target domain while being label- and PI-preserving. Our joint learning objective is described in the following section. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 LEARNING OBJECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            370,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We design a consistent set of loss functions and domain-specific constraints related to the main prediction task $T$ . We optimize the following minimax objective: ",
+        "bbox": [
+            174,
+            722,
+            823,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7d885d5254fdad260b451d44fb870a1db712acd4c1aa596e1a4ef9ddf8c98ad.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta _ { G } , \\theta _ { T } , \\theta _ { P } } \\operatorname* { m a x } _ { \\theta _ { D } } \\alpha \\mathcal { L } _ { \\mathrm { G A N } } + \\beta \\mathcal { L } _ { T } + \\gamma \\mathcal { L } _ { P } + \\delta \\mathcal { L } _ { \\mathrm { p e r c } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            753,
+            655,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha , \\beta , \\gamma , \\delta$ are the weights for adversarial loss, task prediction loss, PI regularization, and perceptual regularization respectively, further described below. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial loss $\\mathcal { L } _ { \\mathbf { G A N } }$ . Instead of using a standard adversarial loss, we use a least-squares based adversarial loss Mao et al. (2016); Zhu et al. (2017), which stabilizes the training process and generates better image results in our experiments: ",
+        "bbox": [
+            174,
+            823,
+            825,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da270e0a9635910f97243dbcb25005baab67906b8f006e55b2f5774db63010d0.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathrm { G A N } } ( D , G ) = \\mathbb { E } _ { x _ { r } \\sim \\mathcal { P } _ { r } } [ ( D ( x _ { r } ; \\theta _ { D } ) - 1 ) ^ { 2 } ] } \\\\ & { \\quad \\quad \\quad \\quad + \\mathbb { E } _ { x _ { s } \\sim \\mathcal { P } _ { s } } [ D ( G ( x _ { s } ; \\theta _ { G } ) ; \\theta _ { D } ) ^ { 2 } ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            867,
+            645,
+            907
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { P } _ { r }$ (resp. $\\mathcal { P } _ { s }$ ) denotes the real-world (resp. synthetic) data distribution. ",
+        "bbox": [
+            176,
+            909,
+            681,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Task prediction loss $\\mathcal { L } _ { T }$ . We learn the task network by optimizing its loss over both synthetic images $x _ { s }$ and their adapted version $G ( x _ { s } , \\theta _ { G } )$ . This assumes the generator is label-preserving, i.e., that $y _ { s }$ can be used as a label for both images. Thanks to our joint objective, this assumption is directly encouraged during the learning of the generator through the joint estimation of $\\theta _ { P }$ , which relates to scene properties captured by the PI. Naturally, different tasks require different loss functions. In our experiments, we consider the task of semantic segmentation and use the standard cross-entropy loss (Eq. 4) over images of size $W \\times H$ and a probability distribution over $C$ semantic categories. The total combined loss in the special case of semantic segmentation is therefore: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2133e55a3a05787df1623d8cf4f474e2efccf218fcd455a1dba83689dc23fa5.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } _ { T } ( T , G ) = \\mathcal { L } _ { \\mathrm { C E } } ( x _ { s } , y _ { s } ) + \\mathcal { L } _ { \\mathrm { C E } } ( G ( x _ { s } ; \\theta _ { G } ) , y _ { s } ) } \\\\ { \\displaystyle \\mathcal { L } _ { \\mathrm { C E } } ( x , y ) = \\frac { - 1 } { W H } \\sum _ { u , v } ^ { W , H } \\sum _ { c = 1 } ^ { C } \\mathbb { 1 } _ { [ c = y _ { u , v } ] } \\log ( T ( x ; \\theta _ { T } ) _ { u , v } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            220,
+            676,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 } _ { [ a = b ] }$ is the indicator function. ",
+        "bbox": [
+            174,
+            292,
+            423,
+            309
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "PI regularization $\\mathcal { L } _ { P }$ . Similarly, the auxiliary task of predicting PI also requires different losses depending on the type of PI. In our experiments, we use depth from the $\\mathbf { Z }$ -buffer and an $\\ell _ { 1 }$ -norm: ",
+        "bbox": [
+            174,
+            324,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b99cd22ac7be7a058cc9c5306178c9f6eea9ade824560000dd9039eacf535123.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { P } ( P , G ) = \\rvert | P ( x _ { s } ; \\theta _ { P } ) - z _ { s } | | _ { 1 } } \\\\ & { \\qquad + | | P ( G ( x _ { s } ; \\theta _ { G } ) ; \\theta _ { P } ) - z _ { s } | | _ { 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            358,
+            632,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Perceptual regularization $\\mathcal { L } _ { \\mathrm { p e r c } }$ . To maintain the semantics of the source images in the generated images, we additionally use the perceptual loss Johnson et al. (2016); Chen & Koltun (2017): ",
+        "bbox": [
+            173,
+            409,
+            826,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad5371232c8c62c67e9e92f37e4c9c326b8b445a83cea5d62fae3c26f75fcd5f.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { p e r c } } ( G ) = | | \\phi ( x _ { s } ) - \\phi ( G ( x _ { s } ; \\theta _ { G } ) ) | | _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            445,
+            627,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi$ is a mapping from image space to a pre-determined feature space Chen & Koltun (2017) (see 4.1 for more details). ",
+        "bbox": [
+            174,
+            469,
+            823,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Optimization. In practice, we follow the standard adversarial training strategy to optimize our joint learning objective (Eq. 1). We alternate between updates to the parameters of the discriminator $\\theta _ { D }$ , keeping all other parameters fixed, then fix $\\theta _ { D }$ and optimize the parameters of the generator $\\theta _ { G }$ , the privileged network $\\theta _ { P }$ , and most importantly the task network $\\theta _ { T }$ . We discuss the details of our implementation, including hyper-parameters, in section 4.1. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            326,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our unsupervised domain adaptation method on the task of semantic segmentation in a challenging real-world domain for which training labels are not available. ",
+        "bbox": [
+            174,
+            637,
+            823,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As our source synthetic domain, we select the public SYNTHIA dataset (Ros et al., 2016) as synthetic source domain given the availability of automatic annotations and PI. SYNTHIA is a dataset generated from an autonomous driving simulator of urban scenes. These images were generated under different weathers and illumination conditions to maximize visual variability. Pixel-wise segmentation and depth labels are provided for each image. In our experiment, we use the sequence of SYNTHIA-RAND-CITYSCAPES, which contains semantic segmentation labels that are more compatible with Cityscapes. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For target real-world domains, we use the Cityscapes (Cordts et al., 2016) and Mapillary Vistas (Neuhold et al., 2017) datasets. Cityscapes is one of most widely used real-world urban scene image segmentation datasets with images collected around urban streets in Europe. For this dataset, We use the standard split for training and validation with 2, 975 and 500 images respectively. Mapillary Vistas is a larger dataset with a wider variety of scenes, cameras, locations, weathers, and illumination conditions. We use 16, 000 images for training and 2, 000 images for evaluation. During training, none of the labels from the real-world domains are used. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our experiment, we first evaluate adaptation from SYNTHIA to Cityscapes on 16 classes, following the standard evaluation protocol used in Hoffman et al. (2016b); Zhang et al. (2017); Saito et al. (2017); Sankaranarayanan et al. (2018); Zou et al. (2018). Then we show the positive impact of using PI by conducting ablation study with and without PI (depth) during adaptation from SYNTHIA to both Cityscapes and Vistas, on a common 7 categories ontology. To be consistent with the semantic segmentation best practices, we use standard intersection-over-union (IoU) per category and mean intersection-over-union (mIoU) as our main validation metric. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3da4f87e4e6e03ec1a538be2ddc0dcc1d24eb3e09d1e909520ffbbc70d72baa2.jpg",
+        "image_caption": [
+            "Figure 3: Loss curves for the task, perceptual, and privileged parts of the learning objective during the training of SYNTHIA-to-Cityscapes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            106,
+            483,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/71a089a07f578db5accb9bb8a9d6d3711c24ab649cb2a8cdf6c65e27f9a92103.jpg",
+        "image_caption": [
+            "Figure 4: Early stopping at the iteration when the discriminator loss is significantly and consistently better than the generator loss (90 here). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            107,
+            818,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            323,
+            823,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            405,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We adapt the generator and discriminator model architectures from CycleGAN (Zhu et al., 2017) and (Johnson et al., 2016). For simplicity, we use a single sim-to-real generator (no cycle consistency) consisting of two down-sampling convolution layers, nine ResNet blocks (He et al., 2016) and two fractionally-strided convolution layers. Our discriminator is a PatchGAN (Isola et al., 2017) network with 3 layers. We use the standard FCN8s architecture Long et al. (2015) for both the task predictor $T$ and the privileged network $P$ , given its ease of training and its acceptance in domain adaptation works Hoffman et al. (2016b). For the perceptual loss $\\mathcal { L } _ { \\mathrm { p e r c } }$ , we follow the implementation in Chen & Koltun (2017). The feature is constructed by the concatenation of the activations of a pre-trained VGG19 network Witten et al. (2016) of layers ”conv1 $\\lrcorner 2 ^ { \\ast }$ , ”conv2 $_ { - 2 } \\mathbf { \\mathit { ^ { , } } }$ , ”conv3 2”, ”conv4 2”, ”conv5 2”. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following the common protocol in unsupervised domain adaptation Shrivastava et al. (2016); Zhu et al. (2017); Bousmalis et al. (2016); Sankaranarayanan et al. (2018), we set hyper-parameters using a coarse grid search on a small validation set different than the target set. For Cityscapes, we use a subset of the validation set of Vistas, and vice-versa. We found a set of values that are effective across datasets and experiments, which show they have a certain degree of robustness and generalization. The weights in our joint adversarial loss (Eq. 1) are set to $\\alpha = 1$ , $\\beta = 0 . 5$ , $\\gamma = 0 . 1$ , $\\delta = 0 . 3 3$ , for the GAN, task, privileged, and perceptual objectives respectively. This confirms that the two most important factors in the objective are the GAN and task losses $\\langle \\alpha = 1$ , $\\beta = 0 . 5$ ). This is intuitive, as the goal is to improve the generalization performance of the task network (the task loss being an empirical proxy) across a potentially large domain gap (addressed first and foremost by the GAN loss). The regularization terms are secondary in the objective, stabilizing the training (perceptual loss) and constraining the adaptation process (privileged loss). Figures 3 and 4 show an example of our loss curves and the stability of our training. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another critical hyper-parameter for unsupervised learning is the stopping criterion. We observed that the stabilizing effects of the task and privileged losses (Eqs. 3,5) on the GAN objective (Eq. 2) made a simple rule effective for early stopping. We stop training at the iteration when the discriminator loss is significantly and consistently better than the generator loss (iteration 90 in Figure 4). This is inspired by the semi-supervised results of Dai et al. (2017), where effective discriminative adaptation of the task network might not always be linked to the best image generator. We evaluate the methods with two resolutions: $3 2 0 \\times 6 4 0$ and $5 1 2 \\times 1 0 2 4$ , respectively. Images are resized to the evaluated size during training and evaluation. During training, we sample crops of size $3 2 0 \\times 3 2 0$ (resp. $4 0 0 \\times 4 0 0 )$ for lower (resp. higher) resolution experiments. In all adversarial learning cases, we do five steps of the generator for every step of the other networks. The Adam optimizer (Kingma & Ba, 2014) is used to adjust all parameters with initial learning rate 0.0002 in our PyTorch implementation (Paszke et al., 2017). ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4190d11ca706820928c63b377620975d32903553239c865baf56b413a34acfa1.jpg",
+        "table_caption": [
+            "Table 1: Semantic segmentation unsupervised domain adaptation from SYNTHIA to Cityscapes. We present semantic segmentation results with per-class IoU and mean IoU. The highest IoU (at the same resolution) for each class within the compared algorithms is highlighted with bold font. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">rrnnrign</td><td rowspan=\"3\">Method</td><td rowspan=\"3\"></td><td rowspan=\"3\">srraar</td><td rowspan=\"3\">Buipling</td><td rowspan=\"3\">1</td><td rowspan=\"3\"></td><td rowspan=\"3\"></td><td rowspan=\"3\">-l</td><td rowspan=\"3\">uIs-L</td><td rowspan=\"3\">Vieeree</td><td rowspan=\"3\">3</td><td rowspan=\"3\">nosiad</td><td rowspan=\"3\"></td><td rowspan=\"3\">3u</td><td rowspan=\"3\"></td><td rowspan=\"3\">mrrriltt</td><td rowspan=\"3\">ealrlr</td><td rowspan=\"3\">ntr eer</td></tr><tr><td></td><td></td></tr><tr><td>reee </td></tr><tr><td>FCNs wild source-only</td><td></td><td>6.4</td><td>17.7</td><td>29.7 1.2</td><td>0.0</td><td>15.1</td><td>0.0</td><td>7.2</td><td>30.3</td><td>66.8</td><td>51.1</td><td>1.5</td><td>47.3</td><td>3.9</td><td>0.1</td><td>0.0</td><td>17.4</td></tr><tr><td rowspan=\"10\">259322</td><td>FCNs wild</td><td>11.5</td><td>19.6</td><td>30.8</td><td>4.4</td><td>0.0</td><td>20.3</td><td>0.1</td><td>11.7</td><td>42.3 68.7</td><td>51.2</td><td>3.8</td><td></td><td>54.0 3.2</td><td>0.2</td><td>0.6</td><td>20.2</td></tr><tr><td>CDA source-only</td><td>5.6</td><td>11.2</td><td>59.6</td><td>0.8</td><td>0.5</td><td>21.5</td><td>8.0 5.3</td><td>72.4</td><td>75.6</td><td>35.1</td><td>9.0</td><td>23.6</td><td>4.5</td><td>0.5</td><td>18.0</td><td>22.0</td></tr><tr><td>CDA</td><td>65.2</td><td>26.1</td><td>74.9</td><td>0.1</td><td>0.5</td><td>10.7 3.7</td><td>3.0</td><td>76.1</td><td>70.6</td><td>47.1</td><td>8.2</td><td>43.2</td><td>20.7</td><td>0.7</td><td>13.1</td><td>29.0</td></tr><tr><td>LSD source-only</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>23.2</td></tr><tr><td>LSD</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>n/a</td><td>34.5</td></tr><tr><td>Our source-only</td><td>14.2</td><td>12.4</td><td>73.3</td><td>0.5</td><td>0.1</td><td>23.1 5.8</td><td>12.2</td><td>79.4</td><td>78.6</td><td>45.1</td><td>7.8</td><td>32.8</td><td>5.7</td><td>5.6</td><td>1.6</td><td>24.9</td></tr><tr><td>SPIGAN-no-PI</td><td>68.8</td><td>24.5</td><td>73.4</td><td>3.6</td><td>0.1</td><td>22.0 5.8</td><td>8.9</td><td>74.6</td><td>77.3</td><td>41.5</td><td>8.8</td><td>58.2</td><td>15.4</td><td>6.7</td><td>8.4</td><td>31.1</td></tr><tr><td>SPIGAN</td><td>80.5</td><td>38.9</td><td>73.4</td><td>1.8</td><td>0.3</td><td>20.3</td><td>7.9 11.3</td><td>77.1</td><td>77.6</td><td>46.6</td><td>13.2</td><td>63.8</td><td>22.8</td><td>8.8</td><td>11.2</td><td>34.7</td></tr><tr><td>LSD source-only</td><td>30.1</td><td>17.5</td><td>70.2</td><td>5.9</td><td>0.1</td><td>16.7 9.1</td><td>12.6</td><td>74.5</td><td>76.3</td><td>43.9</td><td>13.2</td><td>35.7</td><td>14.3</td><td>3.7</td><td>5.6</td><td>26.8</td></tr><tr><td>LSD CBST source-only</td><td>80.1</td><td>29.1</td><td>77.5</td><td>2.8</td><td>0.4</td><td>26.8 11.1</td><td>18.0</td><td>78.1</td><td>76.7</td><td>48.2</td><td>15.2</td><td>70.5</td><td>17.4</td><td>8.7</td><td>16.7</td><td>36.1</td></tr><tr><td rowspan=\"8\">2222222</td><td></td><td>17.2</td><td>19.7</td><td>73.3</td><td>1.1</td><td>0.0</td><td>19.1 3.0</td><td>9.1</td><td>71.8</td><td>78.3</td><td>37.6</td><td>4.7</td><td>42.2</td><td>9.0</td><td>0.1</td><td>0.9</td><td>22.6</td></tr><tr><td>CBST</td><td>69.9</td><td>28.7</td><td>69.5</td><td>12.1</td><td>0.1</td><td>25.4 11.9</td><td>13.6</td><td>82.0</td><td>81.9</td><td>49.1</td><td>14.5</td><td>66.0</td><td>6.6</td><td>3.7</td><td>32.4</td><td>35.4</td></tr><tr><td>Our source-only</td><td>21.2</td><td>12.3</td><td>69.1 2.8</td><td>0.1</td><td>24.8</td><td>10.4</td><td>15.3</td><td>74.8</td><td>78.2</td><td>50.3</td><td>8.8</td><td>41.9</td><td>18.3</td><td>6.6</td><td>6.8</td><td>27.6</td></tr><tr><td>SPIGAN-no-PI</td><td>69.5</td><td>29.4</td><td>68.7</td><td>4.4</td><td>0.3</td><td>32.4 5.8</td><td>15.0</td><td>81.0</td><td>78.7</td><td>52.2</td><td>13.1</td><td>72.8</td><td>23.6</td><td>7.9</td><td>18.7</td><td>35.8</td></tr><tr><td>SPIGAN</td><td>71.1</td><td>29.8</td><td>71.4</td><td>3.7</td><td>0.3</td><td>33.2</td><td>6.4 15.6</td><td>81.2</td><td>78.9</td><td>52.7</td><td>13.1</td><td>75.9</td><td>25.5</td><td>10.0</td><td>20.5</td><td>36.8</td></tr><tr><td>(LSD) Target-only</td><td>96.5</td><td>74.6</td><td>86.1</td><td>37.1</td><td>33.2</td><td>30.2 39.7</td><td>51.6</td><td>87.3</td><td>90.4</td><td>60.1</td><td>31.7</td><td>88.4</td><td>52.5</td><td>33.6</td><td>59.1</td><td>59.5</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            77,
+            825,
+            268
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3f00a87e351f8d632df24f80659d43a77c40b02ade06d6149875d533c4c4375b.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Semantic Segmentation results (per category and mean IoUs, higher is better) for SYNTHIA adapting to Cityscapes and Vistas. The last column is the ratio of images in the validation set for which we observe negative transfer (lower is better). "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Jasetee</td><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>美</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>CJsuoo</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Jrmee</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>ueunu</td><td rowspan=1 colspan=1>Vairee</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>neeee</td></tr><tr><td rowspan=4 colspan=1>ssdesssts</td><td rowspan=1 colspan=1>FCN source</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>79.6</td><td rowspan=1 colspan=1>51.0</td><td rowspan=1 colspan=1>8.7</td><td rowspan=1 colspan=1>29.0</td><td rowspan=1 colspan=1>50.9</td><td rowspan=1 colspan=1>3.0</td><td rowspan=1 colspan=1>31.6</td><td rowspan=1 colspan=2>36.3</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>SPIGAN-baseSPIGAN-no-PISPIGAN</td><td rowspan=2 colspan=1>?</td><td rowspan=2 colspan=1>√</td><td rowspan=2 colspan=1>82.590.391.2</td><td rowspan=2 colspan=1>52.758.266.4</td><td rowspan=2 colspan=1>7.26.89.6</td><td rowspan=2 colspan=1>30.635.856.8</td><td rowspan=1 colspan=1>52.269.0</td><td rowspan=2 colspan=1>5.69.517.7</td><td rowspan=2 colspan=1>34.252.160.3</td><td rowspan=2 colspan=2>37.946.053.4</td><td rowspan=2 colspan=1>0.340.160.09</td></tr><tr><td rowspan=1 colspan=1>71.5</td></tr><tr><td rowspan=1 colspan=1>FCN target</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>95.2</td><td rowspan=1 colspan=1>78.4</td><td rowspan=1 colspan=1>10.0</td><td rowspan=1 colspan=1>80.1</td><td rowspan=1 colspan=1>82.5</td><td rowspan=1 colspan=1>37.0</td><td rowspan=1 colspan=1>75.1</td><td rowspan=1 colspan=2>65.4</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=5 colspan=1>seisit</td><td rowspan=1 colspan=1>FCN source</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>61.5</td><td rowspan=1 colspan=1>40.8</td><td rowspan=1 colspan=1>10.4</td><td rowspan=1 colspan=1>53.3</td><td rowspan=1 colspan=1>65.7</td><td rowspan=1 colspan=1>16.6</td><td rowspan=1 colspan=1>30.4</td><td rowspan=1 colspan=2>39.8</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=3 colspan=1>SPIGAN-baseSPIGAN-no-PISPIGAN</td><td rowspan=3 colspan=1>√</td><td rowspan=3 colspan=1>√</td><td rowspan=3 colspan=1>59.453.074.1</td><td rowspan=2 colspan=1>29.730.8</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>10.4</td><td rowspan=1 colspan=1>52.2</td><td rowspan=1 colspan=1>5.9</td><td rowspan=1 colspan=1>20.3</td><td rowspan=1 colspan=2>22.7</td><td rowspan=1 colspan=1>0.83</td></tr><tr><td rowspan=1 colspan=1>3.6</td><td rowspan=1 colspan=1>14.6</td><td rowspan=1 colspan=1>53.0</td><td rowspan=1 colspan=1>5.8</td><td rowspan=1 colspan=1>26.9</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>26.8</td><td rowspan=1 colspan=1>0.80</td></tr><tr><td rowspan=1 colspan=1>47.1</td><td rowspan=1 colspan=1>6.8</td><td rowspan=1 colspan=1>43.3</td><td rowspan=1 colspan=1>83.7</td><td rowspan=1 colspan=1>11.2</td><td rowspan=1 colspan=1>42.2</td><td rowspan=1 colspan=2>44.1</td><td rowspan=1 colspan=1>0.42</td></tr><tr><td rowspan=1 colspan=1>FCN target</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>90.4</td><td rowspan=1 colspan=1>76.5</td><td rowspan=1 colspan=1>32.8</td><td rowspan=1 colspan=1>82.8</td><td rowspan=1 colspan=1>94.9</td><td rowspan=1 colspan=1>40.3</td><td rowspan=1 colspan=1>77.4</td><td rowspan=1 colspan=2>70.7</td><td rowspan=1 colspan=1>1</td></tr></table>",
+        "bbox": [
+            173,
+            335,
+            821,
+            530
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            403,
+            607
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we present our evaluation of the SPIGAN algorithm in the context of adapting a semantic segmentation network from SYNTHIA to Cityscapes. Depth maps from SYNTHIA are used as PI in the proposed algorithm. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our results to several state-of-art domain adaptation algorithms, including FCNs in the wild (FCNs wild) (Hoffman et al., 2016b), Curriculum DA (CDA) (Zhang et al., 2017), Learning from synthetic data (LSD) (Sankaranarayanan et al., 2018), and Class-balanced Self-Training (CBST) Zou et al. (2018). ",
+        "bbox": [
+            174,
+            667,
+            825,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Quantitative results for these methods are shown in Table 1 for the semantic segmentation task on the target domain of Cityscapes (validation set). As reference baselines, we include results training only on source images and non-adapted labels. We also provide our algorithm performance without the PI for comparison (i.e., $\\gamma = 0$ in Eq. 1, named ”SPIGAN-no-PI”). ",
+        "bbox": [
+            174,
+            731,
+            825,
+            786
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results show that on Cityscapes SPIGAN achieves state-of-the-art semantic segmentation adaptation in terms of mean IoU. A finer analysis of the results attending to individual classes suggests that the use of PI helps to estimate layout-related classes such as road and sidewalk and object-related classes such as person, rider, car, bus and motorcycle. SPIGAN achieves an improvement of $3 \\%$ in $3 2 0 \\times 6 4 0$ , $1 . 0 \\hat { \\% }$ in $5 1 2 \\times 1 0 2 4$ , in mean IoU with respect to the non-PI method. This improvement is thanks to the regularization provided by $P ( x ; \\theta _ { P } )$ during training, which decreases the number of artifacts as shown in Figure 5. This comparison, therefore, confirms our main contribution: a general approach to leveraging synthetic data and $\\mathrm { P I }$ from the simulator to improve generalization performance across the sim-to-real domain gap. ",
+        "bbox": [
+            173,
+            792,
+            825,
+            920
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            97,
+            341,
+            111
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To better understand the proposed algorithm, and the impact of PI, we conduct further experiments comparing SPIGAN (with PI), SPIGAN-no-PI (without PI), and SPIGAN-base (without both PI and perceptual regularization), the task network of SPIGAN trained only on the source domain (FCN source, lower bound, no adaptation), and on the target domain (FCN target, upper bound), all at $3 2 0 \\times 6 4 0$ resolution. We also include results on the Vistas dataset, which presents a more challenging adaptation problem due to the higher diversity of its images. For these experiments, we use a 7 semantic classes ontology to produce a balanced ontology common to the three datasets (SYNTHIA, Cityscapes and Vistas). Adaptation results for both target domains are given in Table 2. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            231
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In addition to the conventional segmentation performance metrics, we also carried out a study to measure the amount of negative transfer, summarized in Table 2. A negative transfer case is defined as a real-world testing sample that has a mIoU lower than the FCN source prediction (no adaptation). ",
+        "bbox": [
+            176,
+            237,
+            825,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 2, SPIGAN-no-PI, including perceptual regularization, performs better than SPIGAN-base in both datasets. The performance is generally improved in all categories, which implies that perceptual regularization effectively stabilizes the adaptation during training. ",
+        "bbox": [
+            176,
+            286,
+            825,
+            328
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For Cityscapes, the quantitative results in Table 2 show that SPIGAN is able to provide dramatic adaptation as hypothesized. SPIGAN improves the mean IoU by $1 7 . 1 \\%$ , with the PI itself providing an improvement of $7 . 4 \\%$ . This is consistent with our observation in the previous experiment (Table 1). We also notice that SPIGAN gets significant improvements on ”nature”, ”construction”, and ”vehicle” categories. In addition, SPIGAN is able to improve the IoU by $+ 1 5 \\%$ on the ”human” category, a difficult class in semantic segmentation. We provide examples of qualitative results for the adaptation from SYNTHIA to Cityscapes in Figure 5 and Figure 7. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            433
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the Vistas dataset, SPIGAN is able to decrease the domain gap by $+ 4 . 3 \\%$ mean IoU. In this case, using PI is crucial to improve generalization performance. SPIGAN-no-PI indeed suffers from negative transfer, with its adapted network performing $- 1 3 \\%$ worse than the FCN source without adaptation. Table 2 shows that $8 0 \\%$ of the evaluation images have a lower individual IoU after adaptation in the SPIGAN-no-PI case (vs. $4 2 \\%$ in the SPIGAN case). ",
+        "bbox": [
+            174,
+            440,
+            823,
+            510
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The main difference between the Cityscapes and Vistas results is due to the difference in visual diversity between the datasets. Cityscapes is indeed a more visually uniform benchmark than Vistas: it was recorded in a few German cities in nice weather, whereas Vistas contains crowdsourced data from all over the world with varying cameras, environments, and weathers. This makes Cityscapes more amenable to image translation methods (including SPIGAN-no-PI), as can be seen in Figure 5 where a lot of the visual adaptation happens at the color and texture levels, whereas Figure 6 shows that SYNTHIA images adapted towards Vistas contain a lot more artifacts. Furthermore, a larger domain gap is known to increase the risk of negative transfer (cf. Csurka (2017)). This is indeed what we quantitatively measured in Table 2 and qualitatively confirmed in Figure 6. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "SPIGAN suffers from similar but less severe artifacts. As shown in Figure 6, they are more consistent with the depth of the scene, which helps addressing the domain gap and avoids the catastrophic failures visible in the SPIGAN-no-PI case. This consistent improvement brought by PI in both of the experiments not only shows that PI imposes useful constraints that promote better task-oriented training, but also implies that PI more robustly guides the training to reduce domain shift. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            718
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "By comparing the results on the two different datasets, we also found that all the unsupervised adaptation methods share some similarity in the performance of certain categories. For instance, the ”vehicle” category has seen the largest improvement for both Cityscapes and Vistas. This trend is consistent with the well-known fact that ”object” categories are easier to adapt than ”stuff” Vazquez et al. (2014). However, the same improvement did not appear in the ”human” category mainly because the SYNTHIA subset we used in our experiments contains very few humans. This phenomenon has been recently studied in Sadat Saleh et al. (2018). ",
+        "bbox": [
+            174,
+            724,
+            823,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            318,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present SPIGAN, a novel method for leveraging synthetic data and Privileged Information (PI) available in simulated environments to perform unsupervised domain adaptation of deep networks. Our approach jointly learns a generative pixel-level adaptation network together with a target task network and privileged information models. We showed that our approach is able to address large domain gaps between synthetic data and target real-world domains, including for challenging realworld tasks like semantic segmentation of urban scenes. For future work, we plan to investigate SPIGAN applied to additional tasks, with different types of PI that can be obtained from simulation. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/87a4b9d18ace4c09cefcbf365caeca81e854bc911e79e3aea688d484076425e7.jpg",
+        "image_caption": [
+            "Figure 5: Adaptation from SYNTHIA to Cityscapes. (a) Examples of images from the source domain. (b) Source images after the adaptation process w/o Privileged Information. (c) Source images after the adaptation process using SPIGAN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            193,
+            812,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d4e4e733a1b35d82f60f02c8a41d9888e81e1ed72394904ad1934c4667bf00e5.jpg",
+        "image_caption": [
+            "Figure 6: Adaptation from SYNTHIA to Vistas. (a) Examples of images from the source domain. (b) Source images after the adaptation process w/o Privileged Information. (c) Source images after the adaptation process using SPIGAN. Image adaptation is more challenging between these two datasets due to a larger domain gap. Qualitative results indicate that SPIGAN is encoding more regularization in the image generation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            534,
+            812,
+            766
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b504b33a01d495e8bd967a858d97f03b1fe93a3d47bb3c3136c8e9f5618f21c.jpg",
+        "image_caption": [
+            "Figure 7: Semantic segmentation results on Cityscapes. For a set of real images (a) we show examples of predicted semantic segmentation masks. SPIGAN predictions (c) are more accurate (i.e., closer to the ground truth (d)) than those produced without PI during training (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            123,
+            812,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/da54b531e53ce799dc9896c8b3974f055dd7fd7af1d1285e675f1a9fec5b9d7c.jpg",
+        "image_caption": [
+            "Figure 8: Semantic segmentation results on Vistas. For a set of real images (a) we show examples of predicted semantic segmentation masks. SPIGAN predictions (c) are more accurate (i.e., closer to the ground truth (d)) than those produced without PI during training (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            536,
+            812,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. In NIPS, 2016. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. In Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            176,
+            162,
+            821,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lin Chen, Wen Li, and Dong Xu. Recognizing rgb images by learning from rgb-d data. In Computer Vision and Pattern Recognition, 2014. ",
+        "bbox": [
+            169,
+            215,
+            825,
+            244
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qifeng Chen and Vladlen Koltun. Photographic image synthesis with cascaded refinement networks. In International Conference on Computer Vision, Oct 2017. ",
+        "bbox": [
+            168,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi-Hsin Chen, Wei-Yu Chen, Yu-Ting Chen, Bo-Cheng Tsai, Yu-Chiang Frank Wang, and Min Sun. No more discrimination: Cross city adaptation of road scene segmenters. In International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            178,
+            291,
+            825,
+            334
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuhua Chen, Wen Li, and Luc Van Gool. Road: Reality oriented adaptation for semantic segmentation of urban scenes. In Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            174,
+            343,
+            821,
+            373
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The Cityscapes dataset for semantic urban scene understanding. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gabriela Csurka. Domain Adaptation in Computer Vision Applications. Springer, 2017. ",
+        "bbox": [
+            171,
+            434,
+            750,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zihang Dai, Zhilin Yang, Fan Yang, William W. Cohen, and Ruslan Salakhutdinov. Good semisupervised learning that requires a bad GAN. NIPS, 2017. ",
+        "bbox": [
+            173,
+            458,
+            820,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cesar Roberto de Souza, Adrien Gaidon, Yohann Cabon, and Antonio Manuel L ´ opez Pe ´ na. Pro- ˜ cedural generation of videos to train deep action recognition networks. In Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            539
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adrien Gaidon, Qiao Wang, Yohann Cabon, and Eleonora Vig. Virtual worlds as proxy for multiobject tracking analysis. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            547,
+            820,
+            578
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            174,
+            585,
+            821,
+            616
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. Journal of Machine Learning Research, 2016. ",
+        "bbox": [
+            176,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nuno Garcia, Pietro Morerio, and Vittorio Murino. Modality distillation with multiple stream networks for action recognition. In European Conference on Computer Vision, 2018. ",
+        "bbox": [
+            169,
+            676,
+            821,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, 2014. ",
+        "bbox": [
+            173,
+            714,
+            823,
+            757
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ankur Handa, Viorica Patraucean, Vijay Badrinarayanan, Simon Stent, and Roberto Cipolla. Understanding real world indoor scenes with synthetic data. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            766,
+            823,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samitha Herath, Mehrtash Harandi, and Fatih Porikli. Learning an invariant hilbert space for domain adaptation. In Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Erik Rodner, Jeff Donahue, Kate Saenko, and Trevor Darrell. Efficient learning of domain-invariant image representations. In International Conference on Learning Representations, 2013. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Saurabh Gupta, and Trevor Darrell. Learning with side information through modality hallucination. In Computer Vision and Pattern Recognition, 2016a. ",
+        "bbox": [
+            171,
+            156,
+            820,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Dequan Wang, Fisher Yu, and Trevor Darrell. Fcns in the wild: Pixel-level adversarial and constraint-based adaptation. arXiv preprint arXiv:1612.02649, 2016b. ",
+        "bbox": [
+            171,
+            195,
+            820,
+            226
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A. Efros. Image-to-image translation with conditional adversarial networks. In Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            265
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European Conference on Computer Vision. Springer, 2016. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            357
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wen Li, Li Niu, and Dong Xu. Exploiting privileged information from web data for image categorization. In European Conference on Computer Vision, 2014. ",
+        "bbox": [
+            173,
+            406,
+            823,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. arXiv preprint arXiv:1703.00848, 2017. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long, Yue Cao, Jianmin Wang, and Michael Jordan. Learning transferable features with deep adaptation networks. In International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            516
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Lopez-Paz, Lon Bottou, Bernhard Schlkopf, and Vladimir Vapnik. Unifying distillation and privileged information. arXiv preprint arXiv:1511.03643, 2015. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, and Zhen Wang. Multi-class generative adversarial networks with the l2 loss function. arXiv preprint arXiv:1611.04076, 2016. ",
+        "bbox": [
+            171,
+            564,
+            823,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Javier Mar´ın, David Vazquez, David Ger ´ onimo, and Antonio M. L ´ opez. Learning appearance in ´ virtual scenarios for pedestrian detection. In Computer Vision and Pattern Recognition, 2010. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nikolaus Mayer, Eddy Ilg, Philip Hausser, Philipp Fischer, Daniel Cremers, Alexey Dosovitskiy, and Thomas Brox. A large dataset to train convolutional networks for disparity, optical flow, and scene flow estimation. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            686
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gerhard Neuhold, Tobias Ollmann, Samuel Rota Bulo, and Peter Kontschieder. The mapillary vistas \\` dataset for semantic understanding of street scenes. In International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            173,
+            696,
+            826,
+            739
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeremie Papon and Markus Schoeler. Semantic pose using deep networks trained on synthetic RGBD. In International Conference on Computer Vision, 2015. ",
+        "bbox": [
+            171,
+            751,
+            823,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, et al. Pytorch, 2017. ",
+        "bbox": [
+            173,
+            790,
+            607,
+            806
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xingchao Peng, Baochen Sun, Karim Ali, and Kate Saenko. Learning deep object detectors from 3D models. In International Conference on Computer Vision, 2015. ",
+        "bbox": [
+            174,
+            815,
+            823,
+            845
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sanjay Purushotham, Wilka Carvalho, Tanachat Nilanon, and Yan Liu. Variational recurrent adversarial deep domain adaptation. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            173,
+            854,
+            823,
+            885
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephan R. Richter, Vibhav Vineet, Stefan Roth, and Koltun Vladlen. Playing for data: Ground truth from computer games. In European Conference on Computer Vision, 2016. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "German Ros, Laura Sellart, Joanna Materzyska, David Vazquez, and Antonio M. L ´ opez. The SYN- ´ THIA dataset: a large collection of synthetic images for semantic segmentation of urban scenes. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fatemeh Sadat Saleh, Mohammad Sadegh Aliakbarian, Mathieu Salzmann, Lars Petersson, and Jose M. Alvarez. Effective use of synthetic data for urban scene semantic segmentation. In European Conference on Computer Vision, 2018. ",
+        "bbox": [
+            176,
+            154,
+            821,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kuniaki Saito, Kohei Watanabe, Yoshitaka Ushiku, and Tatsuya Harada. Maximum classifier discrepancy for unsupervised domain adaptation. arXiv preprint arXiv:1712.02560, 3, 2017. ",
+        "bbox": [
+            171,
+            204,
+            823,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Swami Sankaranarayanan, Yogesh Balaji, Arpit Jain, Ser Nam Lim, and Rama Chellappa. Learning from synthetic data: Addressing domain shift for semantic segmentation. In Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            174,
+            242,
+            823,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nikolaos Sarafianos, Michalis Vrigkas, and Ioannis A Kakadiaris. Adaptive svm+: Learning with privileged information for domain adaptation. arXiv preprint arXiv:1708.09083, 2017. ",
+        "bbox": [
+            171,
+            292,
+            823,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jamie Shotton, Andrew Fitzgibbon, Mat Cook, Toby Sharp, Mark Finocchio, Richard Moore, Alex Kipmanand, and Andrew Blake. Real-time human pose recognition in parts from a single depth image. In Computer Vision and Pattern Recognition, 2011. ",
+        "bbox": [
+            176,
+            329,
+            823,
+            373
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ashish Shrivastava, Tomas Pfister, Oncel Tuzel, Josh Susskind, Wenda Wang, and Russ Webb. Learning from simulated and unsupervised images through adversarial training. arXiv preprint arXiv:1612.07828, 2016. ",
+        "bbox": [
+            174,
+            381,
+            823,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hao Su, Charles R. Qi, Yangyan Yi, and Leonidas Guibas. Render for CNN: viewpoint estimation in images using CNNs trained with rendered 3D model views. In International Conference on Computer Vision, 2015. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Baochen Sun and Kate Saenko. From virtual to reality: Fast adaptation of virtual object detectors to real domains. In British Machine Vision Conference, 2014. ",
+        "bbox": [
+            173,
+            483,
+            823,
+            512
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yaniv Taigman, Adam Polyak, and Lior Wolf. Unsupervised cross-domain image generation. arXiv preprint arXiv:1611.02200, 2016. ",
+        "bbox": [
+            173,
+            520,
+            823,
+            549
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yi-Hsuan Tsai, Wei-Chih Hung, Samuel Schulter, Kihyuk Sohn, Ming-Hsuan Yang, and Manmohan Chandraker. Learning to adapt structured output space for semantic segmentation. In Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            174,
+            556,
+            823,
+            599
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014. ",
+        "bbox": [
+            174,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Vladimir Vapnik and Akshay Vashist. A new learning paradigm: Learning using privileged information. Neural Networks, 2009. ",
+        "bbox": [
+            174,
+            645,
+            821,
+            674
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Vazquez, Antonio M. Lopez, Javier Mar ´ ´ın, Daniel Ponsa, and David Geronimo. Virtual and ´ real world adaptation for pedestrian detection. Transactions on Pattern Analysis and Machine Intelligence, 36(4):797 – 809, 2014. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            724
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ian H Witten, Eibe Frank, Mark A Hall, and Christopher J Pal. Data Mining: Practical machine learning tools and techniques. Morgan Kaufmann, 2016. ",
+        "bbox": [
+            173,
+            732,
+            821,
+            762
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiaolong Xu, David Vazquez, Antonio M. L ´ opez, Javier Mar ´ ´ın, and Daniel Ponsa. Learning a partbased pedestrian detector in a virtual world. Transaction on Intelligent Transportation Systems, 15(5):2121–2131, 2014. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            813
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ke Yan, Lu Kou, and David Zhang. Learning domain-invariant subspace using domain features and independence maximization. Transactions on Cybernetics, 2017. ",
+        "bbox": [
+            171,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yang Zhang, Philip David, and Boqing Gong. Curriculum domain adaptation for semantic segmentation of urban scenes. In International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            174,
+            857,
+            820,
+            887
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yiheng Zhang, Zhaofan Qiu, Ting Yao, Dong Liu, and Tao Mei. Fully convolutional adaptation networks for semantic segmentation. In Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yang Zou, Zhiding Yu, BVK Vijaya Kumar, and Jinsong Wang. Unsupervised domain adaptation for semantic segmentation via class-balanced self-training. In European Conference on Computer Vision, 2018. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 13
+    }
+]